hammerkit 1.27.0-next.9 → 2.0.0-next.2

package/dist/harness/task-tools.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskToolArgs = exports.taskToolSchema = exports.createTaskTools = exports.describeTasks = exports.describeRun = exports.readLogHint = exports.readTaskListing = exports.LIST_TASKS_MS = void 0;
+const sandbox_client_1 = require("./sandbox-client");
+// the most tasks a description lists, and of a task's description or command it shows
+const MAX_LISTED = 40;
+const MAX_DESCRIPTION_CHARS = 200;
+const MAX_COMMAND_CHARS = 100;
+// how long a client waits for the tasks of the build file when it starts, it goes on without them
+exports.LIST_TASKS_MS = 15000;
+// The tasks of the published version, or why they could not be read within `ms`.
+async function readTaskListing(list, ms = exports.LIST_TASKS_MS) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`no answer within ${ms / 1000} s`)), ms);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([list(), timeout]);
+    }
+    catch (e) {
+        return { error: e instanceof Error ? e.message : String(e) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+exports.readTaskListing = readTaskListing;
+// the hint at the end of a cut output or a result, for the model
+function readLogHint(run, task) {
+    return `read more of the log with run_logs { "run": "${run}", "task": "${task}" }`;
+}
+exports.readLogHint = readLogHint;
+// A run of a task in a few lines: how it went, why it ran, its last lines.
+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(readLogHint(ran.run.id, task));
+    return lines.join('\n');
+}
+exports.describeRun = describeRun;
+/**
+ * The tasks for the model, one line each: what it is for (or its command, when the build
+ * file says nothing) and whether it takes arguments. `shell` is left out, the shell tool runs it.
+ */
+function describeTasks(listing, shell) {
+    if (listing === undefined) {
+        return '';
+    }
+    if (!Array.isArray(listing)) {
+        return `The tasks of the build file could not be listed (${listing.error}); name one as the build file does.`;
+    }
+    const tasks = listing.filter((task) => !shell || task.name !== shell);
+    if (tasks.length === 0) {
+        return 'The published build file has no tasks to run.';
+    }
+    const lines = tasks.slice(0, MAX_LISTED).map((task) => {
+        const parts = [`- ${task.name}`];
+        if (task.description) {
+            parts.push(`: ${cut(oneLine(task.description), MAX_DESCRIPTION_CHARS)}`);
+        }
+        else if (task.command) {
+            parts.push(`: runs \`${cut(oneLine(task.command), MAX_COMMAND_CHARS)}\``);
+        }
+        if (task.args === null) {
+            parts.push(' (takes args)');
+        }
+        else if (task.args !== undefined || task.command === null) {
+            parts.push(' (takes no args)');
+        }
+        return parts.join('');
+    });
+    if (tasks.length > MAX_LISTED) {
+        lines.push(`- and ${tasks.length - MAX_LISTED} more`);
+    }
+    return ['The tasks of the published build file:', ...lines].join('\n');
+}
+exports.describeTasks = describeTasks;
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function cut(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+/**
+ * `run_task`, `run_logs` and `check`, with the tasks the description of `run_task` lists. Without a
+ * listing it names none, as the MCP tools before a version could be read.
+ */
+function createTaskTools(listing, shell) {
+    const tasks = describeTasks(listing, shell);
+    return [
+        {
+            name: 'run_task',
+            title: 'Run a 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. It runs in the container, with the network and the ' +
+                'options the build file gives the task.' +
+                (tasks ? `\n\n${tasks}` : ''),
+            parameters: {
+                task: { type: 'string', description: 'The name of the task' },
+                args: { type: 'string[]', description: 'Arguments for its last command' },
+            },
+            required: ['task'],
+            async call(client, args, signal) {
+                const ran = await client.runTask(args.task, { args: args.args?.length ? args.args : undefined, signal });
+                return describeRun(args.task, ran);
+            },
+        },
+        {
+            name: 'run_logs',
+            title: 'Read the log of a run',
+            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.',
+            parameters: {
+                run: { type: 'string', description: 'The id of the run' },
+                task: { type: 'string', description: 'Only the lines of this task' },
+                tail: {
+                    type: 'integer',
+                    description: 'The last lines, or with grep the last matches',
+                    minimum: 1,
+                    maximum: 1000,
+                },
+                from: { type: 'integer', description: 'The first line to read', minimum: 1 },
+                limit: { type: 'integer', description: 'How many lines to read', minimum: 1, maximum: 1000 },
+                grep: { type: 'string', description: 'Only lines that contain this text' },
+                ignore_case: { type: 'boolean', description: 'Ignore case in grep' },
+                context: { type: 'integer', description: 'Lines before and after each match', minimum: 0, maximum: 20 },
+            },
+            required: ['run'],
+            async call(client, args) {
+                const page = await client.logs(args.run, {
+                    task: args.task || undefined,
+                    tail: args.tail || undefined,
+                    from: args.from || undefined,
+                    limit: args.limit || undefined,
+                    grep: args.grep || undefined,
+                    i: args.ignore_case || undefined,
+                    context: args.context || undefined,
+                });
+                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: 'check',
+            title: 'Run a check',
+            description: sandbox_client_1.CHECK_DESCRIPTION,
+            parameters: { task: { type: 'string', description: 'The name of the task' } },
+            required: ['task'],
+            call(client, args, signal) {
+                return (0, sandbox_client_1.runCheck)(client, args.task, signal);
+            },
+        },
+    ];
+}
+exports.createTaskTools = createTaskTools;
+// The parameters as a JSON schema, for MCP and opencode 2.
+function taskToolSchema(tool) {
+    return {
+        type: 'object',
+        properties: Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+            if (parameter.type === 'string[]') {
+                return [name, { type: 'array', items: { type: 'string' }, description: parameter.description }];
+            }
+            if (parameter.type === 'integer') {
+                const { maximum } = parameter;
+                return [
+                    name,
+                    {
+                        type: 'integer',
+                        description: parameter.description,
+                        minimum: parameter.minimum,
+                        ...(maximum !== undefined ? { maximum } : {}),
+                    },
+                ];
+            }
+            return [name, { type: parameter.type, description: parameter.description }];
+        })),
+        required: tool.required,
+    };
+}
+exports.taskToolSchema = taskToolSchema;
+// The parameters with the zod of opencode 1.
+function taskToolArgs(tool, z) {
+    return Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+        let type;
+        if (parameter.type === 'string[]') {
+            type = z.array(z.string());
+        }
+        else if (parameter.type === 'integer') {
+            type = z.number().int().min(parameter.minimum);
+            type = parameter.maximum !== undefined ? type.max(parameter.maximum) : type;
+        }
+        else {
+            type = parameter.type === 'boolean' ? z.boolean() : z.string();
+        }
+        return [name, (tool.required.includes(name) ? type : type.optional()).describe(parameter.description)];
+    }));
+}
+exports.taskToolArgs = taskToolArgs;
+//# sourceMappingURL=task-tools.js.map

package/dist/kubernetes/apply.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replace = exports.apply = exports.statusCodeOf = void 0;
+exports.replaceDeployment = exports.replace = exports.apply = exports.statusCodeOf = void 0;
 // The client throws an ApiException carrying the HTTP status as `code`; watch
 // errors carry it as `statusCode`.
 function statusCodeOf(e) {
@@ -71,4 +71,52 @@ async function replace(instance, spec) {
     }
 }
 exports.replace = replace;
+/**
+ * Makes a Deployment exactly as given, as `replace` does, with a JSON patch of all of it:
+ * the runRole of a server has `patch` on Deployments, not `update` (see the backend docs).
+ * The patch applies only to the version it read, another change in between reads it again.
+ */
+async function replaceDeployment(instance, spec) {
+    const { name, namespace } = spec.metadata;
+    for (let attempt = 1;; attempt++) {
+        let current;
+        try {
+            current = await instance.appsApi.readNamespacedDeployment({ name, namespace });
+        }
+        catch (e) {
+            if (statusCodeOf(e) !== 404) {
+                throw e;
+            }
+            try {
+                return await instance.appsApi.createNamespacedDeployment({ namespace, body: spec });
+            }
+            catch (createError) {
+                if (statusCodeOf(createError) !== 409 || attempt >= 3) {
+                    throw createError;
+                }
+                continue;
+            }
+        }
+        try {
+            return await instance.appsApi.patchNamespacedDeployment({
+                name,
+                namespace,
+                body: [
+                    { op: 'test', path: '/metadata/resourceVersion', value: current.metadata?.resourceVersion },
+                    { op: 'add', path: '/metadata/labels', value: spec.metadata.labels ?? {} },
+                    { op: 'add', path: '/metadata/annotations', value: spec.metadata.annotations ?? {} },
+                    { op: 'add', path: '/spec', value: spec.spec },
+                ],
+            });
+        }
+        catch (e) {
+            // changed since it was read: its test fails (422), or a conflict (409)
+            const code = statusCodeOf(e);
+            if ((code !== 409 && code !== 422) || attempt >= 3) {
+                throw e;
+            }
+        }
+    }
+}
+exports.replaceDeployment = replaceDeployment;
 //# sourceMappingURL=apply.js.map

package/dist/kubernetes/await-running-state.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stopJob = exports.deleteJobAndWait = exports.awaitDeployRunningState = exports.deleteJob = exports.awaitJobCompletion = exports.awaitRunningState = void 0;
+exports.stopJob = exports.deleteJobAndWait = exports.watchKeptPods = exports.KEPT_POD_MS = exports.awaitDeployRollout = exports.awaitDeployRunningState = exports.PASSING_FAILURE_MS = exports.deleteJob = exports.awaitJobCompletion = exports.awaitRunningState = void 0;
 const abort_1 = require("../executer/abort");
 const abort_event_1 = require("../utils/abort-event");
 const apply_1 = require("./apply");
 const sleep_1 = require("../utils/sleep");
+const cluster_state_1 = require("./cluster-state");
 // The waits below poll instead of using the client's Watch: Watch aborts every
 // request after 30s, which a pod or deployment still pulling its image outlasts.
 async function awaitRunningState(instance, env, name, phase, pollInterval = 1000) {
@@ -76,34 +77,192 @@ async function deleteJob(instance, env, name) {
     }
 }
 exports.deleteJob = deleteJob;
-// Waits for a ready replica. The deadline only starts once a pod runs, so an
-// image pull doesn't count against it (as on docker, where it starts after
-// the container started).
+// how long a reason that may still pass (an image pull a registry refused for now, a
+// container the runtime could not create) may last before it fails the service
+exports.PASSING_FAILURE_MS = 60000;
+// Waits for an available replica: a ready one, for a service without a healthcheck one that
+// stayed ready for a while. The deadline only starts once the container runs, and again
+// at each start of it, so an image pull or a back-off doesn't count against it (as on
+// docker, where it starts after the container started). A pod that won't get there without a change (an image
+// that isn't there, a container that crashed once more than its
+// service's `restarts`, 2 by default) fails it at once, with
+// the reason the cluster gives; one that may still pass fails once it lasted a minute.
+// Only the pods of this Deployment count: not the ones of one deleted before it was
+// created again, which may still be there, terminating or not yet.
 async function awaitDeployRunningState(instance, env, name, readiness, pollInterval = 1000, now = Date.now) {
     let runningSince = null;
+    // how often the container was restarted when last looked at
+    let restarts = 0;
+    let said;
+    // since when a pod has had a failure that may still pass, by pod
+    const failingSince = new Map();
     for (;;) {
         const deployment = await instance.appsApi.readNamespacedDeployment({ name, namespace: env.namespace });
-        if ((deployment.status?.readyReplicas ?? 0) > 0) {
+        // available: ready for the Deployment's minReadySeconds
+        if ((deployment.status?.availableReplicas ?? 0) > 0) {
             return;
         }
+        const created = deployment.metadata?.creationTimestamp;
+        const listed = await instance.coreApi.listNamespacedPod({
+            namespace: env.namespace,
+            labelSelector: readiness.podSelector,
+        });
+        const pods = listed.items.filter((pod) => !pod.metadata?.deletionTimestamp &&
+            !(created && pod.metadata?.creationTimestamp && pod.metadata.creationTimestamp < created));
+        for (const [index, pod] of pods.entries()) {
+            const key = pod.metadata?.name ?? `${index}`;
+            const failure = (0, cluster_state_1.getPodFailure)(pod, readiness.container, readiness.restarts);
+            if (!failure) {
+                failingSince.delete(key);
+                continue;
+            }
+            const since = failingSince.get(key) ?? now();
+            failingSince.set(key, since);
+            if (failure.final || now() - since >= exports.PASSING_FAILURE_MS) {
+                throw new Error(`${readiness.subject ?? name} can not become ready, ${failure.text}`);
+            }
+        }
+        const waiting = pods.map((pod) => (0, cluster_state_1.getPodWaiting)(pod, readiness.container)).find((text) => !!text);
+        if (waiting && waiting !== said) {
+            readiness.onWaiting?.(waiting);
+        }
+        said = waiting;
         if (readiness.timeout !== null) {
-            if (runningSince === null) {
-                const pods = await instance.coreApi.listNamespacedPod({
-                    namespace: env.namespace,
-                    labelSelector: readiness.podSelector,
-                });
-                if (pods.items.some((pod) => pod.status?.phase === 'Running')) {
-                    runningSince = now();
-                }
+            // the deadline bounds each start of the container, as on Docker: a crash is counted by
+            // `restarts`, and the back-off before the next start doesn't count against it
+            const statuses = pods.flatMap((pod) => (pod.status?.containerStatuses ?? []).filter((status) => !readiness.container || status.name === readiness.container));
+            const running = statuses.length > 0
+                ? statuses.some((status) => status.state?.running)
+                : pods.some((pod) => pod.status?.phase === 'Running');
+            const restarted = Math.max(0, ...statuses.map((status) => status.restartCount ?? 0));
+            if (!running) {
+                runningSince = null;
+            }
+            else if (runningSince === null || restarted !== restarts) {
+                runningSince = now();
             }
             else if (now() - runningSince >= readiness.timeout) {
                 throw new Error(readiness.timeoutMessage);
             }
+            restarts = restarted;
         }
         await (0, sleep_1.sleep)(pollInterval);
     }
 }
 exports.awaitDeployRunningState = awaitDeployRunningState;
+/**
+ * Waits until every pod of a Deployment is of its spec `generation` and available, as a
+ * rollout of a changed service does. Fails when Kubernetes gave up on it (its progress
+ * deadline), when a new pod (`podSelector`) won't get there without a change (as
+ * awaitDeployRunningState tells), or once one ran for the readiness timeout without getting
+ * ready.
+ */
+async function awaitDeployRollout(instance, env, name, readiness, pollInterval = 1000, now = Date.now) {
+    const subject = readiness.subject ?? name;
+    const timeoutMessage = readiness.timeoutMessage || `${subject} did not get ready`;
+    let runningSince = null;
+    let said;
+    const failingSince = new Map();
+    for (;;) {
+        if (readiness.signal?.aborted) {
+            throw new abort_1.AbortError();
+        }
+        const deployment = await instance.appsApi.readNamespacedDeployment({ name, namespace: env.namespace });
+        const status = deployment.status;
+        if ((status?.observedGeneration ?? 0) >= readiness.generation &&
+            (status?.updatedReplicas ?? 0) >= 1 &&
+            (status?.availableReplicas ?? 0) >= 1 &&
+            (status?.replicas ?? 0) === (status?.updatedReplicas ?? 0)) {
+            return;
+        }
+        const stalled = status?.conditions?.find((condition) => condition.type === 'Progressing' && condition.reason === 'ProgressDeadlineExceeded');
+        if (stalled && (status?.observedGeneration ?? 0) >= readiness.generation) {
+            throw new Error(`${timeoutMessage}: ${stalled.message ?? 'its rollout made no progress'}`);
+        }
+        const listed = await instance.coreApi.listNamespacedPod({
+            namespace: env.namespace,
+            labelSelector: readiness.podSelector,
+        });
+        const pods = listed.items.filter((pod) => !pod.metadata?.deletionTimestamp);
+        for (const [index, pod] of pods.entries()) {
+            const key = pod.metadata?.name ?? `${index}`;
+            const failure = (0, cluster_state_1.getPodFailure)(pod, readiness.container);
+            if (!failure) {
+                failingSince.delete(key);
+                continue;
+            }
+            const since = failingSince.get(key) ?? now();
+            failingSince.set(key, since);
+            if (failure.final || now() - since >= exports.PASSING_FAILURE_MS) {
+                throw new Error(`${subject} can not become ready, ${failure.text}`);
+            }
+        }
+        const waiting = pods.map((pod) => (0, cluster_state_1.getPodWaiting)(pod, readiness.container)).find((text) => !!text);
+        if (waiting && waiting !== said) {
+            readiness.onWaiting?.(waiting);
+        }
+        said = waiting;
+        if (readiness.timeout !== null) {
+            if (runningSince === null) {
+                if (pods.some((pod) => pod.status?.phase === 'Running')) {
+                    runningSince = now();
+                }
+            }
+            else if (now() - runningSince >= readiness.timeout) {
+                throw new Error(timeoutMessage);
+            }
+        }
+        await sleep(pollInterval, readiness.signal ?? new AbortController().signal);
+    }
+}
+exports.awaitDeployRollout = awaitDeployRollout;
+// how long the pod a service that watches its files keeps has to go on running once it got
+// the changed files
+exports.KEPT_POD_MS = 15000;
+/**
+ * Watches the pods of a Deployment that stays (a service that watches its files got the
+ * changed ones, see syncLiveFiles) for `windowMs`: fails when one of them restarts, fails as
+ * awaitDeployRunningState tells, or the Deployment has no available pod any more, so a move
+ * whose files break the service does not count as up.
+ */
+async function watchKeptPods(instance, env, name, readiness, windowMs = exports.KEPT_POD_MS, pollInterval = 1000, now = Date.now) {
+    const subject = readiness.subject ?? name;
+    const restarts = new Map();
+    const started = now();
+    for (;;) {
+        if (readiness.signal?.aborted) {
+            throw new abort_1.AbortError();
+        }
+        const listed = await instance.coreApi.listNamespacedPod({
+            namespace: env.namespace,
+            labelSelector: readiness.podSelector,
+        });
+        for (const pod of listed.items.filter((pod) => !pod.metadata?.deletionTimestamp)) {
+            const key = pod.metadata?.name ?? '';
+            const failure = (0, cluster_state_1.getPodFailure)(pod, readiness.container, readiness.restarts);
+            if (failure) {
+                throw new Error(`${subject} stopped working with the changed files, ${failure.text}`);
+            }
+            const count = (pod.status?.containerStatuses ?? [])
+                .filter((status) => !readiness.container || status.name === readiness.container)
+                .reduce((sum, status) => sum + (status.restartCount ?? 0), 0);
+            const before = restarts.get(key);
+            if (before !== undefined && count > before) {
+                throw new Error(`${subject} stopped working with the changed files, its container restarted`);
+            }
+            restarts.set(key, count);
+        }
+        const deployment = await instance.appsApi.readNamespacedDeployment({ name, namespace: env.namespace });
+        if ((deployment.status?.availableReplicas ?? 0) < 1) {
+            throw new Error(`${subject} stopped working with the changed files, it has no ready pod`);
+        }
+        if (now() - started >= windowMs) {
+            return;
+        }
+        await sleep(pollInterval, readiness.signal ?? new AbortController().signal);
+    }
+}
+exports.watchKeptPods = watchKeptPods;
 // Delete a job and wait until it is gone: its name is reused for the task's next
 // command (and the next run with the same state), and creating it while the old
 // one is still being deleted would pick up the old job.