@1presence/bridge 0.39.0 → 0.42.0

package/dist/config.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureModelChoice = ensureModelChoice;
-exports.getBridgeModel = getBridgeModel;
-const readline_1 = require("readline");
-const child_process_1 = require("child_process");
+import { emitKeypressEvents } from 'readline';
+import { spawn } from 'child_process';
 // ─── In-memory model choice ───────────────────────────────────────────────────
 //
 // The bridge prompts for a model on every interactive startup. The choice is
@@ -27,7 +23,7 @@ function detectClaudeDefaultModel() {
         } };
         let proc;
         try {
-            proc = (0, child_process_1.spawn)('claude', [
+            proc = spawn('claude', [
                 '-p',
                 '--input-format', 'stream-json',
                 '--output-format', 'stream-json',
@@ -111,7 +107,7 @@ function promptForModel(defaultModel) {
             }
         };
         render();
-        (0, readline_1.emitKeypressEvents)(process.stdin);
+        emitKeypressEvents(process.stdin);
         const wasRaw = process.stdin.isRaw;
         if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
@@ -172,7 +168,7 @@ function promptForModel(defaultModel) {
  * in memory only — every startup re-prompts. In a non-TTY environment the
  * prompt is skipped and Claude Code's own default is used.
  */
-async function ensureModelChoice() {
+export async function ensureModelChoice() {
     if (!process.stdin.isTTY) {
         selectedModel = null;
         return;
@@ -187,6 +183,6 @@ async function ensureModelChoice() {
     }
 }
 /** Returns the model id chosen for this session, or null to defer to Claude Code's own default. */
-function getBridgeModel() {
+export function getBridgeModel() {
     return selectedModel;
 }

package/dist/index.js

@@ -1,29 +1,29 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ws_1 = __importDefault(require("ws"));
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const auth_1 = require("./auth");
-const claude_1 = require("./claude");
-const config_1 = require("./config");
-const update_1 = require("./update");
-const accumulator_1 = require("./accumulator");
-const outbox_1 = require("./outbox");
-const timer_1 = require("./timer");
-const package_json_1 = require("../package.json");
+import WebSocket from 'ws';
+import { writeFileSync, chmodSync, existsSync, statSync, readdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { getValidAuth, ensureFreshToken, isTokenValid, AuthCancelledError } from './auth.js';
+import { spawnClaude, killAll, cancelConversation, setVerbose, setDebug, paint, SECTION_COLORS } from './claude.js';
+import { ensureModelChoice } from './config.js';
+import { checkAndUpdate } from './update.js';
+import { makeBridgeAccumulator, postSaveTurn } from './accumulator.js';
+import { writeSpool, deleteSpool, listSpool } from './outbox.js';
+import { startTurnTimer, stopTurnTimer, formatElapsed } from './timer.js';
+// ESM has no __dirname; derive it. JSON version is read via createRequire to
+// avoid version-sensitive import assertions on a published CLI bin.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { version } = createRequire(import.meta.url)('../package.json');
 // Published tarballs don't ship src/, so this fires only when running the
 // dist build from a live workspace checkout. Catches the trap where editing
 // src/ without re-running tsc leaves you executing stale dist code — banner
 // version matches package.json but behavior doesn't match the source.
 if (__dirname.endsWith('dist')) {
-    const srcDir = (0, path_1.join)(__dirname, '..', 'src');
-    if ((0, fs_1.existsSync)(srcDir)) {
-        const newest = (dir) => Math.max(...(0, fs_1.readdirSync)(dir).map(f => (0, fs_1.statSync)((0, path_1.join)(dir, f)).mtimeMs));
+    const srcDir = join(__dirname, '..', 'src');
+    if (existsSync(srcDir)) {
+        const newest = (dir) => Math.max(...readdirSync(dir).map(f => statSync(join(dir, f)).mtimeMs));
         if (newest(srcDir) > newest(__dirname)) {
             console.error('Bridge dist is stale (src/ has been edited since last build). Run: npm run build');
             process.exit(1);
@@ -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
@@ -111,7 +157,7 @@ async function fetchSystemPrompt(token, agentSlug) {
 }
 // ─── Setup files ──────────────────────────────────────────────────────────────
 function tmpFile(name) {
-    return (0, path_1.join)((0, os_1.tmpdir)(), name);
+    return join(tmpdir(), name);
 }
 // Fetch the system prompt and write it to /tmp/agent-${uid}.md. The hosted
 // runtime rebuilds buildSystemBlocks() per turn (dynamic context: vault state,
@@ -123,9 +169,9 @@ async function writeSystemPrompt(auth, agentSlug) {
     const systemPrompt = await fetchSystemPrompt(token, agentSlug);
     writeRestricted(tmpFile(`agent-${uid}.md`), systemPrompt);
     if (VERBOSE) {
-        console.log((0, claude_1.paint)(claude_1.SECTION_COLORS.system, '\n[bridge:verbose] ─── system prompt ───────────────────────'));
-        console.log((0, claude_1.paint)(claude_1.SECTION_COLORS.system, systemPrompt));
-        console.log((0, claude_1.paint)(claude_1.SECTION_COLORS.system, '[bridge:verbose] ─── end system prompt ───────────────────\n'));
+        console.log(paint(SECTION_COLORS.system, '\n[bridge:verbose] ─── system prompt ───────────────────────'));
+        console.log(paint(SECTION_COLORS.system, systemPrompt));
+        console.log(paint(SECTION_COLORS.system, '[bridge:verbose] ─── end system prompt ───────────────────\n'));
     }
 }
 function writeMcpConfig(auth) {
@@ -149,8 +195,8 @@ async function writeSetupFiles(auth, agentSlug) {
 // state. writeFileSync's mode only takes effect on file creation — chmodSync
 // covers the overwrite case so a legacy 0644 file gets tightened on next run.
 function writeRestricted(path, data) {
-    (0, fs_1.writeFileSync)(path, data, { mode: 0o600 });
-    (0, fs_1.chmodSync)(path, 0o600);
+    writeFileSync(path, data, { mode: 0o600 });
+    chmodSync(path, 0o600);
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -162,7 +208,7 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
     // Refresh JWT if <10 min remaining before spawning Claude
     let activeAuth = auth;
     try {
-        const freshAuth = await (0, auth_1.ensureFreshToken)(auth);
+        const freshAuth = await ensureFreshToken(auth);
         if (freshAuth.token !== auth.token) {
             currentAuth = freshAuth;
             activeAuth = freshAuth;
@@ -172,11 +218,11 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
     catch (err) {
         // If the cached token still has time, proceed — refresh was preemptive.
         // If it's already invalid, MCP calls will 401 mid-turn — fail fast instead.
-        if (!(0, auth_1.isTokenValid)(auth.token)) {
+        if (!isTokenValid(auth.token)) {
             const message = 'Authentication expired and refresh failed — please restart the bridge to sign in again.';
-            (0, timer_1.stopTurnTimer)();
+            stopTurnTimer();
             console.error(`[bridge] ${message} (${err.message})`);
-            if (currentWs?.readyState === ws_1.default.OPEN) {
+            if (currentWs?.readyState === WebSocket.OPEN) {
                 currentWs.send(JSON.stringify({ type: 'error', conversationId, message }));
             }
             return;
@@ -195,15 +241,15 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
     }
     catch (err) {
         const message = `System prompt refresh failed: ${err.message}`;
-        (0, timer_1.stopTurnTimer)();
+        stopTurnTimer();
         console.error(`[${new Date().toLocaleTimeString()}] ✗ ${message}`);
-        if (currentWs?.readyState === ws_1.default.OPEN) {
+        if (currentWs?.readyState === WebSocket.OPEN) {
             currentWs.send(JSON.stringify({ type: 'error', conversationId, message }));
         }
         return;
     }
     let responding = false;
-    const accumulator = (0, accumulator_1.makeBridgeAccumulator)();
+    const accumulator = makeBridgeAccumulator();
     const startedAt = Date.now();
     const turnSessionId = sessionId ?? conversationId; // gateway always supplies one; defensive fallback
     // The CLI's `--session-id` is treated as a "claim this new session ID"
@@ -237,14 +283,14 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
         // ack is recoverable by drain-on-startup. The gateway dedupes on
         // conversationId, so a replay is idempotent.
         try {
-            (0, outbox_1.writeSpool)(record);
+            writeSpool(record);
         }
         catch (err) {
             console.warn(`[bridge] spool write failed: ${err.message}`);
         }
-        const result = await (0, accumulator_1.postSaveTurn)(GATEWAY_HTTP, activeAuth.token, record);
+        const result = await postSaveTurn(GATEWAY_HTTP, activeAuth.token, record);
         if (result.ok) {
-            (0, outbox_1.deleteSpool)(record.conversationId);
+            deleteSpool(record.conversationId);
         }
         else {
             // Leave the spool file in place — next startup or next successful
@@ -252,7 +298,7 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
             console.warn(`[bridge] save-turn POST failed (${result.status}): ${result.error ?? 'unknown'} — kept on disk for retry`);
         }
     }
-    (0, claude_1.spawnClaude)({
+    spawnClaude({
         conversationId,
         presenceSessionId: claudePinnedSessionId,
         text,
@@ -267,7 +313,7 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
                 responding = true;
                 console.log(`[${new Date().toLocaleTimeString()}] ◐ responding…`);
             }
-            if (currentWs?.readyState === ws_1.default.OPEN) {
+            if (currentWs?.readyState === WebSocket.OPEN) {
                 currentWs.send(JSON.stringify({ type: 'stream', conversationId, event }));
             }
         },
@@ -275,21 +321,29 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
             // Ephemeral, non-persisted thread notice (admin-only Local Mode). Relayed
             // by the gateway to the PWA SSE stream as a `notice` AgentEvent; it does
             // NOT go through the turn accumulator, so it never lands in history.
-            if (currentWs?.readyState === ws_1.default.OPEN) {
+            if (currentWs?.readyState === WebSocket.OPEN) {
                 currentWs.send(JSON.stringify({ type: 'notice', conversationId, message }));
             }
         },
-        onDone: (messageCount, costUsd, usage, model) => {
-            const elapsed = (0, timer_1.stopTurnTimer)();
-            const parts = [(0, timer_1.formatElapsed)(elapsed)];
+        onDone: (messageCount, costUsd, usage, model, contextTokens) => {
+            const elapsed = stopTurnTimer();
+            const parts = [formatElapsed(elapsed)];
             if (usage)
                 parts.push(`in:${usage.input_tokens} out:${usage.output_tokens}`);
             const costStr = costUsd === 0 ? '$0.0000 (plan usage)' : `$${costUsd.toFixed(4)}`;
             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(paint('90', `             🤖 ${friendlyModelName(model)} · 🧠 ${ctxPct}% · 💰 ${costSeg}`));
             const mapped = toBridgeUsage(usage);
-            if (currentWs?.readyState === ws_1.default.OPEN) {
+            if (currentWs?.readyState === WebSocket.OPEN) {
                 currentWs.send(JSON.stringify({
                     type: 'done',
                     conversationId,
@@ -303,10 +357,10 @@ async function handleMessage(conversationId, text, sessionId, history, auth, vau
             void finalizeAndPost(buildSpoolRecord(mapped, model));
         },
         onError: (message, usage, model) => {
-            const elapsed = (0, timer_1.stopTurnTimer)();
-            console.error(`[${new Date().toLocaleTimeString()}] ✗ ${message}  (${(0, timer_1.formatElapsed)(elapsed)})`);
+            const elapsed = stopTurnTimer();
+            console.error(`[${new Date().toLocaleTimeString()}] ✗ ${message}  (${formatElapsed(elapsed)})`);
             const mapped = toBridgeUsage(usage);
-            if (currentWs?.readyState === ws_1.default.OPEN) {
+            if (currentWs?.readyState === WebSocket.OPEN) {
                 currentWs.send(JSON.stringify({
                     type: 'error',
                     conversationId,
@@ -337,14 +391,14 @@ function toBridgeUsage(usage) {
 // dedupes on conversationId — if it already saved via the WS path, the
 // reply is finalized=false and we still delete the spool.
 async function drainOutbox(auth) {
-    const records = (0, outbox_1.listSpool)();
+    const records = listSpool();
     if (records.length === 0)
         return;
     console.log(`[bridge] draining ${records.length} pending save record${records.length === 1 ? '' : 's'}…`);
     for (const record of records) {
-        const result = await (0, accumulator_1.postSaveTurn)(GATEWAY_HTTP, auth.token, record);
+        const result = await postSaveTurn(GATEWAY_HTTP, auth.token, record);
         if (result.ok) {
-            (0, outbox_1.deleteSpool)(record.conversationId);
+            deleteSpool(record.conversationId);
         }
         else {
             console.warn(`[bridge] drain POST failed (${result.status}): ${result.error ?? 'unknown'} — leaving on disk`);
@@ -357,14 +411,14 @@ async function drainOutbox(auth) {
 const PING_INTERVAL_MS = 30_000;
 const PONG_TIMEOUT_MS = 10_000;
 function connect(auth, retryDelay = 1000) {
-    const ws = new ws_1.default(GATEWAY_WS, {
+    const ws = new WebSocket(GATEWAY_WS, {
         headers: { Authorization: `Bearer ${auth.token}` },
     });
     let pingTimer = null;
     let pongTimer = null;
     function startPing() {
         pingTimer = setInterval(() => {
-            if (ws.readyState !== ws_1.default.OPEN)
+            if (ws.readyState !== WebSocket.OPEN)
                 return;
             ws.send(JSON.stringify({ type: 'ping', ts: Date.now() }));
             pongTimer = setTimeout(() => {
@@ -419,7 +473,7 @@ function connect(auth, retryDelay = 1000) {
         // (PWA→gateway connection dropped). Kill the local Claude Code process for
         // this conversation so it stops generating instead of running to the end.
         if (msg.type === 'cancel' && msg.conversationId) {
-            const cancelled = (0, claude_1.cancelConversation)(msg.conversationId);
+            const cancelled = cancelConversation(msg.conversationId);
             if (cancelled)
                 console.log(`[bridge] ✕ stopped conversation ${msg.conversationId}`);
             return;
@@ -430,9 +484,9 @@ function connect(auth, retryDelay = 1000) {
         const ts = new Date().toLocaleTimeString();
         const hist = Array.isArray(history) ? history : [];
         console.log(`[${ts}] ▶ ${text}${hist.length ? `  (history: ${hist.length} turn${hist.length === 1 ? '' : 's'})` : ''}`);
-        (0, timer_1.startTurnTimer)();
+        startTurnTimer();
         handleMessage(conversationId, text, sessionId ?? null, hist, auth, vaultFileOpen, clientCapabilities, syncedFolders, agentSlug).catch((err) => {
-            (0, timer_1.stopTurnTimer)();
+            stopTurnTimer();
             console.error(`[bridge] handleMessage error: ${err.message}`);
         });
     });
@@ -475,24 +529,24 @@ function connect(auth, retryDelay = 1000) {
 }
 // ─── Main ─────────────────────────────────────────────────────────────────────
 async function main() {
-    console.log(`1Presence Bridge v${package_json_1.version}\n`);
+    console.log(`1Presence Bridge v${version}\n`);
     if (VERBOSE) {
-        (0, claude_1.setVerbose)(true);
+        setVerbose(true);
         console.log('[bridge:verbose] verbose logging enabled — system prompts (magenta), user prompts (blue), assistant text (green), tool inputs (cyan), and tool outputs (yellow) will be printed, colour-coded by kind.\n');
     }
     if (DEBUG) {
-        (0, claude_1.setDebug)(true);
+        setDebug(true);
         console.log('[bridge:debug] debug transcript enabled — user prompts, assistant text, tool inputs, and tool outputs will be printed (system prompt omitted; use --verbose for that).\n');
     }
-    if (await (0, update_1.checkAndUpdate)())
+    if (await checkAndUpdate())
         return;
     // Auth
-    const auth = await (0, auth_1.getValidAuth)(GATEWAY_HTTP, PWA_URL);
+    const auth = await getValidAuth(GATEWAY_HTTP, PWA_URL);
     currentAuth = auth;
     // One-time interactive model choice (only prompts on first run; saved to
     // ~/.1presence/config.json). In a non-TTY environment this is a no-op and
     // Claude Code's own default is used.
-    await (0, config_1.ensureModelChoice)();
+    await ensureModelChoice();
     // Write system prompt + MCP config. If this fails the bridge is dead in the
     // water — surface the underlying error rather than letting it bubble up as
     // a generic "Fatal:" with no context.
@@ -512,7 +566,7 @@ async function main() {
     // Graceful shutdown
     const shutdown = () => {
         console.log('\nShutting down…');
-        (0, claude_1.killAll)();
+        killAll();
         process.exit(0);
     };
     process.on('SIGINT', shutdown);
@@ -534,7 +588,7 @@ async function main() {
     });
 }
 main().catch((err) => {
-    if (err instanceof auth_1.AuthCancelledError) {
+    if (err instanceof AuthCancelledError) {
         console.error(`\n${err.message}`);
         console.error('Run `npx @1presence/bridge` again when you are ready to sign in.');
         process.exit(0);

package/dist/outbox.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSpool = writeSpool;
-exports.deleteSpool = deleteSpool;
-exports.listSpool = listSpool;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
+import { mkdirSync, writeFileSync, readdirSync, readFileSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 // ─── On-disk turn spool ───────────────────────────────────────────────────────
 //
 // Each in-flight bridge turn writes a record to ~/.1presence/outbox/. The file
@@ -20,31 +15,31 @@ const path_1 = require("path");
 //
 // Payload mode 0600 — the file contains the user's assistant transcript and
 // tool inputs. Tightened on every write to handle legacy world-readable files.
-const OUTBOX_DIR = (0, path_1.join)((0, os_1.homedir)(), '.1presence', 'outbox');
+const OUTBOX_DIR = join(homedir(), '.1presence', 'outbox');
 function ensureDir() {
-    (0, fs_1.mkdirSync)(OUTBOX_DIR, { recursive: true });
+    mkdirSync(OUTBOX_DIR, { recursive: true });
 }
 function pathFor(conversationId) {
-    return (0, path_1.join)(OUTBOX_DIR, `${conversationId}.json`);
+    return join(OUTBOX_DIR, `${conversationId}.json`);
 }
-function writeSpool(record) {
+export function writeSpool(record) {
     ensureDir();
-    (0, fs_1.writeFileSync)(pathFor(record.conversationId), JSON.stringify(record), { mode: 0o600 });
+    writeFileSync(pathFor(record.conversationId), JSON.stringify(record), { mode: 0o600 });
 }
-function deleteSpool(conversationId) {
+export function deleteSpool(conversationId) {
     try {
-        (0, fs_1.unlinkSync)(pathFor(conversationId));
+        unlinkSync(pathFor(conversationId));
     }
     catch { /* already gone — fine */ }
 }
-function listSpool() {
+export function listSpool() {
     ensureDir();
     const out = [];
-    for (const file of (0, fs_1.readdirSync)(OUTBOX_DIR)) {
+    for (const file of readdirSync(OUTBOX_DIR)) {
         if (!file.endsWith('.json'))
             continue;
         try {
-            const raw = (0, fs_1.readFileSync)((0, path_1.join)(OUTBOX_DIR, file), 'utf-8');
+            const raw = readFileSync(join(OUTBOX_DIR, file), 'utf-8');
             out.push(JSON.parse(raw));
         }
         catch {

package/dist/timer.js

@@ -1,12 +1,7 @@
-"use strict";
 // Live elapsed-time indicator for the active turn. Writes `\r\x1b[K⏱  Xs`
 // once per second; wraps console.log/error/warn so that any other output
 // clears the timer line before printing, then redraws the timer on the new
 // bottom line. Idempotent — stop is safe to call multiple times.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatElapsed = formatElapsed;
-exports.startTurnTimer = startTurnTimer;
-exports.stopTurnTimer = stopTurnTimer;
 let intervalId = null;
 let startedAt = 0;
 let originalLog = null;
@@ -19,14 +14,14 @@ function draw() {
     const elapsedSec = Math.floor((Date.now() - startedAt) / 1000);
     process.stdout.write(`\r\x1b[K⏱  ${formatElapsed(elapsedSec)}`);
 }
-function formatElapsed(seconds) {
+export function formatElapsed(seconds) {
     if (seconds < 60)
         return `${seconds}s`;
     const m = Math.floor(seconds / 60);
     const s = seconds % 60;
     return `${m}m ${s.toString().padStart(2, '0')}s`;
 }
-function startTurnTimer() {
+export function startTurnTimer() {
     if (intervalId !== null)
         return;
     startedAt = Date.now();
@@ -39,7 +34,7 @@ function startTurnTimer() {
     draw();
     intervalId = setInterval(draw, 1000);
 }
-function stopTurnTimer() {
+export function stopTurnTimer() {
     if (intervalId === null)
         return 0;
     clearInterval(intervalId);

package/dist/update.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAndUpdate = checkAndUpdate;
-const child_process_1 = require("child_process");
-const package_json_1 = require("../package.json");
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+// ESM JSON imports need version-sensitive import assertions; createRequire reads
+// the manifest synchronously on every Node 18+ without that fragility.
+const { version } = createRequire(import.meta.url)('../package.json');
 function isNewer(a, b) {
     const pa = a.split('.').map(Number);
     const pb = b.split('.').map(Number);
@@ -14,7 +14,7 @@ function isNewer(a, b) {
     }
     return false;
 }
-async function checkAndUpdate() {
+export async function checkAndUpdate() {
     try {
         const res = await fetch('https://registry.npmjs.org/@1presence/bridge/latest', {
             signal: AbortSignal.timeout(3000),
@@ -23,10 +23,10 @@ async function checkAndUpdate() {
             return false;
         const data = await res.json();
         const latest = data.version;
-        if (!isNewer(latest, package_json_1.version))
+        if (!isNewer(latest, version))
             return false;
         console.log(`Updating to v${latest}…\n`);
-        const child = (0, child_process_1.spawn)('npx', ['--yes', `@1presence/bridge@${latest}`], {
+        const child = spawn('npx', ['--yes', `@1presence/bridge@${latest}`], {
             stdio: 'inherit',
             env: process.env,
         });

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.39.0",
+  "version": "0.42.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
+  "type": "module",
   "bin": {
     "1presence-bridge": "dist/index.js"
   },
@@ -18,6 +19,7 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.153",
     "ws": "^8.20.0"
   },
   "devDependencies": {