@delegance/claude-autopilot 5.2.2 → 6.2.2

package/dist/src/adapters/deploy/generic.d.ts

@@ -0,0 +1,39 @@
+import type { ChildProcessByStdio } from 'node:child_process';
+import type { Readable, Writable } from 'node:stream';
+import type { DeployAdapter, DeployInput, DeployResult } from './types.ts';
+/**
+ * Function signature for the spawn dependency. Tests inject a fake spawn that
+ * emits canned stdout/exit events without touching the real OS process API.
+ */
+export type SpawnFn = (command: string, args: ReadonlyArray<string>, options: {
+    shell: boolean | string;
+    signal?: AbortSignal;
+}) => ChildProcessByStdio<Writable | null, Readable | null, Readable | null>;
+export interface GenericDeployAdapterOptions {
+    /** Free-form shell command (e.g. `vercel --prod`). Required. */
+    deployCommand: string;
+    /** Optional health-check URL — accepted for forward-compat with Phase 4; unused in Phase 1. */
+    healthCheckUrl?: string;
+    /** Injected spawn implementation (defaults to `node:child_process` spawn). */
+    spawnImpl?: SpawnFn;
+    /** When true, suppress teeing child stdout/stderr to the parent's process streams. Tests pass true. */
+    quiet?: boolean;
+    /** Wall-clock source. Tests pass a controllable counter. */
+    nowImpl?: () => number;
+}
+/**
+ * Generic shell-command deploy adapter.
+ *
+ * Captures stdout, looks for the first http(s) URL, returns it as `deployUrl`.
+ * Exit code 0 → `pass`; non-zero → `fail`.
+ */
+export declare class GenericDeployAdapter implements DeployAdapter {
+    readonly name = "generic";
+    private readonly deployCommand;
+    private readonly spawnImpl;
+    private readonly quiet;
+    private readonly now;
+    constructor(opts: GenericDeployAdapterOptions);
+    deploy(input: DeployInput): Promise<DeployResult>;
+}
+//# sourceMappingURL=generic.d.ts.map

package/dist/src/adapters/deploy/generic.js

@@ -0,0 +1,98 @@
+// src/adapters/deploy/generic.ts
+//
+// Generic deploy adapter — runs an arbitrary shell command and reports back.
+//
+// Wraps the v5.3 "deployCommand" approach as a DeployAdapter so the same
+// CLI surface (`claude-autopilot deploy`) works whether you have a Vercel
+// project, a Fly app with `flyctl deploy`, a custom `make deploy`, or anything
+// else that prints a URL to stdout.
+//
+// `status()` and `rollback()` are deliberately omitted — without platform-API
+// state we have no way to answer "is the build still going" or "promote the
+// previous deploy". Callers that need those can switch to a platform adapter.
+import { spawn as defaultSpawn } from 'node:child_process';
+import { GuardrailError } from "../../core/errors.js";
+const URL_RE = /https?:\/\/[^\s)>"']+/i;
+/**
+ * Generic shell-command deploy adapter.
+ *
+ * Captures stdout, looks for the first http(s) URL, returns it as `deployUrl`.
+ * Exit code 0 → `pass`; non-zero → `fail`.
+ */
+export class GenericDeployAdapter {
+    name = 'generic';
+    deployCommand;
+    spawnImpl;
+    quiet;
+    now;
+    constructor(opts) {
+        if (!opts.deployCommand || opts.deployCommand.trim() === '') {
+            throw new GuardrailError('Generic deploy adapter requires `deployCommand`', { code: 'invalid_config', provider: 'generic' });
+        }
+        this.deployCommand = opts.deployCommand;
+        this.spawnImpl = opts.spawnImpl ?? defaultSpawn;
+        this.quiet = opts.quiet ?? process.env.AUTOPILOT_DEPLOY_QUIET === '1';
+        this.now = opts.nowImpl ?? Date.now;
+    }
+    async deploy(input) {
+        const start = this.now();
+        return new Promise((resolve, reject) => {
+            let stdoutBuf = '';
+            let stderrBuf = '';
+            const child = this.spawnImpl(this.deployCommand, [], {
+                shell: true,
+                signal: input.signal,
+            });
+            child.stdout?.on('data', (chunk) => {
+                const s = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+                stdoutBuf += s;
+                if (!this.quiet)
+                    process.stdout.write(s);
+            });
+            child.stderr?.on('data', (chunk) => {
+                const s = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+                stderrBuf += s;
+                if (!this.quiet)
+                    process.stderr.write(s);
+            });
+            child.on('error', (err) => {
+                // AbortError from a passed signal — surface as an aborted in-progress
+                // result rather than a hard reject.
+                if (err.name === 'AbortError') {
+                    resolve({
+                        status: 'in-progress',
+                        durationMs: this.now() - start,
+                        output: 'Deploy aborted by caller.',
+                    });
+                    return;
+                }
+                reject(new GuardrailError(`Generic deploy adapter failed to spawn: ${err.message}`, { code: 'adapter_bug', provider: 'generic', details: { errno: err.code } }));
+            });
+            child.on('close', (code) => {
+                const durationMs = this.now() - start;
+                const tail = lastNLines(stdoutBuf + stderrBuf, 20);
+                if (code === 0) {
+                    const match = stdoutBuf.match(URL_RE);
+                    resolve({
+                        status: 'pass',
+                        deployUrl: match?.[0],
+                        durationMs,
+                        output: tail,
+                    });
+                }
+                else {
+                    resolve({
+                        status: 'fail',
+                        durationMs,
+                        output: tail,
+                    });
+                }
+            });
+        });
+    }
+}
+function lastNLines(s, n) {
+    const lines = s.split(/\r?\n/);
+    return lines.slice(Math.max(0, lines.length - n)).join('\n');
+}
+//# sourceMappingURL=generic.js.map

