hammerkit 1.27.0-next.27 → 1.27.0-next.28

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/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/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.28",
   "keywords": [
     "build",
     "build-tool",