spudmobile-bridge 1.0.0

package/dist/index.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { program } from 'commander';
+import { getConfig, saveConfig } from './config.js';
+import { SupabaseBridge } from './supabase.js';
+import { findCodexCLI, runCodex } from './codex.js';
+import { startPairingServer } from './pairing.js';
+import { installAutostart, uninstallAutostart, isAutostartInstalled } from './autostart.js';
+// ─── State ────────────────────────────────────────────────
+let isFirstMessage = true;
+// ─── CLI ──────────────────────────────────────────────────
+program
+    .name('spudmobile-bridge')
+    .description('Bridge your mobile app with OpenAI Codex CLI')
+    .version('1.0.0')
+    .option('-p, --path <dir>', 'Project directory for Codex to work in')
+    .option('--port <number>', 'Pairing server port', '38474')
+    .option('--install', 'Install auto-launch (start on login)')
+    .option('--uninstall', 'Remove auto-launch')
+    .parse();
+const opts = program.opts();
+// Handle install/uninstall commands
+if (opts.install) {
+    installAutostart(opts.path);
+    process.exit(0);
+}
+if (opts.uninstall) {
+    uninstallAutostart();
+    process.exit(0);
+}
+const config = getConfig({ path: opts.path, port: parseInt(opts.port) });
+// ─── State ────────────────────────────────────────────────
+let cliPath = null;
+let bridge;
+let activeProcess = null;
+let activeMessageId = null;
+let pairingServer = null;
+// ─── Main ─────────────────────────────────────────────────
+async function main() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════╗');
+    console.log('║     SpudMobile Bridge  v1.0               ║');
+    console.log('║     OpenAI Codex CLI ↔ iOS                ║');
+    console.log('╚══════════════════════════════════════════╝');
+    console.log('');
+    // 1. Find Codex CLI
+    cliPath = findCodexCLI();
+    if (!cliPath) {
+        console.error('❌ Codex CLI not found!');
+        console.error('   Install it: npm i -g @openai/codex');
+        console.error('   Or visit: https://developers.openai.com/codex/cli');
+        process.exit(1);
+    }
+    console.log(`✅ Codex CLI found: ${cliPath}`);
+    // 2. Init Supabase bridge
+    bridge = new SupabaseBridge(config);
+    // 3. Handle pairing
+    let needsPairing = !config.pairId;
+    // Verify saved pair is still active
+    if (config.pairId) {
+        const isActive = await bridge.isPairActive(config.pairId);
+        if (isActive) {
+            console.log(`✅ Using saved pair: ${config.pairId}`);
+        }
+        else {
+            console.log('⚠️  Saved pair is no longer active. Re-pairing...');
+            saveConfig({ pairId: undefined, pairCode: undefined });
+            config.pairId = null;
+            config.pairCode = null;
+            bridge.pairId = null;
+            needsPairing = true;
+        }
+    }
+    if (needsPairing) {
+        await waitForPairing();
+        // Auto-install background service after first successful pairing
+        if (!isAutostartInstalled()) {
+            console.log('');
+            installAutostart(config.projectPath || undefined);
+        }
+    }
+    // Start operations with current pair
+    await startOperations();
+    console.log('');
+    console.log(`📁 Project: ${config.projectPath}`);
+    console.log('🤖 Waiting for messages from mobile app...');
+    console.log('   Press Ctrl+C to stop.\n');
+    // Always keep pairing server running in background for re-pairing
+    ensurePairingServerRunning();
+}
+/**
+ * Wait for initial pairing to complete (one-time, closes after pair)
+ */
+async function waitForPairing() {
+    console.log('🔗 No saved pair found. Starting pairing server...');
+    const { server, paired } = startPairingServer(config.port, async (pairCode) => {
+        console.log(`🔑 Received pair code: ${pairCode}`);
+        const pairId = await bridge.activatePair(pairCode);
+        console.log(`✅ Paired successfully! ID: ${pairId}`);
+    }, false); // one-time mode — closes after first pair
+    pairingServer = server;
+    await paired;
+    pairingServer = null;
+}
+/**
+ * Start persistent pairing server for re-connections.
+ * Server stays alive and handles unlimited re-pairings.
+ */
+function ensurePairingServerRunning() {
+    if (pairingServer)
+        return;
+    const { server } = startPairingServer(config.port, async (pairCode) => {
+        console.log(`\n🔑 Re-pair request received: ${pairCode}`);
+        // End old session
+        await bridge.endSession();
+        isFirstMessage = true;
+        // Activate new pair
+        const pairId = await bridge.activatePair(pairCode);
+        console.log(`✅ Re-paired successfully! ID: ${pairId}`);
+        // Start fresh operations
+        await startOperations();
+        console.log('');
+        console.log(`📁 Project: ${config.projectPath}`);
+        console.log('🤖 Waiting for messages from mobile app...\n');
+    }, true); // persistent mode — keeps running
+    pairingServer = server;
+}
+/**
+ * Start/restart all bridge operations (session, presence, subscriptions)
+ */
+async function startOperations() {
+    // Reuse active session or create new one
+    const session = await bridge.ensureSession();
+    // If session was resumed, continue Codex conversation (not fresh start)
+    if (session.resumed) {
+        isFirstMessage = false;
+    }
+    // Start presence heartbeat
+    bridge.startPresenceHeartbeat();
+    // Process any pending messages
+    const pending = await bridge.getPendingMessages();
+    if (pending.length > 0) {
+        console.log(`📬 Found ${pending.length} pending message(s)`);
+        for (const msg of pending) {
+            await processMessage(msg);
+        }
+    }
+    // Subscribe to new messages
+    bridge.subscribeToMessages(async (message) => {
+        await processMessage(message);
+    }, (messageId) => {
+        handleCancellation(messageId);
+    });
+    // Listen for session changes (iOS "New Session" button)
+    bridge.subscribeToSessionChange(() => {
+        isFirstMessage = true;
+        console.log('🔄 Session reset — next message starts fresh Codex conversation');
+    });
+    // Listen for disconnect from mobile app
+    bridge.subscribeToDisconnect(async () => {
+        console.log('\n🔌 Disconnected by mobile app!');
+        console.log('   Waiting for re-connection...\n');
+        // End current session
+        await bridge.endSession();
+        isFirstMessage = true;
+        // Clear saved config
+        saveConfig({ pairId: undefined, pairCode: undefined });
+        config.pairId = null;
+        config.pairCode = null;
+        bridge.pairId = null;
+        // Pairing server is already running in background,
+        // so user can just tap Connect again on iOS
+        ensurePairingServerRunning();
+    });
+}
+// ─── Process Message ──────────────────────────────────────
+async function processMessage(message) {
+    const prompt = message.content;
+    const model = message.model;
+    console.log(`\n📩 New message: "${prompt.substring(0, 80)}${prompt.length > 80 ? '...' : ''}"`);
+    if (model)
+        console.log(`   Model: ${model}`);
+    // Sync session (in case iOS created new session)
+    const oldSessionId = bridge.sessionId;
+    await bridge.refreshSessionId();
+    if (bridge.sessionId !== oldSessionId) {
+        isFirstMessage = true;
+        console.log('🔄 Session changed — starting fresh Codex conversation');
+    }
+    // Mark as processing
+    await bridge.markAsProcessing(message.id);
+    activeMessageId = message.id;
+    // Run Codex CLI
+    const { process: proc, result } = runCodex(prompt, cliPath, {
+        model: mapModel(model) || undefined,
+        cwd: config.projectPath || undefined,
+        continueSession: !isFirstMessage,
+    }, 
+    // Streaming callback
+    async (chunk, fullOutput) => {
+        // For streaming we just update, but for simplicity
+        // we'll send the final result once complete
+    });
+    isFirstMessage = false;
+    activeProcess = proc;
+    // Wait for result
+    const codexResult = await result;
+    activeProcess = null;
+    activeMessageId = null;
+    if (codexResult.killed) {
+        console.log('⏱️  Timed out');
+        await bridge.sendReply('⚠️ Request timed out after 10 minutes.', message.id, model, 'error');
+        return;
+    }
+    // Send reply
+    const status = codexResult.exitCode === 0 ? 'completed' : 'error';
+    await bridge.sendReply(codexResult.output, message.id, model, status);
+    console.log(`✅ Reply sent (${codexResult.output.length} chars, status: ${status})`);
+}
+// ─── Cancellation ─────────────────────────────────────────
+function handleCancellation(messageId) {
+    if (activeMessageId === messageId && activeProcess) {
+        console.log('🚫 Cancellation received — killing Codex process');
+        activeProcess.kill('SIGTERM');
+        activeProcess = null;
+        activeMessageId = null;
+    }
+}
+// ─── Model Mapping ────────────────────────────────────────
+function mapModel(model) {
+    if (!model || model.toLowerCase() === 'default')
+        return undefined;
+    // Map iOS model names to Codex CLI model flags
+    const mapping = {
+        'gpt-5.4': 'gpt-5.4',
+        'gpt-5.3-codex': 'gpt-5.3-codex',
+        'gpt-5.3-codex-spark': 'gpt-5.3-codex-spark',
+        'codex': 'gpt-5.3-codex',
+        'spark': 'gpt-5.3-codex-spark',
+    };
+    return mapping[model.toLowerCase()] || model;
+}
+// ─── Graceful Shutdown ────────────────────────────────────
+async function shutdown() {
+    console.log('\n🛑 Shutting down...');
+    if (activeProcess) {
+        activeProcess.kill('SIGTERM');
+    }
+    if (bridge) {
+        await bridge.cleanup();
+    }
+    if (pairingServer) {
+        pairingServer.close();
+    }
+    process.exit(0);
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+// ─── Run ──────────────────────────────────────────────────
+main().catch((err) => {
+    console.error('💥 Fatal error:', err.message);
+    process.exit(1);
+});

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,96 @@
+import { BridgeConfig } from './config.js';
+export interface Message {
+    id: string;
+    created_at: string;
+    role: 'user' | 'agent' | 'system';
+    content: string;
+    status: 'pending' | 'processing' | 'streaming' | 'completed' | 'error';
+    session_id: string | null;
+    model: string | null;
+    user_id: string | null;
+    client_type: string;
+    parent_message_id: string | null;
+    pair_id: string | null;
+    sender: string | null;
+    processed_by_mac_at: string | null;
+    is_cancelled: boolean;
+    cancelled_at: string | null;
+}
+export declare class SupabaseBridge {
+    private config;
+    private client;
+    private messageChannel;
+    private presenceInterval;
+    private pollingInterval;
+    private processedMessageIds;
+    private deviceId;
+    pairId: string | null;
+    sessionId: string | null;
+    constructor(config: BridgeConfig);
+    /**
+     * Create a new session, deactivating any old sessions for this pair
+     */
+    createSession(): Promise<string>;
+    /**
+     * Reuse existing active session or create a new one.
+     * This preserves chat history across bridge restarts.
+     * Returns session id and project_name (if available).
+     */
+    ensureSession(): Promise<{
+        id: string;
+        projectName: string | null;
+        resumed: boolean;
+    }>;
+    /**
+     * End the current session
+     */
+    endSession(): Promise<void>;
+    /**
+     * Subscribe to session changes (iOS creates new session)
+     */
+    subscribeToSessionChange(onNewSession: (sessionId: string) => void): void;
+    /**
+     * Refresh sessionId from Supabase (polling fallback for session changes)
+     */
+    refreshSessionId(): Promise<void>;
+    /**
+     * Check if a pair is still active in Supabase
+     */
+    isPairActive(pairId: string): Promise<boolean>;
+    /**
+     * Activate a device pair using the pair code from callback
+     */
+    activatePair(pairCode: string): Promise<string>;
+    /**
+     * Subscribe to new user messages for processing
+     */
+    subscribeToMessages(onNewMessage: (message: Message) => void, onCancellation: (messageId: string) => void): void;
+    /**
+     * Subscribe to disconnect events from mobile app
+     */
+    subscribeToDisconnect(onDisconnect: () => void): void;
+    /**
+     * Mark message as being processed
+     */
+    markAsProcessing(messageId: string): Promise<void>;
+    /**
+     * Send a reply message from the bridge (agent)
+     */
+    sendReply(content: string, parentMessageId: string, model: string | null, status?: 'streaming' | 'completed' | 'error'): Promise<string | null>;
+    /**
+     * Update an existing reply (for streaming updates)
+     */
+    updateReply(replyId: string, content: string, status?: 'streaming' | 'completed' | 'error'): Promise<void>;
+    /**
+     * Start heartbeat to ide_presence table
+     */
+    startPresenceHeartbeat(): void;
+    /**
+     * Check if there are pending messages to process (on startup or polling)
+     */
+    getPendingMessages(): Promise<Message[]>;
+    /**
+     * Clean up on shutdown
+     */
+    cleanup(): Promise<void>;
+}