spudmobile-bridge 1.0.0

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.spudmobile-bridge';
+const LABEL = 'SpudMobile Bridge';
+/**
+ * Get the path to the globally installed bridge binary
+ */
+function getBridgePath() {
+    try {
+        // Try to find the global install
+        const globalBin = execSync('which spudmobile-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} spudmobile-bridge`;
+    }
+    catch {
+        throw new Error('Neither spudmobile-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(), '.spudmobile-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>spudmobile-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, 'spudmobile-bridge.service');
+}
+function installLinux(projectPath) {
+    const bridgePath = getBridgePath();
+    const shellPath = getShellPath();
+    const logDir = join(homedir(), '.spudmobile-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 spudmobile-bridge');
+        execSync('systemctl --user start spudmobile-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 spudmobile-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 spudmobile-bridge');
+}
+function uninstallLinux() {
+    const servicePath = getLinuxServicePath();
+    if (!existsSync(servicePath)) {
+        console.log('ℹ️  Auto-launch is not installed.');
+        return;
+    }
+    try {
+        execSync('systemctl --user stop spudmobile-bridge', { stdio: 'ignore' });
+        execSync('systemctl --user disable spudmobile-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/codex.d.ts

@@ -0,0 +1,32 @@
+import { ChildProcess } from 'child_process';
+/**
+ * Find the Codex CLI binary path
+ */
+export declare function findCodexCLI(): string | null;
+export interface CodexOptions {
+    model?: string;
+    cwd?: string;
+    continueSession?: boolean;
+    timeout?: number;
+}
+export interface CodexResult {
+    output: string;
+    exitCode: number;
+    killed: boolean;
+}
+/**
+ * Run Codex CLI in non-interactive (exec) mode with streaming output
+ *
+ * Uses `codex exec "prompt"` for one-shot execution
+ * Uses `codex exec resume --last "prompt"` to continue the last session
+ *
+ * @param prompt The prompt to send
+ * @param cliPath Path to codex binary
+ * @param options Additional options
+ * @param onChunk Called with each chunk of stdout for streaming
+ * @returns Full result when completed
+ */
+export declare function runCodex(prompt: string, cliPath: string, options?: CodexOptions, onChunk?: (chunk: string, fullOutput: string) => void): {
+    process: ChildProcess;
+    result: Promise<CodexResult>;
+};

package/dist/codex.js

@@ -0,0 +1,106 @@
+import { spawn, execSync } from 'child_process';
+/**
+ * Find the Codex CLI binary path
+ */
+export function findCodexCLI() {
+    // Try `which` first
+    try {
+        const result = execSync('which codex', { encoding: 'utf-8' }).trim();
+        if (result)
+            return result;
+    }
+    catch {
+        // not in PATH
+    }
+    const commonPaths = [
+        '/usr/local/bin/codex',
+        '/opt/homebrew/bin/codex',
+        `${process.env.HOME}/.local/bin/codex`,
+        `${process.env.HOME}/.npm-global/bin/codex`,
+    ];
+    for (const p of commonPaths) {
+        try {
+            execSync(`test -x "${p}"`, { stdio: 'ignore' });
+            return p;
+        }
+        catch {
+            // not found
+        }
+    }
+    return null;
+}
+/**
+ * Run Codex CLI in non-interactive (exec) mode with streaming output
+ *
+ * Uses `codex exec "prompt"` for one-shot execution
+ * Uses `codex exec resume --last "prompt"` to continue the last session
+ *
+ * @param prompt The prompt to send
+ * @param cliPath Path to codex binary
+ * @param options Additional options
+ * @param onChunk Called with each chunk of stdout for streaming
+ * @returns Full result when completed
+ */
+export function runCodex(prompt, cliPath, options = {}, onChunk) {
+    const args = [];
+    if (options.continueSession) {
+        // Resume the last session: codex exec resume --last "prompt"
+        args.push('exec', 'resume', '--last', prompt);
+    }
+    else {
+        // One-shot: codex exec "prompt"
+        args.push('exec', prompt);
+    }
+    if (options.model) {
+        args.push('--model', options.model);
+    }
+    // Full auto approval mode — no interactive prompts
+    args.push('--full-auto');
+    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'],
+    });
+    // Close stdin immediately — exec mode doesn't need it
+    if (proc.stdin) {
+        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 = `⚠️ Codex CLI Error:\n${stderr}`;
+            }
+            resolve({
+                output: output || '(empty response)',
+                exitCode: code ?? 1,
+                killed,
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({
+                output: `⚠️ Failed to start Codex 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(), '.spudmobile');
+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,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';