hammerkit 1.26.0 → 1.27.0-next.10

package/dist/harness/connect.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHarnessEnvironment = exports.connectSandbox = exports.harnessOptionsFromEnv = exports.DEFAULT_SHELL_TASK = void 0;
+const get_file_context_1 = require("../file/get-file-context");
+const log_1 = require("../log");
+const work_item_status_1 = require("../planner/work-item-status");
+const host_config_1 = require("../remote/host-config");
+const redact_1 = require("../utils/redact");
+const empty_writable_1 = require("../utils/empty-writable");
+const token_source_1 = require("../remote/token-source");
+const bundle_1 = require("../remote/bundle");
+const sandbox_client_1 = require("./sandbox-client");
+exports.DEFAULT_SHELL_TASK = 'sh';
+// The same settings as variables, for harnesses that load hammerkit as a plugin.
+function harnessOptionsFromEnv(env) {
+    const value = (name) => (env[name] && env[name]?.trim()) || undefined;
+    return {
+        server: value('HAMMERKIT_SERVER'),
+        sandbox: value('HAMMERKIT_SANDBOX'),
+        repo: value('HAMMERKIT_REPO'),
+        ref: value('HAMMERKIT_REF'),
+        build: value('HAMMERKIT_BUILD'),
+        shell: value('HAMMERKIT_SHELL'),
+    };
+}
+exports.harnessOptionsFromEnv = harnessOptionsFromEnv;
+async function connectSandbox(environment, options, log = () => undefined) {
+    const config = await (0, host_config_1.readHostConfig)(environment);
+    const name = options.server ?? config.run.on;
+    if (!name || !(0, host_config_1.hasServer)(config.servers, name)) {
+        throw new Error(options.server
+            ? `server ${options.server} is not registered, add it with: hammerkit remote add ${options.server} <url> --issuer <url>`
+            : 'name a server (HAMMERKIT_SERVER or --server), or set a default with: hammerkit remote use <name>');
+    }
+    if (!options.build) {
+        throw new Error('name the published version of the build file whose tasks run on the sandbox by its hash (HAMMERKIT_BUILD or --build), as hammerkit remote publish printed it');
+    }
+    // a run names exactly the version it runs, there is no name that follows the latest one
+    if (!bundle_1.HASH_PATTERN.test(options.build)) {
+        throw new Error(`${options.build} is not the hash of a published version (sha256:...), name it as hammerkit remote publish printed it (HAMMERKIT_BUILD or --build)`);
+    }
+    const server = config.servers[name];
+    const connection = { url: server.url, ...(0, token_source_1.getTokenSource)(environment, name, server) };
+    let sandbox;
+    if (options.sandbox) {
+        sandbox = await sandbox_client_1.SandboxClient.get(connection, options.sandbox);
+    }
+    else if (options.repo && options.ref) {
+        sandbox = await reuseSandbox(connection, options.repo, options.ref);
+        if (sandbox) {
+            log(`took sandbox ${sandbox.id} of ${sandbox.repo} at ${sandbox.commit} on ${name}, it had no changes`);
+        }
+        else {
+            sandbox = await sandbox_client_1.SandboxClient.create(connection, options.repo, options.ref);
+            log(`created sandbox ${sandbox.id} of ${sandbox.repo} at ${sandbox.commit} on ${name}, ` +
+                `set HAMMERKIT_SANDBOX=${sandbox.id} to come back to it`);
+        }
+    }
+    else {
+        throw new Error('name a sandbox (HAMMERKIT_SANDBOX or --sandbox), or a repository and ref to create one from (HAMMERKIT_REPO and HAMMERKIT_REF, or --repo and --ref)');
+    }
+    return new sandbox_client_1.SandboxClient(connection, sandbox, { hash: options.build, shell: options.shell ?? exports.DEFAULT_SHELL_TASK });
+}
+exports.connectSandbox = connectSandbox;
+// A client that starts with a repository and ref takes a sandbox of the caller's of the same
+// that nobody changed and no run holds, checked out at the ref again, rather than creating
+// one on every start: sandboxes stay until they are deleted, and only a few are allowed.
+async function reuseSandbox(connection, repo, ref) {
+    const build = { hash: '', shell: exports.DEFAULT_SHELL_TASK };
+    for (const candidate of await sandbox_client_1.SandboxClient.list(connection)) {
+        if (candidate.repo !== repo || candidate.ref !== ref || candidate.busy) {
+            continue;
+        }
+        const changes = await new sandbox_client_1.SandboxClient(connection, candidate, build).changes();
+        if (changes.files.length === 0) {
+            return sandbox_client_1.SandboxClient.fetch(connection, candidate.id, ref);
+        }
+    }
+    return undefined;
+}
+// What hammerkit needs of its environment to read the host config and the sign-in, for a
+// harness that loads it as a plugin rather than through the command line.
+function getHarnessEnvironment(cwd = process.cwd()) {
+    const secrets = (0, redact_1.createSecretRegistry)();
+    return {
+        cwd,
+        abortCtrl: new AbortController(),
+        processEnvs: process.env,
+        file: (0, get_file_context_1.getFileContext)(cwd),
+        console: (0, log_1.consoleContext)((0, empty_writable_1.emptyWritable)()),
+        status: (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)(), secrets),
+        secrets,
+        stdout: (0, empty_writable_1.emptyWritable)(),
+        stderr: (0, empty_writable_1.emptyWritable)(),
+        stdoutColumns: 80,
+    };
+}
+exports.getHarnessEnvironment = getHarnessEnvironment;
+//# sourceMappingURL=connect.js.map

