@1presence/bridge 0.59.0 → 0.61.0

package/dist/claude.js

@@ -41,6 +41,16 @@ import { getBridgeModel } from './config.js';
 // Track whether we've already announced the model this process — printing it
 // per-spawn is noisy; once on startup is what the user actually wants to see.
 let modelAnnounced = false;
+// Claude Code engine version driving the turns, captured from the SDK init
+// event (`claude_code_version`). Constant per process, so cached module-level
+// and read by the after-turn status line — mirrors the `v2.x.x` segment of the
+// local statusline. Null until the first turn's init event arrives.
+let cliVersion = null;
+export function getCliVersion() { return cliVersion; }
+const rateLimitWindows = new Map();
+export function getRateLimitWindow(type) {
+    return rateLimitWindows.get(type);
+}
 // Verbose flag — when set via --verbose, log full tool inputs and outputs
 // PLUS the entire system prompt. Great for prompt debugging, noisy for
 // message debugging (the prompt dump buries the conversation).
@@ -185,6 +195,35 @@ function joinErrorDetail(...parts) {
 // Lines the SDK/CLI writes to its own stderr that look like a failure — surfaced
 // even outside verbose mode so a turn that dies upstream leaves a trail.
 const SDK_STDERR_ERROR_RE = /\b(error|exception|fail(?:ed|ure)?|invalid|unauthor|forbidden|refus|denied|40[0-9]|429|5\d\d|overloaded|rate.?limit)\b/i;
+// The remote 1Presence MCP server's key (matches index.ts writeMcpConfig +
+// the `mcp__1presence__*` allowlist). reconnectMcpServer() takes this name.
+const REMOTE_MCP_SERVER_NAME = '1presence';
+// Signature of a dropped remote MCP session. The pod binds each MCP session to a
+// single long-lived SSE `GET /mcp` stream held in its memory; if that stream
+// drops mid-run (transient network blip on a long workflow stage), the pod
+// deletes the session and every later `POST /mcp/message?sessionId=…` returns
+// HTTP 404 "session not found or expired". The SDK does NOT auto-retry an
+// expired MCP session (sdk.d.ts: "Session expiry is not retried automatically;
+// callers can mcp_reconnect and retry") — it surfaces the 404 as a tool_result
+// error to the model, which then dead-loops calling tools against the same dead
+// session for the rest of the turn. Detecting this lets us reconnect the server
+// so the model's next attempt re-handshakes a fresh session and recovers.
+const MCP_SESSION_EXPIRED_RE = /session not found or expired|Error POSTing to endpoint \(HTTP 404\)/i;
+// Pull every text fragment out of a tool_result `content` (string OR the MCP
+// block-array shape `[{type:'text',text:'…'}]`) so we can scan it for the
+// session-expiry signature above.
+function toolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => (b && typeof b === 'object' && typeof b.text === 'string'
+            ? b.text
+            : ''))
+            .join(' ');
+    }
+    return '';
+}
 /**
  * Copy for an actionable rate-limit notice. The SDK emits `rate_limit_event`
  * whenever rate-limit info CHANGES — including the routine `allowed` case on
@@ -384,10 +423,13 @@ export function spawnClaude(params) {
             const keySource = event['apiKeySource'];
             const model = event['model'];
             const sid = event['session_id'];
+            const ccv = event['claude_code_version'];
             if (sid)
                 currentSessionId = sid;
             if (model)
                 extractedModel = model;
+            if (ccv)
+                cliVersion = ccv;
             if (!modelAnnounced) {
                 const source = keySource === 'none' || !keySource ? 'claude.ai subscription' : keySource;
                 const pin = getBridgeModel() ? '  (selected at startup)' : '';
@@ -636,8 +678,28 @@ export function spawnClaude(params) {
             ...(pinnedModel ? { model: pinnedModel } : {}),
         };
         const promptMessages = buildPromptMessages(history);
+        // Throttle remote-MCP reconnects: a single dropped session produces a burst
+        // of 404 tool_results (the model keeps trying), so reconnect at most once per
+        // window to avoid a reconnect storm. A reconnect is in-flight guard too.
+        let lastMcpReconnectAt = 0;
+        let mcpReconnecting = false;
+        const MCP_RECONNECT_THROTTLE_MS = 10_000;
+        const maybeReconnectRemoteMcp = (q) => {
+            const now = Date.now();
+            if (mcpReconnecting || now - lastMcpReconnectAt < MCP_RECONNECT_THROTTLE_MS)
+                return;
+            mcpReconnecting = true;
+            lastMcpReconnectAt = now;
+            process.stderr.write(paint(SECTION_COLORS.result, '[bridge] remote MCP session expired — reconnecting and retrying') + '\n');
+            onNotice?.('Reconnecting to 1Presence tools…');
+            void q.reconnectMcpServer(REMOTE_MCP_SERVER_NAME)
+                .then(() => process.stderr.write(paint(SECTION_COLORS.result, '[bridge] remote MCP reconnected') + '\n'))
+                .catch((err) => process.stderr.write(paint(SECTION_COLORS.result, `[bridge] remote MCP reconnect failed: ${err.message}`) + '\n'))
+                .finally(() => { mcpReconnecting = false; });
+        };
         try {
-            for await (const m of query({ prompt: promptStream(promptMessages), options })) {
+            const q = query({ prompt: promptStream(promptMessages), options });
+            for await (const m of q) {
                 // Skip echoed input replays — they would double-count in the accumulator
                 // and re-stream prior turns to the PWA.
                 if (m.isReplay)
@@ -647,7 +709,7 @@ export function spawnClaude(params) {
                         const subtype = m.subtype;
                         if (subtype === 'init') {
                             const init = m;
-                            const event = { type: 'system', subtype: 'init', model: init.model, apiKeySource: init.apiKeySource };
+                            const event = { type: 'system', subtype: 'init', model: init.model, apiKeySource: init.apiKeySource, claude_code_version: init.claude_code_version };
                             if (handleEvent(event))
                                 onEvent(event);
                         }
@@ -703,6 +765,19 @@ export function spawnClaude(params) {
                     }
                     case 'user': {
                         const um = m;
+                        // Detect a dropped remote-MCP session in any tool_result and re-handshake
+                        // so the model's next tool call lands on a live session instead of
+                        // 404-looping for the rest of the turn (the SDK won't auto-retry it).
+                        const content = um.message?.['content'];
+                        if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block && typeof block === 'object' && block['type'] === 'tool_result'
+                                    && MCP_SESSION_EXPIRED_RE.test(toolResultText(block['content']))) {
+                                    maybeReconnectRemoteMcp(q);
+                                    break;
+                                }
+                            }
+                        }
                         const event = { type: 'user', message: um.message };
                         if (handleEvent(event))
                             onEvent(event);
@@ -739,6 +814,16 @@ export function spawnClaude(params) {
                         // a notice when the user is actually warned or throttled.
                         const info = m.rate_limit_info;
                         const status = info?.status;
+                        // Retain the latest reading for this window so the after-turn status
+                        // line can render the full 5h/7d picture even though each event only
+                        // carries one window. utilization is a 0–100 used-percentage.
+                        if (info?.rateLimitType && typeof info.utilization === 'number') {
+                            rateLimitWindows.set(info.rateLimitType, {
+                                utilization: info.utilization,
+                                resetsAt: info.resetsAt,
+                                status: status ?? 'allowed',
+                            });
+                        }
                         if (status === 'allowed_warning' || status === 'rejected') {
                             // Admin-only ephemeral notice — jargon is fine in Local Mode.
                             onNotice?.(formatRateLimitNotice(status, info?.resetsAt));

package/dist/index.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { getValidAuth, ensureFreshToken, forceRefreshToken, isTokenValid, AuthCancelledError } from './auth.js';
-import { spawnClaude, killAll, cancelConversation, setVerbose, setDebug, paint, SECTION_COLORS } from './claude.js';
+import { spawnClaude, killAll, cancelConversation, setVerbose, setDebug, paint, SECTION_COLORS, getCliVersion, getRateLimitWindow } from './claude.js';
 import { ensureModelChoice } from './config.js';
 import { checkAndUpdate } from './update.js';
 import { makeBridgeAccumulator, postSaveTurn } from './accumulator.js';
@@ -101,6 +101,51 @@ function contextWindowFor(model) {
     }
     return DEFAULT_CONTEXT_WINDOW;
 }
+// ─── Rate-limit window rendering ──────────────────────────────────────────────
+// Mirrors the local Claude Code statusline's ⏱️ line: a 10-cell bar + used % +
+// reset time per subscription window. Data comes from the SDK's rate_limit_event
+// (captured across turns in claude.ts), so no auth/header probe is needed.
+// 7-day usage may arrive as the generic `seven_day` window or a model-specific
+// variant; surface whichever the SDK has reported, preferring the generic one.
+function sevenDayWindow() {
+    return getRateLimitWindow('seven_day')
+        ?? getRateLimitWindow('seven_day_opus')
+        ?? getRateLimitWindow('seven_day_sonnet');
+}
+function makeBar(pct) {
+    const width = 10;
+    const filled = Math.max(0, Math.min(width, Math.floor((pct * width) / 100)));
+    return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+// Green < 70%, yellow 70–89%, red ≥ 90% — same thresholds as the statusline.
+function rlColor(pct) {
+    return pct >= 90 ? '31' : pct >= 70 ? '33' : '32';
+}
+// "12:20a.m." within a day, "Mon 11:00p.m." when the reset is > 24h out.
+function formatReset(resetsAt) {
+    if (!resetsAt)
+        return '';
+    const ms = resetsAt < 1e12 ? resetsAt * 1000 : resetsAt;
+    const d = new Date(ms);
+    const h24 = d.getHours();
+    const h12 = h24 % 12 === 0 ? 12 : h24 % 12;
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const time = `${h12}:${mm}${h24 < 12 ? 'a.m.' : 'p.m.'}`;
+    if (ms - Date.now() > 86_400_000) {
+        const wd = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][d.getDay()];
+        return `${wd} ${time}`;
+    }
+    return time;
+}
+// One coloured "5h ██░░░░░░░░ 20% resets 12:20a.m." segment; null if unknown.
+function formatWindow(label, w) {
+    if (!w)
+        return null;
+    const pct = Math.round(w.utilization);
+    const reset = formatReset(w.resetsAt);
+    const seg = `${label} ${makeBar(pct)} ${pct}%${reset ? ` resets ${reset}` : ''}`;
+    return paint(rlColor(pct), seg);
+}
 // ─── 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
@@ -436,14 +481,26 @@ 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).
+            // Status-bar line, mirroring the local Claude Code statusline:
+            //   🤖 model v<version> | 🧠 context% | 💰 cost
+            //   ⏱️ 5h <bar> n% resets … | 7d <bar> n% resets …
+            // 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). The ⏱️ window line is only printed
+            // once the SDK has reported at least one window this process.
             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(paint('90', `             🤖 ${friendlyModelName(model)} · 🧠 ${ctxPct}% · 💰 ${costSeg}`));
+            const ver = getCliVersion();
+            const verSeg = ver ? ` v${ver}` : '';
+            console.log(paint('90', `             🤖 ${friendlyModelName(model)}${verSeg} | 🧠 ${ctxPct}% | 💰 ${costSeg}`));
+            const windows = [
+                formatWindow('5h', getRateLimitWindow('five_hour')),
+                formatWindow('7d', sevenDayWindow()),
+            ].filter((s) => s !== null);
+            if (windows.length > 0) {
+                console.log(`             ${paint('90', '⏱️')} ${windows.join(paint('90', ' | '))}`);
+            }
             const mapped = toBridgeUsage(usage);
             if (currentWs?.readyState === WebSocket.OPEN) {
                 currentWs.send(JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.59.0",
+  "version": "0.61.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "type": "module",
   "bin": {