package/dist/src/adapters/deploy/index.d.ts

@@ -0,0 +1,15 @@
+import type { DeployAdapter, DeployConfig } from './types.ts';
+export * from './types.ts';
+export { VercelDeployAdapter } from './vercel.ts';
+export { FlyDeployAdapter } from './fly.ts';
+export { RenderDeployAdapter } from './render.ts';
+export { GenericDeployAdapter } from './generic.ts';
+/**
+ * Construct the right deploy adapter for the supplied config.
+ *
+ * Throws `GuardrailError` (code: invalid_config) when required adapter-specific
+ * fields are missing — failing fast at construction beats silently dropping
+ * the deploy step.
+ */
+export declare function createDeployAdapter(config: DeployConfig): DeployAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/deploy/index.js

@@ -0,0 +1,78 @@
+// src/adapters/deploy/index.ts
+//
+// Public surface for the deploy-adapter package + factory.
+import { GuardrailError } from "../../core/errors.js";
+import { FlyDeployAdapter } from "./fly.js";
+import { GenericDeployAdapter } from "./generic.js";
+import { RenderDeployAdapter } from "./render.js";
+import { VercelDeployAdapter } from "./vercel.js";
+export * from "./types.js";
+export { VercelDeployAdapter } from "./vercel.js";
+export { FlyDeployAdapter } from "./fly.js";
+export { RenderDeployAdapter } from "./render.js";
+export { GenericDeployAdapter } from "./generic.js";
+/**
+ * Construct the right deploy adapter for the supplied config.
+ *
+ * Throws `GuardrailError` (code: invalid_config) when required adapter-specific
+ * fields are missing — failing fast at construction beats silently dropping
+ * the deploy step.
+ */
+export function createDeployAdapter(config) {
+    switch (config.adapter) {
+        case 'vercel': {
+            if (!config.project) {
+                throw new GuardrailError('deploy.adapter=vercel requires deploy.project (Vercel project ID or slug)', { code: 'invalid_config', provider: 'vercel' });
+            }
+            return new VercelDeployAdapter({
+                project: config.project,
+                team: config.team,
+                target: config.target,
+            });
+        }
+        case 'fly': {
+            // v5.6 Phase 1: Fly requires both `app` and `image`. We surface each
+            // missing field with its own error so the user fixes both in one pass
+            // instead of hunting through guardrail.config.yaml twice.
+            if (!config.app) {
+                throw new GuardrailError('deploy.adapter=fly requires deploy.app (Fly app slug)', { code: 'invalid_config', provider: 'fly' });
+            }
+            if (!config.image) {
+                throw new GuardrailError('deploy.adapter=fly requires deploy.image (e.g. registry.fly.io/<app>:<tag>)', { code: 'invalid_config', provider: 'fly' });
+            }
+            return new FlyDeployAdapter({
+                app: config.app,
+                image: config.image,
+                region: config.region,
+            });
+        }
+        case 'render': {
+            // v5.6 Phase 2: Render requires `serviceId`. `clearCache` is optional
+            // and defaults to `'do_not_clear'` inside the adapter. We surface the
+            // missing-field error with the field name so the user knows exactly
+            // what to add to guardrail.config.yaml.
+            if (!config.serviceId) {
+                throw new GuardrailError('deploy.adapter=render requires deploy.serviceId (Render service ID, e.g. srv-abc123)', { code: 'invalid_config', provider: 'render' });
+            }
+            return new RenderDeployAdapter({
+                serviceId: config.serviceId,
+                clearCache: config.clearCache,
+            });
+        }
+        case 'generic': {
+            if (!config.deployCommand) {
+                throw new GuardrailError('deploy.adapter=generic requires deploy.deployCommand (shell command)', { code: 'invalid_config', provider: 'generic' });
+            }
+            return new GenericDeployAdapter({
+                deployCommand: config.deployCommand,
+                healthCheckUrl: config.healthCheckUrl,
+            });
+        }
+        default: {
+            // exhaustiveness guard — TS narrows config.adapter to never here
+            const exhaustive = config.adapter;
+            throw new GuardrailError(`Unknown deploy adapter: ${String(exhaustive)}`, { code: 'invalid_config' });
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/src/adapters/deploy/render.d.ts

@@ -0,0 +1,181 @@
+import type { DeployAdapter, DeployAdapterCapabilities, DeployInput, DeployLogLine, DeployResult, DeployRollbackInput, DeployStatusInput, DeployStatusResult, DeployStreamLogsInput } from './types.ts';
+/**
+ * Render deploy lifecycle states (per https://api-docs.render.com/).
+ *
+ * Terminal: `live` (success), `deactivated` / `build_failed` /
+ * `update_failed` / `canceled` (failure). Everything else is interim and
+ * maps to `in-progress` until the polling budget runs out.
+ *
+ * Render's API has accreted state names over time; new states observed in
+ * the wild are treated as `in-progress` rather than guessing pass/fail.
+ */
+type RenderDeployStatus = 'created' | 'build_in_progress' | 'update_in_progress' | 'live' | 'deactivated' | 'build_failed' | 'update_failed' | 'canceled';
+interface RenderDeployResponse {
+    id: string;
+    /** Commit SHA the deploy is built from — Render returns this on every deploy object. */
+    commit?: {
+        id?: string;
+        message?: string;
+    };
+    /** Lifecycle state. */
+    status?: RenderDeployStatus;
+}
+export interface RenderDeployAdapterOptions {
+    /** Render API key. Falls back to `process.env.RENDER_API_KEY`. */
+    token?: string;
+    /** Render service ID (e.g. `srv-abc123`). Required. */
+    serviceId: string;
+    /**
+     * Whether Render should clear the build cache before deploying.
+     * Default: `'do_not_clear'`. Maps to the API body field 1:1.
+     */
+    clearCache?: 'do_not_clear' | 'clear';
+    /** Polling interval (ms) when waiting for the deploy to reach a terminal state. Default: 2000. */
+    pollIntervalMs?: number;
+    /** Maximum total time to poll before returning `in-progress`. Default: 15 minutes. */
+    maxPollMs?: number;
+    /** Injected fetch implementation — defaults to `globalThis.fetch`. Tests pass a mock. */
+    fetchImpl?: typeof fetch;
+    /** Injected sleep implementation — tests pass a no-op so they don't actually wait. */
+    sleepImpl?: (ms: number) => Promise<void>;
+    /** Wall-clock source — tests pass a controllable counter. */
+    nowImpl?: () => number;
+    /**
+     * Optional caller-supplied redaction patterns (in addition to the
+     * built-in default set in `core/logging/redaction.ts`). Typically wired
+     * from `config.persistence.redactionPatterns` by the CLI; tests omit it.
+     */
+    redactionPatterns?: readonly string[];
+    /**
+     * Polling interval (ms) for the `streamLogs` REST polling loop.
+     * Defaults to 2000ms per the v5.6 spec § "Render adapter → Logs".
+     * Tests override to 0 so they don't actually wait between polls.
+     */
+    logPollIntervalMs?: number;
+}
+/**
+ * Render deploy adapter.
+ *
+ * Construct once per pipeline run. The adapter is stateless across calls —
+ * all configuration (token, serviceId, clearCache) is captured at
+ * construction time. Per the v5.6 spec, only `deploy()` and `status()` are
+ * wired in Phase 2; `streamLogs` (REST polling) and `rollback` (simulated
+ * via re-deploy) land in Phases 3 and 4 respectively.
+ */
+export declare class RenderDeployAdapter implements DeployAdapter {
+    readonly name = "render";
+    readonly capabilities: DeployAdapterCapabilities;
+    private readonly token;
+    private readonly serviceId;
+    private readonly clearCache;
+    private readonly pollIntervalMs;
+    private readonly maxPollMs;
+    private readonly fetchImpl;
+    private readonly sleep;
+    private readonly now;
+    private readonly redactionPatterns;
+    private readonly logPollIntervalMs;
+    constructor(opts: RenderDeployAdapterOptions);
+    deploy(input: DeployInput): Promise<DeployResult>;
+    status(input: DeployStatusInput): Promise<DeployStatusResult>;
+    /**
+     * Phase 3 of v5.6 — REST-polling log stream for a Render deploy.
+     *
+     * Render has no WebSocket log endpoint (cf. v5.6 spec § "Render adapter →
+     * Logs" and capability metadata `streamMode: 'polling'`). This generator
+     * polls `GET /v1/services/{serviceId}/logs?deployId={id}&direction=forward
+     * &limit=100` every 2s while the deploy is `in-progress` and yields any
+     * new lines.
+     *
+     * Cursor invariant — keyed by `(timestamp, logId)`:
+     * - We track the most-recently-yielded `(ts, id)` pair as `cursor`.
+     * - On each poll, we discard every returned line whose `(ts, id)` is
+     *   `<= cursor` (lexicographic on the pair, primary key timestamp). This
+     *   handles two real cases:
+     *     1. Pagination overlap — Render's forward-direction list often
+     *        repeats the last entry of the prior page as the first entry of
+     *        the next. Without dedup we'd yield duplicates.
+     *     2. Same-millisecond entries — multiple log lines can share a `ts`.
+     *        The secondary `id` ordering keeps them stable.
+     * - We never miss a line: `cursor` advances strictly monotonically, and
+     *   the polling URL uses `direction=forward` so Render returns lines
+     *   newer than (or equal to) our cursor's timestamp.
+     *
+     * Termination:
+     * - `signal.aborted` — exit immediately at the next await boundary.
+     * - Deploy status reaches a terminal state (live / build_failed /
+     *   update_failed / canceled / deactivated) — drain one final poll for
+     *   any tail lines, then exit.
+     * - Hard cap of `maxPollMs` ticks — same budget as `pollUntilTerminal`
+     *   to avoid an infinite generator if status is stuck.
+     *
+     * Every yielded line's `text` is run through `redactLogLines()` before
+     * leaving the adapter.
+     */
+    streamLogs(input: DeployStreamLogsInput): AsyncGenerator<DeployLogLine>;
+    /**
+     * Phase 4 of v5.6 — simulated rollback for Render.
+     *
+     * Render has no native rollback verb, so we simulate by re-deploying a
+     * prior commit per spec § "Render adapter → Rollback":
+     *
+     * - List recent deploys: `GET /v1/services/{serviceId}/deploys?limit=20`.
+     * - Select the rollback target:
+     *   - When `input.to` is set: look up that specific deploy in the list,
+     *     read its `commit.id`, and re-deploy that commit. Deploy ID becomes
+     *     the lookup key.
+     *   - When `input.to` is unset: walk the list newest-first and pick the
+     *     most recent deploy with `status === 'live'` *that is not the head*.
+     *     The intent is "go back one" — the head is the deploy we'd be
+     *     rolling back from.
+     * - Re-deploy via `POST /v1/services/{serviceId}/deploys` with `commitId`,
+     *   then poll until terminal — re-uses the existing `deploy()`-style
+     *   machinery via `redeployCommit()`.
+     *
+     * Throws `GuardrailError({ code: 'no_previous_deploy', provider: 'render' })`
+     * when no usable prior `live` deploy exists. Throws `not_found` when
+     * `input.to` references a deploy that isn't in the recent-20 window.
+     *
+     * Returns a `DeployResult` with:
+     * - `deployId` — the *new* deploy ID Render returned for the re-deploy.
+     * - `rolledBackTo` — the *prior* deploy ID we rolled back to.
+     * - `output` — human-readable summary of the swap (commits + IDs), redacted.
+     */
+    rollback(input: DeployRollbackInput): Promise<DeployResult>;
+    /**
+     * Private helper — re-uses the deploy() POST + poll machinery to redeploy
+     * a specific commit. Used by `rollback()` to reissue a prior commit.
+     */
+    private redeployCommit;
+    /**
+     * List the most recent deploys for the configured service. Newest-first.
+     * `limit` caps the result set — defaults to 20 (the spec's recommended
+     * window for the rollback lookup). Each entry includes `id`, `commit.id`,
+     * and `status` per the Render REST API.
+     */
+    listDeploys(limit?: number, signal?: AbortSignal): Promise<RenderDeployResponse[]>;
+    /** Apply the adapter's redaction patterns to a log line's `text` field. */
+    private redactLine;
+    private pollUntilTerminal;
+    private shapeResult;
+    private headers;
+    private buildLogsUrl;
+    /**
+     * HTTP-status-keyed error mapper. Per v5.6 spec:
+     *
+     * | Status | ErrorCode |
+     * |---|---|
+     * | 401 / 403 | `auth` |
+     * | 404 | `not_found` |
+     * | 422 / 400 | `invalid_config` |
+     * | 5xx | `transient_network` (retryable) |
+     * | other 4xx | `adapter_bug` |
+     *
+     * Render echoes a request-id on the `x-request-id` header on most
+     * responses. We capture it into `details.renderRequestId` whenever
+     * present so support tickets can quote it back to Render.
+     */
+    private assertOkOrThrow;
+}
+export {};
+//# sourceMappingURL=render.d.ts.map