@delegance/claude-autopilot 5.5.2 → 6.2.2

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

@@ -0,0 +1,550 @@
+// src/adapters/deploy/render.ts
+//
+// First-class Render deploy adapter. Phase 2 of the v5.6 spec.
+//
+// Implements `deploy()` (POST a new deploy on a configured service, then
+// poll until terminal) and `status()` (one-shot GET). Log streaming is
+// Phase 3 (Render uses REST polling, lands later) and rollback is Phase 4
+// (simulated by re-deploying the previous successful commit — Render has
+// no native rollback verb).
+//
+// All HTTP calls go through an injectable `fetchImpl` so unit tests never
+// hit the real Render API. The endpoint shapes below mirror the Render REST
+// API as documented at https://api-docs.render.com/.
+//
+// Phase 5 (v5.6) consolidated `fetchWithRetry` and `safeReadBody` into the
+// shared `_http.ts` module — see that file's header for the rationale.
+// Error-mapping (`assertOkOrThrow`) stays per-adapter because each one
+// composes a different error message and reads a different request-id
+// header.
+//
+// Spec: docs/specs/v5.6-fly-render-adapters.md
+import { GuardrailError } from "../../core/errors.js";
+import { redactLogLines } from "../../core/logging/redaction.js";
+import { fetchWithRetry, safeReadBody } from "./_http.js";
+const RENDER_API_BASE = 'https://api.render.com';
+const RENDER_DASHBOARD_BASE = 'https://dashboard.render.com';
+const RENDER_TOKEN_DOC_URL = 'https://dashboard.render.com/u/settings#api-keys';
+/**
+ * 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 class RenderDeployAdapter {
+    name = 'render';
+    capabilities = {
+        streamMode: 'polling',
+        nativeRollback: false,
+    };
+    token;
+    serviceId;
+    clearCache;
+    pollIntervalMs;
+    maxPollMs;
+    fetchImpl;
+    sleep;
+    now;
+    redactionPatterns;
+    logPollIntervalMs;
+    constructor(opts) {
+        const token = opts.token ?? process.env.RENDER_API_KEY;
+        if (!token) {
+            throw new GuardrailError(`Render deploy adapter requires RENDER_API_KEY. Create one at ${RENDER_TOKEN_DOC_URL}`, { code: 'auth', provider: 'render' });
+        }
+        if (!opts.serviceId) {
+            throw new GuardrailError('Render deploy adapter requires `serviceId` (Render service ID, e.g. srv-abc123)', { code: 'invalid_config', provider: 'render' });
+        }
+        this.token = token;
+        this.serviceId = opts.serviceId;
+        this.clearCache = opts.clearCache ?? 'do_not_clear';
+        this.pollIntervalMs = opts.pollIntervalMs ?? 2000;
+        this.maxPollMs = opts.maxPollMs ?? 15 * 60 * 1000;
+        this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+        this.sleep = opts.sleepImpl ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+        this.now = opts.nowImpl ?? Date.now;
+        this.redactionPatterns = opts.redactionPatterns;
+        this.logPollIntervalMs = opts.logPollIntervalMs ?? 2000;
+    }
+    async deploy(input) {
+        const start = this.now();
+        const url = `${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/deploys`;
+        const body = {
+            clearCache: this.clearCache,
+        };
+        // Render accepts `commitId` to deploy a specific commit — useful both
+        // for normal deploys driven by a SHA and for the eventual Phase 4
+        // simulated-rollback path that re-deploys a previous commit.
+        if (input.commitSha)
+            body.commitId = input.commitSha;
+        const res = await fetchWithRetry(this.fetchImpl, url, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal: input.signal,
+        }, { sleepImpl: this.sleep, provider: 'render' });
+        await this.assertOkOrThrow(res, 'create deploy');
+        const created = (await res.json());
+        if (!created.id) {
+            throw new GuardrailError(`Render returned no deploy id (got: ${JSON.stringify(created).slice(0, 200)})`, { code: 'adapter_bug', provider: 'render' });
+        }
+        // Fire onDeployStart so callers can subscribe to side-channel work
+        // (log streaming once Phase 3 lands) in parallel with polling. Wrap in
+        // try/catch — a buggy callback must not crash the deploy.
+        try {
+            input.onDeployStart?.(created.id);
+        }
+        catch {
+            /* swallow — observability concern only */
+        }
+        return this.pollUntilTerminal(created.id, start, input.signal);
+    }
+    async status(input) {
+        const start = this.now();
+        // Render's API for fetching a single deploy is service-scoped — the
+        // shorthand /v1/deploys/{id} does NOT exist. Caught by Cursor Bugbot
+        // on PR #73 (HIGH).
+        const url = `${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/deploys/${encodeURIComponent(input.deployId)}`;
+        const res = await fetchWithRetry(this.fetchImpl, url, {
+            method: 'GET',
+            headers: this.headers(),
+            signal: input.signal,
+        }, { sleepImpl: this.sleep, provider: 'render' });
+        await this.assertOkOrThrow(res, 'get deploy');
+        const data = (await res.json());
+        const result = this.shapeResult(input.deployId, data, data.status, this.now() - start);
+        return { ...result, deployId: input.deployId };
+    }
+    /**
+     * 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.
+     */
+    async *streamLogs(input) {
+        const logsUrl = (`${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/logs`
+            + `?deployId=${encodeURIComponent(input.deployId)}`
+            + `&direction=forward&limit=100`);
+        const statusUrl = `${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/deploys/${encodeURIComponent(input.deployId)}`;
+        const start = this.now();
+        let cursorTs = -1;
+        let cursorId = '';
+        let terminalSeen = false;
+        while (true) {
+            if (input.signal?.aborted)
+                return;
+            if (this.now() - start > this.maxPollMs)
+                return;
+            // 1. Fetch the next batch of log lines.
+            let logsRes;
+            try {
+                logsRes = await fetchWithRetry(this.fetchImpl, logsUrl, {
+                    method: 'GET',
+                    headers: this.headers(),
+                    signal: input.signal,
+                }, { sleepImpl: this.sleep, provider: 'render' });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'AbortError')
+                    return;
+                throw err;
+            }
+            if (input.signal?.aborted)
+                return;
+            // 404 here = deploy ID typo or wrong service. Surface as a single
+            // warn line and stop — same shape as the Fly "lost stream" exit.
+            if (!logsRes.ok) {
+                // Re-use the assertOkOrThrow surface for a typed GuardrailError.
+                await this.assertOkOrThrow(logsRes, 'stream logs');
+            }
+            const logsData = (await logsRes.json());
+            const lines = Array.isArray(logsData?.logs) ? logsData.logs : [];
+            // Parse first, then sort by (ts, id) ascending before applying the
+            // cursor filter. Render's API does NOT guarantee that same-millisecond
+            // entries arrive in lexicographic id order — without this sort, an
+            // entry with an alphabetically-earlier id arriving AFTER a same-ts
+            // sibling would advance the cursor past it and silently drop it on
+            // the next pass. Caught by Cursor Bugbot on PR #75 (MEDIUM).
+            const parsedBatch = [];
+            for (const entry of lines) {
+                if (input.signal?.aborted)
+                    return;
+                const parsed = parseRenderLogEntry(entry, this.now());
+                if (parsed)
+                    parsedBatch.push(parsed);
+            }
+            parsedBatch.sort((a, b) => {
+                if (a.ts !== b.ts)
+                    return a.ts - b.ts;
+                return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+            });
+            for (const parsed of parsedBatch) {
+                if (input.signal?.aborted)
+                    return;
+                // Cursor compare: primary timestamp, secondary id. Strictly greater
+                // than previous cursor → yield + advance.
+                if (parsed.ts < cursorTs)
+                    continue;
+                if (parsed.ts === cursorTs && parsed.id <= cursorId)
+                    continue;
+                cursorTs = parsed.ts;
+                cursorId = parsed.id;
+                yield this.redactLine({ timestamp: parsed.ts, level: parsed.level, text: parsed.text });
+            }
+            // 2. After we've drained this poll, check if we already saw a terminal
+            // status on the previous tick — if so, this was the final tail-drain.
+            if (terminalSeen)
+                return;
+            // 3. Status check — same service-scoped endpoint as `pollUntilTerminal`.
+            let statusRes;
+            try {
+                statusRes = await fetchWithRetry(this.fetchImpl, statusUrl, {
+                    method: 'GET',
+                    headers: this.headers(),
+                    signal: input.signal,
+                }, { sleepImpl: this.sleep, provider: 'render' });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'AbortError')
+                    return;
+                throw err;
+            }
+            if (input.signal?.aborted)
+                return;
+            if (statusRes.ok) {
+                const statusData = (await statusRes.json());
+                const s = statusData?.status;
+                if (s === 'live'
+                    || s === 'build_failed'
+                    || s === 'update_failed'
+                    || s === 'canceled'
+                    || s === 'deactivated') {
+                    // Mark terminal — one more poll iteration drains tail lines, then
+                    // the `terminalSeen` short-circuit above exits the loop.
+                    terminalSeen = true;
+                }
+            }
+            // 4. Sleep until the next poll. Honor abort while waiting.
+            if (input.signal?.aborted)
+                return;
+            await this.sleep(this.logPollIntervalMs);
+        }
+    }
+    /**
+     * 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.
+     */
+    async rollback(input) {
+        const start = this.now();
+        const deploys = await this.listDeploys(20, input.signal);
+        let priorDeployId;
+        let priorCommitId;
+        if (input.to) {
+            const match = deploys.find((d) => d.id === input.to);
+            if (!match) {
+                throw new GuardrailError(`Render deploy "${input.to}" not found in the last 20 deploys for service "${this.serviceId}" — cannot rollback`, { code: 'not_found', provider: 'render', step: 'rollback lookup' });
+            }
+            if (!match.commit?.id) {
+                throw new GuardrailError(`Render deploy "${input.to}" has no recorded commit id — cannot simulate rollback`, { code: 'invalid_config', provider: 'render', step: 'rollback lookup' });
+            }
+            priorDeployId = match.id;
+            priorCommitId = match.commit.id;
+        }
+        else {
+            // Walk newest-first. The first `live` deploy is the current head — we
+            // skip it and return the next. This matches the "go back one"
+            // semantics from the spec: the head is the deploy we're rolling
+            // BACK FROM, never the rollback target.
+            let sawHead = false;
+            for (const d of deploys) {
+                if (d.status !== 'live')
+                    continue;
+                if (!sawHead) {
+                    sawHead = true;
+                    continue;
+                }
+                if (!d.commit?.id)
+                    continue;
+                priorDeployId = d.id;
+                priorCommitId = d.commit.id;
+                break;
+            }
+            if (!priorDeployId || !priorCommitId) {
+                throw new GuardrailError(`No previous live Render deploy with a commit id found for service "${this.serviceId}" to roll back to`, { code: 'no_previous_deploy', provider: 'render' });
+            }
+        }
+        const redeployed = await this.redeployCommit(priorCommitId, input.signal);
+        const rawOutput = `Render rollback simulated by re-deploying commit "${priorCommitId}" (prior deploy ${priorDeployId}) → new deploy ${redeployed.deployId ?? '<unknown>'}`;
+        return {
+            ...redeployed,
+            // The prior deploy ID is the rollback target; deployId stays the
+            // newly-created deploy from the re-deploy POST. The CLI surfaces
+            // both in the PR-comment row.
+            rolledBackTo: priorDeployId,
+            durationMs: this.now() - start,
+            output: redactLogLines(rawOutput, this.redactionPatterns),
+        };
+    }
+    /**
+     * Private helper — re-uses the deploy() POST + poll machinery to redeploy
+     * a specific commit. Used by `rollback()` to reissue a prior commit.
+     */
+    async redeployCommit(commitId, signal) {
+        const start = this.now();
+        const url = `${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/deploys`;
+        const body = {
+            clearCache: this.clearCache,
+            commitId,
+        };
+        const res = await fetchWithRetry(this.fetchImpl, url, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal,
+        }, { sleepImpl: this.sleep, provider: 'render' });
+        await this.assertOkOrThrow(res, 'create deploy (rollback)');
+        const created = (await res.json());
+        if (!created.id) {
+            throw new GuardrailError(`Render returned no deploy id during rollback (got: ${JSON.stringify(created).slice(0, 200)})`, { code: 'adapter_bug', provider: 'render' });
+        }
+        return this.pollUntilTerminal(created.id, start, signal);
+    }
+    /**
+     * 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.
+     */
+    async listDeploys(limit = 20, signal) {
+        const url = `${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/deploys`
+            + `?limit=${encodeURIComponent(String(limit))}`;
+        const res = await fetchWithRetry(this.fetchImpl, url, {
+            method: 'GET',
+            headers: this.headers(),
+            signal,
+        }, { sleepImpl: this.sleep, provider: 'render' });
+        await this.assertOkOrThrow(res, 'list deploys');
+        const data = (await res.json());
+        // Render historically returned a top-level array on /deploys; newer
+        // versions wrap entries in `[{deploy: {...}, cursor: '...'}]`. Accept
+        // both shapes — fall back to a bare-array if neither envelope matches.
+        if (Array.isArray(data)) {
+            // Could be either RenderDeployResponse[] OR [{deploy: ...}].
+            const first = data[0];
+            if (first && typeof first === 'object' && 'deploy' in first) {
+                const wrapped = data;
+                return wrapped.map((entry) => entry.deploy).filter(Boolean);
+            }
+            return data;
+        }
+        if (Array.isArray(data?.deploys)) {
+            return data.deploys ?? [];
+        }
+        return [];
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // private helpers
+    // ─────────────────────────────────────────────────────────────────────────────
+    /** Apply the adapter's redaction patterns to a log line's `text` field. */
+    redactLine(line) {
+        return { ...line, text: redactLogLines(line.text, this.redactionPatterns) };
+    }
+    async pollUntilTerminal(deployId, start, signal) {
+        // Service-scoped path — see comment in `status()`.
+        const url = `${RENDER_API_BASE}/v1/services/${encodeURIComponent(this.serviceId)}/deploys/${encodeURIComponent(deployId)}`;
+        while (true) {
+            if (signal?.aborted) {
+                return { status: 'in-progress', deployId, durationMs: this.now() - start };
+            }
+            if (this.now() - start > this.maxPollMs) {
+                return {
+                    status: 'in-progress',
+                    deployId,
+                    durationMs: this.now() - start,
+                    buildLogsUrl: this.buildLogsUrl(deployId),
+                    output: redactLogLines(`Render deploy still in progress after ${this.maxPollMs}ms — check ${this.buildLogsUrl(deployId)}`, this.redactionPatterns),
+                };
+            }
+            const res = await fetchWithRetry(this.fetchImpl, url, {
+                method: 'GET',
+                headers: this.headers(),
+                signal,
+            }, { sleepImpl: this.sleep, provider: 'render' });
+            await this.assertOkOrThrow(res, 'poll deploy');
+            const data = (await res.json());
+            const status = data.status;
+            if (status === 'live'
+                || status === 'build_failed'
+                || status === 'update_failed'
+                || status === 'canceled'
+                || status === 'deactivated') {
+                return this.shapeResult(deployId, data, status, this.now() - start);
+            }
+            await this.sleep(this.pollIntervalMs);
+        }
+    }
+    shapeResult(deployId, data, status, durationMs) {
+        // Map Render's eight-state vocabulary onto our pass/fail/in-progress
+        // tri-state. `live` is the only success terminal; `deactivated`,
+        // `build_failed`, `update_failed`, `canceled` are failure terminals;
+        // everything else is interim.
+        const resultStatus = status === 'live'
+            ? 'pass'
+            : status === 'build_failed'
+                || status === 'update_failed'
+                || status === 'canceled'
+                || status === 'deactivated'
+                ? 'fail'
+                : 'in-progress';
+        // Apply redaction to the human-readable output line. Real-world Render
+        // logs often echo back env vars and tokens; we never want those landing
+        // in PR-comment bodies. (Spec § "Log redaction".)
+        const commitInfo = data.commit?.id ? ` commit=${data.commit.id}` : '';
+        const rawOutput = status ? `Render deploy ${deployId}: status=${status}${commitInfo}` : undefined;
+        return {
+            status: resultStatus,
+            deployId,
+            buildLogsUrl: this.buildLogsUrl(deployId),
+            durationMs,
+            output: rawOutput !== undefined ? redactLogLines(rawOutput, this.redactionPatterns) : undefined,
+        };
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+    }
+    buildLogsUrl(deployId) {
+        return `${RENDER_DASHBOARD_BASE}/web/${encodeURIComponent(this.serviceId)}/deploys/${encodeURIComponent(deployId)}`;
+    }
+    /**
+     * 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.
+     */
+    async assertOkOrThrow(res, step) {
+        if (res.ok)
+            return;
+        const bodyText = await safeReadBody(res);
+        const requestId = readRenderRequestId(res);
+        const details = { status: res.status };
+        if (requestId)
+            details.renderRequestId = requestId;
+        if (res.status === 401 || res.status === 403) {
+            throw new GuardrailError(`Render auth failed (${res.status}) on ${step} — check RENDER_API_KEY scope for service "${this.serviceId}". Regenerate at ${RENDER_TOKEN_DOC_URL}: ${bodyText}`, { code: 'auth', provider: 'render', step, details });
+        }
+        if (res.status === 404) {
+            throw new GuardrailError(`Render resource not found (${res.status}) on ${step} — service ID "${this.serviceId}" may be wrong, or the deploy ID belongs to a different service${requestId ? ` (x-request-id: ${requestId})` : ''}: ${bodyText}`, { code: 'not_found', provider: 'render', step, details });
+        }
+        if (res.status === 422 || res.status === 400) {
+            throw new GuardrailError(`Render rejected the request (${res.status}) on ${step} — likely a malformed serviceId, invalid clearCache value, or unknown commitId: ${bodyText}`, { code: 'invalid_config', provider: 'render', step, details });
+        }
+        if (res.status >= 500 && res.status < 600) {
+            throw new GuardrailError(`Render API server error (${res.status}) on ${step}: ${bodyText}`, { code: 'transient_network', provider: 'render', step, details, retryable: true });
+        }
+        throw new GuardrailError(`Render API error (${res.status}) on ${step}: ${bodyText}`, { code: 'adapter_bug', provider: 'render', step, details });
+    }
+}
+/**
+ * Pull `x-request-id` (case-insensitive) off the response. Render echoes
+ * this header on most API responses; capturing it into
+ * `GuardrailError.details.renderRequestId` lets users quote it back when
+ * filing support tickets.
+ *
+ * Falls back to `null` when `headers.get` is unavailable (e.g. a stubbed
+ * Response in tests that doesn't implement Headers).
+ */
+function readRenderRequestId(res) {
+    const headers = res.headers;
+    if (!headers || typeof headers.get !== 'function')
+        return null;
+    return headers.get('x-request-id') ?? headers.get('X-Request-Id') ?? null;
+}
+/**
+ * Parse a single Render log entry into our cursor-friendly tuple. Returns
+ * `null` for entries that have no usable text (we never yield empty lines)
+ * or no usable timestamp (the cursor invariant requires `ts`).
+ */
+function parseRenderLogEntry(entry, fallbackTs) {
+    const text = typeof entry.message === 'string'
+        ? entry.message
+        : typeof entry.text === 'string' ? entry.text : '';
+    if (!text)
+        return null;
+    let ts = fallbackTs;
+    if (typeof entry.timestamp === 'string' && entry.timestamp.length > 0) {
+        const parsed = Date.parse(entry.timestamp);
+        if (!Number.isNaN(parsed))
+            ts = parsed;
+    }
+    const id = typeof entry.id === 'string' ? entry.id : '';
+    return { ts, id, level: entry.level, text };
+}
+//# sourceMappingURL=render.js.map

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

