hammerkit 1.23.0 → 1.24.0

package/dist/server/proposals-api.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProposals = void 0;
+const zod_1 = require("zod");
+const bundle_1 = require("../remote/bundle");
+const definitions_1 = require("./definitions");
+const http_1 = require("./http");
+const oauth_1 = require("./oauth");
+const policy_1 = require("./policy");
+const server_config_1 = require("./server-config");
+const decisionSchema = zod_1.z.object({ reason: zod_1.z.string().max(500).optional() }).strict();
+const same = (a, b) => a.iss === b.iss && a.sub === b.sub;
+// What the caller is shown of a proposal: what it is, who proposed it and the
+// version it would replace, so the files can be compared.
+function toView(store, proposal, principal, grant) {
+    return {
+        ...proposal,
+        base: store.find(proposal.name, 'latest')?.hash ?? null,
+        mine: same(proposal.proposedBy, principal),
+        // approving needs the permission to publish the name, and somebody else's proposal
+        canDecide: proposal.state === 'waiting' && (0, policy_1.mayPublish)(grant, proposal.name) && !same(proposal.proposedBy, principal),
+    };
+}
+/**
+ * New versions of build files that wait for an approval. Whoever may only
+ * propose a version (`propose` on an entitlement) puts one here; someone who may
+ * `publish` that name approves it, and it is published then.
+ *
+ *   GET  /v1/proposals                          the ones the caller proposed or may decide
+ *   GET  /v1/proposals/<name>/<hash>            one of them
+ *   GET  /v1/proposals/<name>/<hash>/files      its files, for who decides
+ *   POST /v1/proposals/<name>/<hash>/approve    publish it (body: optional {reason})
+ *   POST /v1/proposals/<name>/<hash>/reject     drop it
+ */
+async function handleProposals(config, store, proposals, log, principal, req, res, url) {
+    const match = /^\/v1\/proposals(?:\/([^/]+)\/([^/]+)(?:\/(files|approve|reject))?)?$/.exec(url.pathname);
+    if (!match) {
+        return false;
+    }
+    const [, name, hash, action] = match;
+    const grant = (0, policy_1.getGrant)(config.entitlements, principal);
+    // what the caller neither proposed nor may decide does not exist for them
+    const visible = (proposal) => same(proposal.proposedBy, principal) || (0, policy_1.mayPublish)(grant, proposal.name);
+    if (name === undefined) {
+        if (req.method !== 'GET') {
+            (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'GET' });
+            return true;
+        }
+        (0, http_1.send)(res, 200, {
+            proposals: proposals
+                .all()
+                .filter(visible)
+                .map((proposal) => toView(store, proposal, principal, grant)),
+        });
+        return true;
+    }
+    if (!server_config_1.definitionName.safeParse(name).success || !bundle_1.HASH_PATTERN.test(hash)) {
+        (0, http_1.send)(res, 404, { error: 'not found' });
+        return true;
+    }
+    const proposal = proposals.get(name, hash);
+    if (!action) {
+        if (req.method !== 'GET') {
+            (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'GET' });
+            return true;
+        }
+        proposal && visible(proposal)
+            ? (0, http_1.send)(res, 200, toView(store, proposal, principal, grant))
+            : (0, http_1.send)(res, 404, { error: 'not found' });
+        return true;
+    }
+    if (action === 'files') {
+        if (req.method !== 'GET') {
+            (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'GET' });
+            return true;
+        }
+        // the files are for who decides, and for who wrote them
+        const bundle = proposal && visible(proposal) ? proposals.bundle(name, hash) : undefined;
+        bundle ? (0, http_1.send)(res, 200, bundle) : (0, http_1.send)(res, 404, { error: 'not found' });
+        return true;
+    }
+    if (req.method !== 'POST') {
+        (0, http_1.send)(res, 405, { error: 'method not allowed' }, { allow: 'POST' });
+        return true;
+    }
+    const body = decisionSchema.safeParse(req.headers['content-type'] ? await (0, http_1.readJson)(req) : {});
+    if (!body.success) {
+        const issue = body.error.issues[0];
+        (0, http_1.send)(res, 400, { error: `${issue.path.join('.') || 'request'}: ${issue.message}` });
+        return true;
+    }
+    const outcome = action === 'approve' ? 'approved' : 'rejected';
+    try {
+        const result = await proposals.decide(principal, name, hash, outcome, (n) => (0, policy_1.mayPublish)(grant, n), async (bundle) => {
+            const proposed = proposals.get(name, hash);
+            await store.publish(name, bundle, proposed?.proposedBy ?? principal, principal);
+        }, body.data.reason);
+        log(`${action} proposal=${name}@${hash} iss=${principal.iss} sub=${principal.sub} result=${result.status}${body.data.reason ? ` reason=${(0, oauth_1.quote)(body.data.reason)}` : ''}`);
+        switch (result.status) {
+            case 'ok':
+                (0, http_1.send)(res, 200, toView(store, result.proposal, principal, grant));
+                break;
+            case 'own-proposal':
+                (0, http_1.send)(res, 403, { error: 'a version is approved by somebody else than who proposed it' });
+                break;
+            case 'not-waiting':
+                (0, http_1.send)(res, 409, { error: `the proposal is ${result.state}, it does not wait for an approval` });
+                break;
+            default:
+                (0, http_1.send)(res, 404, { error: 'not found' });
+        }
+    }
+    catch (e) {
+        if (e instanceof definitions_1.DefinitionError) {
+            (0, http_1.send)(res, 400, { error: `the build file does not load: ${e.message}` });
+            return true;
+        }
+        throw e;
+    }
+    return true;
+}
+exports.handleProposals = handleProposals;
+//# sourceMappingURL=proposals-api.js.map