package/dist/harness/format.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capOutput = exports.toColonNumbers = exports.formatTree = exports.formatSearch = void 0;
+// Lines as grep tools print them: `path:line: text` for a match, `path-line- text` around
+// one, the file names alone or `path:count`, with a note when the server answered a part.
+function formatSearch(result) {
+    let lines;
+    if (result.output_mode === 'files_with_matches') {
+        lines = result.files ?? [];
+    }
+    else if (result.output_mode === 'count') {
+        lines = (result.counts ?? []).map((count) => `${count.path}:${count.count}`);
+    }
+    else {
+        lines = (result.matches ?? []).map((match) => match.context ? `${match.path}-${match.line}- ${match.text}` : `${match.path}:${match.line}: ${match.text}`);
+    }
+    if (lines.length === 0) {
+        return 'No matches found';
+    }
+    if (result.truncated) {
+        lines.push('', `(${lines.length} of ${result.exact ? '' : 'at least '}${result.total} shown, narrow the search or ask with a higher limit)`);
+    }
+    return lines.join('\n');
+}
+exports.formatSearch = formatSearch;
+// The paths of a listing, a directory with a trailing `/`.
+function formatTree(result, prefix = '') {
+    const lines = result.entries.map((entry) => {
+        const path = prefix && entry.path.startsWith(prefix) ? entry.path.slice(prefix.length) : entry.path;
+        return entry.type === 'directory' ? `${path}/` : path;
+    });
+    if (lines.length === 0) {
+        return 'No files found';
+    }
+    if (result.truncated) {
+        lines.push('', `(${result.entries.length} of ${result.total} shown, narrow the pattern)`);
+    }
+    return lines.join('\n');
+}
+exports.formatTree = formatTree;
+// The server numbers lines like `cat -n` (`     1\tline`); some harnesses print `1: line`.
+function toColonNumbers(content) {
+    return content
+        .split('\n')
+        .map((line) => {
+        const match = /^\s*(\d+)\t(.*)$/s.exec(line);
+        return match ? `${match[1]}: ${match[2]}` : line;
+    })
+        .join('\n');
+}
+exports.toColonNumbers = toColonNumbers;
+// The most of a command's output a tool answers: its first and last lines, up to about 30 KB.
+// One `cat` of a big file or a verbose install would otherwise fill the model's context.
+const HEAD_LINES = 50;
+const TAIL_LINES = 200;
+const MAX_CHARS = 30000;
+/**
+ * The head and the tail of a long output, with a line in between that says how much is cut
+ * and how to read it (`readMore`, for example the run_logs call for the run).
+ */
+function capOutput(output, readMore) {
+    const lines = output.split('\n');
+    if (lines.length <= HEAD_LINES + TAIL_LINES && output.length <= MAX_CHARS) {
+        return output;
+    }
+    const many = lines.length > HEAD_LINES + TAIL_LINES;
+    // the end tells most of how a command went: it gets the larger part
+    const head = (many ? lines.slice(0, HEAD_LINES).join('\n') : output).slice(0, MAX_CHARS / 4);
+    const tail = (many ? lines.slice(-TAIL_LINES).join('\n') : output).slice(-(MAX_CHARS * 3) / 4);
+    return `${head}\n… the output is cut here, it has ${lines.length} lines in all: ${readMore}\n${tail}`;
+}
+exports.capOutput = capOutput;
+//# sourceMappingURL=format.js.map

