Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y @heyditto/[email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add heyditto-cli -- npx -y @heyditto/cli@3.18.1รันในเทอร์มินัล
{ "mcpServers": { "heyditto-cli": { "command": "npx", "args": [ "-y", "@heyditto/[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
heyditto endpoints provider-keys --output json
heyditto endpoints models gm --output json
heyditto endpoints create --name "Infinite Disk" --slug infinite-disk \
--model gm/gpt-6-luna --billing-mode byok --provider-key <saved-key-UUID>
heyditto endpoints set infinite-disk --recall off --record off --record-trace off
heyditto endpoints keys create infinite-disk --key-file /absolute/private/router-key --yes
Ditto Memory CLI — save, search, fetch, and traverse the Ditto memory graph from the shell.
Provider-key discovery returns only your personal vault's selection metadata,
never raw credentials. --provider-key is repeatable (or comma-separated),
replaces the selected list, and never accepts an empty list as an implicit
"all keys". byok does not fall back to Ditto-funded providers. Endpoints created
without an organization are personal; an existing saved default is unchanged
unless you pass --default.
--key-file (also --store file --secret /absolute/private/router-key) requires
an existing owner-only 0700 parent directory. It creates a new 0600 file without
overwriting existing files or following symlinks. No plaintext key is printed,
put in argv, or returned in JSON. Delivery failure revokes the newly minted key.
Use an endpoint key in your local app, never your management or provider key.
On Windows use one of the external secret managers instead. Router discovery
requires the matching server capability; an older server fails explicitly.
@heyditto/cli — save, search, fetch, and traverse the Ditto memory graph from the shell.
npm install -g @heyditto/cli
heyditto init --name "NAME_OF_AGENT" --json # the name is set once, here
heyditto save "I prefer TypeScript over JS for new projects"
heyditto search "language preferences"
heyditto fetch <id> --memory-format outline
heyditto subjects "memory architecture" --top-k 5
npm install -g @heyditto/cli
# or one-shot via npx
npx -y --package @heyditto/cli heyditto search "what did I say about X"
The package installs two equivalent binaries: ditto and heyditto. They run the same CLI — use whichever you prefer. We recommend heyditto on macOS because Apple ships /usr/bin/ditto (a file-copy utility) that can shadow the npm CLI.
The published npm package is @heyditto/cli. Use the installed heyditto
binary or the scoped npx --package form above; the unscoped heyditto npm name
is not our published package.
Eligible global npm installations check for a newer CLI about every six hours
when invoked. The check and download run quietly in a finite background worker;
your current command keeps running its selected version. A fully verified update
takes effect on a later invocation. Help, version, offline and review --preview
commands do not start a network check. JSON stdout is unchanged.
heyditto self-update status --output json
heyditto self-update check # verify and activate for the next invocation
heyditto self-update disable
heyditto self-update enable
heyditto self-update pin # retain the currently selected version
heyditto self-update unpin
DITTO_CLI_AUTO_UPDATE=0 heyditto search "a memory" # suppress this background check
DITTO_CLI_PINNED=1 heyditto --version # run the installed package, bypassing cached updates
self-update check uses the same bounded verification path even when automatic
checks are disabled, and explicitly activates the verified update for the next
invocation. A persistent pin still prevents it from installing another
version. heyditto --no-auto-update <command> also suppresses a background check;
DISABLE_AUTOUPDATER=1 is supported. Disabling checks retains a validated version
already selected by an earlier launch (or an explicit manual check). It ignores
new background candidates, including a worker that finishes publishing after
disable has acknowledged. Running commands keep their selected version. A pin
selects its retained version even if a newer update has downloaded concurrently.
All self-update controls run the pinned, previously activated or bundled
version; they never adopt a staged candidate before executing the control.
status only inspects. enable and unpin allow a later ordinary launch to
activate a candidate; check can activate only after its explicit manual action.
An ordinary launch that already selected a version under an enabled policy may
finish and record that selection after a concurrent disable returns. Disable
does not restart or undo commands already in progress.
Manual checks return their own worker result in manualResult, separately from
shared last-attempt health. If another worker is active, check reports busy
and exits 75; retry it after that worker finishes. A missing or incomplete worker
result exits nonzero. A concurrent change to shared health cannot turn a blocked
manual request into a successful check.
Homebrew, Nix and operating-system package locations, project installs, npm
scripts, CI and ephemeral npx executions keep their package-manager version;
the updater does not replace their files or override their ownership. Historical
npm install -g @heyditto/cli@<version> intent is not recoverable reliably from
installed npm metadata. Use the persistent pin or DITTO_CLI_PINNED=1 when that
global installation must remain exact. Older CLI versions need one normal npm
upgrade before they have this updater.
Updates are stored under the CLI config directory's updates/ folder, with
separate immutable version directories, an atomic candidate pointer and
append-only activation markers for each
OS, CPU architecture and libc target. Enable/disable is one shared user
preference; pins and cached bundles are target-specific. Each control writes its
own atomic preference file, so concurrent pin and disable commands cannot
overwrite each other's intent. Relative
DITTO_CONFIG_DIR values are resolved before starting a worker. Every
root and locked dependency archive is restricted to the public npm registry and
checked against SHA512 integrity; archive links, unsafe paths and special files
are rejected. No npm configuration, credentials, project files, install scripts,
daemon, sudo or command restart is used. Compatible prebuilt PTY packages and
ordinary executable bits are retained for coding-agent commands.
Each attempt is bounded to 60 seconds plus five seconds of worker cleanup,
128 MiB downloaded, 512 MiB unpacked and
50,000 files. Cached versions are retained so active commands can still read
them; at 2 GiB per target, the updater pauses for manual cleanup instead of deleting a
potentially active version. Immutable attempt leases also have a metadata cap.
A crashed attempt blocks at most its six-hour window and never steals another
worker's live lease. self-update status reports the bundled, selected and
cached versions, eligibility, policy and last result. Invalid selection metadata
falls back before execution; a cached CLI execution failure is quarantined for
the next invocation and never retries the command.
/usr/bin/dittoOn macOS, Apple ships /usr/bin/ditto (a file-copy utility). On a default PATH that puts /usr/bin ahead of /opt/homebrew/bin, plain ditto will run Apple's tool instead of this one — which produces confusing errors like unrecognized option '--output'.
Two ways to disambiguate:
# 1. Use the alias bin shipped by this package:
heyditto status
# 2. Or check which 'ditto' binary your shell resolves first:
type -a ditto
# /usr/bin/ditto ← Apple's tool
# /opt/homebrew/bin/ditto ← @heyditto/cli (use this)
You can also reorder your PATH so the npm global bin comes before /usr/bin, or invoke @heyditto/cli directly via its full path.
Humans sign in through the browser:
heyditto login
This prints a short code, opens https://heyditto.ai/device (pre-filled with the
code), and saves the resulting key to your CLI config directory once you approve
it. Pass a key as an argument (heyditto login ditto_mcp_…), pipe it with
--stdin, or use --paste for the older copy-a-key page.
Agents can self-provision without a browser, email, or OTP:
heyditto init --json
The command creates a free claimable agent account, stores the key in
your CLI config directory (defaults to ~/.config/heyditto/cli/config.json;
override with DITTO_CONFIG_DIR), and prints a claim URL without printing the
agent key. Humans claim the account later from claimURL; agents should share
that link. The claim token is carried in the query string (?t=...).
Decide the agent's name before you run init and pass it with --name:
heyditto init --name "NAME_OF_AGENT" --json
The caller name is set once, at account creation, and it labels everything
the agent saves: after a human claims the account, the agent's memories show up
in the owner's graph as an external agent thread titled by this name. If you
init without --name, the name defaults to agent and every memory is
labeled agent — generic and hard to tell apart from other agents.
So: use the agent's own name, or a name the user has already chosen, and set it up front. Renaming after init is not yet supported from the CLI, so picking the right name at init avoids a stuck label.
heyditto login
opens the Ditto web app with a one-time device code (sign in with Google, X, Apple
or GitHub, or create an account), approves it, and hands the key back to the CLI —
nothing to copy. heyditto claude / heyditto codex run the same flow
automatically on first use, and the web page lets you pick or create the
inference endpoint to launch through, so a fresh machine needs exactly one
command:
npx @heyditto/cli@latest claude --yolo --worktree
You can still paste a key from https://app.heyditto.ai/mcp/newkey
(heyditto login <key>, --paste, or --stdin), or set it in the environment:
export DITTO_API_KEY=ditto_mcp_…
# add to ~/.zshrc / ~/.bashrc to persist
heyditto save <content> [--source <s>] [--source-context <c>]
heyditto search <query>... [--include-public] [--filter-username <u>]
heyditto fetch <id>... [--memory-format full|outline|blocks]
heyditto list [--username <u>] [--limit <n>] [--offset <n>] [--source <s>]
heyditto my-memories [--limit <n>] [--offset <n>] [--source <s>]
heyditto update <id> [--content <text>|--content-file <path>] [--title <t>]
[--source-context <c>] [--edits-json <json>|--edits-file <path>]
[--base-revision <n>]
heyditto publish <id> [--title <t>] [--privacy-mode <mode>]
heyditto unpublish (--memory-id <id>|--share-id <id>|<id>)
heyditto delete <memory-id> --confirm
heyditto subjects <query> [--top-k <n>]
heyditto subject-edges <subject-id> [--limit <n>] [--min-weight <n>] [--kg <alias>]
heyditto memories <subject-id>... [--query <q>]
heyditto network <pair-id> [--limit <n>]
heyditto friends
heyditto knowledge-graphs
heyditto graph-sharing (--enable|--disable) [--title <t>] [--description <d>]
heyditto graphs create <name>
heyditto graphs list
heyditto graphs available
heyditto graphs add <@username>
heyditto graphs remove <@username>
heyditto graphs subscribers
heyditto graphs sharing (--enable|--disable) [--title <t>] [--description <d>]
heyditto init [--name <name>] [--subscribe <@graph>]... [<@graph>...] [--json]
heyditto login [<key>] [--paste] [--stdin]
heyditto endpoints [--set-default <slug>] [--clear-default]
heyditto apps list [--company <id>]
heyditto apps create <name> [--gh-secret NAME --repo o/r | --gcp-secret NAME | …]
heyditto apps show|update|oidc|icon set|origins verify|secret rotate|consent set …
heyditto apps endpoints list|attach|billing|detach <app> [<endpoint>]
heyditto receipts [--leg ditto|byok|covered] [--app <app_id>] [--days <n>]
heyditto claude [options] [-- <claude args>]
heyditto codex [options] [-- <codex args>]
heyditto codex-app [--endpoint <slug>] [--model <id>] [--unset]
heyditto sessions [--json] [--all]
heyditto sessions rm <id>
heyditto session new [<name>...] [--id <id>]
heyditto session list [--all]
heyditto session use <id>
heyditto session current
heyditto session end
heyditto agents [--output <format>]
heyditto logout
heyditto status [--output <format>]
heyditto config
heyditto help [command]
Use -h or --help globally or after any command:
heyditto --help
heyditto search --help
heyditto graphs add --help
saveSave a document or note to the user's memory base.
heyditto save "Project X uses Bun + SolidJS, deployed to Cloud Run"
heyditto save "$(cat note.md)" --source document --source-context note.md
searchSemantic search across memories. Multiple positional args become an array of queries.
Use --include-public to also search public DittoHub memories, optionally scoped
with --filter-username <u>.
heyditto search "typescript preferences"
heyditto search "typescript" "language choices"
heyditto search "launch notes" --include-public --filter-username peyton
reviewheyditto review local --preview
heyditto review local --staged --profile quick --org omniaura
heyditto review local --base main --context-file .tmp/task.md --output json
heyditto review local-status <run-id> --org omniaura
heyditto review local-cancel <run-id> --org omniaura
local uses your existing login and selected organization, and the current
checkout's GitHub origin identifies its configured Review repository. Override
that mapping with --repository owner/name, or the checkout with --directory.
The backend must support local Review runs and the repository must be enabled.
The same permissions and spending policy as manual PR reviews apply.
The default reviews staged, unstaged and eligible untracked changes. --staged
reviews the index bytes, including when a file also has unstaged edits.
--base main includes branch and working changes since the merge base with
main. It cannot be combined with --staged. No commit, push, PR or index
mutation is required.
--preview is offline: it shows the selected paths, snapshot digest, file and
byte counts, exclusions and omitted context without logging in or uploading.
Running without --preview uploads the selected source changes and bounded
surrounding tracked source to Ditto Review, which uses the existing independent
review and verification engine. The immutable snapshot is limited to 16 MiB of
decoded source and 4096 files per tree. Every eligible changed file must fit;
nearby surrounding files fill the remaining budget. Binary files, symlinks and
submodules are recorded as skipped rather than followed or executed.
Git paths must be valid UTF-8. Unsupported path encodings abort capture before
upload rather than changing path identity or silently omitting changes.
Choose quick (default), standard or deep. The service returns the effective
time and budget ceilings; queue and capture time are additional. These profiles
are effort policies, not measured speed guarantees. --timeout bounds the
whole CLI operation and requests cancellation when it expires. Ctrl-C also
requests cancellation; use the printed run ID to inspect or cancel a run later.
An uncertain admission is identified by its request ID and is never retried
automatically. Use the printed recovery command with --request-id <uuid> to
recover that same admission. The server reuses the original run for identical
input and refuses changes to the source snapshot, profile or context under that
ID, so this recovery does not start another paid attempt.
Readable and JSON results identify the reviewed snapshot, findings, coverage, cost receipts and whether the current working tree still matches. Partial reviews return a nonzero exit code. Bounded surrounding context is stated explicitly; "no findings in reviewed scope" is not an assertion that the checkout is bug-free. Results are unpublished local reviews and post nothing to GitHub. Organization learning-memory and complete hosted repository-policy parity remain separate capabilities and are not implied by this command.
Manage Ditto Review and follow reviews from either ditto or heyditto.
Commands use your selected organization (orgs use) or --org; without one,
they use your personal workspace. Repositories must already be set up for
Review. Workspace membership and manager permissions are enforced by the API.
heyditto review repos --org omniaura
heyditto review set ditto-assistant/console --max-minutes 20 --org omniaura
heyditto review pulls ditto-assistant/console --org omniaura
heyditto review start ditto-assistant/console 88 --org omniaura --watch
heyditto review runs ditto-assistant/console --org omniaura --output json
heyditto review status <run-id> --org omniaura --output json
heyditto review watch <run-id> --org omniaura --interval 10 --timeout 3600
heyditto review retry <run-id> --org omniaura
heyditto review cancel <run-id> --org omniaura
Skip entire PRs from the console's repository settings or a JSON policy file:
heyditto review set owner/repo --skip-rules-file rules.json --org omniaura
heyditto review repos --org omniaura --output json
heyditto review set owner/repo --clear-skip-rules --org omniaura
The JSON object accepts headBranches, baseBranches, titles, authors, and labels arrays, plus bots (boolean). For example, {"authors":["dependabot[bot]"],"titles":["chore(i18n):*"],"labels":["skip-review"]}. Any match excludes the PR. * spans any text including slashes; ? matches one character; brackets and all other characters are literal. Authors and labels ignore case; branches and titles match case. Each list permits 50 patterns of up to 200 UTF-8 bytes. Empty rules skip nothing, and bots are included by default. Rules skip automatic reviews. An explicit heyditto review start, console Review now/retry, or authorized @ditto review request overrides skip rules for that review, without changing the saved policy. Settings writes preserve the policy and use the repository revision to refuse concurrent edits. This requires a backend that returns skipRules; an unsupported backend is reported as a failed save.
start reviews the PR's current head using the repository's saved budget and
settings. Starting a previously completed head requests another paid attempt.
retry can reuse a stored result after publication failure; other eligible
retries can spend a new per-run budget. It does not raise any budget or enable
a paused repository. cancel requests cancellation; a running review stops
asynchronously, and a review already being published may refuse cancellation.
runs lists the API's recent workspace runs; status --output json includes findings and
prior attempts. watch polls without starting, retrying, or cancelling the run.
It stops on completion, partial coverage, failure, cancellation, skip, or
supersession. Failed runs and timeouts return a nonzero exit code. A partial
review remains partial even though the command succeeds. A timeout or Ctrl-C
only stops the local watcher; use cancel to stop the server review.
--output json prints one final JSON document, with watch progress on stderr.
The lifecycle commands require a backend with CLI-key access to Review run and PR routes. On an older backend they return an authentication refusal; upgrading the CLI alone cannot enable those routes.
fetchFetch memory content for private pair ids or public share ids. The default
--memory-format full returns the full body. Use outline to get stable block
ids before a structured update, or blocks when you need each block body.
heyditto fetch 3a1084ae-235a-433d-9493-2335a0dfeb57
heyditto fetch 3a1084ae-235a-433d-9493-2335a0dfeb57 --memory-format outline --output json
listList saved memories, or public DittoHub publishes for a username.
heyditto list --limit 10
heyditto list --username peyton --limit 10 --output json
heyditto my-memories --source cli --limit 10 --output json
my-memories is the CLI wrapper for list_my_memories. It only lists your
saved memories, while list --username <u> can switch to public DittoHub
publishes for another user.
updateEdit a saved memory in place. Replace the full body with --content or
--content-file, or use block edits after fetching --memory-format outline.
Block edits require the current revision returned by save or a previous
update.
heyditto update <memory-id> --content-file revised.md --output json
heyditto fetch <memory-id> --memory-format outline --output json
heyditto update <memory-id> --edits-file edits.json --base-revision 3 --output json
publish / unpublishPublish a saved memory to the user's public DittoHub profile, or disable an existing share without deleting the private memory.
heyditto publish <memory-id> --title "Launch notes" --privacy-mode scan_and_block --output json
heyditto unpublish --share-id abc123def4 --output json
deletePermanently delete a saved memory. This is destructive, so the CLI requires
--confirm.
heyditto delete <memory-id> --confirm --output json
subjectsSearch the subject (topic) graph. Returns subject ids you can pass to memories or network.
heyditto subjects "memory architecture"
heyditto subjects "performance" --top-k 5
heyditto subject-edges <subject-id> --limit 10 --min-weight 0.5 --output json
subject-edges is the CLI wrapper for get_subject_edges.
memoriesFetch memory previews scoped to specific subjects.
heyditto memories <subject-id>
heyditto memories <subject-id> --query "deployment tradeoffs"
networkTraverse a memory's network (related memories via shared subjects).
heyditto network <pair-id> --limit 30
friendsList Ditto friends for commands that need usernames.
heyditto friends --output json
graphsManage the public workspaces you're subscribed to. Subscribed workspaces are
folded into your search/fetch read paths (read-only). Subscriptions only ever
cover other users' public workspaces by @username — this command can't touch
your own workspace or an app's workspace, since those aren't subscriptions.
heyditto graphs create feedback-triager # create a NEW dedicated workspace you own (mint its CI key in the Ditto UI)
heyditto graphs list # workspaces you're subscribed to
heyditto graphs available # readable workspaces, including main/app workspaces
heyditto graphs add @minos # subscribe to @minos's public workspace
heyditto graphs remove @minos # unsubscribe
heyditto graphs subscribers # who's subscribed to your workspace
heyditto graphs sharing --disable # disable public subscriptions to your workspace
Top-level aliases are also available:
heyditto knowledge-graphs --output json
heyditto graph-sharing --enable --title "Support Workspace" --description "Public support notes"
apps — developer apps ("Sign in with Ditto")Everything the developer console (developer.heyditto.ai) does for an app, from the shell, so an agent can set an app up end to end. The client secret follows the same rule as endpoint keys: it is forwarded straight into a secret store over that store CLI's stdin and never printed.
heyditto apps create "DittoBench" --gh-secret DITTO_OIDC_CLIENT_SECRET --repo ditto-assistant/ditto-subnet
heyditto apps origins verify dittobench-3f9a https://dittobench.ai # serve the token, then:
heyditto apps origins verify dittobench-3f9a https://dittobench.ai --confirm
heyditto apps consent set dittobench-3f9a credits:spend "Pays for the inference your miner uses."
heyditto apps icon set dittobench-3f9a ./logo.png
heyditto apps oidc dittobench-3f9a --callback https://dittobench.ai/auth/ditto/callback >> .env
heyditto apps endpoints attach dittobench-3f9a screener --billing sponsor
heyditto apps endpoints attach dittobench-3f9a competition --billing user
heyditto endpoints keys create competition --gh-secret DITTO_ROUTER_KEY --repo ditto-assistant/ditto-subnet
create mints the app and its secret. With a store flag the secret is stored and
never shown; without one it is minted but hidden — rotate it into a store later
with apps secret rotate (the previous secret stops working).oidc prints the non-secret OIDC configuration (DITTO_OIDC_ISSUER,
DITTO_OIDC_CLIENT_ID, authorization/token/userinfo/JWKS endpoints) as env lines
or --output json. client_id is the app id; redirect URIs must live on a
verified callback origin.consent set <app> <scope> "<why>" sets the app's own reason under each requested
permission on the consent screen; consent show renders the public consent
profile (GET /api/v5/consent-profile/<app>).endpoints attach <app> <endpoint> --billing user|sponsor makes a Router endpoint
app-owned: the app's users get inference through it (never keys or edits). user
bills the consenting user under their credits:spend grant to this app
(X-Ditto-On-Behalf-Of: <ditto uid> from your server, 402 when not authorized);
sponsor bills the endpoint owner and only records the user for attribution.apps commands use your first-party key against /api/v5/admin/apps; pass
--company <id> to act on an organization's apps.receiptsYour receipts for the last 30 days by billing leg (ditto = your balance, byok =
your own provider keys, no Ditto charge, covered = paid by Ditto) and by the app
that spent under your consent; sponsored app calls show up on the sponsor's account.
heyditto receipts
heyditto receipts --leg byok --days 7
heyditto receipts --app dittobench-3f9a --output json
statusPrint whether DITTO_API_KEY is set and the configured MCP endpoint resolves.
initCreate a free claimable agent account and save its key locally. Use --json for
machine-readable output that includes apiKeyStored, userID, and claimURL.
Share claimURL with the human owner. The CLI stores the generated key locally
without printing it. The claim URL uses a ?t=... query parameter.
Pass --name <name> to set the agent's name. This is set once at init,
defaults to agent, labels every memory the agent saves, and (after the account
is claimed) becomes the title of the agent's external thread in the owner's
graph. Choose it up front — renaming after init isn't yet supported. See
Name the agent at init.
--agent-caller <name> is still accepted as a backward-compatible alias.
configPrint a Claude Desktop / Cursor / generic-MCP-client config snippet for the Ditto memory server.
heyditto claude and heyditto codex launch Claude Code or Codex through one of
your Ditto inference endpoints (managed at https://developer.heyditto.ai/endpoints;
the Ditto app's Settings → Developer page still works too). Each launch:
--endpoint, the saved default, or a picker,--budget <tokens>),X-Ditto-Session-Id, so the
session becomes its own thread with full traces under the endpoint,--keep-key opts out, --expires sets a server-side
safety expiry (default 1mo, so a session left open for days keeps
working; the key is still revoked on exit).npx -y @heyditto/cli login
npx -y @heyditto/cli claude --endpoint my-endpoint
heyditto endpoints --set-default my-endpoint # skip the picker next time
heyditto claude # interactive Claude Code
heyditto codex --yellow # Codex, auto-accept edits
heyditto claude --yolo --worktree fix-login # bypass prompts in <repo>/.worktrees/fix-login
heyditto codex -p "summarize this repo" --json # headless (codex exec)
heyditto claude -p "list TODOs" --output-format json --max-turns 3
heyditto claude --resume # pick a session (type words to search every project)
heyditto claude --resume "Fix login bug" # resume by title, as `claude --resume` prints it
heyditto claude -- --verbose # anything after -- goes to the agent
Options shared by both commands:
Unknown flags and everything after -- are forwarded to the agent, so Claude's
and Codex's own options keep working.
How the wiring works:
Claude Code gets ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN (a bearer
token, which skips Claude's "use this API key?" prompt) and
ANTHROPIC_CUSTOM_HEADERS with the session id. Any inherited
ANTHROPIC_API_KEY is removed from the child environment.
With --no-mcp, router tools run on the server, so Claude Code's own
permission rules never see them. permissions.deny entries for mcp__ditto__<tool> (globs allowed;
a bare mcp__ditto denies them all) in your user, project or local
settings.json are forwarded as X-Ditto-Tool-Deny, and the router refuses
those tools for the session. The header can only add denials.
Claude Code gets the endpoint's tools as its own MCP servers by default: ditto for Ditto's built-ins, plus one server per
connected app or MCP server (ditto-github, ditto-jira, …). Claude Code
discovers them with its own ToolSearch and calls them natively. Every call
still runs on Ditto (/v1/mcp/<server>) with the credentials Ditto holds and
behind the endpoint's approval gate and deny rules, and the router is told
not to offer the same tools again. The session key reaches the MCP headers
as ${DITTO_ROUTER_MCP_KEY}, never argv or disk. Who asks before a gated
call is the endpoint's choice:
client_approvals hands approval to whoever runs the session, so only an
organization's managers can turn it on for an org endpoint. An endpoint
with no tools attaches nothing, and one the MCP surface cannot serve falls
back to the router's tools. --no-mcp keeps the tools on the router (Code
Mode or injected tools, as described above) for one session, and
claude_tool_surface = "router" in an endpoint profile makes that the
endpoint's default.
Codex speaks the Responses API only, so the endpoint is injected as a
ditto model provider via -c overrides (nothing is written to
~/.codex/config.toml) with the key in DITTO_INFERENCE_API_KEY.
codex-appheyditto codex-app wires the Codex desktop app (ChatGPT.app) to one of
your inference endpoints, so its models — GLM Flash and friends — work in the
app behind its own "Sign in with an API key" screen. Unlike the CLI, the
app cannot be handed environment variables (a Dock-launched app inherits
none), so the wiring is file-based in the ~/.codex directory the app shares
with the CLI:
openai_base_url in ~/.codex/config.toml repoints the built-in openai
provider (the Responses wire the gateway speaks) at your endpoint;~/.codex/auth.json as the API-key login,
the same place the app's sign-in screen writes.heyditto codex-app # sign in, pick an endpoint, wire the app
heyditto codex-app --endpoint my-endpoint # route through a specific endpoint
heyditto codex-app --model glm-5.3-flash # pin the app's model
heyditto codex-app --dry-run # show what would be written
heyditto codex-app --unset # restore the previous wiring, revoke the key
The command also enables the endpoint's model picker (--codex-models on),
so the app's model picker lists the endpoint's models. A previous login
(especially a ChatGPT-plan one) is backed up to auth.json.pre-ditto and
confirmed before it is replaced; --unset restores it. The key is long-lived
(unlike heyditto codex's per-session keys) and is revoked by --unset or
rotated on the next run. Both files are shared with the Codex CLI, so a bare
codex run routes through Ditto too; heyditto codex is unaffected.
endpointsManage the inference endpoints the launchers route through — a CLI mirror of
the developer console at https://developer.heyditto.ai/endpoints (open takes
you to an endpoint's page there; set DITTO_DEVELOPER_BASE to point elsewhere):
heyditto endpoints [--set-default <slug>] [--clear-default] list (* = default)
heyditto endpoints create [--name <n>] [--slug <s>] [--model <id>] [--org <org>] [--default]
heyditto endpoints move <endpoint> (--org <org> | --personal) change who owns and pays for it
heyditto endpoints show <endpoint>
heyditto endpoints use <endpoint> make it the default
heyditto endpoints pick choose the default interactively
heyditto endpoints open [endpoint] open the editor in the Ditto app
heyditto endpoints set <endpoint> [settings flags — see the table below]
heyditto endpoints usage <endpoint> [--window 7d|30d|month] requests, tokens, spend and cap
heyditto endpoints delete <endpoint> [--yes]
heyditto endpoints keys <endpoint> list keys
heyditto endpoints keys create <endpoint> --store <destination> --secret <NAME> [scoping flags]
[--name <label>] [--expires <1h…never>] [--budget <tokens>]
[--spend-period <p>] [--yes]
heyditto endpoints keys stores which destinations this machine can write to
heyditto endpoints keys revoke <endpoint> <keyId> [--yes]
Endpoints spend your Ditto credits, so deleting one, revoking a key or raising a
spend limit asks you to type the slug back; pass --yes in scripts. --output json is available everywhere and includes the gateway base URL.
endpoints set — every setting the console hasset is a full mirror of the endpoint editor at
https://developer.heyditto.ai/endpoints: anything the web form can change, this
can change. heyditto endpoints show <endpoint> prints all of it back, and
--output json gives the raw fields.
The three map flags are repeatable and merge onto what the endpoint already has, so setting one route never drops the others. An empty value removes a single entry:
heyditto endpoints set my-endpoint --kind-route aside=openai/gpt-5.6-nano \
--kind-route probe=openai/gpt-5.6-nano
heyditto endpoints set my-endpoint --kind-route aside= # remove just that one
heyditto endpoints set my-endpoint --clear-kind-routes # remove all of them
Choices and numeric bounds are checked locally against the gateway's own enums, so a typo fails instantly instead of costing a round trip.
keys create mints a long-lived key on an endpoint and stores it in a secret
manager by delegating to that platform's own CLI — the key is never shown.
The plaintext goes to the platform CLI over stdin (or through /dev/stdin, for
the CLIs that read a file instead), so it does not appear in argv, ps, shell
history, logs or the CLI's own output, and nothing is kept locally. If the
platform CLI fails, the freshly minted key is revoked again.
Every shorthand is sugar for --store <id> --secret <NAME>; use whichever
reads better. heyditto endpoints keys stores lists the destinations with the
CLI each one needs and whether it is installed here (--output json for
scripts).
cd my-repo
heyditto endpoints keys create my-endpoint --gh-secret DITTO_KEY # repo from the current directory (like gh)
heyditto endpoints keys create my-endpoint --gh-secret DITTO_KEY --repo acme/app --budget 5000000
heyditto endpoints keys create my-endpoint --gh-secret DITTO_KEY --org acme --expires 6mo --output json
heyditto endpoints keys create my-endpoint --store aws --secret DITTO_KEY --region us-east-1
heyditto endpoints keys create my-endpoint --gcp-secret ditto-key --project my-gcp-project
heyditto endpoints keys create my-endpoint --az-secret ditto-key --key-vault my-vault
heyditto endpoints keys create my-endpoint --op-item "Ditto inference" --op-vault Engineering
heyditto endpoints keys create my-endpoint --vault-secret ditto/inference --mount secret --field token
heyditto endpoints keys create my-endpoint --k8s-secret ditto-inference --namespace prod
Requirements: the platform CLI on PATH and signed in — both are checked
before anything is minted, so a missing CLI costs you nothing. Without a
terminal the command needs --yes; interactively it shows what it will do and
asks you to type the secret name back. Defaults: expiry 1y, key label
<store>:<target>:<NAME> (GitHub keeps its original gh:<owner>/<repo>:<NAME>);
--budget caps the key's spend (--spend-period defaults to monthly). A
scoping flag that belongs to another destination is an error rather than being
ignored. The output shows the key's last four characters, expiry, budget, where
it was stored, and how to consume it — for GitHub Actions:
env:
ANTHROPIC_AUTH_TOKEN: ${{ secrets.DITTO_KEY }}
ANTHROPIC_BASE_URL: https://api.heyditto.ai
# OpenAI-compatible clients: OPENAI_API_KEY: ${{ secrets.DITTO_KEY }} with OPENAI_BASE_URL: https://api.heyditto.ai/v1
Revoke it any time with heyditto endpoints keys revoke my-endpoint <keyId>.
Agent accounts. An agent set up with heyditto init can create and manage
endpoints too, but an endpoint created by an unclaimed agent starts inactive:
it serves requests once the person the agent works for claims the agent and
subscribes to Ditto Hero. The CLI prints the server's explanation together with
an activation link (the agent's claim link plus the endpoint) — hand that link
to the user.
sessionsList the coding-agent sessions launched from this machine (stored under
~/.config/heyditto/cli/sessions/). heyditto sessions rm <id> forgets a local
record; the Ditto thread and traces are unaffected.
sessionExplicit MCP sessions. Without one, the server groups your saves and searches
into a time-based implicit session (activity within a cooldown, auto-named
when it goes quiet). heyditto session new [name] pins an explicit session:
every MCP request from then on carries X-Ditto-Session-Id, and the name goes
out once as X-Ditto-Session-Name so the thread gets that title. Saves and
searches land in one thread inside the agent your key is attached to.
heyditto session new "refactor auth module" # prints the id and makes it active
heyditto save "Decided to keep JWT refresh in the gateway"
heyditto session current # the active id (exit 1 when none)
heyditto session list # local history, * marks the active one
heyditto session end # back to implicit sessions
heyditto session use 9e9a93c3 # reactivate by id or unique prefix
DITTO_SESSION_ID=<id> pins a session for one shell or script (it overrides the
saved one and never sends a name). Sessions are tracked locally in
~/.config/heyditto/cli/mcp-sessions.json; the server keeps the threads.
agentsList your Ditto agents (GET /api/v5/chat-agents): id, kind (main, chat,
inference_endpoint, mcp, connector), name, thread count, last activity and
the live connections (API keys, OAuth grants, endpoints) writing into each.
review — Ditto Review from the shellThe developer console's Review pages, as commands. Repository settings:
heyditto review repos --org omniaura # repositories set up for Ditto Review
heyditto review set ditto-assistant/console --max-minutes 20 --org omniaura
Findings on a pull request (its newest run), and acting on one. A finding is
named the way you meet it: by the GitHub review comment's URL
(…/pull/12#discussion_r<id>), by <run-id>:<finding-id>, or by a bare
finding id with --pr. Without --org the PR's repository is looked up in
your personal workspace and then in each organization you belong to.
heyditto review findings https://github.com/ditto-assistant/backend/pull/3158
heyditto review findings ditto-assistant/ditto-app#3163 --all --output json # include dismissed
# Managers: dismiss with a reason. Ditto replies on the GitHub thread, resolves
# it, and keeps the same issue off this PR on later reviews.
heyditto review dismiss "https://github.com/ditto-assistant/backend/pull/3112#discussion_r4171976544" \
--reason "Retrying with different arguments is the documented design (trace_test.go:106-115)."
heyditto review undismiss <run-id>:<finding-id>
# Any member: say whether a finding was useful, wrong or not useful.
heyditto review feedback "<comment-url>" wrong --note "The retry test covers different arguments."
Every action is recorded as the same signal the console records
(review_finding_feedback, review_finding_dismissals), so it feeds
false-positive learning; a plain GitHub reply does not. The key reaches the run
detail, feedback and dismiss routes only — not cancel, retry, the event stream
or posting a withheld finding.
Every heyditto claude / heyditto codex session is reachable from the Ditto
app by default: open the session's thread on your phone and the chat input
becomes the terminal's input. Text and attachments you send there are typed
into the harness on your machine; the harness's own slash commands, skills and
permission prompts work from the app too.
heyditto claude # remote-controllable (the default)
heyditto claude --no-remote-control # local only: never talks to the host bridge
heyditto codex --headless # no terminal UI; each app prompt runs one turn until Ctrl+C
heyditto claude --headless -p "start" # run one turn now, then keep taking turns from the app
How it works:
/api/v5/hosts/ws (host bridge protocol
v1.1), announces the session (session.announce) and its command catalog
(session.commands), and reconnects with backoff when the backend goes
away. The host id the backend assigns is kept in the CLI config so a
machine stays the same device across launches. A backend without the bridge,
or no network, never blocks the harness: remote control just stays off.@lydell/node-pty dependency, which ships prebuilt binaries for
macOS, Linux and Windows on x64/arm64 and runs no install scripts) and
mirrors it to your terminal. A prompt from the app is pasted into the
harness's input box (bracketed paste) and submitted; turn.interrupt sends
Esc (Claude Code) or Ctrl+C (Codex). Without a PTY module for your platform,
or outside a terminal, the launch falls back to a plain spawn and says why
remote control is off.--settings hooks (UserPromptSubmit, Stop,
Notification, PreToolUse for AskUserQuestion); Codex with
-c notify=[…]. Each hook runs dist/remote/hook.js, which writes one JSON
line to a Unix socket the CLI listens on. Stop / agent-turn-complete
mark turn.finished; if a harness never reports (older builds, builtin
commands that run no model turn), a quiet-screen fallback ends the turn.<cwd>/.tmp/ditto/attachments/<turnId>/
(size and sha256 verified, mode 0600). .tmp/ is added to the clone's
.git/info/exclude, never to .gitignore. The prompt the harness sees is
your text followed by Attached files: and the relative paths.turn.deliver {kind: "command"}): the catalog lists Claude
Code builtins, .claude/commands/** and ~/.claude/commands/**, skills from
.claude/skills and ~/.claude/skills, installed plugin skills; Codex
builtins, ~/.codex/prompts/*.md (as /prompts:<name>) and skills (as
$<name>). It is re-sent when those directories change. TUI mode types the
command; headless mode runs it through claude -p "/name args" --resume or
codex exec resume --last, and answers turn.finished {unsupported} for
TUI-only builtins.prompt.request / prompt.answer): a Claude Code permission
dialog or AskUserQuestion is forwarded to the app with its options; the
answer is typed back as the option's hotkey (or as text). Codex exposes no
hook for its approval dialogs, so those still need the keyboard.claude -p --resume <id> --output-format stream-json / codex exec resume --last per turn, prints a compact progress
line per event, and reports turn.finished {exitCode}. Ctrl+C finishes the
current turn, announces the session closed and revokes the session key.checkpoint.request runs the same push as heyditto teleport push and
answers checkpoint.done {generation}.forkStart a new session from a copy of an existing conversation.
heyditto fork <session-id> # copy the transcript under a new session id
heyditto fork <session-id> --worktree try-b # same, in <repo>/.worktrees/try-b on branch try-b
heyditto fork <session-id> --cloud # teleport the fork and resume it in Ditto Cloud
Claude Code transcripts are copied to a new uuid (session id fields rewritten,
and the project directory moved when the fork lives in a new worktree); Codex
rollouts are copied under a new thread id. The original stays untouched; the
fork is a normal local session (heyditto sessions, --resume <new-id>).
Worktrees, clones, package caches and agent traces pile up until a laptop runs out of disk. Teleport moves a coding project — one repo or a whole folder of repos, plus your Claude Code / Codex session — to Ditto Cloud, so you can resume it in the cloud or on another machine, and reclaim the local space. It is a Hero-tier ($20) feature.
A capsule is one teleportable root. Each push appends an immutable
generation; only content-addressed chunks (≤ 24 MiB, deduplicated) reach
storage, and unchanged chunks are never re-uploaded, so re-pushing a mostly
unchanged tree is cheap. Secrets never travel: .env*, key files and package
caches are excluded by construction.
heyditto teleport # push the current directory as a capsule
heyditto teleport --cloud --endpoint work # push, then resume in a Ditto Code cloud job
heyditto teleport push ~/code/project --mirror all
heyditto teleport pull project ~/code/project --restore-harness --resume
heyditto teleport list
heyditto teleport status project # mirror + verification state
heyditto teleport generations project # every committed generation
heyditto teleport targets # mirror targets, quota and capsule limit for your plan
Every teleport command accepts --json (or --output json). pull --json
prints {cwd, harnessSessionId, harnessKind, …}, which is what the Ditto Code
runner reads when it restores a capsule before starting the harness. Capsules
can be referred to by name or id everywhere. --endpoint for --cloud takes an
endpoint id, slug or name; with a single endpoint it is chosen automatically.
Under the hood a push negotiates which content-addressed chunks the server
lacks, uploads only those via presigned URLs, then commits the manifest (the
server answers 201 Created with the new generation and its mirror state).
Every branch's upstream (branchUpstreams) and the real remote-tracking shas
(upstreamTips) travel in the manifest, so a pull recreates remotes and
tracking refs without a network fetch and offload sees exactly the unpushed
commits the source machine saw. A push reports what actually moved, e.g.
Pushed generation 2: 1.2 KiB uploaded (2.0 MiB logical, 99.9% reused), 3 chunks (1 uploaded, 2 reused); --json adds uploadedBytes, logicalBytes,
reusedBytes and savingsRatio, and teleport --cloud --json prints a single
{ push, cloudSession } document. --cloud opens
the thread URL the backend returns for its linked app (falling back to the
production app link on older backends). pull --resume always resumes the
harness inside the restored tree (add --dry-run to see the launch plan), so
the next prompt lands in the restored transcript even when the original
directory still exists on the same machine. Restored Claude transcripts are
filed under Claude Code's own project slug for the destination path (every
non-alphanumeric character becomes -), so claude --resume finds them in
paths with underscores or dots such as /opt/workspace_base/capsule. macOS
AppleDouble ._* files and .DS_Store never enter the worktree archive. Worktrees compressed with zstd
are decompressed by Node itself when the zstd binary is missing; on a Node
without zstd support the pull fails with a message naming the binary to install.
push bundles each repo (thin against the previous generation when possible),
tars the dirty and untracked files, and captures the harness transcript for the
session that was working there. pull reconstructs the repos from their
bundles, restores branches, upstreams and the dirty worktree, and places the
harness transcript under the restored path so --resume continues the exact
session.
offload pushes the project, waits until the capsule is verified on redundant
mirrors, then removes the local copy. On macOS, project files move to Trash.
Recognized, excluded, untracked node_modules directories are deleted from
that Trash copy by default, so dependency bytes actually leave the disk.
--keep-dependencies retains them in Trash. Other caches remain in Trash until
their cleanup patterns have been confirmed. If the move to Trash fails, offload
stops without deleting the project. It refuses when a repo holds commits no
remote has, unless you pass --allow-unpushed.
heyditto offload ~/code/old-project # verify, confirm, delete
heyditto offload --yes # skip the confirmation
heyditto offload --keep-dependencies # preserve node_modules in Trash
Recover any time with heyditto teleport pull <capsule> <path>.
After pulling, reinstall Node dependencies that were removed during offload;
node_modules is not stored in the capsule.
Ditto stores capsules redundantly on its own storage. You can also bring your own S3-compatible bucket (AWS S3, Cloudflare R2, Backblaze B2, MinIO, Hippius) and mirror capsules to it — to all buckets or a chosen subset.
heyditto storage add --name my-r2 --endpoint https://<acct>.r2.cloudflarestorage.com \
--region auto --bucket ditto-teleport --access-key … --secret-key …
heyditto storage list
heyditto storage test my-r2 # name or id
heyditto storage remove my-r2
heyditto storage mirror project all # or: heyditto storage mirror project <id>,<id>
Buckets are managed through the teleport API (/api/v5/teleport/buckets), so the
saved CLI key is all you need. A bucket added with storage add is a teleport
mirror by default; pass --no-mirror to keep it out of mirror policies.
teleport pull and teleport --cloud need a committed generation: a capsule that
was created but whose push failed reports has no generations yet.
DITTO_API_KEY (optional) — MCP API key override. Agents can instead run heyditto init --json for no-human setup.DITTO_API_BASE (optional) — API base URL. Defaults to https://api.heyditto.ai. Useful for local dev (http://localhost:3400).DITTO_SESSION_ID (optional) — pin an explicit MCP session id for this shell (see session).DITTO_CONFIG_DIR (optional) — config directory for the saved key, default endpoint and session records. Defaults to $XDG_CONFIG_HOME/heyditto/cli or ~/.config/heyditto/cli.Every data command and status accepts --output <format>, where <format> is one of:
json — guaranteed structured JSON (parses the server text block, re-emits pretty-printed JSON).text — the server's text block as-is (the default; for data commands this is already JSON).markdown — same as text; reserved for future markdown rendering.raw — the full MCP response envelope as JSON.heyditto search "X" --output json | jq '.results[] | {id, similarity, preview: .userPreview}'
heyditto status --output json | jq '.tools'
@heyditto/mcp — local stdio MCP bridge with OAuth (different surface; pair with Claude Desktop / Cursor).just install
just check # tsc --noEmit
just build # tsc to dist/
just verify # check + build + pack --dry-run
Releases are automated via semantic-release on push to main. npm provenance is enabled — every published version is signed by the GitHub Actions OIDC identity. Trusted publishing is configured at the npm registry.
MIT — see LICENSE.
.ditto/).ditto/ is the versioned, discoverable contract a repository gives Ditto — endpoint
bindings, Teleport policy, environment and task settings — validated by the same
schema in the CLI, backend, web and desktop (vendored as src/dittoconfig/schema.json).
heyditto repo init # scaffold .ditto/config.toml + .ditto/mise.toml from detected projects
heyditto repo validate # exit 1 on any problem, naming the file and key
heyditto repo show # effective document with the layer each table came from
heyditto teleport plan [path] # what a push would capture, per project, with byte estimates
heyditto repo apply [--dry-run] # make your Router endpoints match .ditto/endpoints/*.toml
A .ditto/endpoints/<name>.toml is a Router profile checked into the repository:
model, routing, tools, and the Claude Code or Codex system prompt, which is read
from a file next to it. repository.default_endpoint in .ditto/config.toml
names the profile that heyditto claude / codex use when no --endpoint is
given, from anywhere inside the repository. --endpoint always wins.
# .ditto/endpoints/dev.toml
managed = true
name = "dev"
slug = "ditto-dev" # the endpoint slug within its owner
model = "openai/gpt-6.1-sol"
[settings]
owner = "@omniaura" # or "personal" (the default)
model_mode = "passthrough"
code_mode = true
kind_routes = { aside = "z-ai/glm-5.3-flash" }
claude_prompt = { file = "../prompts/claude.md", mode = "replace" }
owner = "@<org>" targets that organization's endpoint, so you must be a member
who can manage it. owner = "personal" creates the endpoint in your own account,
billed to you, so anyone who clones the repository gets the same setup.
heyditto repo apply creates the endpoint when it is missing and otherwise
changes only the fields that differ. Settings the file does not name, such as a
tool list curated in the console, are left alone. An unknown setting is an
error, not a no-op. Edit the prompt by editing its file and running
heyditto repo apply. heyditto endpoints set <slug> --claude-prompt @file
still works for a one-off change, but the next apply returns the endpoint to
what the repository says.
Settings: owner, claude_prompt / codex_prompt (file, mode,
autoupdate), system_prompt, model_mode, routing_mode, billing_mode,
stream_granularity, context_compaction, result_compression,
speculative_compaction, tool_compression, code_mode,
precompact_at_tokens, max_tool_rounds, memory_depth, recall, record,
record_trace, record_attachments, trace_retention_days, batch,
batch_max_requests, tools, tool_approval_mode, auto_approve_tools,
tool_deny, claude_native_tool_blocks, required_connections, kind_routes, model_routes,
subagent_routes, aliases, failover.
Failover is off unless explicitly enabled. For example, a repository profile can
set failover = { enabled = true, model = "openai/gpt-5.6-luna", max_cost_usd = 0.25 }.
The equivalent command is heyditto endpoints set <slug> --failover on --failover-model openai/gpt-5.6-luna --failover-max-cost 0.25 --yes.
It uses only the endpoint's permitted provider keys and billing mode. Switching
may refill the prompt cache, so the Router checks a conservative cold-cache quote
before sending the request. Missing pricing, an unbounded cost, or a quote above
the cap stops fallback. The chosen provider and model stay pinned for normal
turns and compaction, across backend restarts, until a new session (or seven days
of inactivity). The cap applies to each request on the fallback, not the session
total. Endpoint/key spend limits still apply separately. A session identifier is
required for fallback; Claude Code and Codex supply one automatically.
tool_deny lists router tools the endpoint never runs, whatever a client asks:
tool names, globs such as "gmail__send_*", or a class ("class:gated",
"class:write"). Denied tools are hidden from the model, and a call to one is
refused. On an organization endpoint, changing it needs endpoint policy
authority.
claude_native_tool_blocks = true writes each router tool call and its result
into Claude Code's own transcript (server_tool_use / mcp_tool_result), so
the router rebuilds earlier turns from the transcript instead of its memory, and
a deploy no longer loses them. Claude Code does not draw these blocks in its live
view; they appear in the session file and in tools that read it.
Layers: workspace .ditto/ (a parent folder of many repos) < repository .ditto/ <
ignored .ditto/local.toml < flags. Secrets are never literals: use secret://
references. Paths are repository-relative and cannot escape it.
teleport plan discovers repositories, worktrees and nested projects under a folder
(the folder itself need not be a repository), detects project types from a catalog
adapted from Kondo (MIT; detection and exclusion
knowledge only, never its cleanup), and applies regenerable-artifact exclusions per
project and path: a directory named build is only excluded under a project whose type
says so. Tracked artifact directories are flagged rather than claimed excluded.
heyditto offload refuses to delete a folder when unrelated files, unknown projects or
escaping symlinks beneath it would be lost.
heyditto claude keeps using Ditto Router for inference. --mcp changes
how tools are attached; it does not change the inference provider.
Use your native Claude Code account while attaching only the endpoint's selected MCP tools:
claude auth login
heyditto claude --mcp-only --endpoint my-tools
The CLI terminal bridge remains the default remote transport. The launch prints a direct Ditto chat link, and live launches are listed by harness in the app's Apps view, with Router or MCP-only labels and device presence. MCP-only launches are saved under Claude Code in Main Memory; the endpoint supplies tools with its existing deny rules and approvals. The endpoint credential is never used for native model inference. Missing MCP configuration fails without switching to Router inference.
For Claude Code's Channels research preview:
heyditto claude --mcp-only --endpoint my-tools --remote-transport channels
This attaches a launch-scoped local stdio MCP server declaring claude/channel
and explicitly selects it using Claude's development-channel flag. Claude shows
its own opt-in prompt; organization policy must also permit Channels. A regular
MCP tools connection alone does not enable inbound prompts. Keep a supported,
current Claude Code version and native account signed in.
The adapter pushes notifications/claude/channel with a turn ID. A transport
write is not a model receipt: the session stays awaiting receipt until Claude
calls acknowledge, and finishes only after reply. The reply is shown in the
remote composer. Native local conversation history remains in Claude Code;
this mode does not proxy model requests or mirror its entire transcript.
Channels supports prompt text and attachments. Use the CLI transport for slash commands, remote permission answers, interruption and Teleport checkpoints; Channels cannot perform those terminal operations. Senders authenticate through the same owned-session host bridge as CLI remote control. Redelivery of a turn ID does not inject a second prompt.
Claude Code launch defaults can be saved on an endpoint in the developer console or in a repository endpoint profile:
[settings]
claude_inference = "native" # native Claude account; "router" uses Ditto Router
claude_remote_transport = "channels" # "cli" uses the terminal bridge
heyditto claude reads the repository's default endpoint profile; --endpoint
selects the cloud profile directly. Repository launch settings override cloud
settings without requiring repo apply; repo apply also saves them to the
cloud. Explicit --mcp-only, --no-mcp-only, and --remote-transport flags
win for one launch. Resuming retains the previous session's choices. Channels
requires interactive native Claude Code, an eligible signed-in account and an
organization that allows Channels. The CLI attaches ditto-remote and adds the
development channel flag in one launch; Claude's experimental-channel
confirmation still appears. Router inference defaults to the CLI bridge.
Channel distribution and approval: Claude Code channel approval plan.
Ditto Memory CLI — save, search, fetch, and traverse the Ditto memory graph from the shell.
{ "mcpServers": { "heyditto-cli": { "command": "npx", "args": [ "-y", "@heyditto/[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
@heyditto/cli ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-14 Ditto Memory CLI — save, search, fetch, and traverse the Ditto memory graph from the shell.