@delegance/claude-autopilot 5.5.2 → 7.2.0

package/dist/src/dashboard/auto-upload.d.ts

@@ -0,0 +1,26 @@
+export interface AutoUploadOptions {
+    /** Caller's explicit opt-out (e.g. CLI --no-upload). */
+    disabled?: boolean;
+    /** Test seam — substitute fetch impl. */
+    fetchImpl?: typeof fetch;
+    /** Test seam — silence stdout. */
+    silent?: boolean;
+}
+export interface AutoUploadResult {
+    attempted: boolean;
+    ok: boolean;
+    url: string | null;
+    skipped: boolean;
+    reason?: 'opt-out-flag' | 'env-off' | 'not-logged-in' | 'no-events' | 'aborted' | 'error' | 'limit-reached';
+}
+export declare function shouldAutoUpload(options?: AutoUploadOptions): {
+    ok: boolean;
+    reason?: AutoUploadResult['reason'];
+};
+/**
+ * Run an auto-upload for the given runId. Wraps the foreground uploader
+ * in a SIGINT/SIGTERM handler so Ctrl-C is clean. Always returns a result
+ * — never throws. Caller preserves the run's original exit code.
+ */
+export declare function autoUploadAtComplete(runId: string, runDir: string, options?: AutoUploadOptions): Promise<AutoUploadResult>;
+//# sourceMappingURL=auto-upload.d.ts.map

package/dist/src/dashboard/auto-upload.js

