hammerkit 1.26.0 → 1.27.0-next.1

package/dist/server/runs.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unavailableExecutor = exports.RunRegistry = exports.RUN_ID_PATTERN = exports.QuotaError = exports.RunError = exports.isFinal = void 0;
+exports.unavailableExecutor = exports.RunRegistry = exports.MAX_TASK_ERROR = exports.MAX_CAUSES = exports.SANDBOX_ID_PATTERN = exports.RUN_ID_PATTERN = exports.QuotaError = exports.RunError = exports.isFinal = void 0;
 const crypto_1 = require("crypto");
+const run_logs_1 = require("./run-logs");
 const units_1 = require("../utils/units");
 const FINAL_STATES = ['succeeded', 'failed', 'cancelled', 'rejected'];
 function isFinal(state) {
@@ -25,6 +26,38 @@ class QuotaError extends RunError {
 }
 exports.QuotaError = QuotaError;
 exports.RUN_ID_PATTERN = /^run_[A-Za-z0-9_-]{16}$/;
+exports.SANDBOX_ID_PATTERN = /^sbx_[A-Za-z0-9_-]{16}$/;
+function onSandbox(run, sandbox) {
+    return run.source.type === 'sandbox' && run.source.id === sandbox;
+}
+// how much of the end of a task's output its result carries
+const TAIL_LINES = 20;
+const TAIL_LINE_LENGTH = 1000;
+// what a task event says of why a task ran or failed: a change to thousands of source
+// files is a cause per file. The process of a run cuts them already; an executor that
+// does not can still not make a result of any size.
+exports.MAX_CAUSES = 20;
+exports.MAX_TASK_ERROR = 2 * 1024;
+function bounded(event) {
+    const causes = event.causes;
+    return {
+        ...event,
+        ...(causes
+            ? {
+                causes: [
+                    ...causes.slice(0, exports.MAX_CAUSES).map((cause) => cause.slice(0, exports.MAX_TASK_ERROR)),
+                    ...(causes.length > exports.MAX_CAUSES ? [`… and ${causes.length - exports.MAX_CAUSES} more`] : []),
+                ],
+            }
+            : {}),
+        ...(event.error !== undefined ? { error: event.error.slice(0, exports.MAX_TASK_ERROR) } : {}),
+    };
+}
+// what a task event weighs against the log limits of a run
+function taskEventSize(event) {
+    const causes = (event.causes ?? []).reduce((sum, cause) => sum + Buffer.byteLength(cause) + 4, 0);
+    return 64 + causes + Buffer.byteLength(event.error ?? '');
+}
 // Where runs are kept while the server is up. Everything is scoped to the
 // caller that submitted the run: the same id asked for by someone else is
 // "not found", so ids can't be used to find out which runs exist.
@@ -35,6 +68,8 @@ class RunRegistry {
         this.queue = [];
         this.running = 0;
         this.closed = false;
+        // callers that wait for a run to finish, let go when the server stops
+        this.waiters = new Set();
         this.maxConcurrent = options.maxConcurrent ?? 4;
         this.keep = options.keep ?? 200;
         this.maxEvents = options.maxEvents ?? 5000;
@@ -63,6 +98,7 @@ class RunRegistry {
                 abort: new AbortController(),
                 truncated: events.some((event) => event.type === 'truncated'),
                 bytes: 0,
+                tails: new Map(Object.entries(run.results ?? {}).map(([task, result]) => [task, result.lastLog])),
                 saving: Promise.resolve(),
             };
             this.entries.set(run.id, entry);
@@ -107,6 +143,7 @@ class RunRegistry {
             abort: new AbortController(),
             truncated: false,
             bytes: 0,
+            tails: new Map(),
             saving: Promise.resolve(),
         };
         this.entries.set(run.id, entry);
@@ -148,17 +185,34 @@ class RunRegistry {
         if (!entry) {
             return undefined;
         }
+        this.stop(entry);
+        return this.copy(entry.run);
+    }
+    // The run that holds a sandbox: the oldest on it that is not over. It holds it from
+    // when it is submitted, so the files are not moved under what an approver saw.
+    holder(sandbox) {
+        return [...this.entries.values()].find((entry) => onSandbox(entry.run, sandbox) && !isFinal(entry.run.state))?.run
+            .id;
+    }
+    // Cancels every run on a sandbox and resolves when none of them runs anymore.
+    async stopSandbox(sandbox, reason) {
+        const on = () => [...this.entries.values()].filter((entry) => onSandbox(entry.run, sandbox));
+        on().forEach((entry) => this.stop(entry, reason));
+        while (on().some((entry) => entry.run.state === 'running')) {
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+    }
+    stop(entry, reason) {
         if (entry.run.state === 'queued') {
             this.queue.splice(this.queue.indexOf(entry), 1);
-            this.finish(entry, 'cancelled');
+            this.finish(entry, 'cancelled', reason);
         }
         else if (entry.run.state === 'awaiting-approval') {
-            this.finish(entry, 'cancelled');
+            this.finish(entry, 'cancelled', reason);
         }
         else if (entry.run.state === 'running') {
             entry.abort.abort();
         }
-        return this.copy(entry.run);
     }
     // The runs that wait for an approval, of anybody, oldest first. Who may see
     // them is for the caller to decide.
@@ -234,6 +288,49 @@ class RunRegistry {
         }
         return { events, finished, stop: () => entry.listeners.delete(listener) };
     }
+    /**
+     * The run once it is over, or as it is after `ms` or when `signal` aborts, for clients
+     * that can not hold a stream of events open (a tool call of an agent).
+     */
+    async wait(owner, id, ms, canUse, signal) {
+        const entry = this.find(owner, id, canUse);
+        if (!entry) {
+            return undefined;
+        }
+        if (!isFinal(entry.run.state) && ms > 0 && !this.closed && !signal?.aborted) {
+            await new Promise((resolve) => {
+                const listener = (event) => {
+                    if (event.type === 'state' && isFinal(event.state)) {
+                        done();
+                    }
+                };
+                const done = () => {
+                    clearTimeout(timer);
+                    entry.listeners.delete(listener);
+                    this.waiters.delete(done);
+                    signal?.removeEventListener('abort', done);
+                    resolve();
+                };
+                const timer = setTimeout(done, ms);
+                timer.unref();
+                entry.listeners.add(listener);
+                this.waiters.add(done);
+                signal?.addEventListener('abort', done, { once: true });
+            });
+        }
+        return this.copy(entry.run);
+    }
+    // The log of a run as far as it was kept, and whether it was cut off.
+    logs(owner, id, canUse) {
+        const entry = this.find(owner, id, canUse);
+        if (!entry) {
+            return undefined;
+        }
+        // only the events since the last read are looked at
+        entry.index ?? (entry.index = new run_logs_1.LogIndex());
+        entry.index.update(entry.events);
+        return { events: entry.events, index: entry.index, truncated: entry.truncated };
+    }
     // Stops accepting runs and aborts the ones in flight.
     async close() {
         this.closed = true;
@@ -251,6 +348,10 @@ class RunRegistry {
                 }
             }
         }
+        // who waits for a run that waits for an approval is told how it stands now
+        for (const done of [...this.waiters]) {
+            done();
+        }
         for (const entry of this.entries.values()) {
             if (entry.run.state === 'running') {
                 entry.abort.abort();
@@ -288,12 +389,12 @@ class RunRegistry {
         return {
             ...run,
             tasks: [...run.tasks],
-            definition: { ...run.definition },
             source: { ...run.source },
             options: JSON.parse(JSON.stringify(run.options)),
             owner: { ...run.owner },
             accounts: [...run.accounts],
             ...(run.approvals ? { approvals: JSON.parse(JSON.stringify(run.approvals)) } : {}),
+            ...(run.results ? { results: JSON.parse(JSON.stringify(run.results)) } : {}),
         };
     }
     timestamp() {
@@ -317,11 +418,19 @@ class RunRegistry {
     runningOf(owner) {
         return [...this.entries.values()].filter((entry) => entry.run.state === 'running' && this.owns(owner, entry)).length;
     }
+    // Whether a run on the same sandbox executes: a sandbox runs one at a time.
+    sandboxBusy(run) {
+        const source = run.source;
+        return (source.type === 'sandbox' &&
+            [...this.entries.values()].some((entry) => entry.run.state === 'running' && onSandbox(entry.run, source.id)));
+    }
     // The first run in the queue whose caller has a place left: one caller with many runs
-    // does not keep the others from the machine.
+    // does not keep the others from the machine. A run on a sandbox another run works on
+    // waits for it.
     dispatch() {
         while (this.running < this.maxConcurrent) {
-            const index = this.queue.findIndex((entry) => !this.options.limits || this.runningOf(entry.run.owner) < this.options.limits.running);
+            const perCaller = Math.min(this.options.limits?.running ?? Infinity, this.options.executor.runningPerCaller ?? Infinity);
+            const index = this.queue.findIndex((entry) => this.runningOf(entry.run.owner) < perCaller && !this.sandboxBusy(entry.run));
             if (index < 0) {
                 return;
             }
@@ -370,15 +479,29 @@ class RunRegistry {
         if (error) {
             entry.run.error = error;
         }
+        // a task the executor did not see to its end did not finish
+        for (const result of Object.values(entry.run.results ?? {})) {
+            if (result.status === 'running') {
+                result.status = 'cancelled';
+                result.finishedAt = entry.run.finishedAt;
+            }
+        }
         this.record(entry, { type: 'state', state, ...(error ? { error } : {}) }, true);
         entry.listeners.clear();
         this.evict();
     }
-    record(entry, event, force = false) {
+    record(entry, recorded, force = false) {
+        const event = recorded.type === 'task' ? bounded(recorded) : recorded;
+        if (event.type === 'log') {
+            this.keepTail(entry, event.task, event.text);
+        }
+        else if (event.type === 'task') {
+            this.keepResult(entry, event);
+        }
         // an executor that keeps talking can't fill the memory of the server or its disk; the
-        // state changes, which are few, are always kept
+        // state changes, which are few, are always kept, and the results above are kept apart
         if (!force && event.type !== 'state') {
-            const size = event.type === 'log' ? Buffer.byteLength(event.text) + 64 : 64;
+            const size = event.type === 'log' ? Buffer.byteLength(event.text) + 64 : event.type === 'task' ? taskEventSize(event) : 64;
             if (entry.events.length >= this.maxEvents || entry.bytes + size > this.maxLogBytes) {
                 if (!entry.truncated) {
                     entry.truncated = true;
@@ -390,6 +513,57 @@ class RunRegistry {
         }
         this.push(entry, event);
     }
+    keepTail(entry, task, text) {
+        let tail = entry.tails.get(task);
+        if (!tail) {
+            tail = [];
+            entry.tails.set(task, tail);
+        }
+        for (const line of text.replace(/\r?\n$/, '').split(/\r?\n/)) {
+            tail.push(line.length > TAIL_LINE_LENGTH ? `${line.slice(0, TAIL_LINE_LENGTH)}…` : line);
+        }
+        tail.splice(0, Math.max(0, tail.length - TAIL_LINES));
+    }
+    keepResult(entry, event) {
+        var _a;
+        const results = ((_a = entry.run).results ?? (_a.results = {}));
+        let tail = entry.tails.get(event.task);
+        if (!tail) {
+            tail = [];
+            entry.tails.set(event.task, tail);
+        }
+        const now = this.timestamp();
+        const previous = results[event.task];
+        // A task the run names in several scopes is checked again as a dependency of a later
+        // one: it is then cached or not needed, or stopped with the scope. What it did the
+        // first time is what the caller asked about.
+        if (previous &&
+            ['succeeded', 'failed', 'cached'].includes(previous.status) &&
+            ['cached', 'skipped', 'cancelled'].includes(event.state)) {
+            return;
+        }
+        const over = event.state !== 'running';
+        const result = {
+            status: event.state,
+            ...(event.state === 'running'
+                ? { startedAt: now }
+                : previous?.startedAt
+                    ? { startedAt: previous.startedAt }
+                    : {}),
+            ...(over ? { finishedAt: now } : {}),
+            ...(event.durationMs !== undefined ? { durationMs: event.durationMs } : {}),
+            ...(event.exitCode !== undefined ? { exitCode: event.exitCode } : {}),
+            ...(event.error ? { error: event.error } : {}),
+            ...(event.state === 'cached'
+                ? { cache: { hit: true } }
+                : event.state === 'succeeded' || event.state === 'failed'
+                    ? { cache: { hit: false, ...(event.causes?.length ? { causes: [...event.causes] } : {}) } }
+                    : {}),
+            // the same list the log adds to, so the result always has the newest lines
+            lastLog: tail,
+        };
+        results[event.task] = result;
+    }
     push(entry, event) {
         const stored = { ...event, seq: entry.events.length + 1, time: this.timestamp() };
         entry.events.push(stored);

package/dist/server/sandbox-docker.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerSandboxContainers = void 0;
+const execute_docker_1 = require("../executer/execute-docker");
+const get_docker_executor_1 = require("../executer/get-docker-executor");
+const pull_1 = require("../docker/pull");
+// what gives a sandbox back to the server's user: a shell with chown and chmod
+const HELPER_IMAGE = 'alpine:3.21';
+class DockerSandboxContainers {
+    constructor(host) {
+        this.docker = (0, execute_docker_1.createDockerClient)(host);
+    }
+    async reclaim(directory) {
+        const images = await this.docker.listImages({});
+        if (!(0, pull_1.isImagePresent)(images, HELPER_IMAGE)) {
+            const stream = await this.docker.pull(HELPER_IMAGE);
+            await new Promise((resolve, reject) => this.docker.modem.followProgress(stream, (err) => (err ? reject(err) : resolve())));
+        }
+        const user = `${process.getuid?.() ?? 0}:${process.getgid?.() ?? 0}`;
+        // a link in the sandbox points into this container, not to the server
+        const container = await this.docker.createContainer({
+            Image: HELPER_IMAGE,
+            Cmd: ['sh', '-c', `chown -R -h ${user} /sandbox && chmod -R u+rwX /sandbox`],
+            Labels: { app: 'hammerkit' },
+            NetworkDisabled: true,
+            HostConfig: { Binds: [`${directory}:/sandbox`], NetworkMode: 'none' },
+        });
+        try {
+            await container.start();
+            const result = await container.wait();
+            if (result.StatusCode !== 0) {
+                throw new Error(`giving the files back to the server failed with ${result.StatusCode}`);
+            }
+        }
+        finally {
+            await container.remove({ force: true }).catch(() => undefined);
+        }
+    }
+    async volumes(directory) {
+        const { Volumes } = await this.docker.listVolumes({
+            filters: JSON.stringify({ label: [`${get_docker_executor_1.VOLUME_ROOT_LABEL}=${directory}`] }),
+        });
+        return (Volumes ?? []).map((volume) => volume.Name);
+    }
+    async volumeBytes(directory) {
+        const names = new Set(await this.volumes(directory));
+        if (names.size === 0) {
+            return 0;
+        }
+        const usage = await this.docker.df();
+        return (usage.Volumes ?? [])
+            .filter((volume) => names.has(volume.Name))
+            .reduce((bytes, volume) => bytes + Math.max(0, volume.UsageData?.Size ?? 0), 0);
+    }
+    async removeVolumes(directory) {
+        for (const name of await this.volumes(directory)) {
+            await this.docker.getVolume(name).remove({ force: true });
+        }
+    }
+}
+exports.DockerSandboxContainers = DockerSandboxContainers;
+//# sourceMappingURL=sandbox-docker.js.map

package/dist/server/sandbox-files-api.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSandboxFiles = exports.MAX_EDITS_BODY_BYTES = void 0;
+const zod_1 = require("zod");
+const git_checkout_1 = require("./git-checkout");
+const http_1 = require("./http");
+const sandbox_files_1 = require("./sandbox-files");
+const sandboxes_1 = require("./sandboxes");
+// a batch of edits carries the content it writes
+exports.MAX_EDITS_BODY_BYTES = 16 * 1024 * 1024;
+const hashSchema = zod_1.z.string().regex(/^[0-9a-fA-F]{64}$/, 'expected the sha256 of the file, 64 hex digits');
+const opSchema = zod_1.z.discriminatedUnion('op', [
+    zod_1.z
+        .object({
+        op: zod_1.z.literal('replace'),
+        path: zod_1.z.string(),
+        old_string: zod_1.z.string(),
+        new_string: zod_1.z.string(),
+        replace_all: zod_1.z.boolean().optional(),
+        ifHash: hashSchema.optional(),
+    })
+        .strict(),
+    zod_1.z
+        .object({
+        op: zod_1.z.literal('write'),
+        path: zod_1.z.string(),
+        content: zod_1.z.string(),
+        encoding: zod_1.z.enum(['utf8', 'base64']).optional(),
+        ifHash: hashSchema.optional(),
+    })
+        .strict(),
+    zod_1.z.object({ op: zod_1.z.literal('delete'), path: zod_1.z.string(), ifHash: hashSchema.optional() }).strict(),
+    zod_1.z.object({ op: zod_1.z.literal('move'), path: zod_1.z.string(), to: zod_1.z.string(), ifHash: hashSchema.optional() }).strict(),
+    zod_1.z.object({ op: zod_1.z.literal('patch'), patch: zod_1.z.string().min(1) }).strict(),
+]);
+const editsSchema = zod_1.z.object({ dryRun: zod_1.z.boolean().optional(), ops: zod_1.z.array(opSchema).min(1).max(1000) }).strict();
+// grep tools name the flags `-i`, `-A`: both spellings are taken
+const searchSchema = zod_1.z.preprocess((body) => {
+    if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+        return body;
+    }
+    const renamed = {};
+    for (const [key, value] of Object.entries(body)) {
+        renamed[/^-[iABC]$/.test(key) ? key.slice(1) : key] = value;
+    }
+    return renamed;
+}, zod_1.z
+    .object({
+    pattern: zod_1.z.string().min(1).max(10000),
+    path: zod_1.z.string().optional(),
+    glob: zod_1.z
+        .union([zod_1.z.string().min(1).max(500), zod_1.z.array(zod_1.z.string().min(1).max(500)).max(20)])
+        .transform((glob) => (Array.isArray(glob) ? glob : [glob]))
+        .optional(),
+    type: zod_1.z.string().optional(),
+    i: zod_1.z.boolean().optional(),
+    fixed_strings: zod_1.z.boolean().optional(),
+    multiline: zod_1.z.boolean().optional(),
+    A: zod_1.z.number().int().min(0).max(100).optional(),
+    B: zod_1.z.number().int().min(0).max(100).optional(),
+    C: zod_1.z.number().int().min(0).max(100).optional(),
+    output_mode: zod_1.z.enum(['files_with_matches', 'content', 'count']).optional(),
+    head_limit: zod_1.z.number().int().min(1).max(5000).optional(),
+    cursor: zod_1.z.string().optional(),
+})
+    .strict());
+/**
+ * The files of a sandbox, for clients without tools of their own (typed) and for harnesses
+ * that only swap the backend of theirs (raw):
+ *
+ *   GET  /v1/sandboxes/<id>/tree?path=&depth=&glob=&limit=&cursor=
+ *   GET  /v1/sandboxes/<id>/files/<path>?offset=&limit=   numbered lines
+ *   GET  /v1/sandboxes/<id>/files/<path>?raw              bytes
+ *   GET  /v1/sandboxes/<id>/files/<path>?stat             what it is
+ *   HEAD /v1/sandboxes/<id>/files/<path>                  the same, as headers
+ *   PUT  /v1/sandboxes/<id>/files/<path>                  write bytes, If-Match: "<sha256>"
+ *   POST /v1/sandboxes/<id>/search                        ripgrep
+ *   POST /v1/sandboxes/<id>/edits                         { dryRun, ops }, all or nothing
+ *   GET  /v1/sandboxes/<id>/changes?format=summary|diff|patch
+ *
+ * Reading a file works at any time. Writes, and the reads that walk the files (tree, search,
+ * changes), are `409` while a run holds the sandbox.
+ */
+async function handleSandboxFiles(sandboxes, log, principal, sandbox, action, path, req, res, url) {
+    const who = `iss=${principal.iss} sub=${principal.sub}`;
+    const method = req.method;
+    try {
+        if (action === 'files') {
+            await handleFile(sandboxes, log, principal, sandbox, path, req, res, url);
+        }
+        else if (action === 'tree') {
+            if (method !== 'GET') {
+                return (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'GET' });
+            }
+            const query = {
+                path: url.searchParams.get('path') || undefined,
+                depth: intParam(url, 'depth'),
+                glob: url.searchParams.get('glob') || undefined,
+                limit: intParam(url, 'limit'),
+                cursor: url.searchParams.get('cursor') ?? undefined,
+            };
+            const tree = await sandboxes.read(principal, sandbox.id, (files) => files.tree(query));
+            (0, http_1.send)(res, 200, tree);
+        }
+        else if (action === 'search') {
+            if (method !== 'POST') {
+                return (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'POST' });
+            }
+            const query = parse(searchSchema, await (0, http_1.readJson)(req));
+            (0, http_1.send)(res, 200, await sandboxes.read(principal, sandbox.id, (files) => files.search(query)));
+        }
+        else if (action === 'edits') {
+            if (method !== 'POST') {
+                return (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'POST' });
+            }
+            const body = parse(editsSchema, await (0, http_1.readJson)(req, exports.MAX_EDITS_BODY_BYTES));
+            const files = await sandboxes.edit(principal, sandbox.id, body.ops, body.dryRun);
+            if (!body.dryRun) {
+                log(`sandbox edits ${sandbox.id} ${who} ops=${body.ops.length} files=${files.length}`);
+            }
+            (0, http_1.send)(res, 200, { dryRun: body.dryRun ?? false, files });
+        }
+        else {
+            if (method !== 'GET') {
+                return (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'GET' });
+            }
+            await handleChanges(sandboxes, principal, sandbox, res, url);
+        }
+    }
+    catch (e) {
+        if (e instanceof sandbox_files_1.SandboxFileError) {
+            return (0, http_1.send)(res, e.status, { error: e.message, ...e.details });
+        }
+        if (e instanceof git_checkout_1.GitOutputTooLarge) {
+            return (0, http_1.send)(res, 413, { error: 'the changes are too large to answer, take them out in parts with a push' });
+        }
+        throw e;
+    }
+}
+exports.handleSandboxFiles = handleSandboxFiles;
+async function handleFile(sandboxes, log, principal, sandbox, path, req, res, url) {
+    const method = req.method;
+    const files = sandboxes.files(principal, sandbox.id);
+    if (method === 'HEAD') {
+        const stat = await files.stat(path);
+        if (!stat) {
+            res.writeHead(404, { 'cache-control': 'no-store' });
+            res.end();
+            return;
+        }
+        res.writeHead(200, statHeaders(stat));
+        res.end();
+    }
+    else if (method === 'GET') {
+        if (url.searchParams.has('stat')) {
+            const stat = await files.stat(path);
+            return stat ? (0, http_1.send)(res, 200, stat) : (0, http_1.send)(res, 404, { error: `${path} does not exist` });
+        }
+        if (url.searchParams.has('raw')) {
+            const raw = await files.raw(path);
+            const headers = { ...statHeaders(raw.stat), 'content-type': 'application/octet-stream' };
+            if (raw.content) {
+                res.writeHead(200, { ...headers, etag: `"${raw.sha256}"` });
+                res.end(raw.content);
+                return;
+            }
+            res.writeHead(200, headers);
+            const stream = raw.stream;
+            await new Promise((resolve) => {
+                stream.on('error', () => {
+                    res.destroy();
+                    resolve();
+                });
+                res.on('close', () => {
+                    stream.destroy();
+                    resolve();
+                });
+                stream.pipe(res);
+            });
+            return;
+        }
+        (0, http_1.send)(res, 200, await files.read(path, { offset: intParam(url, 'offset'), limit: intParam(url, 'limit') }));
+    }
+    else if (method === 'PUT') {
+        const content = await readBytes(req, sandbox_files_1.MAX_FILE_BYTES);
+        const ifMatch = /^(?:W\/)?"?([0-9a-fA-F]{64})"?$/.exec(req.headers['if-match'] ?? '');
+        if (req.headers['if-match'] !== undefined && !ifMatch) {
+            return (0, http_1.send)(res, 400, { error: 'If-Match: expected the sha256 of the file in quotes' });
+        }
+        const [written] = await sandboxes.edit(principal, sandbox.id, [
+            { op: 'write', path, content, ifHash: ifMatch?.[1] },
+        ]);
+        log(`sandbox write ${sandbox.id} iss=${principal.iss} sub=${principal.sub} bytes=${content.length}`);
+        // writing what the file already holds changes nothing
+        (0, http_1.send)(res, written?.change === 'added' ? 201 : 200, written ?? { path, change: 'unchanged', size: content.length });
+    }
+    else {
+        (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'GET, HEAD, PUT' });
+    }
+}
+async function handleChanges(sandboxes, principal, sandbox, res, url) {
+    const format = url.searchParams.get('format') ?? 'summary';
+    if (format === 'summary') {
+        const files = await sandboxes.read(principal, sandbox.id, (files) => files.changes());
+        return (0, http_1.send)(res, 200, { commit: sandbox.commit, files });
+    }
+    if (format !== 'diff' && format !== 'patch') {
+        return (0, http_1.send)(res, 400, { error: 'format: expected summary, diff or patch' });
+    }
+    const author = {
+        name: textParam(url, 'name') ?? 'hammerkit',
+        email: textParam(url, 'email') ?? 'hammerkit@localhost',
+        message: textParam(url, 'message', 4000, true) ?? `Changes of sandbox ${sandbox.id}`,
+    };
+    const text = await sandboxes.read(principal, sandbox.id, (files) => files.diff(format, author));
+    res.writeHead(200, { 'content-type': 'text/x-diff; charset=utf-8', 'cache-control': 'no-store' });
+    res.end(text);
+}
+function statHeaders(stat) {
+    return {
+        'cache-control': 'no-store',
+        'content-length': String(stat.size),
+        'last-modified': new Date(stat.modifiedAt).toUTCString(),
+        'x-hammerkit-type': stat.type,
+        'x-hammerkit-exec': String(stat.exec),
+        ...(stat.target !== undefined ? { 'x-hammerkit-target': encodeURIComponent(stat.target) } : {}),
+    };
+}
+function intParam(url, name) {
+    const value = url.searchParams.get(name);
+    if (value === null || value === '') {
+        return undefined;
+    }
+    if (!/^\d{1,9}$/.test(value)) {
+        throw new sandbox_files_1.SandboxFileError(400, `${name}: expected a whole number`);
+    }
+    return Number(value);
+}
+function textParam(url, name, max = 200, lines = false) {
+    const value = url.searchParams.get(name);
+    if (value === null || value === '') {
+        return undefined;
+    }
+    if (value.length > max || (lines ? /\0/ : /[\0\r\n<>]/).test(value)) {
+        throw new sandbox_files_1.SandboxFileError(400, `${name}: at most ${max} characters${lines ? '' : ', no line breaks or <>'}`);
+    }
+    return value;
+}
+async function readBytes(req, limit) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > limit) {
+            throw new http_1.HttpError(413, `the file is larger than ${limit} bytes`);
+        }
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+function parse(schema, body) {
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        throw new sandboxes_1.SandboxError(400, `${issue.path.join('.') || 'request'}: ${issue.message}`);
+    }
+    return parsed.data;
+}
+//# sourceMappingURL=sandbox-files-api.js.map