@zergai/ztc 0.9.0-beta.1 → 0.10.0-beta.1

package/dist/mcp/workspace_server.js

@@ -0,0 +1,403 @@
+/**
+ * `ztc workspace-mcp` — the MCP server attached to Claude Code and Codex panes.
+ *
+ * The CLI starts it from its session-scoped MCP config (see panes/agent_cli.ts).
+ * It reaches this workspace through the pane relay ($ZTC_PANE_RELAY) as pane
+ * $ZTC_PANE_ID, and gives the agent the workspace: list panes; open a ZTC
+ * agent, Claude Code, Codex or a shell; read a pane; type into one; message
+ * another agent; close a pane. Messages travel over ZTC's bus when the mirror
+ * is reachable, so ZTC panes receive them as messages from this pane;
+ * otherwise they are typed in with the sender's name.
+ */
+import { request } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { childZtcPaneEnv, closeTerminalPaneTool, listWorkspacePanes, readTerminalPaneTool, setPaneToolsOwnId, setPaneToolsTuiProcess, waitForPaneCreatedOrError, writeTerminalPaneTool, } from '../agent/tools/pane.js';
+import { AGENT_CLIS, findAgentCli, nextPaneTitle, workspaceMcpProgram } from '../panes/agent_cli.js';
+import { TYPED_ENTER_DELAY_MS, formatAgentPaneMessage, openAgentPane } from '../panes/agent_panes.js';
+import { sessionNamePaneTitle } from '../panes/labels.js';
+import { buildZtcPaneLaunchCommand, createZtcLaunchSpec } from '../panes/ztc_launch.js';
+import { PaneRelayClient } from '../ui/ratatui/pane_relay.js';
+import { buildUserSubprocessEnvOverrides } from '../utils/subprocess_env.js';
+import { getVersion } from '../utils/version.js';
+const PANE_REF = {
+    description: 'The pane: its id, or its name as list_panes shows it.',
+    anyOf: [{ type: 'integer', minimum: 0 }, { type: 'string', minLength: 1 }],
+};
+const TOOLS = [
+    {
+        name: 'list_panes',
+        description: 'List the panes in this ZTC workspace: each pane\'s id, name and kind (ZTC agent, terminal, document), and which one is yours. Pane ids and names work in every other ztc tool.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    },
+    {
+        name: 'open_pane',
+        description: 'Open a new pane in this ZTC workspace: a ZTC agent ("ztc"), Claude Code ("claude"), Codex ("codex") or a shell ("shell"). Claude Code and Codex run the user\'s own installed CLI on the user\'s own account, with these same ztc tools. Give a task to start an agent working on it at once. Returns the new pane\'s id.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kind: { type: 'string', enum: ['ztc', 'claude', 'codex', 'shell'], description: 'What runs in the pane.' },
+                task: { type: 'string', description: 'For an agent pane: its first message. Ignored for a shell.' },
+                name: { type: 'string', description: 'Name for the pane. Defaults to "ZTC", "Claude Code", "Codex" or "Shell", numbered when taken.' },
+                cwd: { type: 'string', description: 'Working directory. Defaults to yours.' },
+                placement: { type: 'string', enum: ['right', 'below', 'tab'], description: 'Next to your pane (right or below) or in a new tab. Defaults to the workspace\'s layout.' },
+            },
+            required: ['kind'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'read_pane',
+        description: 'Read a pane\'s recent output: its scrollback, or just what is on screen with viewport=true.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pane: PANE_REF,
+                lines: { type: 'integer', minimum: 1, maximum: 2000, description: 'Lines of scrollback (default 200).' },
+                viewport: { type: 'boolean', description: 'Read exactly what is visible instead.' },
+            },
+            required: ['pane'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'type_into_pane',
+        description: 'Type text into a pane as keystrokes, then press Enter unless submit is false. Use it to run a command in a shell pane or answer a prompt on screen. To talk to another agent prefer send_message, which says who the message is from.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pane: PANE_REF,
+                text: { type: 'string', minLength: 1 },
+                submit: { type: 'boolean', description: 'Press Enter after the text (default true).' },
+            },
+            required: ['pane', 'text'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'send_message',
+        description: 'Send a message to another pane\'s agent, or "all" for every ZTC agent. ZTC agents receive it as a message from you; Claude Code and Codex panes see it typed in with your pane\'s name. Replies come back to you the same way: typed into your input, starting "[Message from …]".',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                to: { description: 'A pane id or name, or "all".', anyOf: [{ type: 'integer', minimum: 0 }, { type: 'string', minLength: 1 }] },
+                text: { type: 'string', minLength: 1 },
+            },
+            required: ['to', 'text'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'close_pane',
+        description: 'Close a pane and stop its program. Your own pane cannot be closed this way.',
+        inputSchema: { type: 'object', properties: { pane: PANE_REF }, required: ['pane'], additionalProperties: false },
+    },
+];
+class ToolError extends Error {
+}
+const KIND_LABELS = { ztc: 'ZTC', process: 'terminal', command: 'terminal', doc: 'document', feed: 'feed' };
+function paneName(pane) {
+    return pane.labels?.manual_title || pane.title;
+}
+function normalizedName(name) {
+    return name.trim().replace(/^\[[^\]]+\]\s+/, '').toLowerCase();
+}
+function placementOf(value, ownPaneId) {
+    if (value === 'tab')
+        return { newWindow: true };
+    const direction = value === 'right' ? 'horizontal' : value === 'below' ? 'vertical' : undefined;
+    if (!direction)
+        return {};
+    return ownPaneId === null ? { direction } : { direction, target: ownPaneId };
+}
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** The MCP server, connected to a workspace through `transport`. */
+export function createWorkspaceMcpServer(options) {
+    const { transport, ownPaneId } = options;
+    const env = options.env ?? process.env;
+    if (transport) {
+        setPaneToolsTuiProcess(transport);
+        if (ownPaneId !== null)
+            setPaneToolsOwnId(ownPaneId);
+    }
+    const workspace = () => {
+        if (!transport || !transport.isMuxMode) {
+            throw new ToolError('This session is not running in a ZTC workspace pane, so there are no panes to work with. Open it from ZTC (/claude or /codex, or the new-pane menu).');
+        }
+        return transport;
+    };
+    const panes = async () => {
+        const listed = await listWorkspacePanes(workspace());
+        if (listed instanceof Error)
+            throw new ToolError(listed.message.replace(/^Error: /, ''));
+        return listed;
+    };
+    const findPane = async (ref) => {
+        const all = await panes();
+        if (typeof ref === 'number' || (typeof ref === 'string' && /^\d+$/.test(ref.trim()))) {
+            const id = Number(ref);
+            const pane = all.find(candidate => candidate.id === id);
+            if (!pane)
+                throw new ToolError(`There is no pane ${id}. Panes: ${all.map(p => `[${p.id}] ${paneName(p)}`).join(', ')}.`);
+            return pane;
+        }
+        const wanted = normalizedName(String(ref ?? ''));
+        const others = all.filter(pane => pane.id !== ownPaneId);
+        const matches = others.filter(pane => normalizedName(paneName(pane)) === wanted);
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1) {
+            throw new ToolError(`${matches.length} panes are named "${String(ref)}" (${matches.map(pane => pane.id).join(', ')}); use a pane id.`);
+        }
+        throw new ToolError(`No pane is named "${String(ref)}". Panes: ${others.map(p => `[${p.id}] ${paneName(p)}`).join(', ') || 'none besides yours'}.`);
+    };
+    const ownName = async () => {
+        if (ownPaneId === null)
+            return 'an agent';
+        const own = (await panes()).find(pane => pane.id === ownPaneId);
+        return own ? paneName(own) : `pane ${ownPaneId}`;
+    };
+    /** Type into a pane the way its program reads input. */
+    const typeInto = async (pane, text, submit) => {
+        if (pane.pane_type === 'ztc') {
+            return String(await writeTerminalPaneTool.execute({ pane_id: pane.id, input: text, submit }));
+        }
+        const typed = String(await writeTerminalPaneTool.execute({ pane_id: pane.id, input: text, submit: false }));
+        if (!submit)
+            return typed;
+        await delay(TYPED_ENTER_DELAY_MS);
+        await writeTerminalPaneTool.execute({ pane_id: pane.id, input: '\r', submit: false });
+        return `Typed into ${paneName(pane)} (pane ${pane.id}) and pressed Enter.`;
+    };
+    const openZtcPane = async (args, cwd) => {
+        const tui = workspace();
+        const titles = (await panes()).map(paneName);
+        const title = typeof args.name === 'string' && args.name.trim() ? args.name.trim() : nextPaneTitle('ZTC', titles);
+        const spec = createZtcLaunchSpec({ cwd, title });
+        // This process was started as `workspace-mcp`; the child is a ZTC session.
+        const built = buildZtcPaneLaunchCommand(spec, process.argv.slice(0, 2));
+        if (built instanceof Error)
+            throw new ToolError(built.message.replace(/^Error: /, ''));
+        const task = typeof args.task === 'string' ? args.task.trim() : '';
+        const requestId = `ztc-pane-${randomUUID()}`;
+        const created = waitForPaneCreatedOrError(tui, { requestId }, 15000);
+        const placement = placementOf(args.placement, ownPaneId);
+        const sent = tui.send({
+            type: 'create_pane',
+            request_id: requestId,
+            command: built.command,
+            args: task ? [...built.args, '--', task] : built.args,
+            cwd: built.cwd || cwd,
+            title,
+            pane_type: 'ztc',
+            ...(placement.direction ? { direction: placement.direction, ratio: 0.5 } : {}),
+            ...(placement.target !== undefined ? { target: placement.target } : {}),
+            ...(placement.newWindow ? { new_window: true } : {}),
+            env: childZtcPaneEnv(),
+        });
+        if (!sent) {
+            created.catch(() => { });
+            throw new ToolError('The ZTC pane could not be requested: the workspace is not connected.');
+        }
+        const event = await created;
+        if (event.type === 'error')
+            throw new ToolError(`The workspace refused the pane: ${event.message}`);
+        if (event.type !== 'pane_created')
+            throw new ToolError('Unexpected response from the workspace.');
+        tui.send(sessionNamePaneTitle(event.pane_id, title));
+        return `Opened ZTC agent "${title}" in pane ${event.pane_id} (${cwd})${task ? ' with its task' : ''}.`;
+    };
+    const openShellPane = async (args, cwd) => {
+        const tui = workspace();
+        const titles = (await panes()).map(paneName);
+        const title = typeof args.name === 'string' && args.name.trim() ? args.name.trim() : nextPaneTitle('Shell', titles);
+        const requestId = `create-shell-${randomUUID()}`;
+        const created = waitForPaneCreatedOrError(tui, { requestId }, 15000);
+        const placement = placementOf(args.placement, ownPaneId);
+        const sent = tui.send({
+            type: 'create_pane',
+            request_id: requestId,
+            command: env.SHELL || '/bin/sh',
+            args: [],
+            cwd,
+            title,
+            pane_type: 'process',
+            ...(placement.direction ? { direction: placement.direction, ratio: 0.5 } : {}),
+            ...(placement.target !== undefined ? { target: placement.target } : {}),
+            ...(placement.newWindow ? { new_window: true } : {}),
+            env: buildUserSubprocessEnvOverrides(),
+        });
+        if (!sent) {
+            created.catch(() => { });
+            throw new ToolError('The shell pane could not be requested: the workspace is not connected.');
+        }
+        const event = await created;
+        if (event.type === 'error')
+            throw new ToolError(`The workspace refused the pane: ${event.message}`);
+        if (event.type !== 'pane_created')
+            throw new ToolError('Unexpected response from the workspace.');
+        tui.send(sessionNamePaneTitle(event.pane_id, title));
+        return `Opened a shell "${title}" in pane ${event.pane_id} (${cwd}).`;
+    };
+    const handlers = {
+        list_panes: async () => {
+            const all = await panes();
+            if (all.length === 0)
+                return 'The workspace has no panes.';
+            return all
+                .slice()
+                .sort((a, b) => a.id - b.id)
+                .map(pane => {
+                const notes = [
+                    pane.id === ownPaneId ? 'you' : '',
+                    pane.is_focused ? 'focused' : '',
+                    pane.is_alive ? '' : 'exited',
+                ].filter(Boolean);
+                return `[${pane.id}] ${paneName(pane)} (${KIND_LABELS[pane.pane_type] ?? pane.pane_type})${notes.length ? ` — ${notes.join(', ')}` : ''}`;
+            })
+                .join('\n');
+        },
+        open_pane: async (args) => {
+            const kind = String(args.kind ?? '');
+            const cwd = typeof args.cwd === 'string' && args.cwd.trim() ? args.cwd.trim() : (options.cwd ?? process.cwd());
+            if (kind === 'ztc')
+                return openZtcPane(args, cwd);
+            if (kind === 'shell')
+                return openShellPane(args, cwd);
+            if (kind !== 'claude' && kind !== 'codex')
+                throw new ToolError('kind must be "ztc", "claude", "codex" or "shell".');
+            const task = typeof args.task === 'string' ? args.task.trim() : '';
+            const result = await openAgentPane(workspace(), {
+                cli: kind,
+                request: task ? { words: [], prompt: task } : { words: [] },
+                cwd,
+                ...(typeof args.name === 'string' && args.name.trim() ? { title: args.name.trim() } : {}),
+                ...placementOf(args.placement, ownPaneId),
+                findBinary: options.findBinary ?? findAgentCli,
+                server: options.server === undefined ? workspaceMcpProgram(process.argv.slice(0, 2)) : options.server,
+                env,
+            });
+            if (result.error)
+                throw new ToolError(result.error);
+            const opened = `Opened ${result.title ?? AGENT_CLIS[kind].label} in pane ${result.paneId} (${cwd})${task ? ' with its task' : ''}.`;
+            return result.notice ? `${opened} ${result.notice}` : opened;
+        },
+        read_pane: async (args) => {
+            const pane = await findPane(args.pane);
+            return String(await readTerminalPaneTool.execute({
+                pane_id: pane.id,
+                ...(args.lines !== undefined ? { lines: args.lines } : {}),
+                ...(args.viewport === true ? { viewport: true } : {}),
+            }));
+        },
+        type_into_pane: async (args) => {
+            const pane = await findPane(args.pane);
+            const text = String(args.text ?? '');
+            if (!text)
+                throw new ToolError('text is required.');
+            return typeInto(pane, text, args.submit !== false);
+        },
+        send_message: async (args) => {
+            const text = String(args.text ?? '').trim();
+            if (!text)
+                throw new ToolError('text is required.');
+            const from = { id: ownPaneId ?? -1, name: await ownName() };
+            const broadcast = typeof args.to === 'string' && args.to.trim().toLowerCase() === 'all';
+            const target = broadcast ? null : await findPane(args.to);
+            if (options.bus) {
+                await options.bus.send({ from, to: target ? target.id : 'all', type: 'ztc_message', text });
+                return target ? `Message sent to ${paneName(target)} (pane ${target.id}).` : 'Message sent to every ZTC agent.';
+            }
+            if (!target)
+                throw new ToolError('Sending to "all" needs ZTC\'s message bus, which this pane cannot reach; send to one pane at a time.');
+            await typeInto(target, formatAgentPaneMessage({ from, text }), true);
+            return `Message typed into ${paneName(target)} (pane ${target.id}).`;
+        },
+        close_pane: async (args) => {
+            const pane = await findPane(args.pane);
+            if (pane.id === ownPaneId)
+                throw new ToolError('That is your own pane; the user can close it, or you can exit.');
+            return String(await closeTerminalPaneTool.execute({ pane_id: pane.id }));
+        },
+    };
+    const server = new Server({ name: 'ztc', version: getVersion() }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS.map(tool => ({ ...tool })) }));
+    server.setRequestHandler(CallToolRequestSchema, async (call) => {
+        const handler = handlers[call.params.name];
+        if (!handler)
+            return { content: [{ type: 'text', text: `Unknown tool ${call.params.name}.` }], isError: true };
+        try {
+            const text = await handler((call.params.arguments ?? {}));
+            return { content: [{ type: 'text', text }], isError: /^Error\b/.test(text) };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: message.replace(/^Error: /, '') }], isError: true };
+        }
+    });
+    return server;
+}
+/** Posts bus messages to the overseer's mirror, as MirrorClient does, without joining the bus. */
+export function mirrorBusSender(env = process.env) {
+    const port = Number(env.ZTC_MIRROR_PORT);
+    const token = env.ZTC_MIRROR_INTERNAL_TOKEN;
+    if (!Number.isInteger(port) || port <= 0 || !token)
+        return null;
+    const group = env.ZTC_MIRROR_GROUP?.trim();
+    return {
+        send: message => new Promise((resolve, reject) => {
+            const body = JSON.stringify(message);
+            const req = request({
+                hostname: 'localhost',
+                port,
+                path: group ? `/bus/send/${group}` : '/bus/send',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                    'x-ztc-internal-token': token,
+                },
+            }, res => {
+                let text = '';
+                res.on('data', (chunk) => { text += chunk.toString(); });
+                res.on('end', () => {
+                    if (res.statusCode === 200)
+                        resolve();
+                    else
+                        reject(new ToolError(`ZTC's message bus refused the message (HTTP ${res.statusCode}): ${text.slice(0, 200)}`));
+                });
+            });
+            req.on('error', error => reject(new ToolError(`ZTC's message bus is unreachable: ${error.message}`)));
+            req.end(body);
+        }),
+    };
+}
+/** Entry point for `ztc workspace-mcp`: serve on stdio until the CLI closes it. */
+export async function runWorkspaceMcpServer(env = process.env) {
+    let relay = null;
+    if (env.ZTC_PANE_RELAY) {
+        relay = new PaneRelayClient(env.ZTC_PANE_RELAY);
+        try {
+            await relay.connect();
+        }
+        catch (error) {
+            process.stderr.write(`ztc workspace-mcp: cannot reach this workspace (${error.message}); its tools will say so.\n`);
+            relay = null;
+        }
+    }
+    const paneId = Number(env.ZTC_PANE_ID);
+    const server = createWorkspaceMcpServer({
+        transport: relay,
+        ownPaneId: Number.isSafeInteger(paneId) && paneId >= 0 ? paneId : null,
+        bus: mirrorBusSender(env),
+        env,
+    });
+    const stdio = new StdioServerTransport();
+    const closed = new Promise(resolve => { stdio.onclose = () => resolve(); });
+    await server.connect(stdio);
+    process.stdin.on('end', () => { void server.close(); });
+    await closed;
+    relay?.disconnect();
+}

