@1presence/bridge 0.52.0 → 0.55.0

package/dist/index.js

@@ -5,6 +5,7 @@ import { tmpdir } from 'os';
 import { join, dirname } from 'path';
 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 { ensureModelChoice } from './config.js';
@@ -218,6 +219,89 @@ const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 function isUuid(value) {
     return UUID_RE.test(value);
 }
+// ─── Bridge vision reconstruction (no MCP, no chat turn) ──────────────────────
+//
+// A lightweight path for doc reproduction: the gateway sends a signed GCS URL +
+// system prompt. We download the document and call query() with NO MCP tools —
+// just a direct vision call using the user's claude.ai subscription. The whole
+// reply is collected into one string and sent back as doc_recon_response.
+async function handleDocReconRequest(req) {
+    const send = (payload) => {
+        if (currentWs?.readyState === WebSocket.OPEN)
+            currentWs.send(JSON.stringify(payload));
+    };
+    let base64;
+    let mediaType;
+    try {
+        const res = await fetch(req.sourceUrl);
+        if (!res.ok)
+            throw new Error(`download failed: ${res.status}`);
+        const buf = await res.arrayBuffer();
+        base64 = Buffer.from(buf).toString('base64');
+        mediaType = req.sourceContentType || 'application/pdf';
+    }
+    catch (err) {
+        console.error(`[bridge] doc_recon: download failed (reqId: ${req.reqId}): ${err.message}`);
+        send({ type: 'doc_recon_response', reqId: req.reqId, error: `download failed: ${err.message}` });
+        return;
+    }
+    const isImage = mediaType.startsWith('image/');
+    const sourceBlock = isImage
+        ? { type: 'image', source: { type: 'base64', media_type: mediaType, data: base64 } }
+        : { type: 'document', source: { type: 'base64', media_type: 'application/pdf', data: base64 } };
+    // Strip API key so this uses the user's claude.ai subscription (same as every
+    // bridge turn). Spread the rest of the env through — options.env REPLACES.
+    const { ANTHROPIC_API_KEY: _stripped, ...safeEnv } = process.env;
+    if (!safeEnv['MAX_MCP_OUTPUT_TOKENS'])
+        safeEnv['MAX_MCP_OUTPUT_TOKENS'] = '200000';
+    const abort = new AbortController();
+    let assistantText = '';
+    const options = {
+        systemPrompt: req.systemPrompt,
+        mcpServers: {},
+        strictMcpConfig: true,
+        settingSources: [],
+        allowedTools: [],
+        tools: [],
+        cwd: join(tmpdir(), '1presence-bridge'),
+        abortController: abort,
+        includePartialMessages: false,
+        permissionMode: 'default',
+        env: safeEnv,
+    };
+    // Cast through `unknown[]` like buildPromptMessages in claude.ts — the SDK's
+    // discriminated content-block union won't accept the inferred-`string` `type`
+    // discriminants on these literals, but the shape is correct at runtime.
+    const promptMessages = [{
+            type: 'user',
+            message: { role: 'user', content: [sourceBlock, { type: 'text', text: req.userText }] },
+            parent_tool_use_id: null,
+        }];
+    async function* promptGen() { for (const m of promptMessages)
+        yield m; }
+    try {
+        console.log(paint('90', `[bridge] doc_recon: reqId ${req.reqId} — reconstructing`));
+        for await (const m of query({ prompt: promptGen(), options })) {
+            if (m.isReplay)
+                continue;
+            if (m.type === 'assistant') {
+                const am = m;
+                for (const block of (am.message?.content ?? [])) {
+                    if (block.type === 'text' && block.text)
+                        assistantText += block.text;
+                }
+            }
+        }
+        console.log(paint('90', `[bridge] doc_recon: reqId ${req.reqId} — done (${assistantText.length} chars)`));
+        send({ type: 'doc_recon_response', reqId: req.reqId, text: assistantText });
+    }
+    catch (err) {
+        if (!abort.signal.aborted) {
+            console.error(`[bridge] doc_recon: query failed (reqId: ${req.reqId}): ${err.message}`);
+            send({ type: 'doc_recon_response', reqId: req.reqId, error: err.message });
+        }
+    }
+}
 // ─── Handle a single incoming message (token refresh + spawn) ─────────────────
 async function handleMessage(conversationId, text, sessionId, history, auth, vaultFileOpen, clientCapabilities, syncedFolders, agentSlug, model) {
     // Refresh JWT if <10 min remaining before spawning Claude
@@ -499,6 +583,18 @@ function connect(auth, retryDelay = 1000) {
                 console.log(`[bridge] ✕ stopped conversation ${msg.conversationId}`);
             return;
         }
+        if (msg.type === 'doc_recon_request') {
+            const req = msg;
+            if (req.reqId && req.systemPrompt && req.sourceUrl) {
+                handleDocReconRequest(req).catch((err) => {
+                    console.error(`[bridge] doc_recon: unhandled error (reqId: ${req.reqId}): ${err.message}`);
+                    if (currentWs?.readyState === WebSocket.OPEN) {
+                        currentWs.send(JSON.stringify({ type: 'doc_recon_response', reqId: req.reqId, error: err.message }));
+                    }
+                });
+            }
+            return;
+        }
         if (msg.type !== 'message' || !msg.conversationId || !msg.text)
             return;
         const { conversationId, text, sessionId, history, vaultFileOpen, clientCapabilities, syncedFolders, agentSlug, model } = msg;

package/package.json

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