Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
MCP_TOKENNoBearer token for the ZeroIDE MCP server

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

ZeroIDE MCP: hands on the owner's Windows PC, supervised from a tray app. The owner sees every call and may approve, refuse, pause or message you directly from the tray.

  • Pass a one-line note (in the owner's language) with every mutating call: it is shown on the approval card. A call with no note is harder to approve.

  • Pass a consistent short agent name (e.g. your role or task name like "Лендинг", "Backend", "Claude") across your calls so the tray distinguishes you from other parallel agents.

  • MANDATORY TASK TRACKING (task_status): Within your first 2 tool calls on any task, you MUST call task_status({ agent, status: "running", title, current, done, next }) so the PC owner sees what you are working on in the tray. Update task_status every 3–5 calls as steps move from next to current and done. When your task is finished, call task_status({ agent, status: "done", title, current: "Готово: ...", done, next: [] }) so the tray card turns green and stops the running animation.

  • STANDBY MODE (await_owner): Do NOT stall normal chats with a 5-minute wait unless EITHER (a) the owner asks you to wait in the tray, OR (b) task_status / journal_entry returns [HOLD_AFTER_TASK_ENABLED_BY_OWNER] (meaning the owner explicitly flipped the 'Hold 5 min' switch in the tray because they are controlling you from the tray/another PC). When [HOLD_AFTER_TASK_ENABLED_BY_OWNER] is returned, you MUST send your report via user_message and immediately call await_owner({ agent, summary: "...", waitMinutes: 5 }) instead of ending your turn in chat.

  • PROACTIVE OWNER MESSAGES (user_message): The PC owner watches the tray window (often without looking at the chat). Proactively call user_message({ agent, text, kind }) without waiting to be asked whenever: (1) you start a major stage (kind: "status"), (2) you finish a milestone or the task (kind: "status"), (3) you hit a warning or need the owner's attention (kind: "warning" or "request").

  • LIVE OWNER MESSAGES FROM TRAY ([ZEROIDE-OWNER-AUTH: ZIDE-13388B]): The PC owner (or a peer agent via agent_message) can message you live while you work. If a running run_command returns INTERRUPTED_BY_OWNER with a job_id, the command is still running in the background under that job_id while you read the owner's message. If a call returns PAUSED_BY_OWNER, the call was paused BEFORE execution so you could read the message first — follow the owner's instruction, acknowledge via user_message, update task_status, and if the paused call does not conflict with the message, simply call it again.

  • A DENIED result is the owner's decision: do not repeat the same call; explain and ask what to do instead.

  • run_command: anything that may take longer than ~20 s goes with wait=; then poll job_status (wait up to 50 s) and job_output. Output is capped at 30 KB; a truncated result carries a job_id, and job_output pages the full text.

  • Files: read_file before edit_file; prefer edit_file (exact fragment) to rewriting a file with write_file. Several fragments of one file go in ONE edit_file call via edits[] (all-or-nothing). Relative paths resolve against the project dir shown in results.

  • Copy / move / delete / mkdir: use file_ops instead of shell commands. Deleted and overwritten files go to the owner's undo history (the result carries change_id), so the owner can restore them from the tray. Shell deletes (Remove-Item -Recurse, rd /s, del /s) are flagged as high risk and usually wait for approval.

  • Starting on an unfamiliar PC: call system_info once (OS, shells, installed dev tools, project dir, what the owner pre-approved) instead of probing with several commands.

  • Images (screenshots of a design, photos of an error, generated charts): read_image returns them to you as an image; large ones are downscaled.

  • ZeroIDE protects itself: its config.env, tokens, OAuth and tray state files are not readable or writable by agents, and the tray control channel is off-limits. Do not try to work around it; ask the owner instead.

  • Risk: commands and file operations are scored (low/medium/high/critical). High-risk calls may wait for the owner even if the tool is normally allowed; critical ones (formatting disks, wiping system folders, disabling protection) always need a fresh click. Explain why in note.

  • When a result is ready to look at (a built page, a report, a folder), pass open to user_message: the owner gets an 'Open' button in the tray instead of hunting for the path.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
user_messageA

Show a short message to the PC owner in the tray (banner in the panel + icon tooltip; kind=request also pops a toast). PROACTIVELY call this to report key milestones, completion summaries, or questions/blockers — the PC owner watches the tray window directly. Display-only: nothing leaves the PC and nothing is executed. Pass open to hand over a result: the banner gets an Open button for that page, file or folder. Pass agent to identify yourself when multiple agents work in parallel. An empty text clears it.

task_statusA

MANDATORY on all multi-step tasks: register and update your current task in the tray (panel block + multi-agent tab + icon tooltip). Call within your first 2 tool calls with status: 'running', update every 3–5 calls so current, done and next always match reality, and when the task is complete MUST call with status: 'done' so the tray marks the task as completed (green check, stops progress animation) instead of leaving it looking like it is still running.

await_ownerA

Call at the end of a completed task (right after task_status({ status: 'done' })) to hold the MCP connection open for 5 minutes (default waitMinutes: 5) so the PC owner can send you follow-up instructions from the ZeroIDE tray even if they do not have access to the chat window. Uses 45-second keepalive pulses under the hood so cloud proxies never time out. If it returns STANDBY_KEEPALIVE, immediately call await_owner({ agent, continueStandby: true }) until either the owner sends a message (NEW_INSTRUCTION_FROM_OWNER) or the 5 minutes expire (STANDBY_TIMEOUT_COMPLETED / STANDBY_RELEASED_BY_OWNER).

agent_messageA

Send a live message/instruction to another working agent connected to this ZeroIDE MCP server (for example, when coordinating from another PC or another session), or list currently active agents and their tasks (action: 'list_agents'). When action: 'send' is used, if the target agent is currently executing run_command, its command is immediately backgrounded into a job_id (or stopped if stopCommand: true) and your message is delivered in <50ms; otherwise the target agent's very next tool call pauses at the gate with your message.

take_screenshotA

Capture the primary screen (1440px JPEG) and show it to the PC owner on a dedicated approval card with the exact preview image. The image leaves the PC ONLY if the owner approves (once or via a grant). Always asks unless an active grant exists. Pass a short "description" of why you need this screenshot: it is burned as a caption into the archived copy when the owner enabled screenshot archiving.

run_commandA

Run a bash command on this machine as the user who runs the server (that user's rights). Depending on the owner's permission settings a command may wait for approval in the tray or be refused. Default cwd is the project dir. Returns exit_code, status, duration_ms and separate stdout/stderr sections. Output is capped at maxOutputBytes (default 30 KB, head+tail kept, truncation is always reported; a truncated result includes a job_id, and job_output pages the full text). Set wait= to run long commands in background: you get a job_id immediately and poll it with job_status/job_output. Pass a unique requestId to make retries safe (a repeated requestId returns the cached result instead of running again).

job_statusA

Check the status of a background command started by run_command with wait=. Returns status (running/completed/timeout/failed), exit_code and duration. DO NOT poll in a tight loop. Pass waitSec (1-50): the server holds the answer until the job finishes or the time runs out, so one call replaces dozens. Pass tailLines to see the last lines of output and confirm real progress. Use job_output for the full log.

job_outputA

Fetch output of a background job, or of a finished run_command whose result was truncated (it reports a job_id). Supports paging through large output with offsetBytes/maxBytes, so nothing is lost even for very long build logs.

read_fileA

Read a UTF-8 text file on this computer. Supports partial reads via startLine/endLine and a maxBytes cap (default 200 KB) so large files never flood the context. Returns size, total line count and sha256 (pass that sha256 back to write_file/edit_file as expectedSha256 for safe concurrent edits). Binary files are detected and refused.

list_directoryA

List files and folders on this computer with size and mtime. Supports depth (recursive listing) and a result limit. Heavy folders (node_modules, .git, dist, build, ...) are skipped when recursing unless includeIgnored is true.

search_filesA

Search text in one file or across the files of a folder on this computer (path may point to either). Returns file:line matches with optional surrounding context. Heavy folders (node_modules, .git, dist, build, ...) are excluded by default, binary files are skipped. Use include ('*.ts') to narrow by file mask and regex=true for regular expressions. Always reports the true match count.

write_fileA

Write a UTF-8 text file on this computer ATOMICALLY (temp file + rename, so a dropped connection never leaves a half-written file). Creates or overwrites the file. Pass expectedSha256 (from read_file) to refuse the write if the file changed meanwhile — this prevents silently overwriting work done by another agent in parallel. The previous version is kept in ZeroIDE history (not next to the file), so the owner can undo the change in Settings → Changes; backup=false skips that. Use dryRun=true to preview a diff without writing.

edit_fileA

Replace exact text fragments in a file instead of rewriting the whole file. One edit: oldString/newString. Several edits in one atomic change: edits=[{oldString,newString,replaceAll?}] — applied in order, all or nothing. Refuses an edit whose oldString is not found or found more than once (unless replaceAll), so it can never patch the wrong place. Supports expectedSha256 (safe concurrent editing) and dryRun preview; the previous version is kept in ZeroIDE history for undo. Write is atomic.

read_imageA

Look at an image file on this PC (PNG, JPEG, GIF, BMP, ICO, WebP): returns the picture itself, so you can check screenshots, UI renders, charts or photos the owner points you to. Large images are downscaled on the PC (maxSize, default 1600 px on the longer side; the file itself is not changed). Same folder rules as read_file; the owner may require approval because the picture leaves the PC.

file_opsA

Copy, move/rename or delete files and folders, or create a folder, without a shell. delete never destroys data: the files move to ZeroIDE history and the owner can restore them in Settings → Changes. Anything replaced with overwrite=true keeps its previous version too. Prefer this to Remove-Item/Move-Item in run_command: it is reversible and the owner sees exactly what changes.

system_infoA

One read-only call for the context you would otherwise gather with several commands: Windows version, CPU, memory, disks, displays, user, time zone, PowerShell and installed developer tools (node, npm, python, git, dotnet, java, go, rust, docker, winget). It also says how ZeroIDE is set up for you right now: project folder, folder confinement, your access scope, which tools run freely, ask the owner first or are disabled, active temporary grants and where undo history is kept. Call it once at the start of a task.

audit_logA

Read the MCP audit trail: who (which session) ran which command or edited which file, when, and with what exit code. USE THIS FIRST when something broke, when a file looks unexpectedly changed, or when you suspect another agent worked in parallel. Filters: onlyErrors, tool, contains, sinceMinutes.

journal_entryA

Write to the agent journal the outcome of a finished chunk of work. summary — 2-4 sentences: what and why. outcome — done/failed/partial/reverted. next — what is left (optional). commit — git hash, if the work produced a commit (optional). refs — arbitrary references (optional). The server itself attaches all audit entries of the SAME session since the previous journal entry of that same session (or since the start of the connection, if there was no entry yet) — there is no need to find and specify the range manually. If you are explicitly continuing an interrupted task from another (older) session, pass continuesFromSeq — seq of the last accounted audit entry, so its tail is not lost.

journal_logA

Read the agent journal: what was done (summary), with what outcome (outcome), what is left (next), and which range of audit entries was attached automatically to each entry. Use at the start of work to quickly grasp recent context without reading the full audit_log.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4/5.0

Scored across 19 tools

Disambiguation4/5

Each tool targets a distinct resource+action: file ops (read/write/edit/list/search/ops), command execution (run_command/job_status/job_output), and observability (audit_log/journal_entry/journal_log) are cleanly separated. The only soft overlap is in the 'communicate with the human/agents' cluster — user_message vs task_status both render in the tray, and agent_message vs await_owner both concern messaging — but the descriptions make the boundaries clear.

Naming Consistency4/5

Everything is uniformly snake_case with no camelCase or casing drift, which is a strong baseline. However the style mixes verb_first action names (run_command, read_file, take_screenshot, list_directory) with noun_phrase resource names (task_status, agent_message, job_status, system_info, audit_log), so it misses a single predictable verb_noun pattern.

Tool Count4/5

19 tools is at the upper edge of the ideal range but each group earns its place: file CRUD, shell exec + background job management, human/agent messaging, and audit/journal observability. Nothing looks redundant or filler, though it is on the heavier side of well-scoped.

Completeness4/5

Coverage is unusually thorough for an agent control plane: full file lifecycle (read/write/edit/delete/list/search/image), command execution with background jobs and paged output, owner and agent messaging, and audit+journal history. Minor gaps remain (no dedicated job-cancel/kill tool — it is only reachable via agent_message stopCommand — and no first-class git operations), but agents can work around these.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues