@hmduc16031996/claude-mb-bridge 1.1.10 → 2.0.0

package/dist/index.js

@@ -1,117 +1,62 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { supabase } from './supabase.js';
-import { createRequire } from 'module';
-import { execSync } from 'child_process';
-const require = createRequire(import.meta.url);
-const pty = require('node-pty');
+import { CloudflareTunnel } from './tunnel.js';
+import { startTerminalServer } from './server.js';
+import { randomUUID } from 'crypto';
 const program = new Command();
 program
     .name('claude-mobile-bridge')
-    .description('Bridge Claude Code CLI to mobile')
-    .version('1.1.0')
+    .description('Bridge Claude Code CLI to mobile via WebView')
+    .version('2.0.0')
     .option('--token <token>', 'Pairing token from mobile app')
-    .option('--server <url>', 'Backend server URL', 'http://localhost:3000') // Default to local for dev
+    .option('--server <url>', 'Backend server URL', 'http://localhost:3000')
     .option('--path <path>', 'Working directory', process.cwd())
+    .option('--port <port>', 'Local port for terminal server', '38473')
     .action(async (options) => {
-    const { token, server, path } = options;
+    const { token, server, path, port } = options;
     if (!token) {
         console.error('Error: --token is required');
         process.exit(1);
     }
-    console.log(`🚀 Starting bridge for token: ${token}`);
-    // 1. Validate token and pair
+    // 1. Start local terminal server
+    const terminalAuthToken = randomUUID().replace(/-/g, '');
+    const localPort = parseInt(port, 10);
+    const terminalServer = startTerminalServer(localPort, terminalAuthToken, path);
+    // 2. Start Cloudflare Tunnel
+    const tunnel = new CloudflareTunnel();
+    const tunnelResult = await tunnel.start(localPort);
+    if (!tunnelResult.url) {
+        console.error('❌ Failed to start Cloudflare Tunnel.');
+        process.exit(1);
+    }
+    // 3. Validate token and report public URL to central server
     try {
         const res = await fetch(`${server}/api/sessions/${token}/validate`, {
-            method: 'POST'
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                public_url: tunnelResult.url,
+                terminal_auth_token: terminalAuthToken
+            })
         });
         if (!res.ok) {
             throw new Error('Invalid token or session expired');
         }
-        console.log('✅ Session paired successfully.');
+        // ONLY show "session connected" as requested
+        console.log('✅ Session connected');
     }
     catch (err) {
         console.error(`❌ Validation failed: ${err.message}`);
+        tunnelResult.cleanup();
         process.exit(1);
     }
-    // 2. Listen for messages via Supabase Realtime
-    console.log('📡 Listening for messages...');
-    const channel = supabase.channel(`messages:${token}`);
-    channel
-        .on('postgres_changes', {
-        event: 'INSERT',
-        schema: 'public',
-        table: 'messages',
-        filter: `session_id=eq.${token}`
-    }, async (payload) => {
-        const msg = payload.new;
-        if (msg.role === 'user') {
-            console.log(`\n📩 Received prompt: ${msg.content}`);
-            await handleUserPrompt(msg.content, token, path);
-        }
-    })
-        .subscribe((status) => {
-        if (status === 'SUBSCRIBED') {
-            console.log('✅ Subscribed to Realtime channel.');
-        }
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        tunnelResult.cleanup();
+        terminalServer.close();
+        process.exit(0);
     });
-    // 3. Local pairing server (optional / fallback as per plan)
-    // For now, we'll stick to the token-based pairing.
 });
-function resolveClaudePath() {
-    try {
-        return execSync('which claude', { encoding: 'utf8' }).trim();
-    }
-    catch {
-        return 'claude';
-    }
-}
-async function handleUserPrompt(content, sessionId, cwd) {
-    console.log('⏳ Executing Claude Code with PTY...');
-    const isWin = process.platform === 'win32';
-    // Resolve absolute path so posix_spawnp can find it without shell PATH lookup
-    const claudeExe = isWin ? 'cmd.exe' : resolveClaudePath();
-    const args = isWin
-        ? ['/c', 'claude', '--print', content]
-        : ['--print', content];
-    const proc = pty.spawn(claudeExe, args, {
-        name: 'xterm-256color',
-        cols: 80,
-        rows: 24,
-        cwd,
-        env: process.env,
-    });
-    let output = '';
-    // Capture PTY output
-    proc.onData((data) => {
-        output += data;
-        process.stdout.write(data);
-    });
-    return new Promise((resolve) => {
-        proc.onExit(async ({ exitCode }) => {
-            console.log(`\n✅ Claude Code finished with code ${exitCode}`);
-            // Clean up output from common CLI noise and ANSI codes if needed
-            // Note: We might want to keep ANSI codes for the mobile app if it supports them
-            const cleanedOutput = output
-                .replace(/Warning: no stdin data received in 3s, proceeding without it\..*?\n/g, '')
-                .replace(/.*?DeprecationWarning:.*?\n/g, '')
-                .trim();
-            // Insert assistant response back to Supabase
-            const { error } = await supabase
-                .from('messages')
-                .insert({
-                session_id: sessionId,
-                role: 'assistant',
-                content: cleanedOutput || '(No output)'
-            });
-            if (error) {
-                console.error(`❌ Failed to send response: ${error.message}`);
-            }
-            else {
-                console.log('📤 Response sent to mobile.');
-            }
-            resolve();
-        });
-    });
-}
 program.parse();

package/dist/server.d.ts

@@ -0,0 +1 @@
+export declare function startTerminalServer(port: number, authToken: string, workingDir: string): import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;

package/dist/server.js

@@ -0,0 +1,62 @@
+import express from 'express';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pty = require('node-pty');
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function startTerminalServer(port, authToken, workingDir) {
+    const app = express();
+    const server = createServer(app);
+    const wss = new WebSocketServer({ server });
+    const publicPath = path.join(__dirname, '../public');
+    app.use(express.static(publicPath));
+    wss.on('connection', (ws, req) => {
+        const url = new URL(req.url || '/', `http://${req.headers.host}`);
+        const token = url.searchParams.get('token');
+        if (token !== authToken) {
+            ws.close(1008, 'Unauthorized');
+            return;
+        }
+        const shell = process.platform === 'win32' ? 'powershell.exe' : 'bash';
+        const term = pty.spawn(shell, [], {
+            name: 'xterm-256color',
+            cols: 80,
+            rows: 24,
+            cwd: workingDir,
+            env: process.env
+        });
+        // Automatically start claude if available
+        term.write('claude\r');
+        term.onData((data) => {
+            ws.send(data);
+        });
+        ws.on('message', (msg) => {
+            const data = msg.toString();
+            try {
+                const json = JSON.parse(data);
+                if (json.type === 'resize' && json.cols && json.rows) {
+                    term.resize(json.cols, json.rows);
+                }
+                else {
+                    term.write(data);
+                }
+            }
+            catch {
+                term.write(data);
+            }
+        });
+        term.onExit(() => {
+            ws.close();
+        });
+        ws.on('close', () => {
+            term.kill();
+        });
+    });
+    server.listen(port, () => {
+        // console.log(`Local terminal server running on port ${port}`);
+    });
+    return server;
+}

package/dist/tunnel.d.ts

@@ -0,0 +1,9 @@
+export interface TunnelResult {
+    url: string | null;
+    cleanup: () => void;
+}
+export declare class CloudflareTunnel {
+    private process;
+    start(port: number): Promise<TunnelResult>;
+    private cleanup;
+}

package/dist/tunnel.js

