@1presence/bridge 0.61.0 → 0.62.0

package/dist/claudeAuth.js

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+/**
+ * Parse the stdout of `claude auth status --json`. Extracts the first JSON object
+ * (defensive against any banner/log noise around it). Returns null when there is
+ * no parseable object or no boolean `loggedIn` field — i.e. an output shape we
+ * don't recognise, which the caller treats as "unknown, don't block".
+ * Exported for unit testing.
+ */
+export function parseAuthStatus(stdout) {
+    const start = stdout.indexOf('{');
+    const end = stdout.lastIndexOf('}');
+    if (start === -1 || end === -1 || end < start)
+        return null;
+    try {
+        const j = JSON.parse(stdout.slice(start, end + 1));
+        if (typeof j['loggedIn'] !== 'boolean')
+            return null;
+        return {
+            loggedIn: j['loggedIn'],
+            email: typeof j['email'] === 'string' ? j['email'] : undefined,
+            authMethod: typeof j['authMethod'] === 'string' ? j['authMethod'] : undefined,
+            subscriptionType: typeof j['subscriptionType'] === 'string' ? j['subscriptionType'] : undefined,
+            orgName: typeof j['orgName'] === 'string' ? j['orgName'] : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Ask the local `claude` CLI whether it's signed in via `claude auth status
+ * --json`. Zero-cost — no model turn runs. Resolves the parsed status, or null
+ * when we can't determine it (CLI not installed, too old for `auth status`,
+ * errored, or timed out). null means "unknown": a probe we can't trust must
+ * never gate startup — the first turn's error path still guides the user if auth
+ * is genuinely broken.
+ */
+export function probeClaudeAuth(timeoutMs = 8000) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (v) => { if (!settled) {
+            settled = true;
+            resolve(v);
+        } };
+        let proc;
+        try {
+            proc = spawn('claude', ['auth', 'status', '--json'], { stdio: ['ignore', 'pipe', 'ignore'] });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        const timer = setTimeout(() => { try {
+            proc.kill('SIGKILL');
+        }
+        catch { /* already gone */ } finish(null); }, timeoutMs);
+        let out = '';
+        proc.stdout?.on('data', (c) => { out += c.toString('utf-8'); });
+        proc.on('error', () => { clearTimeout(timer); finish(null); });
+        proc.on('close', () => { clearTimeout(timer); finish(parseAuthStatus(out)); });
+    });
+}
+/**
+ * Launch the local Claude Code subscription sign-in (`claude auth login
+ * --claudeai`) with inherited stdio, so the user completes the browser / paste
+ * flow right here. Resolves true when the child exits (any exit code — the caller
+ * re-probes to learn the outcome), or false if it can't be spawned at all (CLI
+ * missing / too old for `auth login`), in which case the poll below still carries
+ * a sign-in the user does in another terminal.
+ */
+export function launchClaudeLogin() {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn('claude', ['auth', 'login', '--claudeai'], { stdio: 'inherit' });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        proc.on('error', () => resolve(false));
+        proc.on('close', () => resolve(true));
+    });
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Poll `claude auth status` until it reports signed-in, or the timeout elapses.
+ * This is also what catches a sign-in the user completes in ANOTHER terminal
+ * window: on macOS the credential lives in the Keychain, which no process can
+ * watch, so polling is the only cross-platform detector. The Agent SDK re-reads
+ * credentials on every query(), so once this returns true the very next turn
+ * works with no bridge restart. `onWaiting` fires once, the first time we find
+ * the user still isn't signed in (so the caller can print a waiting line without
+ * spamming it). Returns true if signed in, false on timeout.
+ */
+export async function waitForClaudeLogin(opts = {}) {
+    const intervalMs = opts.intervalMs ?? 3000;
+    const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1000;
+    const deadline = Date.now() + timeoutMs;
+    let announced = false;
+    for (;;) {
+        const status = await probeClaudeAuth();
+        if (status?.loggedIn)
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        if (!announced) {
+            opts.onWaiting?.();
+            announced = true;
+        }
+        await sleep(intervalMs);
+    }
+}
+/**
+ * Minimal Y/n prompt. Returns the boolean answer; empty input returns `def`.
+ * Caller is responsible for only invoking this when stdin is a TTY.
+ */
+export function promptYesNo(question, def) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (a === '')
+                return resolve(def);
+            resolve(a === 'y' || a === 'yes');
+        });
+    });
+}

package/dist/index.js

@@ -9,6 +9,7 @@ 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, getCliVersion, getRateLimitWindow } from './claude.js';
 import { ensureModelChoice } from './config.js';
+import { probeClaudeAuth, launchClaudeLogin, waitForClaudeLogin, promptYesNo } from './claudeAuth.js';
 import { checkAndUpdate } from './update.js';
 import { makeBridgeAccumulator, postSaveTurn } from './accumulator.js';
 import { writeSpool, deleteSpool, listSpool } from './outbox.js';
@@ -759,6 +760,54 @@ function scheduleReconnect(closeCode, retryDelay) {
     }, delay);
 }
 // ─── Main ─────────────────────────────────────────────────────────────────────
+// Check the LOCAL Claude Code sign-in (the user's own claude.ai subscription
+// OAuth, distinct from the 1Presence gateway login above) before connecting.
+// Local Mode drives Claude Code through the Agent SDK, so if Claude Code isn't
+// signed in every turn fails with the `local_auth` code (and pages ops). Catch
+// it up front: probe, and if signed out, offer to sign in here — polling also
+// picks up a sign-in the user does in another terminal, and the SDK re-reads
+// credentials each turn, so no restart is needed once signed in. Any uncertainty
+// (old CLI without `auth status`, probe error) is treated as "don't block".
+async function ensureClaudeCodeLogin() {
+    const status = await probeClaudeAuth();
+    if (status === null)
+        return; // unknown — don't gate startup on a probe we can't trust
+    if (status.loggedIn) {
+        const who = status.email ? ` as ${status.email}` : '';
+        const plan = status.subscriptionType ? ` (${status.subscriptionType})` : '';
+        console.log(paint(SECTION_COLORS.assistant, `✓ Claude Code signed in${who}${plan}`));
+        return;
+    }
+    console.log(paint(SECTION_COLORS.result, '\n⚠ Your local Claude Code isn’t signed in.'));
+    console.log('  Local Mode runs on your own Claude subscription — Claude Code has to be signed in on this machine, or every message will fail.');
+    if (!process.stdin.isTTY) {
+        console.log('  Not an interactive terminal, so I can’t prompt. Sign in with `claude auth login`, then start the bridge again.\n');
+        return;
+    }
+    const yes = await promptYesNo('  Log in to Claude now? (Y/n) ', true);
+    if (!yes) {
+        console.log('  Skipping sign-in. Messages will fail until you run `claude auth login` — sign in any time and resend.\n');
+        return;
+    }
+    // Best-effort: open the sign-in right here. If the CLI is too old for
+    // `auth login`, this returns false and the poll still catches a sign-in the
+    // user does in another terminal.
+    const launched = await launchClaudeLogin();
+    if (!launched) {
+        console.log('  Couldn’t open sign-in automatically. In another terminal run:  claude auth login');
+    }
+    const ok = await waitForClaudeLogin({
+        onWaiting: () => console.log(paint('90', '  Waiting for sign-in… finish it in the browser (or run `claude auth login` in any terminal). Ctrl+C to abort.')),
+    });
+    if (ok) {
+        const s = await probeClaudeAuth();
+        const who = s?.email ? ` as ${s.email}` : '';
+        console.log(paint(SECTION_COLORS.assistant, `✓ Signed in${who} — continuing.\n`));
+    }
+    else {
+        console.log(paint(SECTION_COLORS.result, '  Still not signed in — starting anyway. Sign in any time and resend your message.\n'));
+    }
+}
 async function main() {
     console.log(`1Presence Bridge v${version}\n`);
     if (VERBOSE) {
@@ -778,6 +827,9 @@ async function main() {
     // ~/.1presence/config.json). In a non-TTY environment this is a no-op and
     // Claude Code's own default is used.
     await ensureModelChoice();
+    // Local Claude Code sign-in check (see fn comment). Runs before setup/connect
+    // so a signed-out user is guided in up front rather than hitting a failed turn.
+    await ensureClaudeCodeLogin();
     // 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.

package/package.json

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