velocious 1.0.571 → 1.0.573

package/build/src/deployment-api/controller.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Authenticated HTTP API for callable deployments. Mounted by
+ * {@link import("./index.js").default} as a route-resolver hook so it can ship
+ * inside the velocious package. Every action is gated by a bearer-token check
+ * against the configured access tokens; the API exposes only allowlisted
+ * project/stage pairs and full immutable revisions, and delegates all
+ * execution to the configured adapter. It never accepts commands, paths,
+ * arbitrary refs, environment variables, or raw log output.
+ */
+export default class VelociousDeploymentApiController extends Controller {
+    /**
+     * Runs mount options.
+     * @returns {import("./registry.js").DeploymentMountOptions} - Options for the mount that matched this request.
+     */
+    _mountOptions(): import("./registry.js").DeploymentMountOptions;
+    /**
+     * Runs store.
+     * @returns {DeploymentRunStore} - Run store scoped to the mount's database.
+     */
+    _store(): DeploymentRunStore;
+    _deploymentRunStore: DeploymentRunStore | undefined;
+    /**
+     * Reports one internally consumed framework failure on both documented
+     * error channels so framework-specific and unified reporters see the same
+     * payload.
+     * @param {object} args - Options.
+     * @param {string} args.context - Deployment API failure context.
+     * @param {?} args.error - Consumed error.
+     * @returns {void} - No return value.
+     */
+    _emitFrameworkError({ context, error }: {
+        context: string;
+        error: unknown;
+    }): void;
+    /**
+     * Authorizes the request with a constant-time bearer-token comparison and
+     * runs the action body only when authorized. Renders a 401 otherwise. The
+     * base controller has no before-action halting, so authorization is enforced
+     * here per action. Tokens are only accepted through the Authorization header
+     * — never through URLs — and are never rendered back.
+     * @param {() => Promise<void>} actionFn - Action body.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _respond(actionFn: () => Promise<void>): Promise<void>;
+    /**
+     * Creates a deployment run for an allowlisted project/stage and a full
+     * immutable revision reachable from the approved release branch. Idempotent:
+     * a retried idempotency key reads the original run, a reused key with a
+     * different payload conflicts, and an active run for the same project/stage
+     * returns a bounded conflict.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    create(): Promise<void>;
+    /**
+     * Renders a previously created run for an idempotency-key hit: a replay when
+     * the payload matches, a bounded conflict when it doesn't.
+     * @param {object} args - Options.
+     * @param {import("./run-store.js").DeploymentRunRow} args.existingRun - The stored run.
+     * @param {string} args.project - Requested project.
+     * @param {string} args.revision - Requested revision.
+     * @param {string} args.stage - Requested stage.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _renderExistingRun({ existingRun, project, revision, stage }: {
+        existingRun: import("./run-store.js").DeploymentRunRow;
+        project: string;
+        revision: string;
+        stage: string;
+    }): Promise<void>;
+    /**
+     * Returns the bounded state of a single run, enriched with the adapter's
+     * live status when the integration provides one.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    show(): Promise<void>;
+    /**
+     * Executes a created run asynchronously: registers it as active in this
+     * process, marks it running, heartbeats its ownership lease while the
+     * adapter deploys, and records the sanitized outcome. A deployment failure
+     * is an expected operational result — it is persisted with its sanitized
+     * recovery information instead of being raised, so it stays visible through
+     * readback and audit rather than crashing the worker.
+     * @param {object} args - Options.
+     * @param {import("./registry.js").DeploymentMountOptions} args.options - Mount options.
+     * @param {import("./run-store.js").DeploymentRunRow} args.run - The created run.
+     * @returns {Promise<void>} - Resolves when the outcome is recorded.
+     */
+    _executeRun({ options, run }: {
+        options: import("./registry.js").DeploymentMountOptions;
+        run: import("./run-store.js").DeploymentRunRow;
+    }): Promise<void>;
+    /**
+     * Records a sanitized audit event. Audit persistence must never strand or
+     * suppress a deployment, so a failure here is reported on the
+     * framework-error and unified all-error channels (where process-level bug
+     * reporters capture it), and execution continues.
+     * @param {object} args - Options.
+     * @param {string} args.event - Event name.
+     * @param {Record<string, ?>} args.payload - Payload; sanitized and redacted before persistence.
+     * @param {string | null} args.runId - Owning run id.
+     * @returns {Promise<void>} - Resolves when recorded or reported.
+     */
+    _audit({ event, payload, runId }: {
+        event: string;
+        payload: Record<string, unknown>;
+        runId: string | null;
+    }): Promise<void>;
+    /**
+     * Serializes a run for the API.
+     * @param {import("./run-store.js").DeploymentRunRow} run - Run row.
+     * @returns {Record<string, ?>} - Serialized run.
+     */
+    _serializeRun(run: import("./run-store.js").DeploymentRunRow): Record<string, unknown>;
+}
+import Controller from "../controller.js";
+import DeploymentRunStore from "./run-store.js";
+//# sourceMappingURL=controller.d.ts.map

