hammerkit 1.23.0 → 1.25.0

package/dist/server/run-request.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRequestSchema = exports.runOptionsSchema = void 0;
+const zod_1 = require("zod");
+const units_1 = require("../utils/units");
+const bundle_1 = require("../remote/bundle");
+const server_config_1 = require("./server-config");
+const repo_1 = require("./repo");
+const name = zod_1.z.string().min(1).max(200);
+// What `POST /v1/runs` takes. Who is asking and which accounts they may use is
+// decided from the token, never from this body; the accounts a run uses are those
+// its secrets are read as, which the server derives from the published build file.
+const duration = zod_1.z.string().refine((value) => {
+    try {
+        (0, units_1.parseDuration)(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, 'expected a duration like 30s, 5m or 1h30m');
+// The settings of `hammerkit run` that make sense for a run on a server. What
+// the server limits itself (workers, resources) and what only a terminal
+// needs (watch, log mode) are left out.
+exports.runOptionsSchema = zod_1.z
+    .object({
+    // as --env
+    env: name.optional(),
+    // as --filter and --exclude: labels
+    filter: zod_1.z.array(name).max(20).optional(),
+    exclude: zod_1.z.array(name).max(20).optional(),
+    // as --cache
+    cache: zod_1.z.enum(['checksum', 'modify-date', 'none']).optional(),
+    // as --cache-read-only
+    cacheReadOnly: zod_1.z.boolean().optional(),
+    // as --timeout
+    timeout: duration.optional(),
+    // as --no-skip-deps when false
+    skipDeps: zod_1.z.boolean().optional(),
+})
+    .strict();
+exports.runRequestSchema = zod_1.z
+    .object({
+    // the published build file to run, and the version of it: a hash, or the
+    // latest when left out. The server answers with the hash it chose.
+    definition: zod_1.z
+        .object({
+        name: server_config_1.definitionName,
+        hash: zod_1.z.union([zod_1.z.literal('latest'), zod_1.z.string().regex(bundle_1.HASH_PATTERN)]).default('latest'),
+    })
+        .strict(),
+    // tasks by their name in the build file, as on the command line; labels in
+    // the options can select tasks instead
+    tasks: zod_1.z.array(name).max(100).default([]),
+    source: zod_1.z.discriminatedUnion('type', [
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('ref'),
+            // `host/path`, such as github.com/corp/payments; the server reads it from its own
+            // sources, a url is never taken from a request
+            repo: zod_1.z.string().transform((value, ctx) => {
+                const repo = (0, repo_1.normalizeRepo)(value);
+                if (!repo) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: 'expected a repository like github.com/corp/payments',
+                    });
+                    return zod_1.z.NEVER;
+                }
+                return repo;
+            }),
+            ref: name,
+        })
+            .strict(),
+        // the name of a tree announced with POST /v1/sources
+        zod_1.z.object({ type: zod_1.z.literal('upload'), snapshot: zod_1.z.string().regex(bundle_1.HASH_PATTERN) }).strict(),
+    ]),
+    options: exports.runOptionsSchema.default({}),
+})
+    .strict()
+    .refine((request) => request.tasks.length > 0 || (request.options.filter ?? []).length > 0, {
+    message: 'name at least one task, or filter by labels',
+    path: ['tasks'],
+});
+//# sourceMappingURL=run-request.js.map

package/dist/server/run-store.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRunStore = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const runs_1 = require("./runs");
+/**
+ * One file per run, written to a temporary file and renamed, so a crash leaves the
+ * old record and not half a new one. A record holds what the server already shows
+ * the caller: the state, the plan, the logs as they were masked. Only the user of the
+ * server can read the files.
+ */
+class FileRunStore {
+    constructor(directory) {
+        this.directory = directory;
+    }
+    async save(record) {
+        await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+        const file = (0, path_1.join)(this.directory, `${record.run.id}.json`);
+        const temporary = `${file}.${process.pid}.tmp`;
+        await (0, promises_1.writeFile)(temporary, JSON.stringify(record), { mode: 0o600 });
+        await (0, promises_1.rename)(temporary, file);
+    }
+    async remove(id) {
+        await (0, promises_1.rm)((0, path_1.join)(this.directory, `${id}.json`), { force: true });
+    }
+    async load() {
+        const records = [];
+        const skipped = [];
+        let names;
+        try {
+            names = await (0, promises_1.readdir)(this.directory);
+        }
+        catch {
+            return { records, skipped };
+        }
+        for (const name of names) {
+            if (!name.endsWith('.json')) {
+                // a record that was being written when the server stopped
+                if (name.endsWith('.tmp')) {
+                    await (0, promises_1.rm)((0, path_1.join)(this.directory, name), { force: true });
+                }
+                continue;
+            }
+            try {
+                const record = JSON.parse(await (0, promises_1.readFile)((0, path_1.join)(this.directory, name), 'utf8'));
+                if (!runs_1.RUN_ID_PATTERN.test(record.run.id) || `${record.run.id}.json` !== name || !Array.isArray(record.events)) {
+                    throw new Error('not a run record');
+                }
+                records.push(record);
+            }
+            catch {
+                skipped.push(name);
+            }
+        }
+        records.sort((a, b) => a.run.createdAt.localeCompare(b.run.createdAt));
+        return { records, skipped };
+    }
+}
+exports.FileRunStore = FileRunStore;
+//# sourceMappingURL=run-store.js.map