@@ -33,9 +33,19 @@ export interface DeployInput {
  * before the platform reached a terminal state — the deploy may still finish
  * later. The adapter does NOT auto-resume in Phase 1; the caller can re-poll
  * via `status({ deployId })`.
+ *
+ * `fail_rolled_back` and `fail_rollback_failed` (Phase 4 of v5.6) describe
+ * the bounded auto-rollback outcomes. They both mean "the deploy itself
+ * succeeded but the post-deploy health check failed"; the suffix indicates
+ * whether the subsequent rollback attempt succeeded (`_rolled_back`) or
+ * failed (`_rollback_failed`). Adapters never set these directly — they are
+ * stamped onto the `DeployResult` by the CLI orchestration in
+ * `src/cli/deploy.ts` after `rollback()` returns. Plain `fail` continues to
+ * cover deploy-itself failures and the "no rollback configured / not
+ * supported" branches so existing consumers keep working.
  */
 export interface DeployResult {
-    status: 'pass' | 'fail' | 'in-progress';
+    status: 'pass' | 'fail' | 'in-progress' | 'fail_rolled_back' | 'fail_rollback_failed';
     /** Adapter-native deploy ID. Vercel uses `dpl_xxx`. Empty for generic when stdout has no extractable URL. */
     deployId?: string;
     /** Public URL of the deploy (e.g. `https://my-app-abc.vercel.app`). */
@@ -105,6 +115,34 @@ export interface DeployLogLine {
     /** Log text, no trailing newline. */
     text: string;
 }
+/**
+ * Self-described capability surface for an adapter.
+ *
+ * Codex review of v5.6 (#4) flagged that Render's REST polling and Fly's
+ * WebSocket streaming offer materially different log-streaming experiences,
+ * and pretending they're equivalent degrades user trust. CLI surfaces (and
+ * downstream consumers) inspect this struct to print a one-line notice when
+ * `--watch` is invoked against a `polling`-mode adapter, and to choose between
+ * native vs simulated rollback messaging in the PR comment.
+ *
+ * The field is optional — adapters that don't declare capabilities are
+ * treated as `streamMode: 'none'`, `nativeRollback: false` for safety.
+ */
+export interface DeployAdapterCapabilities {
+    /**
+     * How `streamLogs()` (when implemented) delivers lines:
+     * - `websocket` — real-time, push-based, near-zero gap between line emit and consumer receive
+     * - `polling` — REST-paginated polling cursor, lines may arrive in batches with short gaps
+     * - `none` — no log-streaming surface at all
+     */
+    streamMode?: 'websocket' | 'polling' | 'none';
+    /**
+     * `true` when the platform exposes a single "promote prior release" verb
+     * (Vercel's `/promote`, Fly's `/rollback`); `false` when rollback must be
+     * simulated by re-deploying a previous successful image/commit (Render).
+     */
+    nativeRollback?: boolean;
+}
 /**
  * The DeployAdapter contract.
  *
@@ -115,6 +153,12 @@ export interface DeployLogLine {
 export interface DeployAdapter {
     /** Stable identifier — surfaced in CLI output and logs. */
     readonly name: string;
+    /**
+     * Optional self-description of the adapter's streaming + rollback shape.
+     * See {@link DeployAdapterCapabilities} for semantics. CLI consumers use
+     * this to decide whether to print the polling-mode notice on `--watch`.
+     */
+    readonly capabilities?: DeployAdapterCapabilities;
     deploy(input: DeployInput): Promise<DeployResult>;
     status?(input: DeployStatusInput): Promise<DeployStatusResult>;
     rollback?(input: DeployRollbackInput): Promise<DeployResult>;
@@ -137,14 +181,34 @@ export interface DeployAdapter {
  * The factory in `./index.ts` enforces these rules at construction time.
  */
 export interface DeployConfig {
-    /** Which adapter to use. Phase 1 ships `vercel` + `generic`. */
-    adapter: 'vercel' | 'generic';
+    /**
+     * Which adapter to use. v5.4 shipped `vercel` + `generic`; v5.6 Phase 1
+     * adds `fly`; v5.6 Phase 2 adds `render`.
+     */
+    adapter: 'vercel' | 'fly' | 'render' | 'generic';
     /** Vercel project ID or slug. Required when `adapter === 'vercel'`. */
     project?: string;
     /** Vercel team ID for team accounts. Optional. */
     team?: string;
     /** Deploy target. Default: `production`. */
     target?: 'production' | 'preview';
+    /** Fly app slug. Required when `adapter === 'fly'`. */
+    app?: string;
+    /**
+     * Pre-pushed image reference, e.g. `registry.fly.io/my-app:deployment-01`.
+     * Required when `adapter === 'fly'` — the Fly adapter does not build the
+     * image; pushing is the user's responsibility (`fly deploy --build-only --push`).
+     */
+    image?: string;
+    /** Optional Fly region pin (e.g. `ord`). Falls back to the app's default region. */
+    region?: string;
+    /** Render service ID (e.g. `srv-abc123`). Required when `adapter === 'render'`. */
+    serviceId?: string;
+    /**
+     * Whether Render should clear the build cache before deploying. Optional,
+     * default `'do_not_clear'`. Maps directly to the Render API body field.
+     */
+    clearCache?: 'do_not_clear' | 'clear';
     /** Shell command to run for the deploy (e.g. `vercel --prod`). Required when `adapter === 'generic'`. */
     deployCommand?: string;
     /** Stream build logs to stderr in real time. Phase 2. */