@hmduc16031996/claude-mb-bridge 1.1.0

package/README.md

@@ -0,0 +1,76 @@
+# Claude MB Bridge 🤖📱
+
+A lightweight bridge between the **Claude Code CLI** and your **mobile app** (e.g., iOS/Android) via Supabase. It allows you to use Claude Code to interact with your codebase directly from your mobile device.
+
+![App Icon](appicon.png)
+
+## ✨ Features
+
+- **Real-time Communication**: USes Supabase Realtime to bridge messages between your Mac and mobile device.
+- **Persistent Sessions**: Resumes previous Claude conversations automatically, even after restarts.
+- **Streaming Output**: (In-progress) Supports viewing Claude's output as it's generated.
+- **Pairing System**: Securely pair your mobile app using a simple 6-digit code.
+- **Background Service**: Easily install as a login item on macOS to keep the bridge running.
+- **Model Selection**: Supports switching between Claude 3.5 Sonnet, 3 Opus, and 3.5 Haiku.
+- **Command Cancellation**: Stop running Claude processes directly from your mobile app.
+
+## 📋 Prerequisites
+
+1.  **Node.js**: Version 18.0.0 or higher.
+2.  **Claude Code CLI**: Must be installed on your Mac.
+    - Install via brew: `brew install --cask claude-code`
+    - Or visit: [code.claude.com](https://code.claude.com)
+3.  **Supabase Account**: A Supabase project with the required schema (tables: `device_pairs`, `bridge_sessions`, `messages`, `ide_presence`).
+
+## 🚀 Installation
+
+Install the package globally or run it directly using `npx`:
+
+```bash
+# Run via npx
+npx claude-mb-bridge
+
+# Or install globally
+npm install -g claude-mb-bridge
+```
+
+## 🔧 Setup & Pairing
+
+1.  **Start the Bridge**: Run `claude-mb-bridge` in your project's root directory.
+2.  **Get Pair Code**: The bridge will start a local pairing server (default port: `38473`).
+3.  **Connect Mobile App**: Open your mobile app, enter the 6-digit code displayed in your terminal.
+4.  **Authorized**: Once paired, the bridge will remember your device and automatically reconnect in the future.
+
+## 💻 CLI Options
+
+| Option | Description |
+| :--- | :--- |
+| `-p, --path <dir>` | Project directory for Claude to work in (defaults to current directory) |
+| `--port <number>` | Port for the pairing server (default: `38473`) |
+| `--install` | Install as a background service (starts on login) |
+| `--uninstall` | Remove the background service |
+| `--version` | Show version number |
+
+## ⚙️ Configuration
+
+The bridge stores its configuration in `~/.claude-mobile/config.json`.
+
+You can override the default Supabase credentials using environment variables:
+
+```bash
+SUPABASE_URL="your-project-url"
+SUPABASE_ANON_KEY="your-anon-key"
+```
+
+## 🏗️ Architecture
+
+The bridge acts as a middleman:
+1.  **Mobile App** inserts a `user` message into the Supabase `messages` table.
+2.  **Bridge** (this package) detects the new message via Realtime/Polling.
+3.  **Bridge** executes the command using the local `claude-code` CLI.
+4.  **Bridge** captures the output and inserts an `agent` reply back into the `messages` table.
+5.  **Mobile App** displays the reply to the user.
+
+## 📄 License
+
+MIT © [Your Name/Company]

package/dist/autostart.d.ts

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

package/dist/autostart.js

@@ -0,0 +1,234 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,48 @@
+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 = process.env.SUPABASE_URL || 'https://dtaegtkfdwgdbyolcxht.supabase.co';
+    const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || 'sb_publishable__giFEuM62kLTFecXfufGIw_a-Dv9y6O';
+    return {
+        supabaseUrl,
+        supabaseAnonKey,
+        pairId: saved.pairId || null,
+        pairCode: saved.pairCode || null,
+        projectPath: options.path || process.cwd(),
+        port: options.port || 38473,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/index.js

@@ -0,0 +1,91 @@
+import { Command } from 'commander';
+import { supabase } from './supabase.js';
+import { spawn } from 'child_process';
+import 'dotenv/config';
+const program = new Command();
+program
+    .name('claude-mobile-bridge')
+    .description('Bridge Claude Code CLI to mobile')
+    .version('1.1.0')
+    .option('--token <token>', 'Pairing token from mobile app')
+    .option('--server <url>', 'Backend server URL', 'http://localhost:3000') // Default to local for dev
+    .option('--path <path>', 'Working directory', process.cwd())
+    .action(async (options) => {
+    const { token, server, path } = options;
+    if (!token) {
+        console.error('Error: --token is required');
+        process.exit(1);
+    }
+    console.log(`🚀 Starting bridge for token: ${token}`);
+    // 1. Validate token and pair
+    try {
+        const res = await fetch(`${server}/api/sessions/${token}/validate`, {
+            method: 'POST'
+        });
+        if (!res.ok) {
+            throw new Error('Invalid token or session expired');
+        }
+        console.log('✅ Session paired successfully.');
+    }
+    catch (err) {
+        console.error(`❌ Validation failed: ${err.message}`);
+        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.');
+        }
+    });
+    // 3. Local pairing server (optional / fallback as per plan)
+    // For now, we'll stick to the token-based pairing.
+});
+async function handleUserPrompt(content, sessionId, cwd) {
+    console.log('⏳ Executing Claude Code...');
+    // Using 'claude' CLI as per plan. 
+    // We'll use '-p' to pass the prompt if supported, or pipe it.
+    // The plan says "runClaudeCode(payload.new.content, path)"
+    const child = spawn('claude', [content], { cwd, shell: true });
+    let output = '';
+    child.stdout.on('data', (data) => {
+        output += data.toString();
+        process.stdout.write(data);
+    });
+    child.stderr.on('data', (data) => {
+        output += data.toString();
+        process.stderr.write(data);
+    });
+    child.on('close', async (code) => {
+        console.log(`\n✅ Claude Code finished with code ${code}`);
+        // Insert assistant response back to Supabase
+        const { error } = await supabase
+            .from('messages')
+            .insert({
+            session_id: sessionId,
+            role: 'assistant',
+            content: output || '(No output)'
+        });
+        if (error) {
+            console.error(`❌ Failed to send response: ${error.message}`);
+        }
+        else {
+            console.log('📤 Response sent to mobile.');
+        }
+    });
+}
+program.parse();

package/dist/pairing.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,137 @@
+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

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

package/dist/supabase.js

@@ -0,0 +1,5 @@
+import { createClient } from '@supabase/supabase-js';
+import 'dotenv/config';
+const supabaseUrl = process.env.SUPABASE_URL;
+const supabaseAnonKey = process.env.SUPABASE_ANON_KEY;
+export const supabase = createClient(supabaseUrl, supabaseAnonKey);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@hmduc16031996/claude-mb-bridge",
+  "version": "1.1.0",
+  "description": "Bridge between Claude Code CLI and your mobile app via Supabase",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "claude-mb-bridge": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.49.0",
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.9",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "appicon.png"
+  ],
+  "keywords": [
+    "claude",
+    "mobile",
+    "bridge",
+    "cli",
+    "supabase"
+  ],
+  "license": "MIT"
+}