@@ -0,0 +1,43 @@
+import { spawn } from 'child_process';
+export class CloudflareTunnel {
+    process = null;
+    async start(port) {
+        return new Promise((resolve) => {
+            try {
+                const proc = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                this.process = proc;
+                let output = '';
+                const timeout = setTimeout(() => {
+                    resolve({ url: null, cleanup: () => this.cleanup() });
+                }, 15000);
+                proc.stderr.on('data', (data) => {
+                    output += data.toString();
+                    const urlMatch = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+                    if (urlMatch) {
+                        clearTimeout(timeout);
+                        resolve({ url: urlMatch[0], cleanup: () => this.cleanup() });
+                    }
+                });
+                proc.on('error', () => {
+                    clearTimeout(timeout);
+                    resolve({ url: null, cleanup: () => this.cleanup() });
+                });
+                proc.on('exit', () => {
+                    clearTimeout(timeout);
+                    this.process = null;
+                });
+            }
+            catch {
+                resolve({ url: null, cleanup: () => this.cleanup() });
+            }
+        });
+    }
+    cleanup() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hmduc16031996/claude-mb-bridge",
-  "version": "1.1.10",
-  "description": "Bridge between Claude Code CLI and your mobile app via Supabase",
+  "version": "2.0.0",
+  "description": "Bridge between Claude Code CLI and your mobile app via WebView",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -10,15 +10,19 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
+    "dev": "tsx src/index.ts",
+    "postinstall": "node scripts/postinstall.cjs"
   },
   "dependencies": {
-    "@supabase/supabase-js": "^2.49.0",
     "commander": "^13.1.0",
-    "node-pty": "^1.1.0"
+    "express": "^4.19.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.16.0"
   },
   "devDependencies": {
+    "@types/express": "^4.17.21",
     "@types/node": "^22.13.9",
+    "@types/ws": "^8.5.10",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2"
   },
@@ -27,15 +31,17 @@
   },
   "files": [
     "dist",
-    "README.md",
-    "appicon.png"
+    "scripts",
+    "public",
+    "README.md"
   ],
   "keywords": [
     "claude",
     "mobile",
     "bridge",
     "cli",
-    "supabase"
+    "terminal",
+    "webview"
   ],
   "license": "MIT"
 }

package/public/index.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <title>Claude Remote Terminal</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/css/xterm.min.css">
+    <style>
+        body, html {
+            margin: 0;
+            padding: 0;
+            height: 100%;
+            background: #0d1117;
+            overflow: hidden;
+        }
+        #terminal-container {
+            width: 100%;
+            height: 100%;
+        }
+        .xterm-viewport {
+            overflow-y: auto !important;
+        }
+    </style>
+</head>
+<body>
+    <div id="terminal-container"></div>
+    <script src="https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/lib/xterm.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/@xterm/addon-fit@0.10.0/lib/addon-fit.min.js"></script>
+    <script>
+        const term = new Terminal({
+            cursorBlink: true,
+            theme: {
+                background: '#0d1117',
+                foreground: '#f0f6fc'
+            },
+            fontSize: 14,
+            fontFamily: 'Menlo, Monaco, "Courier New", monospace'
+        });
+        const fitAddon = new FitAddon.FitAddon();
+        term.loadAddon(fitAddon);
+        term.open(document.getElementById('terminal-container'));
+        fitAddon.fit();
+
+        const urlParams = new URLSearchParams(window.location.search);
+        const token = urlParams.get('token');
+        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const ws = new WebSocket(`${protocol}//${window.location.host}?token=${token}`);
+
+        ws.onopen = () => {
+            // term.write('Connected to bridge.\r\n');
+        };
+
+        ws.onmessage = (event) => {
+            term.write(event.data);
+        };
+
+        term.onData((data) => {
+            ws.send(data);
+        });
+
+        ws.onclose = () => {
+            term.write('\r\nConnection closed.\r\n');
+        };
+
+        window.addEventListener('resize', () => {
+            fitAddon.fit();
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'resize',
+                    cols: term.cols,
+                    rows: term.rows
+                }));
+            }
+        });
+    </script>
+</body>
+</html>

