@delegance/claude-autopilot 6.2.2 → 7.2.1

package/README.md

@@ -4,7 +4,16 @@
 
 **Autonomous development pipeline for Claude Code. Brainstorm → spec → plan → implement → migrate → validate → PR → review → merge — all from your terminal, on your codebase, with your test suite.**
 
-**Open source, MIT-licensed, runs on your machine with your API keys.** No hosted agent, no per-seat subscription — `npm install -g @delegance/claude-autopilot` and you're done.
+**Open source, MIT-licensed, runs on your machine with your API keys.** No hosted agent, no per-seat subscription — `npm install -g @delegance/claude-autopilot@latest` and you're done.
+
+## Hosted product (v7)
+
+A hosted dashboard at **[autopilot.dev](https://autopilot.dev)** complements the self-hosted CLI. The CLI keeps doing all the work locally on your machine — running models, writing code, opening PRs — and optionally uploads each completed run's state + cost summary to the hosted dashboard so your team can see what's been shipped, audit cost, and manage memberships from the browser.
+
+- **CLI (this package)** — local-first, no telemetry by default, your machine + your API keys. Pipeline stays the same.
+- **Dashboard ([autopilot.dev](https://autopilot.dev))** — opt-in. After `claude-autopilot dashboard login` mints a personal API key via a loopback OAuth flow, every engine-on autopilot run uploads its `state.json` + `events.ndjson` + cost roll-up at run.complete. Org admin (members, billing, SSO) lives there.
+
+The CLI works offline; the dashboard is purely additive. See [docs/v7/runbook.md](./docs/v7/runbook.md) for operating the hosted product and [docs/v7/breaking-changes.md](./docs/v7/breaking-changes.md) for the v6→v7 migration checklist.
 
 ```bash
 claude-autopilot brainstorm "add SSO with SAML for enterprise tenants"

package/bin/_launcher.js

@@ -31,44 +31,52 @@ function findTsx() {
   return 'tsx';
 }
 
-// Tracks per-terminal-session whether the deprecation notice has been shown.
-// Uses a temp file keyed by parent PID + stderr's tty so parallel CI jobs don't
-// collide. Falls back to always-emit if the stamp can't be written.
-const DEPRECATION_STAMP_DIR = path.join(os.tmpdir(), 'claude-autopilot');
-function hasShownDeprecation() {
+// v7.1.7 — Per-calendar-day deprecation dedup, keyed in the user's home dir.
+//
+// The previous (v6.3+) implementation used a temp file keyed by `process.ppid
+// + stderr.isTTY` to dedup once per "terminal session." That worked in
+// interactive shells but FAILED for the most common deprecation trigger —
+// the pre-commit/pre-push git hooks. Git spawns a fresh shell for each hook
+// invocation, so the parent PID is fresh on every commit, the stamp file
+// path is unique each time, and the notice printed on every single commit.
+// The v7.1.6 blank-repo benchmark agent surfaced this as the #1 paper cut.
+//
+// New strategy: stamp at `~/.claude-autopilot/.deprecation-shown`, contents =
+// `YYYY-MM-DD` (UTC). Show at most once per day per machine. Operator gets a
+// daily reminder of the rename without per-commit spam. Override env vars
+// (`CLAUDE_AUTOPILOT_DEPRECATION=always|never`) preserved.
+const DEPRECATION_STAMP_PATH = path.join(os.homedir(), '.claude-autopilot', '.deprecation-shown');
+function todayUtc() {
+  return new Date().toISOString().slice(0, 10);
+}
+function hasShownDeprecationToday() {
   try {
-    if (!fs.existsSync(DEPRECATION_STAMP_DIR)) {
-      fs.mkdirSync(DEPRECATION_STAMP_DIR, { recursive: true });
-    }
-    const key = `${process.ppid}-${process.stderr.isTTY ? 'tty' : 'pipe'}.stamp`;
-    const stampPath = path.join(DEPRECATION_STAMP_DIR, key);
-    if (fs.existsSync(stampPath)) return true;
-    fs.writeFileSync(stampPath, String(Date.now()));
-    // Best-effort cleanup of stamps older than 1h to keep tmpdir tidy.
-    const cutoff = Date.now() - 60 * 60 * 1000;
-    for (const f of fs.readdirSync(DEPRECATION_STAMP_DIR)) {
-      const p = path.join(DEPRECATION_STAMP_DIR, f);
-      try {
-        if (fs.statSync(p).mtimeMs < cutoff) fs.unlinkSync(p);
-      } catch { /* ignore */ }
-    }
-    return false;
+    if (!fs.existsSync(DEPRECATION_STAMP_PATH)) return false;
+    return fs.readFileSync(DEPRECATION_STAMP_PATH, 'utf8').trim() === todayUtc();
   } catch {
+    // Stamp unreadable — show notice (better than silently swallowing).
     return false;
   }
 }
+function markDeprecationShown() {
+  try {
+    const dir = path.dirname(DEPRECATION_STAMP_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(DEPRECATION_STAMP_PATH, todayUtc());
+  } catch { /* best-effort; missing stamp re-prints next invocation */ }
+}
 
 /**
  * Decide whether to emit the deprecation notice. Order:
  *   CLAUDE_AUTOPILOT_DEPRECATION=never   → never emit (CI/automation)
  *   CLAUDE_AUTOPILOT_DEPRECATION=always  → always emit (deterministic testing)
- *   otherwise                            → once per terminal session (stamp-based)
+ *   otherwise                            → at most once per UTC day
  */
 function shouldEmitDeprecation() {
   const override = process.env.CLAUDE_AUTOPILOT_DEPRECATION;
   if (override === 'never') return false;
   if (override === 'always') return true;
-  return !hasShownDeprecation();
+  return !hasShownDeprecationToday();
 }
 
 /**
@@ -83,6 +91,13 @@ export function launch(opts) {
       'Migration guide: https://github.com/axledbetter/claude-autopilot/blob/master/docs/migration/v4-to-v5.md\n' +
       'Silence: set CLAUDE_AUTOPILOT_DEPRECATION=never\n',
     );
+    // v7.1.7 — mark stamp AFTER successful emission so a write-failure on
+    // stderr still results in the next invocation re-trying. Skip when
+    // CLAUDE_AUTOPILOT_DEPRECATION=always (deterministic-testing override
+    // shouldn't write the stamp).
+    if (process.env.CLAUDE_AUTOPILOT_DEPRECATION !== 'always') {
+      markDeprecationShown();
+    }
   }
 
   const entry = resolveEntry();

package/dist/src/cli/autopilot.d.ts

@@ -23,6 +23,10 @@ export interface AutopilotOptions {
     /** Test seam — keep stdout banners suppressed. Production callers MUST
      *  NOT pass this; the dispatcher does not surface a flag for it. */
     __silent?: boolean;
+    /** v7.0 Phase 2.3 — opt out of auto-upload at run.complete. Surfaced by
+     *  the CLI as `--no-upload`. Equivalent to `CLAUDE_AUTOPILOT_UPLOAD=off`
+     *  but scoped per-invocation. */
+    noUpload?: boolean;
 }
 export interface AutopilotPhaseSummary {
     name: string;

package/dist/src/cli/autopilot.js

@@ -350,6 +350,21 @@ export async function runAutopilot(options = {}) {
                 process.stdout.write(fmt(ANSI_DIM, `  resume:  claude-autopilot run resume ${created.runId}\n`));
             }
         }
+        // --- v7.0 Phase 2.3 — auto-upload at run.complete ----------------
+        // Non-fatal: never overrides the run's exitCode. Failure prints a
+        // resume command via the helper itself. Skipped silently when the
+        // user isn't logged in or has opted out.
+        try {
+            const { autoUploadAtComplete } = await import("../dashboard/auto-upload.js");
+            await autoUploadAtComplete(created.runId, created.runDir, {
+                ...(options.noUpload ? { disabled: true } : {}),
+                silent,
+            });
+        }
+        catch {
+            // Hosted dashboard is optional. Any unhandled error here MUST NOT
+            // fail the run (spec: "Auto-upload NEVER fails the run").
+        }
         return {
             runId: created.runId,
             runDir: created.runDir,

package/dist/src/cli/dashboard/index.d.ts

@@ -0,0 +1,5 @@
+export interface DashboardArgs {
+    argv: string[];
+}
+export declare function runDashboardVerb(args: DashboardArgs): Promise<number>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/cli/dashboard/index.js

@@ -0,0 +1,49 @@
+// `claude-autopilot dashboard <verb>` — umbrella dispatcher.
+//
+// Verbs: login | logout | status | upload <runId>
+import { runDashboardLogin } from "./login.js";
+import { runDashboardLogout } from "./logout.js";
+import { runDashboardStatus } from "./status.js";
+import { runDashboardUpload } from "./upload.js";
+export async function runDashboardVerb(args) {
+    const [verb, ...rest] = args.argv;
+    switch (verb) {
+        case 'login': {
+            try {
+                await runDashboardLogin();
+                return 0;
+            }
+            catch (err) {
+                process.stderr.write(`[autopilot] login failed: ${err.message}\n`);
+                return 1;
+            }
+        }
+        case 'logout': {
+            await runDashboardLogout();
+            return 0;
+        }
+        case 'status': {
+            await runDashboardStatus();
+            return 0;
+        }
+        case 'upload': {
+            const runId = rest[0];
+            if (!runId) {
+                process.stderr.write(`[autopilot] usage: claude-autopilot dashboard upload <runId>\n`);
+                return 2;
+            }
+            const result = await runDashboardUpload({ runId });
+            if (result.ok)
+                return 0;
+            if (result.notLoggedIn || result.runDirMissing)
+                return 2;
+            return 1;
+        }
+        default: {
+            process.stderr.write(`[autopilot] unknown dashboard verb: ${verb ?? '(none)'}\n`);
+            process.stderr.write(`            valid verbs: login, logout, status, upload <runId>\n`);
+            return 2;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/src/cli/dashboard/login.d.ts

@@ -0,0 +1,22 @@
+import { type DashboardConfig } from '../../dashboard/config.ts';
+export interface LoginOptions {
+    /** Override base URL for tests / staging. */
+    baseUrl?: string;
+    /** Override browser launch — useful in tests + headless CI. */
+    openBrowser?: (url: string) => void | Promise<void>;
+    /** Manual mode: print URL, accept paste of (apiKey, fingerprint, email) on stdin instead of loopback. */
+    manual?: boolean;
+    /** Test seam — let tests force a specific port range start to avoid collisions. */
+    portRangeStart?: number;
+    /** Test seam — abort the listener after a fixed timeout. */
+    timeoutMs?: number;
+    /** Test seam — silence stdout/stderr writes. */
+    silent?: boolean;
+    signal?: AbortSignal;
+}
+export interface LoginResult {
+    config: DashboardConfig;
+    port: number;
+}
+export declare function runDashboardLogin(opts?: LoginOptions): Promise<LoginResult>;
+//# sourceMappingURL=login.d.ts.map

package/dist/src/cli/dashboard/login.js

@@ -0,0 +1,260 @@
+// `claude-autopilot dashboard login` — nonce-bound loopback OAuth-ish flow.
+//
+// 1. Generate 128-bit nonce.
+// 2. Bind a node:http listener on the first available port in 56000-56050.
+// 3. Open https://autopilot.dev/cli-auth?cb=<callback>&nonce=<nonce> in the
+//    user's browser. (User signs in, web page POSTs back to the callback
+//    with { apiKey, fingerprint, accountEmail, nonce }.)
+// 4. Validate nonce with crypto.timingSafeEqual; reject mismatches.
+// 5. Atomically write ~/.claude-autopilot/dashboard.json with mode 0600.
+// 6. Respond 200 to the browser; close listener; print success.
+//
+// The web `/cli-auth` page is operator-deferred to Phase 4 dashboard UI;
+// for now tests use a mock browser handler that simulates the full flow.
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { writeConfig, getAutopilotBaseUrl, } from "../../dashboard/config.js";
+const PORT_START = 56000;
+const PORT_END = 56050;
+const NONCE_BYTES = 16; // 128-bit
+const TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_BODY_BYTES = 4096;
+const KEY_RE = /^clp_[0-9a-f]{64}$/;
+function nonceMatch(expected, candidate) {
+    // timingSafeEqual requires equal-length buffers.
+    const a = Buffer.from(expected, 'utf-8');
+    const b = Buffer.from(candidate, 'utf-8');
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(a, b);
+}
+async function tryListen(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        const onError = () => {
+            server.removeListener('listening', onListening);
+            resolve(null);
+        };
+        const onListening = () => {
+            server.removeListener('error', onError);
+            resolve({ server, port });
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function bindFirstPort(start, end) {
+    for (let p = start; p <= end; p++) {
+        const r = await tryListen(p);
+        if (r)
+            return r;
+    }
+    throw new Error(`could not bind any port in ${start}-${end}`);
+}
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let bytes = 0;
+        const chunks = [];
+        req.on('data', (c) => {
+            bytes += c.length;
+            if (bytes > MAX_BODY_BYTES) {
+                req.destroy();
+                reject(new Error('body too large'));
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on('end', () => {
+            try {
+                const buf = Buffer.concat(chunks);
+                resolve(JSON.parse(buf.toString('utf-8')));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function openInBrowser(url) {
+    // Best-effort cross-platform; ignored on test/headless paths.
+    const platform = process.platform;
+    let cmd;
+    let args;
+    if (platform === 'darwin') {
+        cmd = 'open';
+        args = [url];
+    }
+    else if (platform === 'win32') {
+        cmd = 'cmd';
+        args = ['/c', 'start', '""', url];
+    }
+    else {
+        cmd = 'xdg-open';
+        args = [url];
+    }
+    try {
+        spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+    }
+    catch {
+        /* noop */
+    }
+}
+export async function runDashboardLogin(opts = {}) {
+    // Phase 4 — unified env name. AUTOPILOT_PUBLIC_BASE_URL is canonical
+    // (matches apps/web). AUTOPILOT_DASHBOARD_BASE_URL is the deprecated
+    // Phase 2.3 alias and triggers a one-time warning.
+    const baseUrl = opts.baseUrl ?? getAutopilotBaseUrl();
+    const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
+    const portStart = opts.portRangeStart ?? PORT_START;
+    const portEnd = portStart + (PORT_END - PORT_START);
+    const nonce = randomBytes(NONCE_BYTES).toString('hex');
+    const { server, port } = await bindFirstPort(portStart, portEnd);
+    const cb = `http://127.0.0.1:${port}/cli-callback`;
+    const authUrl = `${baseUrl}/cli-auth?cb=${encodeURIComponent(cb)}&nonce=${encodeURIComponent(nonce)}`;
+    let resolved = null;
+    let rejected = null;
+    const result = new Promise((resolve, reject) => {
+        resolved = resolve;
+        rejected = reject;
+    });
+    let settled = false;
+    const settle = (fn) => {
+        if (settled)
+            return;
+        settled = true;
+        fn();
+        // Force-close active connections so the event loop drains immediately
+        // (matters for tests; production callers exit the process anyway).
+        try {
+            server.closeAllConnections?.();
+        }
+        catch { /* noop */ }
+        server.close();
+    };
+    const timer = setTimeout(() => {
+        settle(() => rejected?.(new Error(`login timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+    // Don't keep the event loop alive solely for the timeout watchdog —
+    // matters in tests when the suite has finished but timers linger.
+    timer.unref?.();
+    if (opts.signal) {
+        if (opts.signal.aborted) {
+            clearTimeout(timer);
+            server.close();
+            throw new Error('aborted');
+        }
+        opts.signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            settle(() => rejected?.(new Error('aborted')));
+        }, { once: true });
+    }
+    // Phase 4 CORS — the /cli-auth page POSTs to this loopback with
+    // mode: 'cors'. Without OPTIONS preflight + Access-Control-Allow-Origin
+    // matching the configured public base URL, the browser fetch fails
+    // silently (opaque response) and the user sees "loopback failed" with
+    // no signal here.
+    const allowedOrigin = baseUrl;
+    server.on('request', (req, res) => {
+        void (async () => {
+            try {
+                // OPTIONS preflight — no body, no auth, just CORS headers.
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204, {
+                        'Access-Control-Allow-Origin': allowedOrigin,
+                        'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                        'Access-Control-Allow-Headers': 'content-type',
+                        'Access-Control-Max-Age': '60',
+                        Vary: 'Origin',
+                    });
+                    res.end();
+                    return;
+                }
+                if (req.method !== 'POST' || req.url !== '/cli-callback') {
+                    res.statusCode = 404;
+                    res.end('not found');
+                    return;
+                }
+                const ct = (req.headers['content-type'] ?? '').toString();
+                if (!ct.includes('application/json')) {
+                    res.statusCode = 415;
+                    res.end('unsupported media type');
+                    return;
+                }
+                const body = await readJsonBody(req);
+                // Codex NOTE — CORS header on POST response so the browser can
+                // read the JSON body under mode: 'cors'.
+                const corsHeaders = {
+                    'Access-Control-Allow-Origin': allowedOrigin,
+                    Vary: 'Origin',
+                };
+                if (typeof body.nonce !== 'string' || !nonceMatch(nonce, body.nonce)) {
+                    res.writeHead(403, { ...corsHeaders, 'content-type': 'text/plain' });
+                    res.end('nonce mismatch');
+                    clearTimeout(timer);
+                    settle(() => rejected?.(new Error('nonce mismatch')));
+                    return;
+                }
+                if (typeof body.apiKey !== 'string' || !KEY_RE.test(body.apiKey)) {
+                    res.writeHead(422, { ...corsHeaders, 'content-type': 'text/plain' });
+                    res.end('invalid apiKey');
+                    clearTimeout(timer);
+                    settle(() => rejected?.(new Error('invalid apiKey from callback')));
+                    return;
+                }
+                if (typeof body.fingerprint !== 'string' || !/^clp_[0-9a-f]{12}$/.test(body.fingerprint)) {
+                    res.writeHead(422, { ...corsHeaders, 'content-type': 'text/plain' });
+                    res.end('invalid fingerprint');
+                    clearTimeout(timer);
+                    settle(() => rejected?.(new Error('invalid fingerprint from callback')));
+                    return;
+                }
+                if (typeof body.accountEmail !== 'string') {
+                    res.writeHead(422, { ...corsHeaders, 'content-type': 'text/plain' });
+                    res.end('invalid accountEmail');
+                    clearTimeout(timer);
+                    settle(() => rejected?.(new Error('invalid accountEmail from callback')));
+                    return;
+                }
+                const cfg = {
+                    schemaVersion: 1,
+                    apiKey: body.apiKey,
+                    fingerprint: body.fingerprint,
+                    accountEmail: body.accountEmail,
+                    loggedInAt: new Date().toISOString(),
+                    lastUploadAt: null,
+                };
+                await writeConfig(cfg);
+                res.writeHead(200, {
+                    ...corsHeaders,
+                    'content-type': 'application/json',
+                });
+                res.end(JSON.stringify({ ok: true, nonce }));
+                clearTimeout(timer);
+                settle(() => resolved?.({ config: cfg, port }));
+            }
+            catch (err) {
+                res.statusCode = 500;
+                res.setHeader('Access-Control-Allow-Origin', allowedOrigin);
+                res.end(err.message ?? 'error');
+                clearTimeout(timer);
+                settle(() => rejected?.(err instanceof Error ? err : new Error(String(err))));
+            }
+        })();
+    });
+    // Print + open after the server is listening.
+    if (!opts.silent) {
+        process.stdout.write(`[autopilot] sign in here: ${authUrl}\n`);
+        process.stdout.write(`            (a browser window will open; loopback callback on port ${port})\n`);
+    }
+    if (opts.openBrowser) {
+        await opts.openBrowser(authUrl);
+    }
+    else {
+        openInBrowser(authUrl);
+    }
+    return result;
+}
+//# sourceMappingURL=login.js.map

package/dist/src/cli/dashboard/logout.d.ts

@@ -0,0 +1,12 @@
+export interface LogoutOptions {
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    silent?: boolean;
+}
+export interface LogoutResult {
+    hadConfig: boolean;
+    serverRevoked: boolean;
+    serverStatus: number | null;
+}
+export declare function runDashboardLogout(opts?: LogoutOptions): Promise<LogoutResult>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/src/cli/dashboard/logout.js

@@ -0,0 +1,45 @@
+// `claude-autopilot dashboard logout` — revoke server-side, delete config locally.
+//
+// Idempotent: missing config or HTTP failure both still result in the
+// local file being deleted. Server-side revocation is best-effort but we
+// surface the status code on stdout for transparency.
+import { readConfig, deleteConfig } from "../../dashboard/config.js";
+export async function runDashboardLogout(opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const baseUrl = opts.baseUrl ?? process.env.AUTOPILOT_DASHBOARD_BASE_URL ?? 'https://autopilot.dev';
+    const cfg = await readConfig();
+    if (!cfg) {
+        if (!opts.silent)
+            process.stdout.write(`[autopilot] not logged in.\n`);
+        await deleteConfig();
+        return { hadConfig: false, serverRevoked: false, serverStatus: null };
+    }
+    let status = null;
+    let revoked = false;
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/dashboard/api-keys/revoke`, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${cfg.apiKey}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ apiKey: cfg.apiKey }),
+        });
+        status = res.status;
+        revoked = res.ok;
+    }
+    catch {
+        /* network error — local delete still proceeds */
+    }
+    await deleteConfig();
+    if (!opts.silent) {
+        if (revoked) {
+            process.stdout.write(`[autopilot] logged out (key ${cfg.fingerprint} revoked).\n`);
+        }
+        else {
+            process.stdout.write(`[autopilot] local config deleted; server revocation status=${status ?? 'network error'}.\n`);
+        }
+    }
+    return { hadConfig: true, serverRevoked: revoked, serverStatus: status };
+}
+//# sourceMappingURL=logout.js.map

package/dist/src/cli/dashboard/status.d.ts

@@ -0,0 +1,30 @@
+export interface StatusOptions {
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    silent?: boolean;
+}
+export interface MeResponse {
+    email: string | null;
+    fingerprint: string | null;
+    organizations: Array<{
+        id: string;
+        name: string;
+        role: string;
+    }>;
+    lastUploadAt: string | null;
+}
+export interface StatusResult {
+    loggedIn: boolean;
+    fingerprint: string | null;
+    email: string | null;
+    serverOk: boolean;
+    organizations: Array<{
+        id: string;
+        name: string;
+        role: string;
+    }>;
+    lastUploadAt: string | null;
+    permissiveWarning: string | null;
+}
+export declare function runDashboardStatus(opts?: StatusOptions): Promise<StatusResult>;
+//# sourceMappingURL=status.d.ts.map

package/dist/src/cli/dashboard/status.js

@@ -0,0 +1,65 @@
+// `claude-autopilot dashboard status` — read config + call /me + print.
+import { readConfig, warnIfPermissive, getConfigPath, } from "../../dashboard/config.js";
+export async function runDashboardStatus(opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const baseUrl = opts.baseUrl ?? process.env.AUTOPILOT_DASHBOARD_BASE_URL ?? 'https://autopilot.dev';
+    const cfg = await readConfig();
+    const permissive = await warnIfPermissive();
+    if (!cfg) {
+        if (!opts.silent) {
+            process.stdout.write(`[autopilot] not logged in. Run: claude-autopilot dashboard login\n`);
+            process.stdout.write(`            (config path: ${getConfigPath()})\n`);
+        }
+        return {
+            loggedIn: false,
+            fingerprint: null,
+            email: null,
+            serverOk: false,
+            organizations: [],
+            lastUploadAt: null,
+            permissiveWarning: permissive,
+        };
+    }
+    let me = null;
+    let serverOk = false;
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/dashboard/me`, {
+            method: 'GET',
+            headers: { authorization: `Bearer ${cfg.apiKey}` },
+        });
+        if (res.ok) {
+            me = await res.json();
+            serverOk = true;
+        }
+    }
+    catch {
+        /* network error — fall through with serverOk=false */
+    }
+    if (!opts.silent) {
+        process.stdout.write(`[autopilot] logged in as ${cfg.accountEmail} (${cfg.fingerprint}).\n`);
+        if (serverOk && me) {
+            if (me.organizations.length > 0) {
+                process.stdout.write(`            organizations: ${me.organizations.map((o) => `${o.name} (${o.role})`).join(', ')}\n`);
+            }
+            if (me.lastUploadAt) {
+                process.stdout.write(`            last upload: ${me.lastUploadAt}\n`);
+            }
+        }
+        else {
+            process.stdout.write(`            (server unreachable; using cached config)\n`);
+        }
+        if (permissive) {
+            process.stderr.write(`${permissive}\n`);
+        }
+    }
+    return {
+        loggedIn: true,
+        fingerprint: cfg.fingerprint,
+        email: cfg.accountEmail,
+        serverOk,
+        organizations: me?.organizations ?? [],
+        lastUploadAt: me?.lastUploadAt ?? null,
+        permissiveWarning: permissive,
+    };
+}
+//# sourceMappingURL=status.js.map

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

@@ -0,0 +1,16 @@
+import { type UploadResult } from '../../dashboard/upload/uploader.ts';
+export interface ManualUploadOptions {
+    runId: string;
+    runsDir?: string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    silent?: boolean;
+    signal?: AbortSignal;
+}
+export interface ManualUploadResult extends UploadResult {
+    notLoggedIn?: boolean;
+    runDirMissing?: boolean;
+    runDir?: string;
+}
+export declare function runDashboardUpload(opts: ManualUploadOptions): Promise<ManualUploadResult>;
+//# sourceMappingURL=upload.d.ts.map