Preface¶

Some desktop operations are very difficult to write into prompts. File pickers, menus, pop-ups, drag-and-drop, switching across multiple apps, plus personal workspace layouts and team internal habits—writing a detailed runbook is time-consuming and prone to missing steps. For Computer Use-style agents, it is often clearer for users to demonstrate a workflow once than to describe it verbally.

DeepSeek Harness (dsh) is an open-source agent runtime from DeepSeek AI, with the architectural slogan of “Everything is a plugin”. Someone in the community turned “demonstrate once, learn one workflow” into a plugin: dsh-record-replay. It does not draw the desktop itself or directly click the mouse for you. Instead, it connects another macOS recorder, Open Record/Replay, to the Harness, allowing the agent to first record evidence, then use it to create skills.

This article is organized after checking the plugin directory page, GitHub repository README/source code, and Open Record/Replay documentation: what it is, what tools are available after installation, how to configure the local recorder, and the permissions and privacy boundaries to note when using it. The community plugin directory deepseek-harness-plugin.com is an independent site and has no official affiliation with DeepSeek / HyperMind. Do not treat it as an official app store.

What It Is¶

dsh-record-replay is a DeepSeek Harness plugin categorized under “Development & Runtime” on the directory page. Its maintainer is GitHub user humblebanana, with the repository address at humblebanana/dsh-record-replay, licensed under MIT, and primarily written in TypeScript. The current version in the repository’s package.json is 0.2.0 (released on 2026-08-13). As of the verification for this article, GitHub shows 8 stars; the community directory page still lists 7 stars, so please refer to the repository for the correct star count.

The problem it solves can be summarized in one sentence: record a user’s real desktop operations on Mac into structured evidence, then package it into skill inputs that agents can learn from.

The plugin itself is just an adaptation layer, not a full recorder. The actual work is done by open-record-replay, also maintained by the same author: a native macOS backend written in Swift, plus a bin/orr.js CLI. The plugin calls this CLI via Harness’s subprocess service, and registers:
- A runtime skill: open-record-replay
- A set of model-facing orr_* tools

The repository README still starts with “six model-facing tools”, corresponding to the 0.1.0 recording/validation/packaging workflow. Version 0.2.0 added the built-in fallback tool orr_skill_create, and the source code src/tools.ts actually registers 7 tools. The following explanation follows the source code and CHANGELOG.

Open Record/Replay itself is labeled as alpha. The current stable public path is: native macOS recording, CLI, session.json / events.jsonl, recording quality validation, skill input packages, and handing them over to the host agent to create the final skill. Screenshots are not part of the current core recording workflow.

Core Features¶

From Demonstration to Skill¶

The official README outlines the main workflow as:

User demonstrates the workflow
  -> orr_record_start            (generates session.json + events.jsonl)
  -> orr_record_stop             (finalizes the recording)
  -> orr_session_validate        (validates recording quality against official specs)
  -> orr_session_events          (reads what the user actually did)
  -> orr_skill_prepare           (packages the skill input directory)
  -> Host skill creator

The skill manifest open-record-replay also stipulates: after recording starts, the agent must end the current turn and wait for the user to finish demonstrating; do not poll or continue working while recording. When the user explicitly cancels the recording, do not continue creating the skill.

The final skill should be handed over to the host’s built-in Skill Creator first. If there is no host creator, use orr_skill_create to generate and install SKILL.md according to the Anthropic skills spec. Do not stop at a summary or Markdown operation instructions unless the user only wants that.

Model-Facing Tools¶

The default recording name for orr_record_start is screen-activity, and you can pass a short name such as send-file-demo. When requestPermissions is true, missing permissions will trigger the system authorization dialog. The first call to orr_permissions_check or orr_record_start may take several minutes, as it will compile the Swift recorder.

orr_session_events returns the first 50 events by default, with a maximum of 500. The full evidence is in the workspace’s events.jsonl file, which you can read directly when needed.

The usage of orr_skill_create has two steps: first pass no draft parameter to generate a specification-compliant skeleton (kebab-case name, description front metadata, progressive disclosure body, and evals/evals.json placeholder); after the agent rewrites the description, steps, acceptance criteria, and privacy notice, pass the complete SKILL.md as the draft parameter, and install it to ~/.agents/skills/<name>/ after verification. Do not use this fallback path when the host has a native Skill Creator.

Recording Evidence¶