package/build/src/deployment-api/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/deployment-api/controller.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH;IACE;;;OAGG;IACH,iBAFa,OAAO,eAAe,EAAE,sBAAsB,CAS1D;IAED;;;OAGG;IACH,UAFa,kBAAkB,CAa9B;IATG,oDAKE;IAMN;;;;;;;;OAQG;IACH,wCAJG;QAAqB,OAAO,EAApB,MAAM;QACE,KAAK,EAAb,OAAC;KACT,GAAU,IAAI,CAQhB;IAED;;;;;;;;OAQG;IACH,mBAHW,MAAM,OAAO,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAED;;;;;;;OAOG;IACH,UAFa,OAAO,CAAC,IAAI,CAAC,CAsGzB;IAED;;;;;;;;;OASG;IACH,8DANG;QAAwD,WAAW,EAA3D,OAAO,gBAAgB,EAAE,gBAAgB;QAC5B,OAAO,EAApB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,KAAK,EAAlB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAWzB;IAED;;;;OAIG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CA2BzB;IAED;;;;;;;;;;;OAWG;IACH,8BAJG;QAA6D,OAAO,EAA5D,OAAO,eAAe,EAAE,sBAAsB;QACE,GAAG,EAAnD,OAAO,gBAAgB,EAAE,gBAAgB;KACjD,GAAU,OAAO,CAAC,IAAI,CAAC,CAsGzB;IAED;;;;;;;;;;OAUG;IACH,kCALG;QAAqB,KAAK,EAAlB,MAAM;QACkB,OAAO,EAA/B,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACG,KAAK,EAAzB,MAAM,GAAG,IAAI;KACrB,GAAU,OAAO,CAAC,IAAI,CAAC,CAUzB;IAED;;;;OAIG;IACH,mBAHW,OAAO,gBAAgB,EAAE,gBAAgB,GACvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAgB7B;CACF;uBAlbsB,kBAAkB;+BACoD,gBAAgB"}

package/build/src/deployment-api/controller.js