package/dist/server/proposals.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalRegistry = exports.ProposalError = void 0;
+class ProposalError extends Error {
+}
+exports.ProposalError = ProposalError;
+// The proposals of the server, in memory: a restart forgets what waits, and
+// whoever proposed it proposes it again. Nothing in here is runnable.
+class ProposalRegistry {
+    constructor(options = {}) {
+        this.entries = new Map();
+        this.closed = false;
+        this.maxWaiting = options.maxWaiting ?? 100;
+        this.timeout = options.timeout ?? 60 * 60 * 1000;
+        this.keep = options.keep ?? 100;
+        this.now = options.now ?? Date.now;
+    }
+    // Proposing what already waits is not an error and changes nothing.
+    propose(version, bundle, proposer) {
+        if (this.closed) {
+            throw new ProposalError('the server is shutting down');
+        }
+        const key = this.key(version.name, version.hash);
+        const existing = this.entries.get(key);
+        if (existing && existing.proposal.state === 'waiting') {
+            return { proposal: { ...existing.proposal }, created: false };
+        }
+        if (this.waiting().length >= this.maxWaiting) {
+            throw new ProposalError('too many build file versions are waiting for an approval');
+        }
+        const proposal = {
+            name: version.name,
+            hash: version.hash,
+            entry: version.entry,
+            tasks: version.tasks,
+            services: version.services,
+            proposedBy: { iss: proposer.iss, sub: proposer.sub },
+            createdAt: new Date(this.now()).toISOString(),
+            expiresAt: new Date(this.now() + this.timeout).toISOString(),
+            state: 'waiting',
+        };
+        const entry = { proposal, bundle };
+        entry.timer = setTimeout(() => this.settle(entry, 'expired'), this.timeout);
+        entry.timer.unref();
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        this.evict();
+        return { proposal: { ...proposal }, created: true };
+    }
+    waiting() {
+        return [...this.entries.values()].filter((e) => e.proposal.state === 'waiting').map((e) => ({ ...e.proposal }));
+    }
+    // Everything kept, newest first.
+    all() {
+        return [...this.entries.values()].map((e) => ({ ...e.proposal })).reverse();
+    }
+    get(name, hash) {
+        const entry = this.entries.get(this.key(name, hash));
+        return entry ? { ...entry.proposal } : undefined;
+    }
+    // The files of one that still waits, for whoever decides on it.
+    bundle(name, hash) {
+        return this.entries.get(this.key(name, hash))?.bundle;
+    }
+    // An approval publishes the files first (`publish`), and only then is the
+    // proposal approved, so it never claims a version that is not there. Nobody
+    // decides on their own proposal.
+    async decide(decider, name, hash, outcome, mayDecide, publish, reason) {
+        const entry = this.entries.get(this.key(name, hash));
+        if (!entry || !mayDecide(name)) {
+            return { status: 'not-found' };
+        }
+        if (entry.proposal.proposedBy.iss === decider.iss && entry.proposal.proposedBy.sub === decider.sub) {
+            return { status: 'own-proposal' };
+        }
+        if (entry.proposal.state !== 'waiting' || !entry.bundle) {
+            return { status: 'not-waiting', state: entry.proposal.state };
+        }
+        if (outcome === 'approved') {
+            await publish(entry.bundle);
+            if (entry.proposal.state !== 'waiting') {
+                return { status: 'not-waiting', state: entry.proposal.state };
+            }
+        }
+        this.settle(entry, outcome, { iss: decider.iss, sub: decider.sub }, reason);
+        return { status: 'ok', proposal: { ...entry.proposal } };
+    }
+    close() {
+        this.closed = true;
+        for (const entry of this.entries.values()) {
+            if (entry.timer) {
+                clearTimeout(entry.timer);
+                entry.timer = undefined;
+            }
+        }
+    }
+    settle(entry, state, by, reason) {
+        if (entry.proposal.state !== 'waiting') {
+            return;
+        }
+        if (entry.timer) {
+            clearTimeout(entry.timer);
+            entry.timer = undefined;
+        }
+        entry.proposal.state = state;
+        entry.proposal.decidedAt = new Date(this.now()).toISOString();
+        if (by) {
+            entry.proposal.decidedBy = by;
+        }
+        if (reason) {
+            entry.proposal.reason = reason;
+        }
+        entry.bundle = undefined;
+    }
+    evict() {
+        const decided = [...this.entries.entries()].filter(([, e]) => e.proposal.state !== 'waiting');
+        for (const [key] of decided.slice(0, Math.max(0, decided.length - this.keep))) {
+            this.entries.delete(key);
+        }
+    }
+    key(name, hash) {
+        return `${name}@${hash}`;
+    }
+}
+exports.ProposalRegistry = ProposalRegistry;
+//# sourceMappingURL=proposals.js.map

package/dist/server/run-request.js

@@ -0,0 +1,67 @@
+"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 name = zod_1.z.string().min(1).max(200);
+// What `POST /v1/runs` takes. Who is asking, which accounts they may use and
+// where code may come from is decided from the token, never from this body.
+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([]),
+    // the service account to use; the caller's default when left out
+    account: name.optional(),
+    source: zod_1.z.discriminatedUnion('type', [
+        zod_1.z.object({ type: zod_1.z.literal('ref'), 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/runs.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unavailableExecutor = exports.RunRegistry = exports.RUN_ID_PATTERN = exports.RunError = exports.isFinal = void 0;
+const crypto_1 = require("crypto");
+const FINAL_STATES = ['succeeded', 'failed', 'cancelled', 'rejected'];
+function isFinal(state) {
+    return FINAL_STATES.includes(state);
+}
+exports.isFinal = isFinal;
+class RunError extends Error {
+}
+exports.RunError = RunError;
+exports.RUN_ID_PATTERN = /^run_[A-Za-z0-9_-]{16}$/;
+// 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.
+class RunRegistry {
+    constructor(options) {
+        this.options = options;
+        this.entries = new Map();
+        this.queue = [];
+        this.running = 0;
+        this.closed = false;
+        this.maxConcurrent = options.maxConcurrent ?? 4;
+        this.keep = options.keep ?? 200;
+        this.maxEvents = options.maxEvents ?? 5000;
+        this.maxWaiting = options.maxWaiting ?? 100;
+        this.approvalTimeout = options.approvalTimeout ?? 60 * 60 * 1000;
+        this.now = options.now ?? Date.now;
+    }
+    // A run that needs an approval waits for it, the others are queued at once.
+    submit(owner, spec, needsApproval = false) {
+        if (this.closed) {
+            throw new RunError('the server is shutting down');
+        }
+        const waiting = needsApproval;
+        if (waiting && this.waiting().length >= this.maxWaiting) {
+            throw new RunError('too many runs are waiting for an approval');
+        }
+        const run = {
+            ...spec,
+            id: `run_${(0, crypto_1.randomBytes)(12).toString('base64url')}`,
+            owner: { iss: owner.iss, sub: owner.sub },
+            state: waiting ? 'awaiting-approval' : 'queued',
+            createdAt: this.timestamp(),
+        };
+        const entry = { run, events: [], listeners: new Set(), abort: new AbortController(), truncated: false };
+        this.entries.set(run.id, entry);
+        this.record(entry, { type: 'state', state: run.state });
+        if (waiting) {
+            run.approval = {
+                expiresAt: new Date(this.now() + this.approvalTimeout).toISOString(),
+            };
+            entry.timer = setTimeout(() => this.expire(entry), this.approvalTimeout);
+            entry.timer.unref();
+        }
+        else {
+            this.queue.push(entry);
+        }
+        this.evict();
+        // what the caller is told is the run as accepted, even when it starts at once
+        const accepted = this.copy(run);
+        this.dispatch();
+        return accepted;
+    }
+    get(owner, id) {
+        const entry = this.find(owner, id);
+        return entry ? this.copy(entry.run) : undefined;
+    }
+    // newest first
+    list(owner) {
+        return [...this.entries.values()]
+            .filter((entry) => this.owns(owner, entry))
+            .map((entry) => this.copy(entry.run))
+            .reverse();
+    }
+    // A queued run is cancelled at once; a running one when its executor stops.
+    cancel(owner, id) {
+        const entry = this.find(owner, id);
+        if (!entry) {
+            return undefined;
+        }
+        if (entry.run.state === 'queued') {
+            this.queue.splice(this.queue.indexOf(entry), 1);
+            this.finish(entry, 'cancelled');
+        }
+        else if (entry.run.state === 'awaiting-approval') {
+            this.finish(entry, 'cancelled');
+        }
+        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.
+    waiting() {
+        return [...this.entries.values()]
+            .filter((entry) => entry.run.state === 'awaiting-approval')
+            .map((entry) => this.copy(entry.run));
+    }
+    // One run that waits (or waited), if `canDecide` says the decider is admin of
+    // its account.
+    getForApproval(id, canDecide) {
+        const entry = this.entries.get(id);
+        if (!entry || !this.mayDecide(entry, canDecide)) {
+            return undefined;
+        }
+        return this.copy(entry.run);
+    }
+    // An approval queues the run, a rejection ends it. Nobody decides on their own run.
+    decide(decider, id, outcome, canDecide, reason) {
+        const entry = this.entries.get(id);
+        if (!entry || !this.mayDecide(entry, canDecide)) {
+            return { status: 'not-found' };
+        }
+        if (this.owns(decider, entry)) {
+            return { status: 'own-run' };
+        }
+        if (entry.run.state !== 'awaiting-approval' || !entry.run.approval) {
+            return { status: 'not-waiting', state: entry.run.state };
+        }
+        const by = { iss: decider.iss, sub: decider.sub };
+        this.record(entry, { type: 'approval', outcome, by, ...(reason ? { reason } : {}) });
+        if (outcome === 'rejected') {
+            this.finish(entry, 'rejected', `rejected by ${by.sub}${reason ? `: ${reason}` : ''}`);
+            return { status: 'ok', run: this.copy(entry.run) };
+        }
+        entry.run.approval.approvedBy = by;
+        entry.run.approval.approvedAt = this.timestamp();
+        this.clearTimer(entry);
+        entry.run.state = 'queued';
+        this.record(entry, { type: 'state', state: 'queued' });
+        this.queue.push(entry);
+        const approved = this.copy(entry.run);
+        this.dispatch();
+        return { status: 'ok', run: approved };
+    }
+    // The events after `after` (0 for all), and a way to follow new ones. The
+    // listener is not called for a run that is already over.
+    watch(owner, id, after, listener) {
+        const entry = this.find(owner, id);
+        if (!entry) {
+            return undefined;
+        }
+        const events = entry.events.filter((event) => event.seq > after);
+        const finished = FINAL_STATES.includes(entry.run.state);
+        if (!finished) {
+            entry.listeners.add(listener);
+        }
+        return { events, finished, stop: () => entry.listeners.delete(listener) };
+    }
+    // Stops accepting runs and aborts the ones in flight.
+    async close() {
+        this.closed = true;
+        for (const entry of this.queue.splice(0)) {
+            this.finish(entry, 'cancelled');
+        }
+        for (const entry of this.entries.values()) {
+            if (entry.run.state === 'awaiting-approval') {
+                this.finish(entry, 'cancelled');
+            }
+        }
+        for (const entry of this.entries.values()) {
+            if (entry.run.state === 'running') {
+                entry.abort.abort();
+            }
+        }
+        while (this.running > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    find(owner, id) {
+        const entry = this.entries.get(id);
+        return entry && this.owns(owner, entry) ? entry : undefined;
+    }
+    mayDecide(entry, canDecide) {
+        return entry.run.approval !== undefined && canDecide(entry.run.account);
+    }
+    expire(entry) {
+        if (entry.run.state === 'awaiting-approval') {
+            this.finish(entry, 'rejected', 'nobody approved it in time');
+        }
+    }
+    clearTimer(entry) {
+        if (entry.timer) {
+            clearTimeout(entry.timer);
+            entry.timer = undefined;
+        }
+    }
+    owns(owner, entry) {
+        return entry.run.owner.iss === owner.iss && entry.run.owner.sub === owner.sub;
+    }
+    copy(run) {
+        return {
+            ...run,
+            tasks: [...run.tasks],
+            definition: { ...run.definition },
+            source: { ...run.source },
+            options: JSON.parse(JSON.stringify(run.options)),
+            owner: { ...run.owner },
+            ...(run.approval ? { approval: JSON.parse(JSON.stringify(run.approval)) } : {}),
+        };
+    }
+    timestamp() {
+        return new Date(this.now()).toISOString();
+    }
+    dispatch() {
+        while (this.running < this.maxConcurrent && this.queue.length > 0) {
+            const entry = this.queue.shift();
+            this.running++;
+            this.execute(entry).finally(() => {
+                this.running--;
+                this.dispatch();
+            });
+        }
+    }
+    async execute(entry) {
+        entry.run.state = 'running';
+        entry.run.startedAt = this.timestamp();
+        this.record(entry, { type: 'state', state: 'running' });
+        try {
+            await this.options.executor.execute(this.copy(entry.run), {
+                emit: (event) => this.record(entry, event),
+                signal: entry.abort.signal,
+            });
+            this.finish(entry, entry.abort.signal.aborted ? 'cancelled' : 'succeeded');
+        }
+        catch (e) {
+            this.finish(entry, entry.abort.signal.aborted ? 'cancelled' : 'failed', entry.abort.signal.aborted ? undefined : e instanceof Error ? e.message : String(e));
+        }
+    }
+    finish(entry, state, error) {
+        this.clearTimer(entry);
+        entry.run.state = state;
+        entry.run.finishedAt = this.timestamp();
+        if (error) {
+            entry.run.error = error;
+        }
+        this.record(entry, { type: 'state', state, ...(error ? { error } : {}) }, true);
+        entry.listeners.clear();
+        this.evict();
+    }
+    record(entry, event, force = false) {
+        // an executor that keeps talking can't fill the memory of the server; the
+        // state changes, which are few, are always kept
+        if (!force && event.type !== 'state' && entry.events.length >= this.maxEvents) {
+            if (!entry.truncated) {
+                entry.truncated = true;
+                this.push(entry, { type: 'truncated' });
+            }
+            return;
+        }
+        this.push(entry, event);
+    }
+    push(entry, event) {
+        const stored = { ...event, seq: entry.events.length + 1, time: this.timestamp() };
+        entry.events.push(stored);
+        for (const listener of entry.listeners) {
+            listener(stored);
+        }
+    }
+    // Only finished runs are dropped, oldest first.
+    evict() {
+        const finished = [...this.entries.values()].filter((entry) => FINAL_STATES.includes(entry.run.state));
+        for (const entry of finished.slice(0, Math.max(0, finished.length - this.keep))) {
+            this.entries.delete(entry.run.id);
+        }
+    }
+}
+exports.RunRegistry = RunRegistry;
+// Used until a backend is wired in: runs are accepted, recorded and failed with
+// a reason, so the API can be used and tested without pretending to execute.
+exports.unavailableExecutor = {
+    async execute() {
+        throw new Error('this server has no backend that can execute runs yet');
+    },
+};
+//# sourceMappingURL=runs.js.map

package/dist/server/server-command.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServerCommand = void 0;
+const commander_1 = require("commander");
+const log_1 = require("../log");
+const server_config_1 = require("./server-config");
+const server_1 = require("./server");
+// Runs this machine as a hammerkit server until interrupted. Like `remote`, it
+// only needs its own config file, not a build file.
+function registerServerCommand(program, environment) {
+    program
+        .command('server')
+        .description('serve this machine to remote runs (experimental)')
+        .addOption(new commander_1.Option('-c, --config <file>', 'server config file').env('HAMMERKIT_SERVER_CONFIG'))
+        .action(async (options) => {
+        try {
+            if (!options.config) {
+                throw new Error('pass the server config with --config or HAMMERKIT_SERVER_CONFIG');
+            }
+            const config = await (0, server_config_1.readServerConfig)(environment, options.config);
+            const server = await (0, server_1.startServer)(config, environment, {
+                log: (line) => environment.stdout.write(`${line}\n`),
+            });
+            environment.stdout.write(`hammerkit server listening on ${server.url}\n`);
+            await new Promise((resolve) => {
+                if (environment.abortCtrl.signal.aborted) {
+                    resolve();
+                }
+                environment.abortCtrl.signal.addEventListener('abort', () => resolve(), { once: true });
+            });
+            await server.close();
+            environment.stdout.write('hammerkit server stopped\n');
+        }
+        catch (e) {
+            if (e instanceof commander_1.CommanderError) {
+                throw e;
+            }
+            program.error(`Server was not successful: ${(0, log_1.getErrorMessage)(e)}`, { exitCode: 1 });
+        }
+    });
+}
+exports.registerServerCommand = registerServerCommand;
+//# sourceMappingURL=server-command.js.map