npm - @1presence/bridge - Versions diffs - 0.1.2 - Mend

@1presence/bridge 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/auth.js ADDED Viewed

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidAuth = getValidAuth;
+exports.refreshAuth = refreshAuth;
+exports.clearAuth = clearAuth;
+const http_1 = require("http");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+// ─── Paths ────────────────────────────────────────────────────────────────────
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.1presence');
+const AUTH_FILE = (0, path_1.join)(CONFIG_DIR, 'auth.json');
+function ensureConfigDir() {
+    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+}
+// ─── JWT helpers ──────────────────────────────────────────────────────────────
+function parseJwt(token) {
+    try {
+        const payload = token.split('.')[1];
+        const decoded = Buffer.from(payload, 'base64url').toString('utf-8');
+        return JSON.parse(decoded);
+    }
+    catch {
+        return {};
+    }
+}
+function isTokenValid(token) {
+    const { exp } = parseJwt(token);
+    if (!exp)
+        return false;
+    // Require at least 5 minutes of validity remaining
+    return exp > Math.floor(Date.now() / 1000) + 300;
+}
+function uidFromToken(token) {
+    return parseJwt(token).sub ?? '';
+}
+function emailFromToken(token) {
+    return parseJwt(token).email;
+}
+// ─── Cache read/write ─────────────────────────────────────────────────────────
+function loadCachedAuth() {
+    try {
+        const raw = (0, fs_1.readFileSync)(AUTH_FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!data.token || !isTokenValid(data.token))
+            return null;
+        return { token: data.token, uid: data.uid, email: data.email };
+    }
+    catch {
+        return null;
+    }
+}
+function saveCachedAuth(auth) {
+    ensureConfigDir();
+    const data = { ...auth, savedAt: Date.now() };
+    (0, fs_1.writeFileSync)(AUTH_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+// ─── Browser auth flow ────────────────────────────────────────────────────────
+function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === 'darwin' ? `open "${url}"`
+        : platform === 'win32' ? `start "" "${url}"`
+            : `xdg-open "${url}"`;
+    (0, child_process_1.exec)(cmd, (err) => {
+        if (err)
+            console.error('Could not open browser automatically. Please open this URL manually:\n' + url);
+    });
+}
+function runBrowserAuthFlow(gatewayUrl) {
+    return new Promise((resolve, reject) => {
+        const server = (0, http_1.createServer)((req, res) => {
+            try {
+                const url = new URL(req.url ?? '/', 'http://localhost');
+                const token = url.searchParams.get('token');
+                if (!token) {
+                    res.writeHead(400, { 'Content-Type': 'text/plain' });
+                    res.end('Missing token');
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(`<!DOCTYPE html>
+<html>
+<head><title>1Presence Bridge</title>
+<style>
+  body { font-family: Georgia, serif; display:flex; align-items:center; justify-content:center;
+         min-height:100vh; margin:0; background:#faf8f4; color:#3a3028; }
+  .card { text-align:center; padding:40px; }
+  h1 { font-size:1.5rem; font-weight:400; margin:0 0 12px; }
+  p  { color:#7a6a5a; font-size:0.9rem; }
+</style></head>
+<body><div class="card">
+  <h1>Bridge connected</h1>
+  <p>You can close this tab and return to your terminal.</p>
+</div></body></html>`);
+                server.close();
+                const uid = uidFromToken(token);
+                const email = emailFromToken(token);
+                if (!uid) {
+                    reject(new Error('Invalid token — missing uid'));
+                    return;
+                }
+                resolve({ token, uid, email });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const { port } = server.address();
+            const base = gatewayUrl.replace(/^wss?:/, 'https:').replace(/\/$/, '');
+            const authUrl = `${base}/cli-auth?port=${port}`;
+            console.log('\nOpening browser for sign-in…');
+            console.log(`If the browser doesn't open, visit:\n  ${authUrl}\n`);
+            openBrowser(authUrl);
+        });
+        setTimeout(() => {
+            server.close();
+            reject(new Error('Sign-in timed out after 5 minutes. Please try again.'));
+        }, 5 * 60 * 1000);
+    });
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+async function getValidAuth(gatewayUrl) {
+    const cached = loadCachedAuth();
+    if (cached)
+        return cached;
+    console.log('Sign-in required.');
+    const auth = await runBrowserAuthFlow(gatewayUrl);
+    saveCachedAuth(auth);
+    return auth;
+}
+function refreshAuth(auth) {
+    saveCachedAuth(auth);
+}
+function clearAuth() {
+    try {
+        (0, fs_1.writeFileSync)(AUTH_FILE, '{}', 'utf-8');
+    }
+    catch { /* ignore */ }
+}

package/dist/claude.js ADDED Viewed

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnClaude = spawnClaude;
+exports.killAll = killAll;
+const child_process_1 = require("child_process");
+const os_1 = require("os");
+const path_1 = require("path");
+const sessions_1 = require("./sessions");
+// ─── Active processes ─────────────────────────────────────────────────────────
+const active = new Map();
+// ─── Spawn ────────────────────────────────────────────────────────────────────
+function spawnClaude(params) {
+    const { conversationId, presenceSessionId, text, uid, onEvent, onDone, onError } = params;
+    const systemPromptPath = (0, path_1.join)((0, os_1.tmpdir)(), `agent-${uid}.md`);
+    const mcpConfigPath = (0, path_1.join)((0, os_1.tmpdir)(), `mcp-${uid}.json`);
+    const claudeSessionId = presenceSessionId ? (0, sessions_1.getClaudeSession)(presenceSessionId) : undefined;
+    const args = [
+        '-p', text,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--allowedTools', 'mcp__1presence__*',
+        '--system-prompt', systemPromptPath,
+        '--mcp-config', mcpConfigPath,
+    ];
+    if (claudeSessionId) {
+        args.push('--resume', claudeSessionId);
+    }
+    const proc = (0, child_process_1.spawn)('claude', args, {
+        env: { ...process.env },
+    });
+    active.set(conversationId, proc);
+    let sessionIdExtracted = false;
+    let messageCount = 0;
+    let buffer = '';
+    proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString('utf-8');
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            const type = event['type'];
+            // Extract claude session ID from the first system/init event
+            if (!sessionIdExtracted && type === 'system' && event['subtype'] === 'init') {
+                const sid = event['session_id'];
+                if (sid && presenceSessionId) {
+                    (0, sessions_1.saveClaudeSession)(presenceSessionId, sid);
+                }
+                sessionIdExtracted = true;
+            }
+            // Count complete assistant turns
+            if (type === 'assistant')
+                messageCount++;
+            onEvent(event);
+        }
+    });
+    proc.stderr.on('data', (chunk) => {
+        // claude CLI writes logs to stderr — not errors, just noise
+        const line = chunk.toString('utf-8').trim();
+        if (line)
+            process.stderr.write(`[claude] ${line}\n`);
+    });
+    proc.on('close', (code) => {
+        active.delete(conversationId);
+        // Flush any remaining buffer
+        if (buffer.trim()) {
+            try {
+                onEvent(JSON.parse(buffer.trim()));
+            }
+            catch { /* ignore */ }
+        }
+        if (code !== 0 && code !== null) {
+            onError(`claude exited with code ${code}`);
+        }
+        else {
+            onDone(messageCount);
+        }
+    });
+    proc.on('error', (err) => {
+        active.delete(conversationId);
+        if (err.code === 'ENOENT') {
+            onError('claude CLI not found. Please install Claude Code: https://claude.ai/code');
+        }
+        else {
+            onError(err.message);
+        }
+    });
+}
+function killAll() {
+    for (const [, proc] of active) {
+        proc.kill('SIGTERM');
+    }
+    active.clear();
+}

package/dist/index.js ADDED Viewed

@@ -0,0 +1,148 @@
+#!/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");
+// ─── Config ───────────────────────────────────────────────────────────────────
+const GATEWAY_URL = process.env.BRIDGE_GATEWAY_URL ?? 'https://1presence.com';
+const GATEWAY_WS = GATEWAY_URL.replace(/^https?:/, 'wss:').replace(/\/$/, '') + '/bridge';
+const GATEWAY_HTTP = GATEWAY_URL.replace(/^wss?:/, 'https:').replace(/\/$/, '');
+// ─── In-memory state ──────────────────────────────────────────────────────────
+let currentAuth = null;
+// ─── Vault file fetch ─────────────────────────────────────────────────────────
+async function fetchVaultFile(path, token) {
+    try {
+        const res = await fetch(`${GATEWAY_HTTP}/vault/file?path=${encodeURIComponent(path)}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return null;
+        return res.text();
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Setup files ──────────────────────────────────────────────────────────────
+function tmpFile(name) {
+    return (0, path_1.join)((0, os_1.tmpdir)(), name);
+}
+async function writeSetupFiles(auth) {
+    const { uid, token } = auth;
+    // Fetch user's AGENT.md (fall back to empty if missing — claude will still run)
+    const agentMd = await fetchVaultFile('AGENT.md', token)
+        ?? await fetchVaultFile('CLAUDE.md', token)
+        ?? '';
+    (0, fs_1.writeFileSync)(tmpFile(`agent-${uid}.md`), agentMd, 'utf-8');
+    // MCP config pointing at gateway's /mcp endpoint (proxied to agent-api)
+    const mcpConfig = {
+        mcpServers: {
+            '1presence': {
+                type: 'sse',
+                url: `${GATEWAY_HTTP}/mcp`,
+                headers: { Authorization: `Bearer ${token}` },
+            },
+        },
+    };
+    (0, fs_1.writeFileSync)(tmpFile(`mcp-${uid}.json`), JSON.stringify(mcpConfig, null, 2), 'utf-8');
+}
+// ─── WebSocket connection ─────────────────────────────────────────────────────
+function connect(auth, retryDelay = 1000) {
+    const ws = new ws_1.default(GATEWAY_WS, {
+        headers: { Authorization: `Bearer ${auth.token}` },
+    });
+    ws.on('open', () => {
+        console.log('✓ Bridge connected. Local Mode active on all your devices.\n');
+    });
+    ws.on('message', (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(raw.toString());
+        }
+        catch {
+            return;
+        }
+        if (msg.type !== 'message' || !msg.conversationId || !msg.text)
+            return;
+        const { conversationId, text, sessionId } = msg;
+        (0, claude_1.spawnClaude)({
+            conversationId,
+            presenceSessionId: sessionId ?? null,
+            text,
+            uid: auth.uid,
+            onEvent: (event) => {
+                if (ws.readyState === ws_1.default.OPEN) {
+                    ws.send(JSON.stringify({ type: 'stream', conversationId, event }));
+                }
+            },
+            onDone: (messageCount) => {
+                if (ws.readyState === ws_1.default.OPEN) {
+                    ws.send(JSON.stringify({ type: 'done', conversationId, messageCount, costUsd: 0 }));
+                }
+            },
+            onError: (message) => {
+                console.error(`[bridge] conversation ${conversationId}: ${message}`);
+                if (ws.readyState === ws_1.default.OPEN) {
+                    ws.send(JSON.stringify({ type: 'error', conversationId, message }));
+                }
+            },
+        });
+    });
+    ws.on('close', (code, reason) => {
+        if (code === 4001) {
+            console.error('Authentication failed — clearing cached credentials. Please restart the bridge.');
+            (0, auth_1.clearAuth)();
+            process.exit(1);
+        }
+        const delay = Math.min(retryDelay, 30_000);
+        console.log(`Bridge disconnected (${code}). Reconnecting in ${delay / 1000}s…`);
+        setTimeout(async () => {
+            try {
+                // Refresh setup files on reconnect in case token was refreshed
+                if (currentAuth)
+                    await writeSetupFiles(currentAuth);
+                connect(currentAuth, Math.min(retryDelay * 2, 30_000));
+            }
+            catch (err) {
+                console.error('Reconnect failed:', err.message);
+            }
+        }, delay);
+    });
+    ws.on('error', (err) => {
+        // close event fires after error — reconnect handled there
+        console.error(`[bridge] ws error: ${err.message}`);
+    });
+    return ws;
+}
+// ─── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    console.log('1Presence Bridge\n');
+    // Auth
+    const auth = await (0, auth_1.getValidAuth)(GATEWAY_HTTP);
+    currentAuth = auth;
+    // Write system prompt + MCP config
+    process.stdout.write('Setting up…');
+    await writeSetupFiles(auth);
+    process.stdout.write(' done.\n');
+    // Connect
+    connect(auth);
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log('\nShutting down…');
+        (0, claude_1.killAll)();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((err) => {
+    console.error('Fatal:', err.message);
+    process.exit(1);
+});

package/dist/sessions.js ADDED Viewed

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClaudeSession = getClaudeSession;
+exports.saveClaudeSession = saveClaudeSession;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+// ─── Storage ──────────────────────────────────────────────────────────────────
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.1presence');
+const SESSIONS_FILE = (0, path_1.join)(CONFIG_DIR, 'sessions.json');
+function load() {
+    try {
+        const raw = (0, fs_1.readFileSync)(SESSIONS_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function save(map) {
+    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(SESSIONS_FILE, JSON.stringify(map, null, 2), 'utf-8');
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function getClaudeSession(presenceSessionId) {
+    return load()[presenceSessionId];
+}
+function saveClaudeSession(presenceSessionId, claudeSessionId) {
+    const map = load();
+    map[presenceSessionId] = claudeSessionId;
+    save(map);
+}

package/package.json ADDED Viewed

@@ -0,0 +1,26 @@
+{
+  "name": "@1presence/bridge",
+  "version": "0.1.2",
+  "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
+  "bin": {
+    "1presence-bridge": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  }
+}