@@ -0,0 +1,384 @@
+// @ts-check
+import Controller from "../controller.js";
+import DeploymentRunStore, { registerActiveDeploymentRun, unregisterActiveDeploymentRun } from "./run-store.js";
+import { bearerToken, constantTimeEqual } from "../utils/bearer-token.js";
+import { getDeploymentMount } from "./registry.js";
+import { sanitizeAdapterValue, sanitizeErrorPayload } from "./sanitize.js";
+const REVISION_PATTERN = /^[0-9a-f]{40}$/;
+const MAX_IDEMPOTENCY_KEY_LENGTH = 255;
+/**
+ * Resolves allowlisted stage options with own-property checks only, so
+ * request-controlled names like "__proto__" or "constructor" can never
+ * resolve inherited values. The normalized maps are also null-prototype, so
+ * this is defense in depth.
+ * @param {import("./registry.js").DeploymentMountOptions} options - Mount options.
+ * @param {string} project - Requested project identifier.
+ * @param {string} stage - Requested stage identifier.
+ * @returns {import("./registry.js").DeploymentStageOptions | undefined} - Stage options when allowlisted.
+ */
+function lookupStageOptions(options, project, stage) {
+    if (!Object.hasOwn(options.projects, project))
+        return undefined;
+    const stages = options.projects[project].stages;
+    if (!Object.hasOwn(stages, stage))
+        return undefined;
+    return stages[stage];
+}
+/**
+ * Authenticated HTTP API for callable deployments. Mounted by
+ * {@link import("./index.js").default} as a route-resolver hook so it can ship
+ * inside the velocious package. Every action is gated by a bearer-token check
+ * against the configured access tokens; the API exposes only allowlisted
+ * project/stage pairs and full immutable revisions, and delegates all
+ * execution to the configured adapter. It never accepts commands, paths,
+ * arbitrary refs, environment variables, or raw log output.
+ */
+export default class VelociousDeploymentApiController extends Controller {
+    /**
+     * Runs mount options.
+     * @returns {import("./registry.js").DeploymentMountOptions} - Options for the mount that matched this request.
+     */
+    _mountOptions() {
+        const at = /** @type {string} */ (this.params().velociousDeploymentMountAt);
+        const options = getDeploymentMount(this.getConfiguration(), at);
+        if (!options)
+            throw new Error(`No deployment API mount registered at ${at}`);
+        return options;
+    }
+    /**
+     * Runs store.
+     * @returns {DeploymentRunStore} - Run store scoped to the mount's database.
+     */
+    _store() {
+        if (!this._deploymentRunStore) {
+            this._deploymentRunStore = new DeploymentRunStore({
+                configuration: this.getConfiguration(),
+                databaseIdentifier: this._mountOptions().databaseIdentifier,
+                mountIdentifier: this._mountOptions().mountIdentifier,
+                staleRunTimeoutMs: this._mountOptions().staleRunTimeoutMs
+            });
+        }
+        return this._deploymentRunStore;
+    }
+    /**
+     * Reports one internally consumed framework failure on both documented
+     * error channels so framework-specific and unified reporters see the same
+     * payload.
+     * @param {object} args - Options.
+     * @param {string} args.context - Deployment API failure context.
+     * @param {?} args.error - Consumed error.
+     * @returns {void} - No return value.
+     */
+    _emitFrameworkError({ context, error }) {
+        const errorEvents = this.getConfiguration().getErrorEvents();
+        const payload = { context, error, request: this.getRequest() };
+        errorEvents.emit("framework-error", payload);
+        errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+    }
+    /**
+     * Authorizes the request with a constant-time bearer-token comparison and
+     * runs the action body only when authorized. Renders a 401 otherwise. The
+     * base controller has no before-action halting, so authorization is enforced
+     * here per action. Tokens are only accepted through the Authorization header
+     * — never through URLs — and are never rendered back.
+     * @param {() => Promise<void>} actionFn - Action body.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _respond(actionFn) {
+        const token = bearerToken(this.request());
+        let authorized = false;
+        if (token) {
+            for (const accessToken of this._mountOptions().accessTokens) {
+                if (constantTimeEqual(token, accessToken)) {
+                    authorized = true;
+                    break;
+                }
+            }
+        }
+        if (!authorized) {
+            await this.render({ json: { error: "unauthorized" }, status: 401 });
+            return;
+        }
+        await actionFn();
+    }
+    /**
+     * Creates a deployment run for an allowlisted project/stage and a full
+     * immutable revision reachable from the approved release branch. Idempotent:
+     * a retried idempotency key reads the original run, a reused key with a
+     * different payload conflicts, and an active run for the same project/stage
+     * returns a bounded conflict.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async create() {
+        await this._respond(async () => {
+            const params = this.params();
+            const revision = typeof params.revision === "string" ? params.revision : null;
+            const idempotencyKey = typeof params.idempotencyKey === "string" ? params.idempotencyKey : null;
+            const invalidFields = [];
+            if (!revision || !REVISION_PATTERN.test(revision))
+                invalidFields.push("revision");
+            if (!idempotencyKey || idempotencyKey.length === 0 || idempotencyKey.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
+                invalidFields.push("idempotencyKey");
+            }
+            if (invalidFields.length > 0) {
+                await this.render({ json: { error: "invalid_params", fields: invalidFields }, status: 422 });
+                return;
+            }
+            const options = this._mountOptions();
+            const project = typeof params.project === "string" ? params.project : "";
+            const stage = typeof params.stage === "string" ? params.stage : "";
+            const stageOptions = lookupStageOptions(options, project, stage);
+            if (!stageOptions) {
+                await this.render({ json: { error: "not_found" }, status: 404 });
+                return;
+            }
+            const store = this._store();
+            const validRevision = /** @type {string} */ (revision);
+            const validIdempotencyKey = /** @type {string} */ (idempotencyKey);
+            // Retries read the original run before anything else — a replay must
+            // never re-validate or re-deploy.
+            const existingRun = await store.findRunByKey(validIdempotencyKey);
+            if (existingRun) {
+                await this._renderExistingRun({ existingRun, project, revision: validRevision, stage });
+                return;
+            }
+            const reachable = await options.adapter.validateRevision({
+                configuration: this.getConfiguration(),
+                project,
+                releaseBranch: stageOptions.releaseBranch,
+                revision: validRevision,
+                stage
+            });
+            if (!reachable) {
+                await this.render({ json: { error: "revision_not_reachable" }, status: 422 });
+                return;
+            }
+            const outcome = await store.createRunIfPossible({
+                idempotencyKey: validIdempotencyKey,
+                project,
+                revision: validRevision,
+                stage
+            });
+            if (outcome.outcome === "replay" || outcome.outcome === "conflict") {
+                const existingFromStore = outcome.run;
+                if (!existingFromStore)
+                    throw new Error(`Deployment run store reported '${outcome.outcome}' without a run`);
+                await this._renderExistingRun({ existingRun: existingFromStore, project, revision: validRevision, stage });
+                return;
+            }
+            if (outcome.outcome === "in_progress") {
+                const activeRun = outcome.run;
+                await this.render({ json: { error: "deployment_in_progress", runId: activeRun ? activeRun.id : undefined }, status: 409 });
+                return;
+            }
+            if (outcome.outcome === "reconciliation_required") {
+                const blockedRun = outcome.run;
+                if (!blockedRun)
+                    throw new Error("Deployment run store reported 'reconciliation_required' without a run");
+                await this.render({ json: { error: "deployment_reconciliation_required", runId: blockedRun.id }, status: 409 });
+                return;
+            }
+            const run = outcome.run;
+            if (!run)
+                throw new Error("Deployment run store reported 'created' without a run");
+            await this._audit({ event: "run_requested", payload: { project, revision: validRevision, stage }, runId: run.id });
+            // Execution is deliberately not awaited: the deploy runs under the
+            // integration's own lock/build/health/rollback semantics and the caller
+            // reads progress back through the show action.
+            this._executeRun({ options, run }).catch((error) => {
+                this._emitFrameworkError({ context: "deployment-api-execute-run", error });
+            });
+            await this.render({ json: { run: this._serializeRun(run) }, status: 202 });
+        });
+    }
+    /**
+     * Renders a previously created run for an idempotency-key hit: a replay when
+     * the payload matches, a bounded conflict when it doesn't.
+     * @param {object} args - Options.
+     * @param {import("./run-store.js").DeploymentRunRow} args.existingRun - The stored run.
+     * @param {string} args.project - Requested project.
+     * @param {string} args.revision - Requested revision.
+     * @param {string} args.stage - Requested stage.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _renderExistingRun({ existingRun, project, revision, stage }) {
+        const samePayload = existingRun.project === project && existingRun.stage === stage && existingRun.revision === revision;
+        if (!samePayload) {
+            await this.render({ json: { error: "idempotency_conflict", runId: existingRun.id }, status: 409 });
+            return;
+        }
+        await this.render({ json: { replayed: true, run: this._serializeRun(existingRun) }, status: 200 });
+    }
+    /**
+     * Returns the bounded state of a single run, enriched with the adapter's
+     * live status when the integration provides one.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async show() {
+        await this._respond(async () => {
+            const run = await this._store().findRunById(/** @type {string} */ (this.params().id));
+            if (!run) {
+                await this.render({ json: { error: "not_found" }, status: 404 });
+                return;
+            }
+            const options = this._mountOptions();
+            /** @type {Record<string, ?>} */
+            const body = { run: this._serializeRun(run) };
+            if (options.adapter.readStatus) {
+                const liveStatus = await options.adapter.readStatus({
+                    configuration: this.getConfiguration(),
+                    project: run.project,
+                    stage: run.stage
+                });
+                body.current = sanitizeAdapterValue(liveStatus, options.accessTokens) ?? null;
+            }
+            await this.render({ json: body, status: 200 });
+        });
+    }
+    /**
+     * Executes a created run asynchronously: registers it as active in this
+     * process, marks it running, heartbeats its ownership lease while the
+     * adapter deploys, and records the sanitized outcome. A deployment failure
+     * is an expected operational result — it is persisted with its sanitized
+     * recovery information instead of being raised, so it stays visible through
+     * readback and audit rather than crashing the worker.
+     * @param {object} args - Options.
+     * @param {import("./registry.js").DeploymentMountOptions} args.options - Mount options.
+     * @param {import("./run-store.js").DeploymentRunRow} args.run - The created run.
+     * @returns {Promise<void>} - Resolves when the outcome is recorded.
+     */
+    async _executeRun({ options, run }) {
+        const store = this._store();
+        const secrets = options.accessTokens;
+        const stageOptions = lookupStageOptions(options, run.project, run.stage);
+        if (!stageOptions)
+            throw new Error(`Deployment run ${run.id} references non-allowlisted ${run.project}/${run.stage}`);
+        if (!run.ownerToken)
+            throw new Error(`Deployment run ${run.id} has no execution owner token`);
+        const ownerToken = run.ownerToken;
+        registerActiveDeploymentRun(run.id);
+        /** @type {ReturnType<typeof setInterval> | null} */
+        let heartbeatTimer = null;
+        try {
+            await store.markRunning({ id: run.id, startedAtMs: Date.now() });
+            // Renew the ownership lease while the deploy runs so reconciliation
+            // never reclaims this genuinely active run; unref'd so the timer alone
+            // keeps no process alive.
+            const heartbeatIntervalMs = Math.max(1000, Math.floor(options.staleRunTimeoutMs / 4));
+            heartbeatTimer = setInterval(() => {
+                store.heartbeat({ heartbeatAtMs: Date.now(), id: run.id }).catch((error) => {
+                    this._emitFrameworkError({ context: "deployment-api-heartbeat", error });
+                });
+            }, heartbeatIntervalMs);
+            heartbeatTimer.unref();
+            await this._audit({ event: "run_started", payload: { project: run.project, revision: run.revision, stage: run.stage }, runId: run.id });
+            let report;
+            try {
+                report = await options.adapter.deploy({
+                    configuration: this.getConfiguration(),
+                    project: run.project,
+                    releaseBranch: stageOptions.releaseBranch,
+                    revision: run.revision,
+                    runId: run.id,
+                    stage: run.stage
+                });
+            }
+            catch (error) {
+                const errorPayload = sanitizeErrorPayload(error, secrets);
+                try {
+                    await store.markFailed({ error: errorPayload, finishedAtMs: Date.now(), id: run.id, ownerToken });
+                    await this._audit({
+                        event: "run_failed",
+                        payload: { message: errorPayload.message, project: run.project, revision: run.revision, stage: run.stage },
+                        runId: run.id
+                    });
+                }
+                catch (storeError) {
+                    // Recording the failure itself failed — that is an unexpected bug
+                    // and must surface to process-level error reporters.
+                    this._emitFrameworkError({ context: "deployment-api-record-failure", error: storeError });
+                }
+                return;
+            }
+            try {
+                const result = sanitizeAdapterValue(report ?? {}, secrets) ?? {};
+                await store.markSucceeded({ finishedAtMs: Date.now(), id: run.id, ownerToken, result });
+                await this._audit({ event: "run_succeeded", payload: { project: run.project, revision: run.revision, stage: run.stage }, runId: run.id });
+            }
+            catch (error) {
+                // The adapter already returned success. Surface the recording error,
+                // then fence the run in a durable non-retryable state rather than
+                // falsely recording an external success as a deployment failure.
+                this._emitFrameworkError({ context: "deployment-api-record-success", error });
+                const reconciliationError = {
+                    message: "Deployment activation succeeded, but its result could not be persisted; operator reconciliation is required"
+                };
+                try {
+                    await store.markReconciliationRequired({
+                        error: reconciliationError,
+                        finishedAtMs: Date.now(),
+                        id: run.id,
+                        ownerToken
+                    });
+                    await this._audit({
+                        event: "run_reconciliation_required",
+                        payload: { message: reconciliationError.message, project: run.project, revision: run.revision, stage: run.stage },
+                        runId: run.id
+                    });
+                }
+                catch (reconciliationErrorPersistenceError) {
+                    this._emitFrameworkError({
+                        context: "deployment-api-record-reconciliation-required",
+                        error: reconciliationErrorPersistenceError
+                    });
+                }
+            }
+        }
+        finally {
+            if (heartbeatTimer)
+                clearInterval(heartbeatTimer);
+            unregisterActiveDeploymentRun(run.id);
+        }
+    }
+    /**
+     * Records a sanitized audit event. Audit persistence must never strand or
+     * suppress a deployment, so a failure here is reported on the
+     * framework-error and unified all-error channels (where process-level bug
+     * reporters capture it), and execution continues.
+     * @param {object} args - Options.
+     * @param {string} args.event - Event name.
+     * @param {Record<string, ?>} args.payload - Payload; sanitized and redacted before persistence.
+     * @param {string | null} args.runId - Owning run id.
+     * @returns {Promise<void>} - Resolves when recorded or reported.
+     */
+    async _audit({ event, payload, runId }) {
+        const sanitized = sanitizeAdapterValue(payload, this._mountOptions().accessTokens) ?? {};
+        try {
+            await this._store().addAuditEvent({ event, payload: sanitized, runId });
+        }
+        catch (error) {
+            this._emitFrameworkError({ context: "deployment-api-audit", error });
+        }
+    }
+    /**
+     * Serializes a run for the API.
+     * @param {import("./run-store.js").DeploymentRunRow} run - Run row.
+     * @returns {Record<string, ?>} - Serialized run.
+     */
+    _serializeRun(run) {
+        return {
+            error: run.error,
+            finishedAtMs: run.finishedAtMs,
+            id: run.id,
+            idempotencyKey: run.idempotencyKey,
+            project: run.project,
+            requestedAtMs: run.requestedAtMs,
+            result: run.result,
+            revision: run.revision,
+            stage: run.stage,
+            startedAtMs: run.startedAtMs,
+            status: run.status
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/deployment-api/controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Controller from \"../controller.js\"\nimport DeploymentRunStore, {registerActiveDeploymentRun, unregisterActiveDeploymentRun} from \"./run-store.js\"\nimport {bearerToken, constantTimeEqual} from \"../utils/bearer-token.js\"\nimport {getDeploymentMount} from \"./registry.js\"\nimport {sanitizeAdapterValue, sanitizeErrorPayload} from \"./sanitize.js\"\n\nconst REVISION_PATTERN = /^[0-9a-f]{40}$/\nconst MAX_IDEMPOTENCY_KEY_LENGTH = 255\n\n/**\n * Resolves allowlisted stage options with own-property checks only, so\n * request-controlled names like \"__proto__\" or \"constructor\" can never\n * resolve inherited values. The normalized maps are also null-prototype, so\n * this is defense in depth.\n * @param {import(\"./registry.js\").DeploymentMountOptions} options - Mount options.\n * @param {string} project - Requested project identifier.\n * @param {string} stage - Requested stage identifier.\n * @returns {import(\"./registry.js\").DeploymentStageOptions | undefined} - Stage options when allowlisted.\n */\nfunction lookupStageOptions(options, project, stage) {\n  if (!Object.hasOwn(options.projects, project)) return undefined\n\n  const stages = options.projects[project].stages\n\n  if (!Object.hasOwn(stages, stage)) return undefined\n\n  return stages[stage]\n}\n\n/**\n * Authenticated HTTP API for callable deployments. Mounted by\n * {@link import(\"./index.js\").default} as a route-resolver hook so it can ship\n * inside the velocious package. Every action is gated by a bearer-token check\n * against the configured access tokens; the API exposes only allowlisted\n * project/stage pairs and full immutable revisions, and delegates all\n * execution to the configured adapter. It never accepts commands, paths,\n * arbitrary refs, environment variables, or raw log output.\n */\nexport default class VelociousDeploymentApiController extends Controller {\n  /**\n   * Runs mount options.\n   * @returns {import(\"./registry.js\").DeploymentMountOptions} - Options for the mount that matched this request.\n   */\n  _mountOptions() {\n    const at = /** @type {string} */ (this.params().velociousDeploymentMountAt)\n    const options = getDeploymentMount(this.getConfiguration(), at)\n\n    if (!options) throw new Error(`No deployment API mount registered at ${at}`)\n\n    return options\n  }\n\n  /**\n   * Runs store.\n   * @returns {DeploymentRunStore} - Run store scoped to the mount's database.\n   */\n  _store() {\n    if (!this._deploymentRunStore) {\n      this._deploymentRunStore = new DeploymentRunStore({\n        configuration: this.getConfiguration(),\n        databaseIdentifier: this._mountOptions().databaseIdentifier,\n        mountIdentifier: this._mountOptions().mountIdentifier,\n        staleRunTimeoutMs: this._mountOptions().staleRunTimeoutMs\n      })\n    }\n\n    return this._deploymentRunStore\n  }\n\n  /**\n   * Reports one internally consumed framework failure on both documented\n   * error channels so framework-specific and unified reporters see the same\n   * payload.\n   * @param {object} args - Options.\n   * @param {string} args.context - Deployment API failure context.\n   * @param {?} args.error - Consumed error.\n   * @returns {void} - No return value.\n   */\n  _emitFrameworkError({context, error}) {\n    const errorEvents = this.getConfiguration().getErrorEvents()\n    const payload = {context, error, request: this.getRequest()}\n\n    errorEvents.emit(\"framework-error\", payload)\n    errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n  }\n\n  /**\n   * Authorizes the request with a constant-time bearer-token comparison and\n   * runs the action body only when authorized. Renders a 401 otherwise. The\n   * base controller has no before-action halting, so authorization is enforced\n   * here per action. Tokens are only accepted through the Authorization header\n   * — never through URLs — and are never rendered back.\n   * @param {() => Promise<void>} actionFn - Action body.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _respond(actionFn) {\n    const token = bearerToken(this.request())\n    let authorized = false\n\n    if (token) {\n      for (const accessToken of this._mountOptions().accessTokens) {\n        if (constantTimeEqual(token, accessToken)) {\n          authorized = true\n          break\n        }\n      }\n    }\n\n    if (!authorized) {\n      await this.render({json: {error: \"unauthorized\"}, status: 401})\n      return\n    }\n\n    await actionFn()\n  }\n\n  /**\n   * Creates a deployment run for an allowlisted project/stage and a full\n   * immutable revision reachable from the approved release branch. Idempotent:\n   * a retried idempotency key reads the original run, a reused key with a\n   * different payload conflicts, and an active run for the same project/stage\n   * returns a bounded conflict.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async create() {\n    await this._respond(async () => {\n      const params = this.params()\n      const revision = typeof params.revision === \"string\" ? params.revision : null\n      const idempotencyKey = typeof params.idempotencyKey === \"string\" ? params.idempotencyKey : null\n      const invalidFields = []\n\n      if (!revision || !REVISION_PATTERN.test(revision)) invalidFields.push(\"revision\")\n      if (!idempotencyKey || idempotencyKey.length === 0 || idempotencyKey.length > MAX_IDEMPOTENCY_KEY_LENGTH) {\n        invalidFields.push(\"idempotencyKey\")\n      }\n\n      if (invalidFields.length > 0) {\n        await this.render({json: {error: \"invalid_params\", fields: invalidFields}, status: 422})\n        return\n      }\n\n      const options = this._mountOptions()\n      const project = typeof params.project === \"string\" ? params.project : \"\"\n      const stage = typeof params.stage === \"string\" ? params.stage : \"\"\n      const stageOptions = lookupStageOptions(options, project, stage)\n\n      if (!stageOptions) {\n        await this.render({json: {error: \"not_found\"}, status: 404})\n        return\n      }\n\n      const store = this._store()\n      const validRevision = /** @type {string} */ (revision)\n      const validIdempotencyKey = /** @type {string} */ (idempotencyKey)\n\n      // Retries read the original run before anything else — a replay must\n      // never re-validate or re-deploy.\n      const existingRun = await store.findRunByKey(validIdempotencyKey)\n\n      if (existingRun) {\n        await this._renderExistingRun({existingRun, project, revision: validRevision, stage})\n        return\n      }\n\n      const reachable = await options.adapter.validateRevision({\n        configuration: this.getConfiguration(),\n        project,\n        releaseBranch: stageOptions.releaseBranch,\n        revision: validRevision,\n        stage\n      })\n\n      if (!reachable) {\n        await this.render({json: {error: \"revision_not_reachable\"}, status: 422})\n        return\n      }\n\n      const outcome = await store.createRunIfPossible({\n        idempotencyKey: validIdempotencyKey,\n        project,\n        revision: validRevision,\n        stage\n      })\n\n      if (outcome.outcome === \"replay\" || outcome.outcome === \"conflict\") {\n        const existingFromStore = outcome.run\n\n        if (!existingFromStore) throw new Error(`Deployment run store reported '${outcome.outcome}' without a run`)\n\n        await this._renderExistingRun({existingRun: existingFromStore, project, revision: validRevision, stage})\n        return\n      }\n\n      if (outcome.outcome === \"in_progress\") {\n        const activeRun = outcome.run\n\n        await this.render({json: {error: \"deployment_in_progress\", runId: activeRun ? activeRun.id : undefined}, status: 409})\n        return\n      }\n\n      if (outcome.outcome === \"reconciliation_required\") {\n        const blockedRun = outcome.run\n\n        if (!blockedRun) throw new Error(\"Deployment run store reported 'reconciliation_required' without a run\")\n\n        await this.render({json: {error: \"deployment_reconciliation_required\", runId: blockedRun.id}, status: 409})\n        return\n      }\n\n      const run = outcome.run\n\n      if (!run) throw new Error(\"Deployment run store reported 'created' without a run\")\n\n      await this._audit({event: \"run_requested\", payload: {project, revision: validRevision, stage}, runId: run.id})\n\n      // Execution is deliberately not awaited: the deploy runs under the\n      // integration's own lock/build/health/rollback semantics and the caller\n      // reads progress back through the show action.\n      this._executeRun({options, run}).catch((error) => {\n        this._emitFrameworkError({context: \"deployment-api-execute-run\", error})\n      })\n\n      await this.render({json: {run: this._serializeRun(run)}, status: 202})\n    })\n  }\n\n  /**\n   * Renders a previously created run for an idempotency-key hit: a replay when\n   * the payload matches, a bounded conflict when it doesn't.\n   * @param {object} args - Options.\n   * @param {import(\"./run-store.js\").DeploymentRunRow} args.existingRun - The stored run.\n   * @param {string} args.project - Requested project.\n   * @param {string} args.revision - Requested revision.\n   * @param {string} args.stage - Requested stage.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _renderExistingRun({existingRun, project, revision, stage}) {\n    const samePayload = existingRun.project === project && existingRun.stage === stage && existingRun.revision === revision\n\n    if (!samePayload) {\n      await this.render({json: {error: \"idempotency_conflict\", runId: existingRun.id}, status: 409})\n      return\n    }\n\n    await this.render({json: {replayed: true, run: this._serializeRun(existingRun)}, status: 200})\n  }\n\n  /**\n   * Returns the bounded state of a single run, enriched with the adapter's\n   * live status when the integration provides one.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async show() {\n    await this._respond(async () => {\n      const run = await this._store().findRunById(/** @type {string} */ (this.params().id))\n\n      if (!run) {\n        await this.render({json: {error: \"not_found\"}, status: 404})\n        return\n      }\n\n      const options = this._mountOptions()\n      /** @type {Record<string, ?>} */\n      const body = {run: this._serializeRun(run)}\n\n      if (options.adapter.readStatus) {\n        const liveStatus = await options.adapter.readStatus({\n          configuration: this.getConfiguration(),\n          project: run.project,\n          stage: run.stage\n        })\n\n        body.current = sanitizeAdapterValue(liveStatus, options.accessTokens) ?? null\n      }\n\n      await this.render({json: body, status: 200})\n    })\n  }\n\n  /**\n   * Executes a created run asynchronously: registers it as active in this\n   * process, marks it running, heartbeats its ownership lease while the\n   * adapter deploys, and records the sanitized outcome. A deployment failure\n   * is an expected operational result — it is persisted with its sanitized\n   * recovery information instead of being raised, so it stays visible through\n   * readback and audit rather than crashing the worker.\n   * @param {object} args - Options.\n   * @param {import(\"./registry.js\").DeploymentMountOptions} args.options - Mount options.\n   * @param {import(\"./run-store.js\").DeploymentRunRow} args.run - The created run.\n   * @returns {Promise<void>} - Resolves when the outcome is recorded.\n   */\n  async _executeRun({options, run}) {\n    const store = this._store()\n    const secrets = options.accessTokens\n    const stageOptions = lookupStageOptions(options, run.project, run.stage)\n\n    if (!stageOptions) throw new Error(`Deployment run ${run.id} references non-allowlisted ${run.project}/${run.stage}`)\n    if (!run.ownerToken) throw new Error(`Deployment run ${run.id} has no execution owner token`)\n\n    const ownerToken = run.ownerToken\n\n    registerActiveDeploymentRun(run.id)\n\n    /** @type {ReturnType<typeof setInterval> | null} */\n    let heartbeatTimer = null\n\n    try {\n      await store.markRunning({id: run.id, startedAtMs: Date.now()})\n\n      // Renew the ownership lease while the deploy runs so reconciliation\n      // never reclaims this genuinely active run; unref'd so the timer alone\n      // keeps no process alive.\n      const heartbeatIntervalMs = Math.max(1000, Math.floor(options.staleRunTimeoutMs / 4))\n\n      heartbeatTimer = setInterval(() => {\n        store.heartbeat({heartbeatAtMs: Date.now(), id: run.id}).catch((error) => {\n          this._emitFrameworkError({context: \"deployment-api-heartbeat\", error})\n        })\n      }, heartbeatIntervalMs)\n      heartbeatTimer.unref()\n\n      await this._audit({event: \"run_started\", payload: {project: run.project, revision: run.revision, stage: run.stage}, runId: run.id})\n\n      let report\n\n      try {\n        report = await options.adapter.deploy({\n          configuration: this.getConfiguration(),\n          project: run.project,\n          releaseBranch: stageOptions.releaseBranch,\n          revision: run.revision,\n          runId: run.id,\n          stage: run.stage\n        })\n      } catch (error) {\n        const errorPayload = sanitizeErrorPayload(error, secrets)\n\n        try {\n          await store.markFailed({error: errorPayload, finishedAtMs: Date.now(), id: run.id, ownerToken})\n          await this._audit({\n            event: \"run_failed\",\n            payload: {message: errorPayload.message, project: run.project, revision: run.revision, stage: run.stage},\n            runId: run.id\n          })\n        } catch (storeError) {\n          // Recording the failure itself failed — that is an unexpected bug\n          // and must surface to process-level error reporters.\n          this._emitFrameworkError({context: \"deployment-api-record-failure\", error: storeError})\n        }\n\n        return\n      }\n\n      try {\n        const result = sanitizeAdapterValue(report ?? {}, secrets) ?? {}\n\n        await store.markSucceeded({finishedAtMs: Date.now(), id: run.id, ownerToken, result})\n        await this._audit({event: \"run_succeeded\", payload: {project: run.project, revision: run.revision, stage: run.stage}, runId: run.id})\n      } catch (error) {\n        // The adapter already returned success. Surface the recording error,\n        // then fence the run in a durable non-retryable state rather than\n        // falsely recording an external success as a deployment failure.\n        this._emitFrameworkError({context: \"deployment-api-record-success\", error})\n\n        const reconciliationError = {\n          message: \"Deployment activation succeeded, but its result could not be persisted; operator reconciliation is required\"\n        }\n\n        try {\n          await store.markReconciliationRequired({\n            error: reconciliationError,\n            finishedAtMs: Date.now(),\n            id: run.id,\n            ownerToken\n          })\n          await this._audit({\n            event: \"run_reconciliation_required\",\n            payload: {message: reconciliationError.message, project: run.project, revision: run.revision, stage: run.stage},\n            runId: run.id\n          })\n        } catch (reconciliationErrorPersistenceError) {\n          this._emitFrameworkError({\n            context: \"deployment-api-record-reconciliation-required\",\n            error: reconciliationErrorPersistenceError\n          })\n        }\n      }\n    } finally {\n      if (heartbeatTimer) clearInterval(heartbeatTimer)\n      unregisterActiveDeploymentRun(run.id)\n    }\n  }\n\n  /**\n   * Records a sanitized audit event. Audit persistence must never strand or\n   * suppress a deployment, so a failure here is reported on the\n   * framework-error and unified all-error channels (where process-level bug\n   * reporters capture it), and execution continues.\n   * @param {object} args - Options.\n   * @param {string} args.event - Event name.\n   * @param {Record<string, ?>} args.payload - Payload; sanitized and redacted before persistence.\n   * @param {string | null} args.runId - Owning run id.\n   * @returns {Promise<void>} - Resolves when recorded or reported.\n   */\n  async _audit({event, payload, runId}) {\n    const sanitized = sanitizeAdapterValue(payload, this._mountOptions().accessTokens) ?? {}\n\n    try {\n      await this._store().addAuditEvent({event, payload: sanitized, runId})\n    } catch (error) {\n      this._emitFrameworkError({context: \"deployment-api-audit\", error})\n    }\n  }\n\n  /**\n   * Serializes a run for the API.\n   * @param {import(\"./run-store.js\").DeploymentRunRow} run - Run row.\n   * @returns {Record<string, ?>} - Serialized run.\n   */\n  _serializeRun(run) {\n    return {\n      error: run.error,\n      finishedAtMs: run.finishedAtMs,\n      id: run.id,\n      idempotencyKey: run.idempotencyKey,\n      project: run.project,\n      requestedAtMs: run.requestedAtMs,\n      result: run.result,\n      revision: run.revision,\n      stage: run.stage,\n      startedAtMs: run.startedAtMs,\n      status: run.status\n    }\n  }\n}\n"]}