@@ -0,0 +1,107 @@
+// Auto-upload at run.complete — non-fatal hosted-product hook.
+//
+// Contract (per spec): never fails the run. Always preserves the original
+// exit code. Failure prints a resume command. Empty events.ndjson skips
+// upload cleanly (Phase 2.2's POST /api/upload-session 422s expectedChunkCount=0).
+//
+// Opt-outs:
+//   - explicit `--no-upload` flag → caller passes options.disabled=true
+//   - env CLAUDE_AUTOPILOT_UPLOAD=off
+//   - not logged in (no config)
+//   - events.ndjson missing or 0 bytes
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { readConfig } from "./config.js";
+import { uploadRun, UploadLimitError } from "./upload/uploader.js";
+export function shouldAutoUpload(options = {}) {
+    if (options.disabled)
+        return { ok: false, reason: 'opt-out-flag' };
+    const env = process.env.CLAUDE_AUTOPILOT_UPLOAD;
+    if (env && /^(off|false|0|no)$/i.test(env))
+        return { ok: false, reason: 'env-off' };
+    return { ok: true };
+}
+async function fileExistsNonEmpty(p) {
+    try {
+        const stat = await fs.stat(p);
+        return stat.isFile() && stat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run an auto-upload for the given runId. Wraps the foreground uploader
+ * in a SIGINT/SIGTERM handler so Ctrl-C is clean. Always returns a result
+ * — never throws. Caller preserves the run's original exit code.
+ */
+export async function autoUploadAtComplete(runId, runDir, options = {}) {
+    const gate = shouldAutoUpload(options);
+    if (!gate.ok) {
+        return { attempted: false, ok: true, url: null, skipped: true, reason: gate.reason ?? 'opt-out-flag' };
+    }
+    const cfg = await readConfig();
+    if (!cfg) {
+        return { attempted: false, ok: true, url: null, skipped: true, reason: 'not-logged-in' };
+    }
+    const eventsPath = path.join(runDir, 'events.ndjson');
+    const hasEvents = await fileExistsNonEmpty(eventsPath);
+    if (!hasEvents) {
+        return { attempted: false, ok: true, url: null, skipped: true, reason: 'no-events' };
+    }
+    const ac = new AbortController();
+    const sigintHandler = () => ac.abort();
+    process.on('SIGINT', sigintHandler);
+    process.on('SIGTERM', sigintHandler);
+    try {
+        const result = await uploadRun(runId, runDir, {
+            apiKey: cfg.apiKey,
+            signal: ac.signal,
+            ...(options.fetchImpl !== undefined ? { fetchImpl: options.fetchImpl } : {}),
+        });
+        if (result.ok && result.url) {
+            if (!options.silent)
+                process.stdout.write(`[autopilot] uploaded to ${result.url}\n`);
+            return { attempted: true, ok: true, url: result.url, skipped: false };
+        }
+        if (result.ok && result.skipped) {
+            if (!options.silent)
+                process.stdout.write(`[autopilot] skipping upload — events.ndjson is empty\n`);
+            return { attempted: true, ok: true, url: null, skipped: true, reason: 'no-events' };
+        }
+        if (!options.silent) {
+            process.stderr.write(`[autopilot] upload failed: ${result.error}\n`);
+            process.stderr.write(`            Resume with: claude-autopilot dashboard upload ${runId}\n`);
+        }
+        return { attempted: true, ok: false, url: null, skipped: false, reason: 'error' };
+    }
+    catch (err) {
+        if (ac.signal.aborted) {
+            if (!options.silent) {
+                process.stderr.write(`\n[autopilot] upload interrupted. Run is saved locally.\n`);
+                process.stderr.write(`            Resume with: claude-autopilot dashboard upload ${runId}\n`);
+            }
+            return { attempted: true, ok: false, url: null, skipped: false, reason: 'aborted' };
+        }
+        // Phase 3 — runs/storage cap reached. Print a friendly message but
+        // do NOT print the resume hint (resume would just hit 402 again until
+        // the user upgrades) and do NOT bubble the error so the run's exit
+        // code is preserved.
+        if (err instanceof UploadLimitError) {
+            if (!options.silent) {
+                process.stderr.write(`[autopilot] ${err.message}\n`);
+            }
+            return { attempted: true, ok: false, url: null, skipped: false, reason: 'limit-reached' };
+        }
+        if (!options.silent) {
+            process.stderr.write(`[autopilot] upload error: ${err.message}\n`);
+            process.stderr.write(`            Resume with: claude-autopilot dashboard upload ${runId}\n`);
+        }
+        return { attempted: true, ok: false, url: null, skipped: false, reason: 'error' };
+    }
+    finally {
+        process.off('SIGINT', sigintHandler);
+        process.off('SIGTERM', sigintHandler);
+    }
+}
+//# sourceMappingURL=auto-upload.js.map

package/dist/src/dashboard/config.d.ts

@@ -0,0 +1,22 @@
+export interface DashboardConfig {
+    schemaVersion: 1;
+    apiKey: string;
+    fingerprint: string;
+    accountEmail: string;
+    loggedInAt: string;
+    lastUploadAt: string | null;
+}
+export declare function getConfigDir(): string;
+export declare function getConfigPath(): string;
+export declare function readConfig(): Promise<DashboardConfig | null>;
+export declare function writeConfig(config: DashboardConfig): Promise<void>;
+export declare function deleteConfig(): Promise<void>;
+export declare function getAutopilotBaseUrl(): string;
+export declare function _resetAutopilotBaseUrlWarning(): void;
+/**
+ * Returns a warning string if the config file is group/world-readable on
+ * a POSIX filesystem; null otherwise (or on Windows, where mode bits
+ * don't apply meaningfully).
+ */
+export declare function warnIfPermissive(): Promise<string | null>;
+//# sourceMappingURL=config.d.ts.map

package/dist/src/dashboard/config.js

@@ -0,0 +1,109 @@
+// CLI dashboard config — atomic read/write of ~/.claude-autopilot/dashboard.json.
+//
+// Codex plan-pass WARNING: respect CLAUDE_AUTOPILOT_HOME env override so
+// tests + experimentation never touch the developer's real home dir.
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const KEY_RE = /^clp_[0-9a-f]{64}$/;
+function resolveHome() {
+    return process.env.CLAUDE_AUTOPILOT_HOME ?? path.join(os.homedir(), '.claude-autopilot');
+}
+export function getConfigDir() {
+    return resolveHome();
+}
+export function getConfigPath() {
+    return path.join(resolveHome(), 'dashboard.json');
+}
+export async function readConfig() {
+    try {
+        const raw = await fs.readFile(getConfigPath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1)
+            return null;
+        if (!KEY_RE.test(parsed.apiKey))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeConfig(config) {
+    if (!KEY_RE.test(config.apiKey)) {
+        throw new Error('writeConfig: invalid apiKey shape');
+    }
+    const dir = getConfigDir();
+    const file = getConfigPath();
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    // Try to tighten dir mode even if it already existed.
+    try {
+        await fs.chmod(dir, 0o700);
+    }
+    catch { /* best effort */ }
+    // Atomic write: temp-file + rename.
+    const tmp = `${file}.tmp.${process.pid}.${Date.now()}`;
+    const payload = JSON.stringify(config, null, 2);
+    await fs.writeFile(tmp, payload, { mode: 0o600 });
+    await fs.chmod(tmp, 0o600);
+    await fs.rename(tmp, file);
+}
+export async function deleteConfig() {
+    try {
+        await fs.unlink(getConfigPath());
+    }
+    catch {
+        /* idempotent */
+    }
+}
+/**
+ * Phase 4 — resolve the dashboard / public base URL from env, with
+ * AUTOPILOT_PUBLIC_BASE_URL preferred and AUTOPILOT_DASHBOARD_BASE_URL
+ * accepted as a deprecated alias. Logs a one-time deprecation warning
+ * when only the older variable is set.
+ *
+ * Defaults to https://autopilot.dev when neither is present.
+ */
+let _deprecationWarned = false;
+export function getAutopilotBaseUrl() {
+    const canonical = process.env.AUTOPILOT_PUBLIC_BASE_URL;
+    const legacy = process.env.AUTOPILOT_DASHBOARD_BASE_URL;
+    if (canonical)
+        return canonical;
+    if (legacy) {
+        if (!_deprecationWarned) {
+            _deprecationWarned = true;
+            // eslint-disable-next-line no-console
+            console.warn('[autopilot] AUTOPILOT_DASHBOARD_BASE_URL is deprecated; ' +
+                'use AUTOPILOT_PUBLIC_BASE_URL instead. Both are accepted for now.');
+        }
+        return legacy;
+    }
+    return 'https://autopilot.dev';
+}
+// Test seam — reset the one-shot warning flag.
+export function _resetAutopilotBaseUrlWarning() {
+    _deprecationWarned = false;
+}
+/**
+ * Returns a warning string if the config file is group/world-readable on
+ * a POSIX filesystem; null otherwise (or on Windows, where mode bits
+ * don't apply meaningfully).
+ */
+export async function warnIfPermissive() {
+    if (process.platform === 'win32')
+        return null;
+    const file = getConfigPath();
+    try {
+        const stat = await fs.stat(file);
+        const mode = stat.mode & 0o777;
+        if ((mode & 0o077) !== 0) {
+            return `Warning: ${file} mode is ${mode.toString(8)} (group/world readable). Run: chmod 600 ${file}`;
+        }
+    }
+    catch {
+        /* file doesn't exist, no warning */
+    }
+    return null;
+}
+//# sourceMappingURL=config.js.map

package/dist/src/dashboard/upload/canonical.d.ts

@@ -0,0 +1,3 @@
+export declare function canonicalJsonBytes(value: unknown): Buffer;
+export declare function sha256OfCanonical(value: unknown): string;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/src/dashboard/upload/canonical.js

@@ -0,0 +1,16 @@
+// Parity copy of apps/web/lib/upload/canonical.ts (RFC 8785 / JCS).
+// CLI ↔ web byte-equality asserted in tests/dashboard/parity.test.ts.
+import canonicalize from 'canonicalize';
+import { createHash } from 'node:crypto';
+export function canonicalJsonBytes(value) {
+    // canonicalize implements RFC 8785 (JCS). Returns undefined only for
+    // inputs JSON cannot represent at the root; coerce to '' so callers
+    // always get a Buffer.
+    const str = canonicalize(value) ?? '';
+    return Buffer.from(str, 'utf-8');
+}
+export function sha256OfCanonical(value) {
+    const bytes = canonicalJsonBytes(value);
+    return createHash('sha256').update(bytes).digest('hex');
+}
+//# sourceMappingURL=canonical.js.map

package/dist/src/dashboard/upload/chain.d.ts

@@ -0,0 +1,9 @@
+export declare const ZERO_HASH: string;
+export declare function hashChunk(prevHashHex: string, body: Buffer): string;
+/**
+ * Compute the chain root for an ordered sequence of chunks.
+ * Unambiguous loop form (per spec): prev=ZERO_HASH; for seq in 0..N-1:
+ *   h[seq] = sha256(chunk[seq] || prev); prev = h[seq]; root = prev.
+ */
+export declare function computeChainRoot(chunks: Buffer[]): string;
+//# sourceMappingURL=chain.d.ts.map

package/dist/src/dashboard/upload/chain.js

@@ -0,0 +1,27 @@
+// Parity copy of apps/web/lib/upload/chain.ts.
+// CLI ↔ web hash agreement is asserted in tests/dashboard/parity.test.ts.
+import { createHash } from 'node:crypto';
+export const ZERO_HASH = '0'.repeat(64);
+export function hashChunk(prevHashHex, body) {
+    if (!/^[0-9a-f]{64}$/.test(prevHashHex)) {
+        throw new Error(`hashChunk: prev hash must be 64 lowercase hex chars`);
+    }
+    const prevBytes = Buffer.from(prevHashHex, 'hex');
+    const hash = createHash('sha256');
+    hash.update(body);
+    hash.update(prevBytes);
+    return hash.digest('hex');
+}
+/**
+ * Compute the chain root for an ordered sequence of chunks.
+ * Unambiguous loop form (per spec): prev=ZERO_HASH; for seq in 0..N-1:
+ *   h[seq] = sha256(chunk[seq] || prev); prev = h[seq]; root = prev.
+ */
+export function computeChainRoot(chunks) {
+    let prev = ZERO_HASH;
+    for (const chunk of chunks) {
+        prev = hashChunk(prev, chunk);
+    }
+    return prev;
+}
+//# sourceMappingURL=chain.js.map

package/dist/src/dashboard/upload/snapshot.d.ts

@@ -0,0 +1,23 @@
+export interface SnapshotPaths {
+    snapshotDir: string;
+    events: string;
+    state: string;
+}
+export interface SnapshotResult extends SnapshotPaths {
+    /** Bytes of the snapshot events file. May be 0. */
+    eventsBytes: number;
+}
+export declare class SnapshotMismatchError extends Error {
+    constructor(message: string);
+}
+/**
+ * Copy events.ndjson + state.json from `runDir` to `runDir/.upload-snapshot/`.
+ *
+ * Defense in depth: stat-before/stat-after on the source files, fail
+ * loudly if size or mtime changes during copy. Per spec, snapshot is
+ * post-`run.complete` only (writers are flushed) so this should never
+ * fire — but if it does, abort rather than upload a torn read.
+ */
+export declare function snapshotRun(runDir: string): Promise<SnapshotResult>;
+export declare function deleteSnapshot(runDir: string): Promise<void>;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/src/dashboard/upload/snapshot.js

@@ -0,0 +1,66 @@
+// Snapshot-before-upload — copy events.ndjson + state.json to
+// <runDir>/.upload-snapshot/ atomically before chunking begins.
+// The uploader then reads only the snapshot, so the writer streaming new
+// events into events.ndjson can't shift bytes mid-upload.
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+export class SnapshotMismatchError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SnapshotMismatchError';
+    }
+}
+/**
+ * Copy events.ndjson + state.json from `runDir` to `runDir/.upload-snapshot/`.
+ *
+ * Defense in depth: stat-before/stat-after on the source files, fail
+ * loudly if size or mtime changes during copy. Per spec, snapshot is
+ * post-`run.complete` only (writers are flushed) so this should never
+ * fire — but if it does, abort rather than upload a torn read.
+ */
+export async function snapshotRun(runDir) {
+    const eventsSrc = path.join(runDir, 'events.ndjson');
+    const stateSrc = path.join(runDir, 'state.json');
+    const snapshotDir = path.join(runDir, '.upload-snapshot');
+    const eventsDst = path.join(snapshotDir, 'events.ndjson');
+    const stateDst = path.join(snapshotDir, 'state.json');
+    const eventsBefore = await fs.stat(eventsSrc);
+    let stateBefore = null;
+    try {
+        stateBefore = await fs.stat(stateSrc);
+    }
+    catch {
+        // state.json may not exist for an in-flight run; we still snapshot events.
+    }
+    await fs.mkdir(snapshotDir, { recursive: true });
+    await fs.copyFile(eventsSrc, eventsDst);
+    if (stateBefore) {
+        await fs.copyFile(stateSrc, stateDst);
+    }
+    const eventsAfter = await fs.stat(eventsSrc);
+    if (eventsAfter.size !== eventsBefore.size || eventsAfter.mtimeMs !== eventsBefore.mtimeMs) {
+        throw new SnapshotMismatchError(`events.ndjson changed during snapshot (size ${eventsBefore.size}->${eventsAfter.size}, mtime ${eventsBefore.mtimeMs}->${eventsAfter.mtimeMs})`);
+    }
+    if (stateBefore) {
+        const stateAfter = await fs.stat(stateSrc);
+        if (stateAfter.size !== stateBefore.size || stateAfter.mtimeMs !== stateBefore.mtimeMs) {
+            throw new SnapshotMismatchError(`state.json changed during snapshot (size ${stateBefore.size}->${stateAfter.size})`);
+        }
+    }
+    return {
+        snapshotDir,
+        events: eventsDst,
+        state: stateDst,
+        eventsBytes: eventsAfter.size,
+    };
+}
+export async function deleteSnapshot(runDir) {
+    const snapshotDir = path.join(runDir, '.upload-snapshot');
+    try {
+        await fs.rm(snapshotDir, { recursive: true, force: true });
+    }
+    catch {
+        /* idempotent */
+    }
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/src/dashboard/upload/uploader.d.ts

@@ -0,0 +1,54 @@
+export interface UploadOptions {
+    signal?: AbortSignal;
+    baseUrl?: string;
+    apiKey: string;
+    onProgress?: (event: ProgressEvent) => void;
+    /** Test seam — substitute fetch impl. Defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+export type ProgressEvent = {
+    kind: 'snapshot';
+    bytes: number;
+} | {
+    kind: 'session';
+    resumed: boolean;
+    nextExpectedSeq: number;
+} | {
+    kind: 'chunk-uploaded';
+    seq: number;
+    total: number;
+} | {
+    kind: 'finalized';
+};
+export interface UploadResult {
+    ok: boolean;
+    url?: string;
+    skipped?: boolean;
+    error?: string;
+}
+export declare class UploadError extends Error {
+    readonly status: number | null;
+    constructor(message: string, status?: number | null);
+}
+/**
+ * Phase 3 — thrown when /api/upload-session returns 402 with a structured
+ * `limit_reached` payload. Auto-upload entry point detects this subclass
+ * and prints a friendly message without retrying or overriding the run's
+ * exit code.
+ */
+export declare class UploadLimitError extends UploadError {
+    readonly payload: {
+        limit: string;
+        current: number;
+        max: number;
+        upgrade_url: string;
+    };
+    constructor(message: string, payload: {
+        limit: string;
+        current: number;
+        max: number;
+        upgrade_url: string;
+    });
+}
+export declare function uploadRun(runId: string, runDir: string, opts: UploadOptions): Promise<UploadResult>;
+//# sourceMappingURL=uploader.d.ts.map