package/dist/server/run-worker-command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunWorkerCommand = void 0;
+const run_worker_1 = require("./run-worker");
+// `hammerkit server-run`: what the server starts for each run. It reads the run on its
+// standard input, executes it in the current directory and reports on its standard output.
+// Not for people: the input comes from the server and says which accounts it may read.
+function registerRunWorkerCommand(program, environment) {
+    program
+        .command('server-run', { hidden: true })
+        .description('execute one run for a hammerkit server (internal)')
+        .action(async () => {
+        await (0, run_worker_1.workerMain)(process.stdin, environment.stdout, environment.processEnvs, environment.cwd, environment.abortCtrl);
+    });
+}
+exports.registerRunWorkerCommand = registerRunWorkerCommand;
+//# sourceMappingURL=run-worker-command.js.map

package/dist/server/run-worker-main.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const run_worker_1 = require("./run-worker");
+// The process of a run without the command line, for tests that run from source
+// (`vite-node src/server/run-worker-main.ts`). A build uses `hammerkit server-run`.
+(0, run_worker_1.workerMain)(process.stdin, process.stdout, process.env, process.cwd(), new AbortController()).then(() => process.exit(0), () => process.exit(1));
+//# sourceMappingURL=run-worker-main.js.map

package/dist/server/run-worker.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerMain = exports.runTasks = exports.workerInputSchema = void 0;
+const zod_1 = require("zod");
+const cli_1 = require("../cli");
+const get_file_context_1 = require("../file/get-file-context");
+const log_1 = require("../log");
+const schema_parser_1 = require("../schema/schema-parser");
+const reference_parser_1 = require("../schema/reference-parser");
+const work_scope_parser_1 = require("../schema/work-scope-parser");
+const work_item_status_1 = require("../planner/work-item-status");
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+const redact_1 = require("../utils/redact");
+const empty_writable_1 = require("../utils/empty-writable");
+const units_1 = require("../utils/units");
+const run_request_1 = require("./run-request");
+const run_plan_1 = require("./run-plan");
+// one log line of a task is cut here, the registry caps how many events a run keeps
+const MAX_LOG_TEXT = 8 * 1024;
+/**
+ * What the process that executes a run is told, on its standard input. A run executes
+ * in a process of its own, started with an environment the server built, so what the
+ * engine reads of its process (the home directory, the docker host, the cache directory)
+ * is the run's and not the server's.
+ */
+exports.workerInputSchema = zod_1.z
+    .object({
+    // the build file to start from, in the checkout
+    entry: zod_1.z.string().min(1),
+    tasks: zod_1.z.array(zod_1.z.string()),
+    options: run_request_1.runOptionsSchema,
+    // the accounts the run was admitted for; a secret of any other is refused
+    accounts: zod_1.z.array(zod_1.z.string()),
+    // the operator's providers and accounts, as the server read them from its config
+    catalog: zod_1.z.custom((value) => typeof value === 'object' && value !== null),
+})
+    .strict();
+/**
+ * Executes the tasks of a run with the engine of `hammerkit run`. The caller says which
+ * process this is in: it reports what happens through `emit` and stops when `abortCtrl`
+ * is aborted.
+ */
+async function runTasks(input, cwd, processEnvs, abortCtrl, 
+// whether the run was stopped from outside; the engine aborts too when a task fails
+cancelled, emit) {
+    const secrets = (0, redact_1.createSecretRegistry)();
+    const status = (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)(), secrets);
+    // what the engine would print to a terminal is not wanted, its status console
+    // is what is streamed: it is redacted with the secrets of this run
+    const environment = {
+        processEnvs,
+        hosted: { catalog: input.catalog, accounts: input.accounts },
+        abortCtrl,
+        cwd,
+        file: (0, get_file_context_1.getFileContext)(cwd),
+        console: (0, log_1.consoleContext)((0, empty_writable_1.emptyWritable)()),
+        status,
+        secrets,
+        stdout: (0, empty_writable_1.emptyWritable)(),
+        stderr: (0, empty_writable_1.emptyWritable)(),
+        stdoutColumns: 120,
+    };
+    const listener = status.on((message) => {
+        if (message.type === 'console') {
+            emit({
+                type: 'log',
+                task: message.context.name,
+                stream: message.console,
+                text: message.message.slice(0, MAX_LOG_TEXT),
+            });
+        }
+        else if (message.level === 'error' || message.level === 'warn') {
+            emit({
+                type: 'log',
+                task: message.context.name,
+                stream: 'stderr',
+                text: message.message.slice(0, MAX_LOG_TEXT),
+            });
+        }
+    });
+    try {
+        const options = input.options;
+        const execOptions = {
+            logMode: 'live',
+            cacheDefault: options.cache ?? 'checksum',
+            cacheReadOnly: options.cacheReadOnly ?? false,
+            timeout: options.timeout ? (0, units_1.parseDuration)(options.timeout) : null,
+            skipDeps: options.skipDeps !== false,
+        };
+        for (const { name, scope } of (0, run_plan_1.getRunScopes)(input.tasks, options)) {
+            const { ctx, scope: parsed } = await (0, schema_parser_1.createParseContext)(input.entry, environment);
+            const workTree = (0, work_scope_parser_1.getWorkContext)(await (0, reference_parser_1.parseReferences)(ctx, parsed, environment), scope, environment);
+            const cli = (0, cli_1.getCli)(workTree, environment);
+            if (cli.tasks().length === 0) {
+                throw new Error(`no tasks found for ${name}`);
+            }
+            const execution = cli.exec({ ...execOptions, workers: cli.defaultWorkers() });
+            const seen = new Map();
+            const watch = execution.state.on('run-events', () => reportTasks(emit, execution.state.current, seen));
+            try {
+                const result = await execution.start();
+                reportTasks(emit, execution.state.current, seen);
+                if (!result.success) {
+                    throw new Error(cancelled() ? 'the run was cancelled' : `${name} failed`);
+                }
+            }
+            finally {
+                watch.close();
+            }
+        }
+    }
+    finally {
+        listener.close();
+    }
+}
+exports.runTasks = runTasks;
+// A task event when a task has moved on since the last look.
+function reportTasks(emit, workTree, seen) {
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const state = task.state.current;
+        let event = null;
+        if (state.type === 'running') {
+            event = 'running';
+        }
+        else if (state.type === 'completed') {
+            event = state.skipped ? null : state.cached ? 'cached' : 'succeeded';
+        }
+        else if (state.type === 'error' || state.type === 'crash') {
+            event = 'failed';
+        }
+        if (event && seen.get(task.name) !== event) {
+            seen.set(task.name, event);
+            emit({ type: 'task', task: task.name, state: event });
+        }
+    }
+}
+async function readAll(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * The process of one run: reads its input, executes the tasks in the current directory
+ * and reports as lines of JSON. It exits 0 when it could say how the run ended, and the
+ * server reads that from the last line; a process that dies before has crashed.
+ */
+async function workerMain(stdin, stdout, processEnvs, cwd, abortCtrl) {
+    const say = (message) => stdout.write(`${JSON.stringify(message)}\n`);
+    // the server stops a run with a signal
+    let cancelled = false;
+    const stop = () => {
+        cancelled = true;
+        abortCtrl.abort();
+    };
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+    signals.forEach((signal) => process.on(signal, stop));
+    let input;
+    try {
+        input = exports.workerInputSchema.parse(JSON.parse(await readAll(stdin)));
+    }
+    catch (e) {
+        say({ kind: 'result', ok: false, error: `the run could not be read: ${e instanceof Error ? e.message : e}` });
+        return;
+    }
+    try {
+        await runTasks(input, cwd, processEnvs, abortCtrl, () => cancelled, (event) => say({ kind: 'event', event }));
+        say({ kind: 'result', ok: true });
+    }
+    catch (e) {
+        say({ kind: 'result', ok: false, error: e instanceof Error ? e.message : String(e) });
+    }
+    finally {
+        signals.forEach((signal) => process.off(signal, stop));
+    }
+}
+exports.workerMain = workerMain;
+//# sourceMappingURL=run-worker.js.map