package/build/src/deployment-api/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Mountable authenticated deployment API. A narrowly configured consumer
+ * mounts it in its routes file and supplies an adapter owned by the deployment
+ * integration (e.g. Rampway) that performs the actual lock/build/release/
+ * health/rollback/cleanup work:
+ *
+ * ```js
+ * routes.draw((route) => {
+ *   route.mount(VelociousDeploymentApi, {
+ *     at: "/velocious/deployments",
+ *     accessTokens: [secrets.deploymentApiToken],
+ *     adapter: rampwayDeploymentAdapter,
+ *     projects: {
+ *       "my-app": {stages: {production: {releaseBranch: "master"}}}
+ *     }
+ *   })
+ * })
+ * ```
+ */
+export default class VelociousDeploymentApi {
+    /**
+     * Registers the deployment API under `at`. Implemented as a route-resolver
+     * hook so the controller can live inside the velocious package rather than
+     * the host app's `src/routes` directory. Invoked by the routing layer for
+     * each `route.mount(...)` registration.
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {string} args.at - Mount path prefix (e.g. "/velocious/deployments").
+     * @param {string[]} args.accessTokens - Accepted bearer tokens; requests authenticate with `Authorization: Bearer <token>` only.
+     * @param {import("./registry.js").DeploymentAdapter} args.adapter - Deployment integration adapter that owns execution.
+     * @param {Record<string, import("./registry.js").DeploymentProjectOptions>} args.projects - Allowlisted projects/stages with their approved release branches.
+     * @param {string} [args.databaseIdentifier] - Database identifier the run store reads from.
+     * @param {number} [args.staleRunTimeoutMs] - Lease timeout after which an active run without a heartbeat is reconciled according to its execution state; defaults to 60000.
+     * @returns {void} - No return value.
+     */
+    static mountInto({ accessTokens, adapter, at, configuration, databaseIdentifier, projects, staleRunTimeoutMs }: {
+        configuration: import("../configuration.js").default;
+        at: string;
+        accessTokens: string[];
+        adapter: import("./registry.js").DeploymentAdapter;
+        projects: Record<string, import("./registry.js").DeploymentProjectOptions>;
+        databaseIdentifier?: string | undefined;
+        staleRunTimeoutMs?: number | undefined;
+    }): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/src/deployment-api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deployment-api/index.js"],"names":[],"mappings":"AAkJA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;;;;;;;;;;;OAcG;IACH,gHATG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACxB,EAAE,EAAf,MAAM;QACS,YAAY,EAA3B,MAAM,EAAE;QACwC,OAAO,EAAvD,OAAO,eAAe,EAAE,iBAAiB;QAC8B,QAAQ,EAA/E,MAAM,CAAC,MAAM,EAAE,OAAO,eAAe,EAAE,wBAAwB,CAAC;QAClD,kBAAkB;QAClB,iBAAiB;KACvC,GAAU,IAAI,CA6BhB;CACF"}