Open Record/Replay writes a single demonstration into session artifacts. The recording directory defaults to being relative to the workspace:

runs/sessions/<session-id>/
├── session.json
├── events.jsonl
├── orr_session.json
└── recording_manifest.json

orr_skill_prepare then packages it into a skill input package:

skill-inputs/<session-id>/
├── README.md
├── events.jsonl
└── session.json

session.json records recording boundaries, timestamps, and event paths. events.jsonl is the source of truth for determining exactly what the user did. The listed event types in the documentation include:
- window.changed
- mouse.click
- mouse.drag
- keyboard.text_input
- keyboard.submit
- selection.changed
- App/window ownership, UI target, selected files or text
- Accessibility tree or diff context

The skill manifest requires: do not infer unsupported operations from generalized targets like AXGroup, AXScrollArea, or low-confidence action clusters. When key actions or destinations are ambiguous, ask the user for clarification.

The supported recording scenarios listed in the Open Record/Replay README include: sending files or images in a desktop chat app, creating documents and sharing links, opening a web page to search and play specified media, switching between browsers and desktop apps, and reproducing UI workflows without a stable API. These are capability descriptions from the recorder’s documentation, not third-party user feedback.

Installation and Enablement¶

Environment Requirements¶

The prerequisites listed in the plugin README:
- macOS. The native recorder is written in Swift, requiring Xcode Command Line Tools.
- Node.js >= 22.19 (for the Harness runtime; the recorder repository itself requires Node.js 18+, and installing this plugin follows the Harness requirements).
- DeepSeek Harness already installed.
- A local checkout of open-record-replay, as the plugin will call bin/orr.js from it.

The recorder also requires macOS Accessibility and Input Monitoring permissions. The core recording path does not require Screen Recording.

DeepSeek Harness can be started using the method described in the official repository, for example:

npx @deepseek-ai/dsh web

The default Web UI is at http://127.0.0.1:3080. Harness is currently in developer preview, and the official README notes that there will be breaking changes.

Installation Command from the Community Directory Page¶

The installation command given on the community directory page is as per the original text on the page, run in the DeepSeek Harness terminal:

dsh plugin add github:humblebanana/dsh-record-replay

For reproducible installations, the directory page recommends pinning to a specific commit hash:

dsh plugin add github:humblebanana/dsh-record-replay#commit

Replace #commit with the actual commit hash. Plugins installed from GitHub may run build scripts during installation; pnpm 10+ rejects prepare scripts for git dependencies by default. If the first add fails, follow the dsh prompt to add the package name to the allowBuilds field in the profile’s pnpm-workspace.yaml. The directory page also reminds users: the plugin runs with the permissions of the current dsh process, so you should check the source code and license before installing.

Local Tarball Installation¶

The repository README also provides a set of steps to build a tarball and install it into the web profile, suitable for local code modifications or avoiding running git dependencies directly:

git clone https://github.com/humblebanana/dsh-record-replay.git
cd dsh-record-replay
pnpm install
pnpm build
pnpm pack
dsh plugin --profile web add ./dsh-record-replay-0.2.0.tgz

The filename in the README example still uses dsh-record-replay-0.1.0.tgz, which does not match the current 0.2.0 version in package.json. pnpm pack generates the package name based on the version field, so refer to the actual output file.

dsh plugin add writes the package to the profile’s package.json (dependencies and dsh.profile.bundles), and the harness maintains a fallback at profiles/node_modules.

Point to the Recorder Checkout¶

Installing the plugin alone is not enough. The included cordis.patch.yml only has a neutral configuration line, and you must overwrite the entire line in the profile’s cordis.patch.yml to point to your local open-record-replay directory. The README example:

- id: record-replay
  config:
    repoRoot: '/absolute/path/to/open-record-replay'
    runsOut: 'runs'
    skillInputsOut: 'skill-inputs'

The meaning of each configuration item is as follows:

The CLI runs with the session workspace as its working directory, so recording artifacts will be placed in a location accessible by the agent’s filesystem tools. The profile’s patch file will be hot-loaded, and you do not need to restart the running GUI; if you are not using a live profile, you need to restart Harness.

You can install the recorder separately first:

git clone https://github.com/humblebanana/open-record-replay.git
cd open-record-replay
npm install
npm run check

Typical Usage¶

The following workflow comes from the plugin’s skill manifest and the Open Record/Replay Quick Demo, and you can follow it step by step. Assuming the plugin is installed and repoRoot points to the local checkout.