package/dist/panes/agent_cli.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Agent CLIs that run in ZTC panes under the user's own accounts.
+ *
+ * ZTC hosts Claude Code and Codex the way a terminal does: it runs the user's
+ * own, unmodified `claude` or `codex` binary in a pane, and the user signs in
+ * through that CLI's own flow. ZTC never reads, stores or forwards their
+ * credentials. (Anthropic's terms for Claude subscription sign-in:
+ * https://code.claude.com/docs/en/legal-and-compliance.)
+ *
+ * What ZTC adds is a session-scoped MCP server, `ztc workspace-mcp`, passed on
+ * the command line (Claude Code `--mcp-config`, Codex `-c mcp_servers.ztc.*`),
+ * so the agent can list, open, read, type into, message and close the other
+ * panes of the workspace. The user's own CLI configuration is never edited.
+ */
+export type AgentCliId = 'claude' | 'codex';
+export interface AgentCliSpec {
+    id: AgentCliId;
+    /** What the pane is called and what the chooser shows. */
+    label: string;
+    /** The executable's name on PATH. */
+    binary: string;
+    /** The vendor's install page. */
+    setupUrl: string;
+    /** One install command from that page. */
+    install: string;
+}
+export declare const AGENT_CLIS: Readonly<Record<AgentCliId, AgentCliSpec>>;
+export declare const AGENT_CLI_IDS: readonly AgentCliId[];
+export declare function isAgentCliId(value: string): value is AgentCliId;
+export interface BinaryLookup {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    platform?: NodeJS.Platform;
+    /** Shared bin directories checked after PATH and the user's own. */
+    systemDirs?: readonly string[];
+}
+/** The absolute path of the user's `claude` or `codex`, or null when it is not installed. */
+export declare function findAgentCli(id: AgentCliId, lookup?: BinaryLookup): string | null;
+export declare class CliArgumentsError extends Error {
+    constructor(message: string);
+}
+/**
+ * Split words the way a POSIX shell does, without expanding anything: quotes
+ * group, a backslash escapes, and `$`, backticks, globs and `;` stay literal.
+ */
+export declare function splitCliArguments(raw: string): string[];
+/** Words as a shell would accept them back: quoted only where needed. */
+export declare function formatCliArguments(words: readonly string[]): string;
+/** What to start the CLI with: its own flags, an opening prompt, or both. */
+export interface AgentLaunchRequest {
+    words: string[];
+    prompt?: string;
+}
+/**
+ * Read the text after `/claude` or `/codex`. Text that starts with a flag is
+ * the CLI's own arguments, split like a shell command line (`/claude
+ * --continue`, `/codex -m gpt-5 "review this"`). Anything else is the opening
+ * prompt, kept exactly as typed, apostrophes and all (`/claude don't touch the
+ * migrations`).
+ */
+export declare function parseAgentCommandBody(body: string): AgentLaunchRequest;
+export interface PaneProgram {
+    command: string;
+    args: string[];
+}
+export declare const WORKSPACE_MCP_SERVER_NAME = "ztc";
+/**
+ * Variables the workspace server reads. Codex starts MCP servers with a short
+ * allowlist of variables, so these are named for it to forward; Claude Code
+ * passes its whole environment. They reach the pane through its environment,
+ * never its command line.
+ */
+export declare const WORKSPACE_MCP_ENV: readonly string[];
+/** The CLI's own arguments that attach the workspace server, or nothing without one. */
+export declare function workspaceMcpArgs(id: AgentCliId, server: PaneProgram | null): string[];
+/**
+ * The CLI's full argument list. Codex takes its overrides first, before any
+ * subcommand. Claude Code's `--mcp-config` takes several values, so it goes
+ * after the user's flags, ahead of a `--` they typed, and a prompt follows its
+ * own `--` so a prompt starting with "-" is never read as a flag.
+ */
+export declare function agentCliArgs(id: AgentCliId, request: AgentLaunchRequest, server: PaneProgram | null): string[];
+/**
+ * Run the binary from a login shell, as custom panes are, so PATH and the rest
+ * of the login environment apply. The binary and its arguments travel as
+ * separate argv entries (`exec "$0" "$@"`): no shell ever re-parses them, so
+ * quotes, `$` and `;` in a prompt arrive exactly as written. A shell outside
+ * the POSIX family (fish, nushell), or no shell at all, is replaced by /bin/sh
+ * for this one step.
+ */
+export declare function loginShellExec(binary: string, args: readonly string[], shell: string | undefined, platform?: NodeJS.Platform): PaneProgram;
+/** "Claude Code", then "Claude Code 2", "Claude Code 3"… so every pane name stays unique. */
+export declare function nextPaneTitle(label: string, existing: readonly string[]): string;
+/**
+ * The pane's environment overrides: ZTC's control variables are cleared as for
+ * any user program, except what the workspace server needs to reach this
+ * workspace. Everything else is the user's own environment, untouched, so the
+ * CLI offers every sign-in method it normally would.
+ */
+export declare function agentPaneEnv(source?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * How to start `ztc workspace-mcp` from the running installation: the desktop
+ * app's own launcher, or this Node and entrypoint.
+ */
+export declare function workspaceMcpProgram(argv?: readonly string[]): PaneProgram | Error;