package/scripts/postinstall.cjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script to fix node-pty spawn-helper permissions on macOS.
+ *
+ * node-pty's prebuilt binaries for macOS include a spawn-helper executable
+ * that sometimes loses its execute permission when installed via npm/npx.
+ * This script restores the permission.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Check both nested (local) and flat (npm/npx) node_modules layouts
+const possiblePaths = [
+  path.join(__dirname, '..', 'node_modules', 'node-pty', 'prebuilds'),
+  path.join(__dirname, '..', '..', 'node-pty', 'prebuilds'),
+];
+
+for (const prebuildsPath of possiblePaths) {
+  try {
+    const entries = fs.readdirSync(prebuildsPath);
+
+    for (const entry of entries) {
+      if (!entry.startsWith('darwin-')) continue;
+
+      const spawnHelper = path.join(prebuildsPath, entry, 'spawn-helper');
+
+      try {
+        fs.chmodSync(spawnHelper, 0o755);
+        console.log(`✅ Fixed spawn-helper permissions: ${spawnHelper}`);
+      } catch (e) {
+        // Ignore errors (file might not exist on some platforms)
+      }
+    }
+  } catch (e) {
+    // Directory doesn't exist, skip
+  }
+}

package/dist/autostart.d.ts

@@ -1,3 +0,0 @@
-export declare function installAutostart(projectPath?: string): void;
-export declare function uninstallAutostart(): void;
-export declare function isAutostartInstalled(): boolean;

package/dist/autostart.js