package/dist/harness/mcp-command.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpCommand = void 0;
+const commander_1 = require("commander");
+const log_1 = require("../log");
+const version_1 = require("../version");
+const connect_1 = require("./connect");
+const mcp_1 = require("./mcp");
+// `hammerkit remote mcp`: a Model Context Protocol server on stdio for one sandbox of a
+// server. It lives under `remote`, which already is a command: a top-level `mcp` would hide a
+// task named `mcp`, since `hammerkit <task>` runs a task. Like the other `remote` commands it
+// needs no build file of its own: the tasks are the published ones.
+function registerMcpCommand(remote, environment, input = process.stdin) {
+    // errors go through the program, like those of the other remote commands: it carries the exit handling
+    const program = remote.parent ?? remote;
+    remote
+        .command('mcp')
+        .description('serve the files, shell and tasks of a sandbox on a server as MCP tools over stdio (experimental)')
+        .addOption(new commander_1.Option('--server <name>', 'registered server (default: hammerkit remote use)').env('HAMMERKIT_SERVER'))
+        .addOption(new commander_1.Option('--sandbox <id>', 'a sandbox of yours on the server').env('HAMMERKIT_SANDBOX'))
+        .addOption(new commander_1.Option('--repo <repo>', 'create a sandbox of this repository').env('HAMMERKIT_REPO'))
+        .addOption(new commander_1.Option('--ref <ref>', 'at this branch').env('HAMMERKIT_REF'))
+        .addOption(new commander_1.Option('--build <hash>', 'hash of the published version of the build file whose tasks run on it').env('HAMMERKIT_BUILD'))
+        .addOption(new commander_1.Option('--shell <task>', 'its task whose last command is a shell, like sh -c')
+        .env('HAMMERKIT_SHELL')
+        .default(connect_1.DEFAULT_SHELL_TASK))
+        .action(async (options) => {
+        try {
+            // stdout carries the protocol only, everything else goes to stderr
+            const log = (line) => environment.stderr.write(`hammerkit remote mcp: ${line}\n`);
+            const sandbox = await (0, connect_1.connectSandbox)(environment, options, log);
+            log(`sandbox ${sandbox.id} of ${sandbox.sandbox.repo} at ${sandbox.sandbox.commit}`);
+            const instructions = `The tools work on hammerkit sandbox ${sandbox.id}, a checkout of ${sandbox.sandbox.repo} at ` +
+                `${sandbox.sandbox.commit} on a server. Paths are relative to its root. bash runs a command as the ` +
+                `task ${sandbox.build.shell} of the published build file ${sandbox.build.hash}, run_task runs its other ` +
+                'tasks; only the files are kept between commands. changes shows what changed since the fetch.';
+            const served = (0, mcp_1.serveMcp)(input, environment.stdout, (0, mcp_1.createMcpTools)(async () => sandbox), {
+                name: 'hammerkit',
+                version: (0, version_1.getVersion)(),
+                instructions,
+            });
+            const stopped = new Promise((resolve) => {
+                if (environment.abortCtrl.signal.aborted) {
+                    resolve();
+                }
+                environment.abortCtrl.signal.addEventListener('abort', () => resolve(), { once: true });
+            });
+            await Promise.race([served, stopped]);
+        }
+        catch (e) {
+            if (e instanceof commander_1.CommanderError) {
+                throw e;
+            }
+            program.error(`Mcp was not successful: ${(0, log_1.getErrorMessage)(e)}`, { exitCode: 1 });
+        }
+    });
+}
+exports.registerMcpCommand = registerMcpCommand;
+//# sourceMappingURL=mcp-command.js.map

