@1presence/bridge 0.38.0 → 0.40.0

package/dist/auth.js

@@ -86,26 +86,32 @@ function runBrowserAuthFlow(gatewayUrl, pwaUrl) {
                 res.setHeader('Access-Control-Allow-Origin', pwaOrigin);
             }
             res.setHeader('Vary', 'Origin');
-            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
             res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
             if (req.method === 'OPTIONS') {
                 res.writeHead(204);
                 res.end();
                 return;
             }
-            if (req.method !== 'POST') {
-                res.writeHead(405);
-                res.end();
-                return;
-            }
             const reqUrl = new URL(req.url ?? '/', 'http://localhost');
             const path = reqUrl.pathname;
-            // Every POST must carry the launch-specific nonce.
+            // Every request must carry the launch-specific nonce.
             if (!checkNonce(reqUrl.searchParams.get('nonce'))) {
                 res.writeHead(403);
                 res.end();
                 return;
             }
+            // Lets the PWA verify the bridge is still listening before POSTing the token.
+            if (req.method === 'GET' && (path === '/' || path === '')) {
+                res.writeHead(200, { 'Content-Type': 'text/plain' });
+                res.end('1Presence bridge waiting for sign-in');
+                return;
+            }
+            if (req.method !== 'POST') {
+                res.writeHead(405);
+                res.end();
+                return;
+            }
             // Status beacon from the PWA — used so we exit early when the user closes
             // the auth tab before signing in (sendBeacon path).
             if (path === '/status') {

package/dist/claude.js

@@ -154,8 +154,15 @@ const RETRY_WALL_CLOCK_CAP_MS = 12_000; // stop retrying past this much elapsed
 // latest), so upgrading does NOT fix it. We deliberately do not suggest an
 // upgrade; the automatic retry is the real mitigation and resending sometimes
 // gets through.
-function describeCliFailure(code, apiErrorText) {
+function describeCliFailure(code, apiErrorText, authFailure) {
     const t = apiErrorText.trim();
+    // Auth/credential failure (401/403). Local Mode runs the user's own Claude
+    // Code, so naming it (and /login) is intentional and consistent with the
+    // "claude CLI not found" message — this is the only place that can tell them
+    // how to recover. Takes precedence over the generic branches below.
+    if (authFailure) {
+        return 'Local Mode could not sign in to Claude Code on this machine. Open a terminal, run `claude` and sign in (or run /login inside Claude Code), then send your message again.';
+    }
     if (/API Error:\s*400/i.test(t) && /(tool use|concurren|parallel)/i.test(t)) {
         return 'Local Mode hit a known Claude Code error (a print-mode bug that affects every current version). I retried a few times automatically — sending the message again sometimes gets through. See https://github.com/anthropics/claude-code/issues/18131';
     }
@@ -342,6 +349,11 @@ function spawnClaude(params) {
     let messageCount = 0;
     let costUsd = 0;
     let usage = null;
+    // Prompt size of the MOST RECENT assistant call (input + both cache buckets),
+    // overwritten on each assistant event so it ends on the turn's final, fullest
+    // call. This — not the summed `usage` above — is the current context fill the
+    // status line's 🧠 segment reports against the model's window.
+    let lastContextTokens = 0;
     let extractedModel = null;
     let buffer = '';
     let killedForViolation = false;
@@ -352,6 +364,10 @@ function spawnClaude(params) {
     //  - producedRealOutput: any real assistant text or tool_use was emitted, so
     //    a later failure must NOT be retried (could double-run a side-effect).
     let sawApiError = false;
+    //  - sawAuthFailure: a 401/403 auth/credential failure (the user's local
+    //    Claude Code is not signed in). Surfaced as an actionable message and
+    //    never retried (re-spawning won't add credentials).
+    let sawAuthFailure = false;
     let apiErrorText = '';
     let producedRealOutput = false;
     proc.stdout.on('data', (chunk) => {
@@ -408,6 +424,10 @@ function spawnClaude(params) {
                         cache_read_input_tokens: (usage?.cache_read_input_tokens ?? 0) + (u['cache_read_input_tokens'] ?? 0),
                         cache_creation_input_tokens: (usage?.cache_creation_input_tokens ?? 0) + (u['cache_creation_input_tokens'] ?? 0),
                     };
+                    // Full prompt size of THIS assistant call — non-cached input plus both
+                    // cache buckets. Overwrite (don't sum): the last write wins, which is
+                    // the turn's largest/final context.
+                    lastContextTokens = (u['input_tokens'] ?? 0) + (u['cache_read_input_tokens'] ?? 0) + (u['cache_creation_input_tokens'] ?? 0);
                 }
                 const content = msg?.['content'];
                 if (Array.isArray(content)) {
@@ -463,14 +483,30 @@ function spawnClaude(params) {
                         else if (block['type'] === 'text') {
                             const text = block['text'];
                             if (text) {
-                                if (/^API Error:/i.test(text.trimStart())) {
-                                    // The CLI is reporting an underlying API failure as assistant
-                                    // text. Capture it for the user-facing message, and suppress
-                                    // the whole event so the raw error never reaches the PWA or
-                                    // the accumulator (the gateway also blanks it via
+                                // The CLI reports auth/credential failures (401/403) as a
+                                // <synthetic> assistant text turn whose wording varies and does
+                                // NOT reliably start with "API Error:" — e.g. "Please run /login
+                                // · API Error: 401 Invalid authentication credentials" or
+                                // "Failed to authenticate. API Error: 401 …". Detect by the
+                                // structured signal (the event's `error: authentication_failed`
+                                // / `model: <synthetic>`) plus a wording fallback, so it is
+                                // classified instead of leaking raw into the chat as if the
+                                // model had said it.
+                                const isSynthetic = msg?.['model'] === '<synthetic>';
+                                const isAuthFailure = event['error'] === 'authentication_failed' ||
+                                    (isSynthetic && /(api error:\s*40[13]\b|invalid (api key|authentication)|please run \/login|failed to authenticate|unauthor)/i.test(text));
+                                if (/^API Error:/i.test(text.trimStart()) || isAuthFailure) {
+                                    // The CLI is reporting an underlying API/auth failure as
+                                    // assistant text. Capture it for the user-facing message, and
+                                    // suppress the whole event so the raw error never reaches the
+                                    // PWA or the accumulator (the gateway also blanks it via
                                     // cleanTurnText — this is the upstream defense).
                                     sawApiError = true;
                                     apiErrorText = text.trim();
+                                    if (isAuthFailure)
+                                        sawAuthFailure = true;
+                                    // Operator log keeps the raw provider line verbatim (with a
+                                    // [bridge] prefix) so the real reason is diagnosable locally.
                                     suppressEvent = true;
                                     process.stderr.write(paint(exports.SECTION_COLORS.result, `[bridge] ${text.replace(/\n+/g, ' ')}`) + '\n');
                                 }
@@ -513,11 +549,25 @@ function spawnClaude(params) {
                     }
                 }
             }
-            // Extract cost from the final result event
+            // Extract cost from the final result event. The CLI also stamps auth/API
+            // failures here as `is_error` + `api_error_status` (even though `subtype`
+            // stays "success"), so treat it as a robust backstop in case the
+            // assistant-text signal above was missed (wording drift across CLI
+            // versions). 401/403 → auth failure; other statuses keep the existing
+            // 400-retry behaviour (sawApiError only).
             if (type === 'result') {
                 const c = event['cost_usd'] ?? event['total_cost_usd'];
                 if (typeof c === 'number')
                     costUsd = c;
+                if (event['is_error'] === true) {
+                    sawApiError = true;
+                    const status = event['api_error_status'];
+                    if (status === 401 || status === 403)
+                        sawAuthFailure = true;
+                    if (!apiErrorText && typeof event['result'] === 'string') {
+                        apiErrorText = event['result'].trim();
+                    }
+                }
             }
             if (!suppressEvent)
                 onEvent(event);
@@ -541,14 +591,20 @@ function spawnClaude(params) {
             }
             catch { /* ignore */ }
         }
-        if (code !== 0 && code !== null) {
+        // An auth failure can land on a "successful" exit (the CLI stamps it on the
+        // result event but still exits 0 in some versions), and we've suppressed its
+        // text — so without this the turn would finish silently empty. Treat it as a
+        // failure regardless of exit code.
+        if (sawAuthFailure || (code !== 0 && code !== null)) {
             // Auto-retry when the CLI failed BEFORE producing any real output — the
             // signature of the known print-mode 400 regression. A fresh spawn (new
             // --session-id) often succeeds. We never retry once real text or a tool
-            // call landed, to avoid double-running a side-effectful tool. Retries use
-            // escalating backoff and stop past the wall-clock cap (see consts above).
+            // call landed, to avoid double-running a side-effectful tool. We also
+            // never retry an auth failure — re-spawning won't add missing credentials,
+            // it just burns the user's plan. Retries use escalating backoff and stop
+            // past the wall-clock cap (see consts above).
             const elapsed = Date.now() - firstAttemptAt;
-            if (attemptIdx < MAX_TURN_RETRIES && sawApiError && !producedRealOutput && elapsed < RETRY_WALL_CLOCK_CAP_MS) {
+            if (attemptIdx < MAX_TURN_RETRIES && sawApiError && !sawAuthFailure && !producedRealOutput && elapsed < RETRY_WALL_CLOCK_CAP_MS) {
                 const delay = RETRY_BACKOFF_BASE_MS * (attemptIdx + 1);
                 const nextAttempt = attemptIdx + 2;
                 process.stderr.write(`[bridge] turn failed before output (${apiErrorText.replace(/\n+/g, ' ').slice(0, 120)}) — retrying (${nextAttempt} of ${MAX_TURN_RETRIES + 1}) in ${delay}ms\n`);
@@ -564,10 +620,10 @@ function spawnClaude(params) {
             // Pass any partial token usage we observed before the failure so the
             // PWA and the gateway's bridge usage store can still record it. Surface a
             // classified, user-readable message instead of the opaque exit code.
-            onError(describeCliFailure(code, apiErrorText), usage, extractedModel);
+            onError(describeCliFailure(code, apiErrorText, sawAuthFailure), usage, extractedModel);
         }
         else {
-            onDone(messageCount, costUsd, usage, extractedModel);
+            onDone(messageCount, costUsd, usage, extractedModel, lastContextTokens);
         }
     });
     proc.on('error', (err) => {

package/dist/index.js

@@ -45,6 +45,52 @@ const PWA_URL = process.env.BRIDGE_PWA_URL ?? GATEWAY_HTTP.replace('://api.', ':
 // ─── In-memory state ──────────────────────────────────────────────────────────
 let currentAuth = null;
 let currentWs = null;
+// Running cost across all turns this process has handled, for the cost segment
+// of the per-turn status line. On a pure subscription the CLI often reports a
+// per-turn cost of 0, in which case this stays at 0 and reads as "plan usage".
+let sessionCostUsd = 0;
+// ─── Status line ──────────────────────────────────────────────────────────────
+//
+// A compact line printed after each completed turn echoing the segments local
+// Claude Code shows in its own status bar: model, context fill, and cost. The
+// 5h/7d subscription rate-limit windows it also shows are deliberately absent —
+// those ride in the API's rate-limit response HEADERS, which the bridge (a
+// consumer of the CLI's stream-json stdout only) never sees. Display only.
+// Raw model id (claude-opus-4-7, claude-sonnet-4-6-20250101) to friendly "Opus
+// 4.7". Regex-based so new dated snapshots format without a table edit; an
+// unrecognised shape falls back to the raw id rather than guessing.
+function friendlyModelName(model) {
+    if (!model)
+        return 'unknown';
+    const m = /claude-(opus|sonnet|haiku)-(\d+)-(\d+)/i.exec(model);
+    if (!m)
+        return model;
+    return `${m[1].charAt(0).toUpperCase()}${m[1].slice(1)} ${m[2]}.${m[3]}`;
+}
+// Context window (tokens) per model, for the context-fill estimate. Keyed by a
+// family regex against the raw model id; first match wins, and an unrecognised
+// id falls back to the Claude 4.x baseline rather than guessing high.
+//
+// Every model the bridge can currently run is 200k: Opus/Sonnet/Haiku 4.x are
+// 200k on the standard path, and the 1M-context window is an API beta that the
+// bridge's subscription print mode never opts into — so it does not apply here.
+// When a model ships with a different standard window, add a row above the
+// baseline; that one line keeps the estimate honest without touching anything
+// else. (The percentage is of the raw window — local Claude's own gauge also
+// reserves output headroom, so its reading runs a few points higher near full.)
+const CONTEXT_WINDOWS = [
+    { match: /claude-(opus|sonnet|haiku)-4/i, tokens: 200_000 },
+];
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+function contextWindowFor(model) {
+    if (model) {
+        for (const { match, tokens } of CONTEXT_WINDOWS) {
+            if (match.test(model))
+                return tokens;
+        }
+    }
+    return DEFAULT_CONTEXT_WINDOW;
+}
 // ─── System prompt fetch ──────────────────────────────────────────────────────
 // Pulls the fully-built system prompt from agent-api (via gateway proxy).
 // This MUST match the hosted runtime exactly — STATIC_SYSTEM_PROMPT + dynamic
@@ -60,19 +106,43 @@ async function fetchSystemPrompt(token, agentSlug) {
     // default 1Presence. Without it, every Local Mode turn was the generalist.
     const agentParam = agentSlug ? `&agent=${encodeURIComponent(agentSlug)}` : '';
     const url = `${GATEWAY_HTTP}/system-prompt-for-bridge?timezone=${encodeURIComponent(tz)}${agentParam}`;
-    let res;
-    try {
-        res = await fetch(url, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-    }
-    catch (err) {
-        throw new Error(`fetch failed for ${url}: ${err.message}`);
-    }
-    if (!res.ok) {
-        const body = await res.text().catch(() => '<unreadable body>');
-        throw new Error(`/system-prompt-for-bridge returned ${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
+    const headers = { Authorization: `Bearer ${token}` };
+    const maxAttempts = 8;
+    let res = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            res = await fetch(url, { headers });
+        }
+        catch (err) {
+            if (attempt === maxAttempts) {
+                throw new Error(`fetch failed for ${url}: ${err.message}`);
+            }
+            await new Promise((r) => setTimeout(r, 2_000));
+            continue;
+        }
+        if (res.status === 503 || res.status === 502) {
+            const body = await res.text().catch(() => '');
+            let retryable = true;
+            try {
+                const parsed = JSON.parse(body);
+                retryable = parsed.error === 'agent_waking' || parsed.error === 'agent_unreachable';
+            }
+            catch { /* use default */ }
+            if (retryable && attempt < maxAttempts) {
+                const delayMs = Math.min(2_000 * attempt, 10_000);
+                console.log(`[bridge] agent pod waking (${res.status}), retrying system prompt in ${delayMs / 1000}s…`);
+                await new Promise((r) => setTimeout(r, delayMs));
+                continue;
+            }
+        }
+        if (!res.ok) {
+            const body = await res.text().catch(() => '<unreadable body>');
+            throw new Error(`/system-prompt-for-bridge returned ${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
+        }
+        break;
     }
+    if (!res)
+        throw new Error(`/system-prompt-for-bridge failed after ${maxAttempts} attempts`);
     let data;
     try {
         data = await res.json();
@@ -255,7 +325,7 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
                 currentWs.send(JSON.stringify({ type: 'notice', conversationId, message }));
             }
         },
-        onDone: (messageCount, costUsd, usage, model) => {
+        onDone: (messageCount, costUsd, usage, model, contextTokens) => {
             const elapsed = (0, timer_1.stopTurnTimer)();
             const parts = [(0, timer_1.formatElapsed)(elapsed)];
             if (usage)
@@ -264,6 +334,14 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
             parts.push(costStr);
             const suffix = `  ${parts.join('  ')}`;
             console.log(`[${new Date().toLocaleTimeString()}] ✓ done${suffix}`);
+            // Status-bar line, mirroring local Claude Code: model · context fill ·
+            // session cost. Dimmed and indented so it groups under the done line
+            // without competing with it. The cost segment falls back to "plan usage"
+            // whenever the running total is 0 (the subscription case).
+            sessionCostUsd += costUsd;
+            const ctxPct = Math.max(0, Math.min(100, Math.round((contextTokens / contextWindowFor(model)) * 100)));
+            const costSeg = sessionCostUsd > 0 ? `$${sessionCostUsd.toFixed(2)} session` : 'plan usage';
+            console.log((0, claude_1.paint)('90', `             🤖 ${friendlyModelName(model)} · 🧠 ${ctxPct}% · 💰 ${costSeg}`));
             const mapped = toBridgeUsage(usage);
             if (currentWs?.readyState === ws_1.default.OPEN) {
                 currentWs.send(JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "bin": {
     "1presence-bridge": "dist/index.js"