1. Check Permissions First¶

Ask the agent to call orr_permissions_check, or run directly in the recorder repository:

node bin/orr.js permissions check

If permissions are missing:

node bin/orr.js permissions request

This corresponds to the requestPermissions: true parameter in orr_record_start.

2. Start Recording, Then Demonstrate and Stop¶

Start recording only after the user is ready. CLI example (from the recorder documentation):

node bin/orr.js record start --name send-file-demo --out runs --request-permissions

In Harness, the equivalent action is orr_record_start with the name field filled as send-file-demo. After starting, the agent should end the current turn and ask the user to demonstrate on their Mac. The example given in the documentation is:
1. Open a desktop chat app.
2. Select a contact or group chat.
3. Attach a local file.
4. Confirm the upload.
5. Send a supplementary message.

Do not ask the agent to call other tools during the demonstration.

3. Stop, Validate, and Read Evidence¶

After the user says the demonstration is complete:

node bin/orr.js record stop latest
node bin/orr.js session validate-recording latest
node bin/orr.js session events latest

The corresponding tools are orr_record_stop, orr_session_validate, and orr_session_events in order. You can use latest as the session ID to refer to the most recent recording.

4. Package or Create a Skill¶

When handing over to the host Skill Creator:

node bin/orr.js skill prepare latest --runs runs --out skill-inputs

This is equivalent to orr_skill_prepare. Pass the returned directory to the host’s creation workflow.

If there is no host Skill Creator, call orr_skill_create according to the plugin’s skill manifest: first pass no draft parameter to generate the skeleton, then pass the modified draft parameter to install the finished skill. The generated skill follows the Anthropic skills spec: kebab-case name, description explaining when to trigger and its purpose, progressive disclosure body, and optional evals/evals.json.

Applicable Scenarios and Notes¶

It is suitable for use under these conditions:
- Your working environment is macOS, and you are already running DeepSeek Harness.
- You want to teach the agent a desktop UI workflow, rather than a clean API call.
- You are willing to demonstrate the workflow once, and accept that the recording files will be stored in your local workspace.

Things that are not suitable, or at least do not expect it to do:
- Windows / Linux. The recording backend is macOS Swift.
- Treat the plugin as “operating the computer for you”. Controlling the desktop is another type of plugin (such as dsh-computer-use in the directory). The public path of this plugin is recording, validating, and packaging skill inputs.
- Relying on screenshots for review. The current core evidence is the event stream, not screen recordings.
- Treating the alpha scope of Open Record/Replay as a stable product promise. The documentation makes it clear that richer adapters and optional visual evidence are not part of the current stable public path.

There are several specific matters to handle before use.

Permissions and Process Permissions. Recording requires Accessibility and Input Monitoring permissions. The plugin runs with the permissions of the current dsh process, and may execute code during installation. Read the repository source code and MIT license before installing; do not run dsh plugin add for untrusted sources.

Privacy. Both the plugin’s SECURITY.md and the recorder’s privacy documentation state: recordings are not uploaded by default; events.jsonl may still contain window titles, URLs, typed text, selected text, file names, local paths, and accessibility tree text from apps and web pages. You should review it before sharing or submitting it to the agent summary. Do not publicly share original recordings containing keys, private documents, customer data, internal URLs, or personal information. The plugin’s skill manifest requires: passwords, OTPs, API tokens, financial or identity numbers, private personal/medical/legal/customer data, private local paths and document names must not be included in the summary or generated skills, use placeholders instead.

Evidence Interpretation. Do not force creation of a skill if validation fails. Ask the user when events are ambiguous, rather than filling in unrecorded steps.

Missing Configuration. If you only run the dsh plugin add command from the directory page and do not set repoRoot / cliPath, the plugin will not be able to find bin/orr.js, and tool calls will fail.

Summary¶

dsh-record-replay connects Open Record/Replay to DeepSeek Harness: after the user demonstrates a macOS workflow once, the agent uses the orr_* tools to record events, validate them, package skill packages, and then hand them over to the host Skill Creator (or the 0.2.0 orr_skill_create fallback). It solves the problem of “these operations are hard to write clearly, and a single demonstration is clearer”, rather than being general desktop automation.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-record-replay/

Plugin repository: https://github.com/humblebanana/dsh-record-replay

Recorder repository: https://github.com/humblebanana/open-record-replay

DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness