hammerkit 1.27.0-next.27 → 1.27.0-next.29

package/build.schema.json

@@ -651,6 +651,12 @@
                     "$ref": "#/definitions/hammerkit/properties/tasks/additionalProperties/anyOf/0/properties/resources",
                     "description": "cpu and memory requests and limits"
                   },
+                  "restarts": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 10,
+                    "description": "crashes restarted before it fails on Kubernetes, 0 to 10, 2 by default"
+                  },
                   "volumeSize": {
                     "$ref": "#/definitions/hammerkit/properties/tasks/additionalProperties/anyOf/0/properties/volumeSize",
                     "description": "size of its claim on Kubernetes, e.g. 10Gi"

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

@@ -81,15 +81,18 @@ exports.deleteJob = deleteJob;
 // 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 a pod runs, so an
-// image pull 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 twice in a row) fails it at once, with
+// 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();
@@ -108,7 +111,7 @@ async function awaitDeployRunningState(instance, env, name, readiness, pollInter
             !(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);
+            const failure = (0, cluster_state_1.getPodFailure)(pod, readiness.container, readiness.restarts);
             if (!failure) {
                 failingSince.delete(key);
                 continue;
@@ -125,14 +128,23 @@ async function awaitDeployRunningState(instance, env, name, readiness, pollInter
         }
         said = waiting;
         if (readiness.timeout !== null) {
-            if (runningSince === null) {
-                if (pods.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);
     }

package/dist/kubernetes/cluster-state.js

@@ -12,8 +12,8 @@ const MAX_MESSAGE = 500;
 const MAX_EVENTS = 20;
 // events the result of a task says better: a Job of a failed command
 const SAID_ELSEWHERE = ['BackoffLimitExceeded'];
-// A container restarted this often in a row is taken as one that keeps crashing: once may be
-// a race with a dependency or a slow first start
+// A container restarted this often (ended three times) is taken as one that keeps crashing,
+// unless its service sets `restarts`: once may be a race with a dependency or a slow first start
 exports.CRASHES_TO_FAIL = 2;
 // what a pull error says when the image is not there to pull, or not for this cluster:
 // waiting does not change it. Others (a registry that limits, a token not there yet) may pass.
@@ -21,13 +21,14 @@ const IMAGE_GONE = /not found|manifest unknown|unauthorized|denied|forbidden|inv
 /**
  * Why a pod of a service will not become ready without a change, as the cluster says it:
  * an image that can not be pulled, a container that keeps crashing or can not be created,
- * an init container that failed. Null while it may still get there.
+ * an init container that failed. Null while it may still get there. A container fails once
+ * it was restarted `restarts` times and crashed again.
  *
  * Only what the cluster wrote is quoted: the termination message of a container is its
  * own output (and may hold a value it read), except for the network gate's, which says why
  * the policy did not take hold.
  */
-function getPodFailure(pod, container) {
+function getPodFailure(pod, container, restarts = exports.CRASHES_TO_FAIL) {
     for (const status of pod.status?.initContainerStatuses ?? []) {
         const terminated = status.state?.terminated ?? status.lastState?.terminated;
         if (!terminated || terminated.exitCode === 0) {
@@ -44,7 +45,7 @@ function getPodFailure(pod, container) {
         }
     }
     for (const status of mainStatuses(pod, container)) {
-        const failure = getContainerFailure(status);
+        const failure = getContainerFailure(status, restartsEnded(pod, status), restarts);
         if (failure) {
             return failure;
         }
@@ -52,7 +53,7 @@ function getPodFailure(pod, container) {
     return null;
 }
 exports.getPodFailure = getPodFailure;
-function getContainerFailure(status) {
+function getContainerFailure(status, restartsEnded, restarts) {
     const waiting = status.state?.waiting;
     const reason = waiting?.reason;
     const said = waiting?.message ? `: ${cut(waiting.message)}` : '';
@@ -76,15 +77,21 @@ function getContainerFailure(status) {
         case 'RunContainerError':
             return { text: `its container could not be started (${reason})${said}`, final: false };
         case 'CrashLoopBackOff':
-            return status.restartCount >= exports.CRASHES_TO_FAIL
+            return status.restartCount >= restarts
                 ? { text: `it keeps crashing: ${describeLastExit(status)}`, final: true }
                 : null;
     }
+    // a kubelet may leave an instance that ended as it is until its back-off is over, and say
+    // CrashLoopBackOff only when it looks at the pod again, a minute later: the same crash
+    if (restartsEnded && status.state?.terminated && status.restartCount >= restarts) {
+        return { text: `it keeps crashing: ${describeLastExit(status)}`, final: true };
+    }
     return null;
 }
 // How the last instance of a container ended, as the cluster says it.
 function describeLastExit(status) {
-    const last = status.lastState?.terminated ?? status.state?.terminated;
+    // the instance that ended now, else the one before the one that waits or runs
+    const last = status.state?.terminated ?? status.lastState?.terminated;
     const restarts = `, restarted ${status.restartCount} time${status.restartCount === 1 ? '' : 's'}`;
     if (!last) {
         return `it ended${restarts}`;
@@ -120,6 +127,10 @@ function getPodWaiting(pod, container) {
             case 'CrashLoopBackOff':
                 return `crashed and starts again: ${describeLastExit(status)}`;
         }
+        const ended = status.state?.terminated;
+        if (ended && restartsEnded(pod, status)) {
+            return `${ended.exitCode === 0 ? 'ended' : 'crashed'} and starts again: ${describeLastExit(status)}`;
+        }
         if (status.restartCount > 0 && status.state?.running && !status.ready) {
             return `restarted: ${describeLastExit(status)}`;
         }
@@ -127,6 +138,16 @@ function getPodWaiting(pod, container) {
     return undefined;
 }
 exports.getPodWaiting = getPodWaiting;
+// Whether the kubelet starts a container that ended again: not one of a pod that finished (a
+// task's Job, an evicted pod, which its ReplicaSet replaces) or that never restarts.
+function restartsEnded(pod, status) {
+    const phase = pod.status?.phase;
+    if (phase === 'Succeeded' || phase === 'Failed') {
+        return false;
+    }
+    const policy = pod.spec?.restartPolicy ?? 'Always';
+    return policy === 'Always' || (policy === 'OnFailure' && status.state?.terminated?.exitCode !== 0);
+}
 function mainStatuses(pod, container) {
     return (pod.status?.containerStatuses ?? []).filter((status) => !container || status.name === container);
 }

package/dist/kubernetes/ensure-kubernetes-deployment-exists.js

@@ -17,6 +17,8 @@ const network_policy_1 = require("./network-policy");
 const egress_proxy_1 = require("../network/egress-proxy");
 // what the service was created from, to tell a changed one
 exports.DEFINITION_LABEL = 'hammerkit.dev/definition';
+// how often a starting container is checked: as the liveness probe
+const STARTUP_PERIOD_SECONDS = 5;
 async function ensureKubernetesDeploymentExists(instance, env, service, persistence, secrets, stateKey, 
 // the needed services by name, and the proxy of a limited network
 network) {
@@ -34,6 +36,16 @@ network) {
             failureThreshold: 3,
         }
         : undefined;
+    // the healthcheck's `timeout` for each start: until it passed once, the liveness probe
+    // doesn't kill a container that starts slowly, and the wait fails it with the timeout
+    const startupProbe = probe && service.data.healthcheck
+        ? {
+            ...probe,
+            // a check more than the timeout holds, and one more for the first check's offset: the
+            // wait fails it with the timeout before the kubelet restarts it
+            failureThreshold: Math.ceil(service.data.healthcheck.timeout / (STARTUP_PERIOD_SECONDS * 1000)) + 2,
+        }
+        : undefined;
     const server = env.server;
     const placement = server ? (0, job_placement_1.getPodPlacement)(server, undefined) : null;
     const workspace = (0, volumes_1.getWorkspacePodSpec)(env, persistence);
@@ -103,6 +115,7 @@ network) {
                             })),
                             readinessProbe: probe,
                             livenessProbe: probe,
+                            startupProbe,
                             ...(0, container_resources_1.getKubernetesResources)(service.data.resources),
                             volumeMounts: [...persistence.mounts.map((m) => m.mount), ...secrets.mounts],
                             ...(0, job_placement_1.getContainerSecurity)(env),
@@ -134,6 +147,7 @@ network) {
         container: getServiceContainerName(service),
         subject: `service ${service.name}`,
         onWaiting: (text) => service.status.write('warn', `${service.name} ${text}`),
+        ...(service.data.restarts !== null ? { restarts: service.data.restarts } : {}),
     });
 }
 exports.ensureKubernetesDeploymentExists = ensureKubernetesDeploymentExists;

package/dist/main.js

@@ -8,6 +8,7 @@ const redact_1 = require("./utils/redact");
 const empty_writable_1 = require("./utils/empty-writable");
 const run_program_1 = require("./run-program");
 const abort_on_signals_1 = require("./utils/abort-on-signals");
+const terminal_prompt_1 = require("./utils/terminal-prompt");
 const abortCtrl = new AbortController();
 (0, abort_on_signals_1.abortOnSignals)(process, abortCtrl);
 let settled = false;
@@ -32,6 +33,7 @@ const secrets = (0, redact_1.createSecretRegistry)();
     stdout: process.stdout,
     stderr: process.stderr,
     stdoutColumns: process.stdout.columns,
+    prompt: (0, terminal_prompt_1.getTerminalPrompt)(process.env, abortCtrl.signal),
 }, process.argv, false).then(() => {
     settled = true;
 }, () => {

package/dist/planner/utils/append-work-service.js

@@ -118,6 +118,7 @@ function parseService(workTree, service, environment, context) {
             secrets: (0, work_secret_1.parseWorkSecrets)(service.cwd, context.projectRoot, service.schema.secrets, envs, environment, context.secrets, service.schema.account),
             resources: (0, work_resources_1.parseWorkResources)(service.schema.resources),
             volumeSize: service.schema.volumeSize ?? null,
+            restarts: service.schema.restarts ?? null,
             network: (0, work_network_1.parseWorkNetwork)(service.schema.network),
             networkCeiling: null,
             args: service.schema.args ?? null,

package/dist/remote/remote-work-commands.js

@@ -17,6 +17,7 @@ const units_1 = require("../utils/units");
 const service_tools_1 = require("../harness/service-tools");
 const path_1 = require("path");
 const check_keys_1 = require("../optimizer/check-keys");
+const terminal_prompt_1 = require("../utils/terminal-prompt");
 function describeOutcome(planned) {
     switch (planned.outcome) {
         case 'published':
@@ -174,6 +175,125 @@ function registerWorkCommands(remote, context) {
         const token = await (0, token_source_1.getTokenSource)(environment, chosen.name, chosen.server).token();
         return { ...chosen, token };
     };
+    // publishes the bundle with where it comes from and says what it is now: published,
+    // already published, or only proposed
+    const publishBundle = async (serverName, server, token, bundle, annotations) => {
+        const answer = await (0, server_client_1.callServer)(server, token, 'POST', '/v1/definitions', {
+            ...bundle,
+            annotations,
+        });
+        const version = answer.body;
+        const files = Object.keys(bundle.files).length;
+        // a proposal that already waits answers 200 like a published version, with its state
+        const proposed = answer.status === 202 || version.state !== undefined;
+        const verb = answer.status === 202
+            ? 'proposed'
+            : proposed
+                ? 'already proposed'
+                : answer.status === 201
+                    ? 'published'
+                    : 'already published';
+        environment.stdout.write(`${verb} to ${serverName}: ${(0, server_client_1.printable)(version.hash)} (${files} ${files === 1 ? 'file' : 'files'})\n`);
+        const names = [...(version.tasks ?? []), ...(version.services ?? [])];
+        environment.stdout.write(`tasks and services: ${names.map(server_client_1.printable).join(', ') || 'none'}\n`);
+        for (const line of annotationLines(version.annotations, 'from')) {
+            environment.stdout.write(`${line.trimStart()}\n`);
+        }
+        if (proposed) {
+            environment.stdout.write(`it can not run before somebody who may publish approves it, until ${(0, server_client_1.printable)(version.expiresAt)}\n`);
+        }
+        return { version, proposed };
+    };
+    // what publishing the bundle would do, undefined from a server that can't say (before 1.27)
+    const planBundle = async (server, token, bundle) => {
+        try {
+            return (await (0, server_client_1.callServer)(server, token, 'POST', '/v1/definitions/plan', bundle)).body;
+        }
+        catch (e) {
+            if (e instanceof server_client_1.ServerError && e.status === 404) {
+                return undefined;
+            }
+            throw e;
+        }
+    };
+    // The build file a run or up names, and what `--publish` may publish: the hash of the
+    // build file here, unless `--build` or HAMMERKIT_BUILD names a version.
+    const runDefinition = async (options) => {
+        const named = options.build ?? environment.processEnvs.HAMMERKIT_BUILD;
+        if (named !== undefined) {
+            if (options.publish) {
+                throw new Error(`--publish publishes the build file here, it does not go with ${options.build !== undefined ? '--build' : 'HAMMERKIT_BUILD'}`);
+            }
+            if (!bundle_1.HASH_PATTERN.test(named)) {
+                throw new Error(`${(0, server_client_1.printable)(named)} is not the hash of a published version (sha256:...)`);
+            }
+            return { definition: named };
+        }
+        const local = await (0, collect_bundle_1.collectBundle)(buildFile, environment);
+        return { definition: (0, bundle_1.hashBundle)(local), local };
+    };
+    // Submits a run of a published version. When the server does not have the build file
+    // here, it is published first: with --publish at once, else when the person at the
+    // terminal says so. Without a terminal and without --publish the run fails and says how
+    // to publish it, so CI never waits on a question.
+    const submitPublishing = async (target, request, local, publish) => {
+        const { serverName, server, connection } = target;
+        try {
+            return await (0, sandbox_client_1.submitRun)(connection, request);
+        }
+        catch (e) {
+            const status = e.status;
+            if (!local || status !== 400 || !/no published build file/.test(String(e))) {
+                throw e;
+            }
+        }
+        const definition = request.definition;
+        const notPublished = `the build file here is not published on ${serverName} (${definition})`;
+        const token = await connection.token();
+        if (!publish) {
+            if (!environment.prompt) {
+                throw new Error(`${notPublished}, publish it first with: hammerkit remote publish ${serverName}, or pass --publish`);
+            }
+            // a server before 1.27 can't say what publishing would do: it is asked all the same,
+            // and refuses then what the caller may not do
+            const planned = await planBundle(server, token, local);
+            if (planned && planned.outcome === null) {
+                throw new Error(`${notPublished}, and you may only run published build files (builds: run): ` +
+                    `somebody who may publish publishes it with: hammerkit remote publish ${serverName}`);
+            }
+            if (planned?.outcome !== 'already published') {
+                const files = Object.keys(local.files).length;
+                environment.stdout.write(`${notPublished}, ${files} ${files === 1 ? 'file' : 'files'}\n`);
+                if (planned) {
+                    const names = [...(planned.tasks ?? []), ...(planned.services ?? [])];
+                    environment.stdout.write(`tasks and services: ${names.map(server_client_1.printable).join(', ') || 'none'}\n`);
+                }
+                const proposing = planned?.outcome === 'proposed';
+                if (proposing) {
+                    environment.stdout.write(`${describeOutcome(planned)}\n`);
+                }
+                const answer = await environment.prompt(proposing ? `propose it to ${serverName} now? [y/N] ` : `publish it to ${serverName} now and go on? [y/N] `);
+                if (environment.abortCtrl.signal.aborted) {
+                    throw new Error(`stopped, nothing was published`);
+                }
+                if (!(0, terminal_prompt_1.isYes)(answer)) {
+                    throw new Error(`${notPublished}, nothing was published`);
+                }
+            }
+        }
+        const annotations = await (0, annotations_1.collectAnnotations)(buildFile, Object.keys(local.files));
+        const { version, proposed } = await publishBundle(serverName, server, token, local, annotations).catch((e) => {
+            throw e instanceof server_client_1.ServerError && e.status === 403 ? new Error(`${notPublished}, ${e.message}`) : e;
+        });
+        if (version.hash !== definition) {
+            throw new Error(`${serverName} published ${(0, server_client_1.printable)(version.hash)}, not ${definition} as computed here, nothing was started`);
+        }
+        if (proposed) {
+            throw new Error(`${definition} is only proposed on ${serverName}, nothing was started: ` +
+                'run this again once somebody who may publish approves it');
+        }
+        return (0, sandbox_client_1.submitRun)(connection, request);
+    };
     remote
         .command('publish [server]')
         .description('publish the build file and the files it includes to a server, runs refer to it by its hash')
@@ -198,23 +318,7 @@ function registerWorkCommands(remote, context) {
         }
         const annotations = (0, annotations_1.applyAnnotations)(await (0, annotations_1.collectAnnotations)(buildFile, Object.keys(bundle.files)), options.annotation ?? []);
         const { name: serverName, server, token } = await connect(name);
-        const answer = await (0, server_client_1.callServer)(server, token, 'POST', '/v1/definitions', {
-            ...bundle,
-            annotations,
-        });
-        const version = answer.body;
-        const files = Object.keys(bundle.files).length;
-        const proposed = answer.status === 202;
-        const verb = proposed ? 'proposed' : answer.status === 201 ? 'published' : 'already published';
-        environment.stdout.write(`${verb} to ${serverName}: ${(0, server_client_1.printable)(version.hash)} (${files} ${files === 1 ? 'file' : 'files'})\n`);
-        const names = [...(version.tasks ?? []), ...(version.services ?? [])];
-        environment.stdout.write(`tasks and services: ${names.map(server_client_1.printable).join(', ') || 'none'}\n`);
-        for (const line of annotationLines(version.annotations, 'from')) {
-            environment.stdout.write(`${line.trimStart()}\n`);
-        }
-        if (proposed) {
-            environment.stdout.write(`it can not run before somebody who may publish approves it, until ${(0, server_client_1.printable)(version.expiresAt)}\n`);
-        }
+        await publishBundle(serverName, server, token, bundle, annotations);
     }));
     remote
         .command('run <tasks...>')
@@ -229,12 +333,9 @@ function registerWorkCommands(remote, context) {
         .addOption(new commander_1.Option('--timeout <duration>', 'as --timeout of run: for tasks without their own, such as 30m'))
         .addOption(new commander_1.Option('--max-timeout <duration>', 'as --max-timeout of run: for every task, also one with its own timeout'))
         .addOption(new commander_1.Option('--detach', 'submit the run and exit, without following it: for a check that CI verifies later'))
+        .addOption(new commander_1.Option('--publish', 'publish the build file here first when the server does not have it, without asking; for CI and scripts'))
         .action(guarded('Remote run was not successful', async (tasks, options) => {
-        const named = options.build ?? environment.processEnvs.HAMMERKIT_BUILD;
-        const definition = named ?? (0, bundle_1.hashBundle)(await (0, collect_bundle_1.collectBundle)(buildFile, environment));
-        if (!bundle_1.HASH_PATTERN.test(definition)) {
-            throw new Error(`${(0, server_client_1.printable)(definition)} is not the hash of a published version (sha256:...)`);
-        }
+        const { definition, local } = await runDefinition(options);
         const source = await refSource(options);
         const ref = source.ref;
         const { name: serverName, server } = await getServer(options.server);
@@ -248,21 +349,7 @@ function registerWorkCommands(remote, context) {
         if (passthrough.length > 0) {
             runOptions.args = passthrough;
         }
-        let submitted;
-        try {
-            submitted = await (0, sandbox_client_1.submitRun)(connection, {
-                definition,
-                tasks,
-                source,
-                options: runOptions,
-            });
-        }
-        catch (e) {
-            if (e.status === 400 && !named && /no published build file/.test(String(e))) {
-                throw new Error(`the build file here is not published on ${serverName} (${definition}), publish it first`);
-            }
-            throw e;
-        }
+        const submitted = await submitPublishing({ serverName, server, connection }, { definition, tasks, source, options: runOptions }, local, !!options.publish);
         const at = submitted.source.type === 'ref' ? ` at ${(0, server_client_1.printable)(submitted.source.commit)}` : '';
         environment.stdout.write(`${(0, server_client_1.printable)(submitted.id)} on ${serverName}: ${tasks.map(server_client_1.printable).join(', ')} from ${(0, server_client_1.printable)(ref)}${at}\n`);
         if (options.detach) {
@@ -314,17 +401,14 @@ function registerWorkCommands(remote, context) {
         .addOption(new commander_1.Option('--ref <ref>', 'the branch or tag to start; the branch checked out here when left out'))
         .addOption(new commander_1.Option('--commit <sha>', 'the commit the ref has to be at; the commit checked out here when --ref is left out'))
         .addOption(new commander_1.Option('--env <name>', 'the environment of the build file, as --env of run'))
+        .addOption(new commander_1.Option('--publish', 'publish the build file here first when the server does not have it, without asking; for CI and scripts'))
         .action(guarded('Remote up was not successful', async (services, options) => {
-        const named = options.build ?? environment.processEnvs.HAMMERKIT_BUILD;
-        const definition = named ?? (0, bundle_1.hashBundle)(await (0, collect_bundle_1.collectBundle)(buildFile, environment));
-        if (!bundle_1.HASH_PATTERN.test(definition)) {
-            throw new Error(`${(0, server_client_1.printable)(definition)} is not the hash of a published version (sha256:...)`);
-        }
+        const { definition, local } = await runDefinition(options);
         const endpoints = (options.endpoint ?? []).map(service_tools_1.parseEndpoint);
         const source = await refSource(options);
         const { name: serverName, server } = await getServer(options.server);
         const connection = { url: server.url, ...(0, token_source_1.getTokenSource)(environment, serverName, server) };
-        const submitted = await (0, sandbox_client_1.submitRun)(connection, {
+        const submitted = await submitPublishing({ serverName, server, connection }, {
             definition,
             services,
             endpoints,
@@ -333,7 +417,7 @@ function registerWorkCommands(remote, context) {
             ...(options.name ? { name: options.name } : {}),
             source,
             options: options.env ? { env: options.env } : {},
-        });
+        }, local, !!options.publish);
         environment.stdout.write(`${(0, server_client_1.printable)(submitted.id)} on ${serverName}: ${services.map(server_client_1.printable).join(', ')} from ${(0, server_client_1.printable)(source.ref)}${submitted.source.type === 'ref' ? ` at ${(0, server_client_1.printable)(submitted.source.commit)}` : ''}\n`);
         const followed = await (0, sandbox_client_1.followRun)(connection, submitted, {
             signal: environment.abortCtrl.signal,

package/dist/schema/build-file-container-service-schema.js

@@ -41,6 +41,14 @@ exports.buildFileContainerServiceSchema = (0, zod_1.object)({
     // the service account its provider secrets are read as, unless a secret names one
     account: (0, zod_1.string)().optional(),
     resources: resources_schema_1.resourcesSchema.optional(),
+    // on Kubernetes, how often its container may crash and be restarted before the
+    // service fails (2 by default): it fails when it crashes once more
+    restarts: (0, zod_1.number)()
+        .int()
+        .min(0)
+        .max(10)
+        .describe('crashes restarted before it fails on Kubernetes, 0 to 10, 2 by default')
+        .optional(),
     // on Kubernetes, the size of the claim that holds its sources, mounts and volumes
     volumeSize: size_schema_1.sizeSchema.describe('size of its claim on Kubernetes, e.g. 10Gi').optional(),
     // what the service reaches besides its needs; tasks needing it always reach it

package/dist/utils/terminal-prompt.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isYes = exports.getTerminalPrompt = exports.terminalPrompt = void 0;
+const readline_1 = require("readline");
+/**
+ * Asks the person at the terminal one question and answers the line they typed, or
+ * undefined when the input ended or the signal stopped the command first (Ctrl-C).
+ * The terminal stays in its own line mode, so Ctrl-C is a signal as anywhere else.
+ */
+function terminalPrompt(input, output, signal) {
+    return (question) => new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve(undefined);
+            return;
+        }
+        const lines = (0, readline_1.createInterface)({ input, output, terminal: false });
+        let answer;
+        const stop = () => lines.close();
+        signal.addEventListener('abort', stop, { once: true });
+        lines.once('close', () => {
+            signal.removeEventListener('abort', stop);
+            if (answer === undefined) {
+                // what was asked ends on a line of its own
+                output.write('\n');
+            }
+            resolve(answer);
+        });
+        lines.question(question, (line) => {
+            answer = line;
+            lines.close();
+        });
+    });
+}
+exports.terminalPrompt = terminalPrompt;
+/**
+ * The prompt of the CLI: only when somebody sits at a terminal to answer it, never in
+ * CI, where a question would wait until the job times out.
+ */
+function getTerminalPrompt(processEnvs, signal, stdio = process) {
+    if (!stdio.stdin.isTTY || !stdio.stdout.isTTY || isSet(processEnvs.CI)) {
+        return undefined;
+    }
+    return terminalPrompt(stdio.stdin, stdio.stdout, signal);
+}
+exports.getTerminalPrompt = getTerminalPrompt;
+function isSet(value) {
+    return value !== undefined && value !== '' && value !== '0' && value.toLowerCase() !== 'false';
+}
+function isYes(answer) {
+    return /^\s*y(es)?\s*$/i.test(answer ?? '');
+}
+exports.isYes = isYes;
+//# sourceMappingURL=terminal-prompt.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hammerkit",
   "description": "Containerized build tool with incremental caching that runs the same build file locally, in Docker and on Kubernetes.",
-  "version": "1.27.0-next.27",
+  "version": "1.27.0-next.29",
   "keywords": [
     "build",
     "build-tool",