@@ -1,234 +0,0 @@
-import { execSync } from 'child_process';
-import { writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { platform, homedir } from 'os';
-const SERVICE_NAME = 'com.claude-mb-bridge';
-const LABEL = 'Claude Mobile Bridge';
-/**
- * Get the path to the globally installed bridge binary
- */
-function getBridgePath() {
-    try {
-        // Try to find the global install
-        const globalBin = execSync('which claude-mb-bridge', { encoding: 'utf-8' }).trim();
-        if (globalBin)
-            return globalBin;
-    }
-    catch {
-        // not found
-    }
-    // Fallback: use npx
-    try {
-        const npxPath = execSync('which npx', { encoding: 'utf-8' }).trim();
-        return `${npxPath} claude-mb-bridge`;
-    }
-    catch {
-        throw new Error('Neither claude-mb-bridge nor npx found in PATH');
-    }
-}
-/**
- * Get the full PATH from current shell (needed for LaunchAgent)
- */
-function getShellPath() {
-    try {
-        return execSync('echo $PATH', { encoding: 'utf-8', shell: '/bin/zsh' }).trim();
-    }
-    catch {
-        return '/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin';
-    }
-}
-// ─── macOS LaunchAgent ────────────────────────────────────
-function getMacPlistPath() {
-    return join(homedir(), 'Library', 'LaunchAgents', `${SERVICE_NAME}.plist`);
-}
-function installMac(projectPath) {
-    const shellPath = getShellPath();
-    const logDir = join(homedir(), '.claude-mb-bridge');
-    try {
-        if (!existsSync(logDir)) {
-            mkdirSync(logDir, { recursive: true });
-        }
-    }
-    catch {
-        // Directory might already exist or be created by another process
-    }
-    // Always use npx with @latest to ensure the latest version runs
-    let npxPath;
-    try {
-        npxPath = execSync('which npx', { encoding: 'utf-8', shell: '/bin/zsh' }).trim();
-    }
-    catch {
-        npxPath = '/usr/local/bin/npx';
-    }
-    let programArgs = `    <string>${npxPath}</string>\n    <string>-y</string>\n    <string>claude-mb-bridge@latest</string>`;
-    if (projectPath) {
-        programArgs += `\n    <string>--path</string>\n    <string>${projectPath}</string>`;
-    }
-    const plist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${SERVICE_NAME}</string>
-  <key>ProgramArguments</key>
-  <array>
-${programArgs}
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>PATH</key>
-    <string>${shellPath}</string>
-    <key>HOME</key>
-    <string>${homedir()}</string>
-  </dict>
-  <key>StandardOutPath</key>
-  <string>${logDir}/bridge.log</string>
-  <key>StandardErrorPath</key>
-  <string>${logDir}/bridge-error.log</string>
-  <key>WorkingDirectory</key>
-  <string>${projectPath || homedir()}</string>
-</dict>
-</plist>`;
-    const plistPath = getMacPlistPath();
-    writeFileSync(plistPath, plist);
-    // Load the agent
-    try {
-        execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: 'ignore' });
-    }
-    catch { /* ignore */ }
-    execSync(`launchctl load "${plistPath}"`);
-    console.log('✅ Auto-launch installed (macOS LaunchAgent)');
-    console.log(`   Plist: ${plistPath}`);
-    console.log(`   Logs:  ${logDir}/bridge.log`);
-    console.log('   Bridge will start automatically on login.');
-}
-function uninstallMac() {
-    const plistPath = getMacPlistPath();
-    if (!existsSync(plistPath)) {
-        console.log('ℹ️  Auto-launch is not installed.');
-        return;
-    }
-    try {
-        execSync(`launchctl unload "${plistPath}"`, { stdio: 'ignore' });
-    }
-    catch { /* ignore */ }
-    unlinkSync(plistPath);
-    console.log('✅ Auto-launch removed (macOS LaunchAgent)');
-}
-// ─── Linux systemd ───────────────────────────────────────
-function getLinuxServicePath() {
-    const dir = join(homedir(), '.config', 'systemd', 'user');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    return join(dir, 'claude-mb-bridge.service');
-}
-function installLinux(projectPath) {
-    const bridgePath = getBridgePath();
-    const shellPath = getShellPath();
-    const logDir = join(homedir(), '.claude-mb-bridge');
-    try {
-        if (!existsSync(logDir)) {
-            mkdirSync(logDir, { recursive: true });
-        }
-    }
-    catch {
-        // ignore
-    }
-    let execStart = bridgePath;
-    if (projectPath) {
-        execStart += ` --path "${projectPath}"`;
-    }
-    const service = `[Unit]
-Description=${LABEL}
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${execStart}
-Restart=on-failure
-RestartSec=10
-Environment=PATH=${shellPath}
-Environment=HOME=${homedir()}
-WorkingDirectory=${projectPath || homedir()}
-
-[Install]
-WantedBy=default.target
-`;
-    const servicePath = getLinuxServicePath();
-    writeFileSync(servicePath, service);
-    // Enable and start
-    try {
-        execSync('systemctl --user daemon-reload');
-        execSync('systemctl --user enable claude-mb-bridge');
-        execSync('systemctl --user start claude-mb-bridge');
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.log(`⚠️  Could not start service: ${msg}`);
-        console.log('   Try manually: systemctl --user start claude-mb-bridge');
-    }
-    console.log('✅ Auto-launch installed (systemd user service)');
-    console.log(`   Service: ${servicePath}`);
-    console.log('   Bridge will start automatically on login.');
-    console.log('   Status:  systemctl --user status claude-mb-bridge');
-}
-function uninstallLinux() {
-    const servicePath = getLinuxServicePath();
-    if (!existsSync(servicePath)) {
-        console.log('ℹ️  Auto-launch is not installed.');
-        return;
-    }
-    try {
-        execSync('systemctl --user stop claude-mb-bridge', { stdio: 'ignore' });
-        execSync('systemctl --user disable claude-mb-bridge', { stdio: 'ignore' });
-    }
-    catch { /* ignore */ }
-    unlinkSync(servicePath);
-    try {
-        execSync('systemctl --user daemon-reload');
-    }
-    catch { /* ignore */ }
-    console.log('✅ Auto-launch removed (systemd user service)');
-}
-// ─── Public API ──────────────────────────────────────────
-export function installAutostart(projectPath) {
-    const os = platform();
-    if (os === 'darwin') {
-        installMac(projectPath);
-    }
-    else if (os === 'linux') {
-        installLinux(projectPath);
-    }
-    else {
-        console.log(`❌ Auto-launch is not supported on ${os}`);
-        console.log('   Supported: macOS (LaunchAgent), Linux (systemd)');
-    }
-}
-export function uninstallAutostart() {
-    const os = platform();
-    if (os === 'darwin') {
-        uninstallMac();
-    }
-    else if (os === 'linux') {
-        uninstallLinux();
-    }
-    else {
-        console.log(`❌ Auto-launch is not supported on ${os}`);
-    }
-}
-export function isAutostartInstalled() {
-    const os = platform();
-    if (os === 'darwin') {
-        return existsSync(getMacPlistPath());
-    }
-    else if (os === 'linux') {
-        return existsSync(getLinuxServicePath());
-    }
-    return false;
-}

package/dist/claude.d.ts

@@ -1,30 +0,0 @@
-import { ChildProcess } from 'child_process';
-/**
- * Find the Claude CLI binary path
- */
-export declare function findClaudeCLI(): string | null;
-export interface ClaudeOptions {
-    model?: string;
-    cwd?: string;
-    resumeSession?: string;
-    continueSession?: boolean;
-    timeout?: number;
-}
-export interface ClaudeResult {
-    output: string;
-    exitCode: number;
-    killed: boolean;
-}
-/**
- * Run Claude CLI with streaming output
- *
- * @param prompt The prompt to send
- * @param cliPath Path to claude binary
- * @param options Additional options
- * @param onChunk Called with each chunk of stdout for streaming
- * @returns Full result when completed
- */
-export declare function runClaude(prompt: string, cliPath: string, options?: ClaudeOptions, onChunk?: (chunk: string, fullOutput: string) => void): {
-    process: ChildProcess;
-    result: Promise<ClaudeResult>;
-};

package/dist/claude.js

@@ -1,102 +0,0 @@
-import { spawn, execSync } from 'child_process';
-/**
- * Find the Claude CLI binary path
- */
-export function findClaudeCLI() {
-    const commonPaths = [
-        '/usr/local/bin/claude',
-        '/opt/homebrew/bin/claude',
-        `${process.env.HOME}/.local/bin/claude`,
-        `${process.env.HOME}/.claude/bin/claude`,
-    ];
-    // Try `which` first
-    try {
-        const result = execSync('which claude', { encoding: 'utf-8' }).trim();
-        if (result)
-            return result;
-    }
-    catch {
-        // not in PATH
-    }
-    // Check common paths
-    for (const p of commonPaths) {
-        try {
-            execSync(`test -x "${p}"`, { stdio: 'ignore' });
-            return p;
-        }
-        catch {
-            // not found
-        }
-    }
-    return null;
-}
-/**
- * Run Claude CLI with streaming output
- *
- * @param prompt The prompt to send
- * @param cliPath Path to claude binary
- * @param options Additional options
- * @param onChunk Called with each chunk of stdout for streaming
- * @returns Full result when completed
- */
-export function runClaude(prompt, cliPath, options = {}, onChunk) {
-    const args = ['--print', '--dangerously-skip-permissions'];
-    if (options.model) {
-        args.push('--model', options.model);
-    }
-    if (options.resumeSession) {
-        args.push('--resume', options.resumeSession);
-    }
-    else if (options.continueSession) {
-        args.push('--continue');
-    }
-    // Prompt passed via stdin pipe for max CLI compatibility
-    const timeout = options.timeout || 10 * 60 * 1000; // 10 min default
-    const proc = spawn(cliPath, args, {
-        cwd: options.cwd || process.cwd(),
-        env: { ...process.env },
-        stdio: ['pipe', 'pipe', 'pipe'], // stdin is pipe — we write prompt then close
-    });
-    // Write prompt to stdin and close
-    if (proc.stdin) {
-        proc.stdin.write(prompt);
-        proc.stdin.end();
-    }
-    const result = new Promise((resolve) => {
-        let output = '';
-        let stderr = '';
-        let killed = false;
-        const timer = setTimeout(() => {
-            killed = true;
-            proc.kill('SIGTERM');
-        }, timeout);
-        proc.stdout?.on('data', (data) => {
-            const chunk = data.toString('utf-8');
-            output += chunk;
-            onChunk?.(chunk, output);
-        });
-        proc.stderr?.on('data', (data) => {
-            stderr += data.toString('utf-8');
-        });
-        proc.on('close', (code) => {
-            clearTimeout(timer);
-            if (stderr && !output) {
-                output = `⚠️ Claude CLI Error:\n${stderr}`;
-            }
-            resolve({
-                output: output || '(empty response)',
-                exitCode: code ?? 1,
-                killed,
-            });
-        });
-        proc.on('error', (err) => {
-            clearTimeout(timer);
-            resolve({
-                output: `⚠️ Failed to start Claude CLI: ${err.message}`,
-                exitCode: 1,
-                killed: false,
-            });
-        });
-    });
-    return { process: proc, result };
-}

package/dist/config.d.ts

@@ -1,25 +0,0 @@
-export interface BridgeConfig {
-    supabaseUrl: string;
-    supabaseAnonKey: string;
-    pairId: string | null;
-    pairCode: string | null;
-    projectPath: string | null;
-    port: number;
-}
-interface SavedConfig {
-    pairId?: string;
-    pairCode?: string;
-    projectPath?: string;
-}
-/**
- * Save config to ~/.claude-mobile/config.json
- */
-export declare function saveConfig(updates: Partial<SavedConfig>): void;
-/**
- * Build the full BridgeConfig from env + saved config + CLI args
- */
-export declare function getConfig(options: {
-    path?: string;
-    port?: number;
-}): BridgeConfig;
-export {};

package/dist/config.js

@@ -1,48 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-// Config file location: ~/.claude-mobile/config.json
-const CONFIG_DIR = join(homedir(), '.claude-mobile');
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-/**
- * Load saved config from ~/.claude-mobile/config.json
- */
-function loadSavedConfig() {
-    try {
-        if (existsSync(CONFIG_FILE)) {
-            const data = readFileSync(CONFIG_FILE, 'utf-8');
-            return JSON.parse(data);
-        }
-    }
-    catch {
-        // ignore
-    }
-    return {};
-}
-/**
- * Save config to ~/.claude-mobile/config.json
- */
-export function saveConfig(updates) {
-    const current = loadSavedConfig();
-    const merged = { ...current, ...updates };
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), 'utf-8');
-}
-/**
- * Build the full BridgeConfig from env + saved config + CLI args
- */
-export function getConfig(options) {
-    const saved = loadSavedConfig();
-    const supabaseUrl = 'https://cyhklykwiqmwpcwnfszv.supabase.co';
-    const supabaseAnonKey = 'sb_publishable_703eeIzzKe8olUyXFB84fw_0HN6NEWH';
-    return {
-        supabaseUrl,
-        supabaseAnonKey,
-        pairId: saved.pairId || null,
-        pairCode: saved.pairCode || null,
-        projectPath: options.path || process.cwd(),
-        port: options.port || 38473,
-    };
-}

package/dist/pairing.d.ts

@@ -1,14 +0,0 @@
-import { Server } from 'http';
-/**
- * Start a local HTTP server to receive pairing callbacks from the web page.
- * The `connect` edge function redirects to http://127.0.0.1:38473/callback?token=PAIR_CODE
- *
- * @param port Port to listen on (default 38473)
- * @param onPairCode Called when a valid pair code is received
- * @param persistent If true, server stays running after pairing (for re-connections)
- * @returns Server instance and a promise that resolves when pairing succeeds
- */
-export declare function startPairingServer(port: number, onPairCode: (code: string) => Promise<void>, persistent?: boolean): {
-    server: Server;
-    paired: Promise<void>;
-};

package/dist/pairing.js

@@ -1,137 +0,0 @@
-import { createServer } from 'http';
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
-/**
- * Start a local HTTP server to receive pairing callbacks from the web page.
- * The `connect` edge function redirects to http://127.0.0.1:38473/callback?token=PAIR_CODE
- *
- * @param port Port to listen on (default 38473)
- * @param onPairCode Called when a valid pair code is received
- * @param persistent If true, server stays running after pairing (for re-connections)
- * @returns Server instance and a promise that resolves when pairing succeeds
- */
-export function startPairingServer(port, onPairCode, persistent = false) {
-    let resolvePaired;
-    const paired = new Promise((resolve) => {
-        resolvePaired = resolve;
-    });
-    const server = createServer(async (req, res) => {
-        // CORS headers for browser requests
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
-        if (req.method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        const url = new URL(req.url || '/', `http://localhost:${port}`);
-        if (url.pathname === '/callback') {
-            const token = url.searchParams.get('token');
-            if (!token) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<h1>Missing token</h1>');
-                return;
-            }
-            try {
-                await onPairCode(token);
-                // Send success response
-                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                res.end(`
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Connected!</title>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <style>
-    body { font-family: -apple-system, system-ui, sans-serif; background: #0a0a0b; color: white; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; }
-    .container { text-align: center; }
-    .icon { width: 80px; height: 80px; margin-bottom: 20px; opacity: 0.85; }
-    h1 { font-size: 24px; margin-bottom: 8px; font-weight: 700; }
-    p { color: #71717a; font-size: 15px; line-height: 1.5; }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <img class="icon" src="/icon" alt="App Icon" />
-    <h1>Connected!</h1>
-    <p>You can close this tab and return to your mobile app.</p>
-  </div>
-</body>
-</html>`);
-                if (!persistent) {
-                    // Close server after successful pairing (one-time mode)
-                    setTimeout(() => {
-                        server.close();
-                        resolvePaired();
-                    }, 500);
-                }
-                else {
-                    // In persistent mode, just resolve the promise but keep server running
-                    resolvePaired();
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                res.writeHead(500, { 'Content-Type': 'text/html' });
-                res.end(`<h1>Pairing failed</h1><p>${message}</p>`);
-            }
-        }
-        else if (url.pathname === '/icon') {
-            // Serve the app icon
-            try {
-                const iconPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'appicon.png');
-                const icon = readFileSync(iconPath);
-                res.writeHead(200, { 'Content-Type': 'image/png', 'Cache-Control': 'public, max-age=3600' });
-                res.end(icon);
-            }
-            catch {
-                res.writeHead(404);
-                res.end();
-            }
-        }
-        else if (url.pathname === '/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'waiting_for_pair' }));
-        }
-        else {
-            res.writeHead(404);
-            res.end('Not found');
-        }
-    });
-    server.on('error', (err) => {
-        if (err.code === 'EADDRINUSE') {
-            if (persistent) {
-                // Already paired, just skip the pairing server
-                console.log(`\n⚠️  Port ${port} is already in use (another bridge may be running).`);
-                console.log('   Pairing server skipped — bridge continues working.\n');
-                resolvePaired();
-            }
-            else {
-                // Need to pair! Kill the existing process on port and retry
-                console.log(`\n⚠️  Port ${port} is busy. Freeing port...`);
-                try {
-                    execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null`, { stdio: 'ignore' });
-                }
-                catch { /* ignore */ }
-                // Retry after a short delay
-                setTimeout(() => {
-                    server.listen(port, '127.0.0.1', () => {
-                        console.log(`\n🔗 Pairing server ready at http://127.0.0.1:${port}`);
-                        console.log('   👉 Now go to the mobile app and tap "Connect" on the setup page.\n');
-                    });
-                }, 1000);
-            }
-        }
-        else {
-            console.error('❌ Pairing server error:', err.message);
-        }
-    });
-    server.listen(port, '127.0.0.1', () => {
-        console.log(`\n🔗 Pairing server ready at http://127.0.0.1:${port}`);
-        console.log('   👉 Now go to the mobile app and tap "Connect" on the setup page.\n');
-    });
-    return { server, paired };
-}

package/dist/supabase.d.ts

@@ -1 +0,0 @@
-export declare const supabase: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;

package/dist/supabase.js

@@ -1,4 +0,0 @@
-import { createClient } from '@supabase/supabase-js';
-const supabaseUrl = 'https://cyhklykwiqmwpcwnfszv.supabase.co';
-const supabaseAnonKey = 'sb_publishable_703eeIzzKe8olUyXFB84fw_0HN6NEWH';
-export const supabase = createClient(supabaseUrl, supabaseAnonKey);