package/dist/harness/mcp.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveMcp = exports.createMcpTools = void 0;
+const readline_1 = require("readline");
+const format_1 = require("./format");
+const sandbox_client_1 = require("./sandbox-client");
+// the newest first; a client asking for an older one gets it
+const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+const READ_ONLY = { readOnlyHint: true, openWorldHint: false };
+const EDITS = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false,
+};
+const text = (description) => ({ type: 'string', description });
+const count = (description, minimum = 0, maximum) => ({
+    type: 'integer',
+    description,
+    minimum,
+    ...(maximum !== undefined ? { maximum } : {}),
+});
+const flag = (description) => ({ type: 'boolean', description });
+// MCP clients send paths as they like them: `/src/a.ts` is `src/a.ts` of the sandbox
+function sandboxPath(path) {
+    return (path ?? '').replace(/\\/g, '/').replace(/^\/+/, '');
+}
+function readLog(run, task) {
+    return `read more of the log with run_logs { "run": "${run}", "task": "${task}" }`;
+}
+function describeRun(task, ran) {
+    const result = ran.result;
+    const lines = [`run ${ran.run.id}: ${ran.run.state}`];
+    if (result) {
+        lines.push(`task ${task}: ${result.status}` +
+            (result.exitCode !== undefined ? `, exit code ${result.exitCode}` : '') +
+            (result.durationMs !== undefined ? `, ${result.durationMs} ms` : '') +
+            (result.cache?.hit ? ', from the cache' : ''));
+        if (result.error) {
+            lines.push(`error: ${result.error}`);
+        }
+        if (result.cache?.causes?.length) {
+            lines.push(`ran because: ${result.cache.causes.join('; ')}`);
+        }
+    }
+    else if (ran.run.error) {
+        lines.push(`error: ${ran.run.error}`);
+    }
+    if (result && result.lastLog.length > 0) {
+        lines.push('last lines:', ...result.lastLog);
+    }
+    lines.push(readLog(ran.run.id, task));
+    return lines.join('\n');
+}
+/**
+ * The tools of `hammerkit remote mcp`, for chat clients and agents without file and shell tools of
+ * their own. They take the shapes models are trained on: numbered reads with offset and
+ * limit, exact-string replace, `apply_patch` or a git diff, ripgrep's parameters, a shell
+ * command. Paths are relative to the root of the sandbox.
+ */
+function createMcpTools(client) {
+    return inOrder([
+        {
+            name: 'read',
+            description: 'Read a file of the sandbox. Lines come back numbered like `cat -n`: the number, a tab, the line. ' +
+                'Long files come in parts; offset is the first line (1-based), limit the number of lines.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: text('Path of the file, relative to the root of the sandbox'),
+                    offset: count('The first line to read, 1 for the start', 1),
+                    limit: count('How many lines to read', 1),
+                },
+                required: ['path'],
+            },
+            annotations: { title: 'Read a file', ...READ_ONLY },
+            async call(args) {
+                const read = await (await client()).read(sandboxPath(args.path), args.offset, args.limit);
+                const footer = read.nextOffset
+                    ? `(lines ${read.offset} to ${read.nextOffset - 1} of ${read.lines}, read on with offset ${read.nextOffset})`
+                    : `(end of file, ${read.lines} lines)`;
+                return `${read.content.replace(/\n$/, '')}\n\n${footer}`;
+            },
+        },
+        {
+            name: 'write',
+            description: 'Write a file of the sandbox, replacing what it held. Directories are made as needed.',
+            inputSchema: {
+                type: 'object',
+                properties: { path: text('Path of the file'), content: text('The whole new content of the file') },
+                required: ['path', 'content'],
+            },
+            annotations: { title: 'Write a file', ...EDITS, idempotentHint: true },
+            async call(args) {
+                const written = await (await client()).writeRaw(sandboxPath(args.path), args.content);
+                return `${written.change} ${written.path} (${written.size ?? Buffer.byteLength(args.content)} bytes)`;
+            },
+        },
+        {
+            name: 'edit',
+            description: 'Replace an exact string in a file of the sandbox. old_string has to match exactly once, with its ' +
+                'whitespace and indentation, unless replace_all is set; give enough lines around the change to make it unique.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: text('Path of the file'),
+                    old_string: text('The text to replace, exactly as it is in the file'),
+                    new_string: text('The text to put in its place'),
+                    replace_all: flag('Replace every occurrence of old_string'),
+                },
+                required: ['path', 'old_string', 'new_string'],
+            },
+            annotations: { title: 'Edit a file', ...EDITS },
+            async call(args) {
+                const files = await (await client()).edit([
+                    {
+                        op: 'replace',
+                        path: sandboxPath(args.path),
+                        old_string: args.old_string,
+                        new_string: args.new_string,
+                        replace_all: args.replace_all,
+                    },
+                ]);
+                return files.map((file) => `${file.change} ${file.path}`).join('\n') || 'nothing changed';
+            },
+        },
+        {
+            name: 'apply_patch',
+            description: 'Change several files at once with a patch: the `*** Begin Patch` format (`*** Add File:`, ' +
+                '`*** Update File:` with `@@` context lines, `*** Delete File:`, `*** Move to:`) or a unified git diff. ' +
+                'Every file changes, or none does.',
+            inputSchema: {
+                type: 'object',
+                properties: { patch: text('The patch, from `*** Begin Patch` to `*** End Patch`, or a git diff') },
+                required: ['patch'],
+            },
+            annotations: { title: 'Apply a patch', ...EDITS },
+            async call(args) {
+                const files = await (await client()).edit([{ op: 'patch', patch: args.patch }]);
+                return files.map((file) => `${file.change} ${file.path}`).join('\n') || 'nothing changed';
+            },
+        },
+        {
+            name: 'search',
+            description: 'Search the files of the sandbox with ripgrep. pattern is a regular expression (Rust syntax); output_mode ' +
+                'is files_with_matches (the default), content (matching lines, with -A/-B/-C context) or count.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    pattern: text('The regular expression to look for'),
+                    path: text('A file or directory to search in, the whole sandbox by default'),
+                    glob: text('Only files matching this glob, like "*.ts" or "src/**/*.tsx"'),
+                    type: text('Only files of this ripgrep type, like ts, py or rust'),
+                    '-i': flag('Ignore case'),
+                    fixed_strings: flag('Take the pattern as a literal string'),
+                    multiline: flag('Let the pattern match across lines'),
+                    '-A': count('Lines after each match (content mode)', 0, 100),
+                    '-B': count('Lines before each match (content mode)', 0, 100),
+                    '-C': count('Lines before and after each match (content mode)', 0, 100),
+                    output_mode: { type: 'string', enum: ['files_with_matches', 'content', 'count'] },
+                    head_limit: count('The most results to answer', 1, 5000),
+                },
+                required: ['pattern'],
+            },
+            annotations: { title: 'Search files', ...READ_ONLY },
+            async call(args) {
+                const query = { ...args, path: args.path ? sandboxPath(args.path) || undefined : undefined };
+                return (0, format_1.formatSearch)(await (await client()).search(query));
+            },
+        },
+        {
+            name: 'glob',
+            description: 'List the files of the sandbox that match a glob, like "**/*.ts" or "src/**/package.json".',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    pattern: text('The glob, relative to path'),
+                    path: text('The directory to look in, the root by default'),
+                },
+                required: ['pattern'],
+            },
+            annotations: { title: 'Find files', ...READ_ONLY },
+            async call(args) {
+                const path = sandboxPath(args.path) || undefined;
+                return (0, format_1.formatTree)(await (await client()).tree({ path, glob: args.pattern, limit: 500 }));
+            },
+        },
+        {
+            name: 'bash',
+            description: 'Run a shell command on the sandbox and answer its output and exit code. It runs as the shell task of ' +
+                'the published build file, in its container and with its network; commands run one at a time, and ' +
+                'only the files are kept between them.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    command: text('The command'),
+                    workdir: text('The directory to run it in, relative to the root of the sandbox'),
+                    timeout: count('Stop the command after this many seconds', 1),
+                },
+                required: ['command'],
+            },
+            annotations: { title: 'Run a command' },
+            async call(args, signal) {
+                const sandbox = await client();
+                const ran = await sandbox.exec(args.command, sandboxPath(args.workdir), {
+                    signal,
+                    timeoutSeconds: args.timeout,
+                });
+                const output = (0, format_1.capOutput)(ran.output, readLog(ran.run.id, sandbox.build.shell));
+                const lines = output ? [output, ''] : [];
+                if (ran.exitCode === null) {
+                    lines.push(`hammerkit: ${ran.result?.error ?? ran.run.error ?? `the run ended ${ran.run.state}`}`);
+                }
+                else {
+                    lines.push(`exit code ${ran.exitCode}`);
+                }
+                return lines.join('\n');
+            },
+        },
+        {
+            name: 'run_task',
+            description: 'Run a task of the published build file on the sandbox, such as test or build, and answer how it went: ' +
+                'its status, exit code, why it was not taken from the cache, and its last lines. args are appended to ' +
+                'its last command, for example a test file.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: text('The name of the task'),
+                    args: { type: 'array', items: { type: 'string' }, description: 'Arguments for its last command' },
+                },
+                required: ['task'],
+            },
+            annotations: { title: 'Run a task' },
+            async call(args, signal) {
+                const ran = await (await client()).runTask(args.task, { args: args.args, signal });
+                return describeRun(args.task, ran);
+            },
+        },
+        {
+            name: 'run_logs',
+            description: 'Read the log of a run as numbered lines: one task, the last lines (tail), a range (from, limit) or ' +
+                'the lines that contain a text (grep, a fixed string) with lines of context around them.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    run: text('The id of the run'),
+                    task: text('Only the lines of this task'),
+                    tail: count('The last lines, or with grep the last matches', 1, 1000),
+                    from: count('The first line to read', 1),
+                    limit: count('How many lines to read', 1, 1000),
+                    grep: text('Only lines that contain this text'),
+                    ignore_case: flag('Ignore case in grep'),
+                    context: count('Lines before and after each match', 0, 20),
+                },
+                required: ['run'],
+            },
+            annotations: { title: 'Read the log of a run', ...READ_ONLY },
+            async call(args) {
+                const page = await (await client()).logs(args.run, {
+                    task: args.task,
+                    tail: args.tail,
+                    from: args.from,
+                    limit: args.limit,
+                    grep: args.grep,
+                    i: args.ignore_case,
+                    context: args.context,
+                });
+                const lines = page.lines.map((line) => `${line.line}${line.match === false ? '-' : ':'} ${args.task ? '' : `[${line.task}] `}${line.text}`);
+                lines.push('', `(${page.total} lines${args.grep ? ` searched, ${page.lines.filter((line) => line.match !== false).length} match here` : ''}${page.next ? `, read on with from ${page.next}` : ''}${page.truncated ? ', the server cut the log off at its limit' : ''})`);
+                return lines.join('\n');
+            },
+        },
+        {
+            name: 'changes',
+            description: 'What changed in the sandbox since the commit it was fetched at: a summary of the files, a diff, or a ' +
+                'patch to apply elsewhere with git am.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    format: { type: 'string', enum: ['summary', 'diff', 'patch'], description: 'summary by default' },
+                },
+            },
+            annotations: { title: 'Show the changes', ...READ_ONLY },
+            async call(args) {
+                const sandbox = await client();
+                if (args.format === 'diff' || args.format === 'patch') {
+                    return (await sandbox.diff(args.format)) || 'no changes';
+                }
+                const changes = await sandbox.changes();
+                if (changes.files.length === 0) {
+                    return `no changes since ${changes.commit}`;
+                }
+                return [
+                    `changes since ${changes.commit}:`,
+                    ...changes.files.map((file) => `${file.status} ${file.from ? `${file.from} -> ` : ''}${file.path}` +
+                        (file.additions !== null ? ` +${file.additions} -${file.deletions}` : ' (binary)')),
+                ].join('\n');
+            },
+        },
+        {
+            name: 'push',
+            description: 'Commit the changes of the sandbox and push them to a branch of its repository, for review. The server ' +
+                'pushes only to the branches its operator allows; the sandbox is at the pushed commit afterwards.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    branch: text('the branch to push to, created when it does not exist'),
+                    message: text('the commit message'),
+                },
+                required: ['branch', 'message'],
+            },
+            annotations: { title: 'Push a branch', readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+            async call(args) {
+                const pushed = await (await client()).push(args.branch, args.message);
+                return `pushed ${pushed.commit} to ${pushed.branch}`;
+            },
+        },
+    ]);
+}
+exports.createMcpTools = createMcpTools;
+// the calls of a client go to the sandbox one at a time, in the order the client sent them
+function inOrder(tools) {
+    const inTurn = (0, sandbox_client_1.oneAtATime)();
+    return tools.map((tool) => ({ ...tool, call: (args, signal) => inTurn(() => tool.call(args, signal)) }));
+}
+/**
+ * A Model Context Protocol server over stdio: one JSON-RPC message per line on `input`, the
+ * answers on `output`. It answers `initialize`, `ping`, `tools/list` and `tools/call`, and
+ * stops a call when the client cancels it. Resolves when the input ends.
+ */
+async function serveMcp(input, output, tools, server) {
+    const running = new Map();
+    const pending = new Set();
+    const send = (message) => {
+        output.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`);
+    };
+    const reply = (id, result) => send({ id, result });
+    const fail = (id, code, message) => send({ id, error: { code, message } });
+    const handle = async (message) => {
+        const id = message.id;
+        if (message.method === 'notifications/cancelled') {
+            running.get(message.params?.requestId)?.abort();
+            return;
+        }
+        if (id === undefined || id === null || message.method === undefined) {
+            // a notification, or an answer of the client to a request this server never sends
+            return;
+        }
+        if (message.method === 'initialize') {
+            const asked = message.params?.protocolVersion;
+            reply(id, {
+                protocolVersion: PROTOCOL_VERSIONS.includes(asked) ? asked : PROTOCOL_VERSIONS[0],
+                capabilities: { tools: { listChanged: false } },
+                serverInfo: { name: server.name, version: server.version },
+                ...(server.instructions ? { instructions: server.instructions } : {}),
+            });
+        }
+        else if (message.method === 'ping') {
+            reply(id, {});
+        }
+        else if (message.method === 'tools/list') {
+            reply(id, {
+                tools: tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                    annotations: tool.annotations,
+                })),
+            });
+        }
+        else if (message.method === 'tools/call') {
+            const tool = tools.find((candidate) => candidate.name === message.params?.name);
+            if (!tool) {
+                return fail(id, -32602, `unknown tool ${String(message.params?.name)}`);
+            }
+            const args = message.params?.arguments ?? {};
+            const missing = (tool.inputSchema.required ?? []).filter((name) => args[name] === undefined);
+            if (missing.length > 0) {
+                return reply(id, { content: [{ type: 'text', text: `missing ${missing.join(', ')}` }], isError: true });
+            }
+            const abort = new AbortController();
+            running.set(id, abort);
+            try {
+                const text = await tool.call(args, abort.signal);
+                if (!abort.signal.aborted) {
+                    reply(id, { content: [{ type: 'text', text }] });
+                }
+            }
+            catch (e) {
+                if (!abort.signal.aborted) {
+                    // a failed call is an answer the model reads, not a protocol error
+                    reply(id, { content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }], isError: true });
+                }
+            }
+            finally {
+                running.delete(id);
+            }
+        }
+        else {
+            fail(id, -32601, `method not found: ${String(message.method)}`);
+        }
+    };
+    const lines = (0, readline_1.createInterface)({ input, crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (line.trim().length === 0) {
+            continue;
+        }
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            fail(null, -32700, 'parse error');
+            continue;
+        }
+        if (typeof message !== 'object' || message === null || Array.isArray(message)) {
+            fail(null, -32600, 'invalid request');
+            continue;
+        }
+        const work = handle(message).catch((e) => message.id !== undefined && message.id !== null
+            ? fail(message.id, -32603, e instanceof Error ? e.message : String(e))
+            : undefined);
+        pending.add(work);
+        work.finally(() => pending.delete(work));
+    }
+    for (const abort of running.values()) {
+        abort.abort();
+    }
+    await Promise.all(pending);
+}
+exports.serveMcp = serveMcp;
+//# sourceMappingURL=mcp.js.map