zenflo 0.11.7 → 0.11.9

package/dist/status-Crjj5AbA.mjs

@@ -0,0 +1,92 @@
+import { execSync } from 'child_process';
+import { r as readDaemonState, l as logger } from './types-CTT5Uja5.mjs';
+import chalk from 'chalk';
+import 'axios';
+import 'fs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:fs/promises';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'node:events';
+import 'socket.io-client';
+import 'util';
+import 'fs/promises';
+import 'crypto';
+import 'path';
+import 'url';
+import 'os';
+import 'expo-server-sdk';
+
+const TASK_NAME = "ZenFlo Daemon";
+async function status() {
+  try {
+    console.log(chalk.cyan.bold("\u{1F50D} ZenFlo Daemon Status\n"));
+    let isTaskInstalled = false;
+    let taskStatus = "Unknown";
+    try {
+      const output = execSync(`schtasks /Query /TN "${TASK_NAME}" /FO LIST /V`, { encoding: "utf-8" });
+      isTaskInstalled = true;
+      const statusMatch = output.match(/Status:\s+(.+)/);
+      if (statusMatch) {
+        taskStatus = statusMatch[1].trim();
+      }
+    } catch (error) {
+      isTaskInstalled = false;
+    }
+    const daemonState = await readDaemonState();
+    let mode;
+    if (isTaskInstalled) {
+      mode = "task";
+    } else if (daemonState?.pid) {
+      mode = "autostart";
+    } else {
+      mode = "none";
+    }
+    console.log(chalk.white.bold("Configuration:"));
+    if (mode === "task") {
+      console.log(chalk.green("  \u2713 Task Scheduler: Installed"));
+      console.log(chalk.dim(`    Task Status: ${taskStatus}`));
+      console.log(chalk.dim("    Runs automatically at login"));
+    } else {
+      console.log(chalk.dim("  \u25CB Task Scheduler: Not installed"));
+      console.log(chalk.dim("    Using auto-start mode (starts with zenflo command)"));
+    }
+    console.log("");
+    console.log(chalk.white.bold("Daemon Status:"));
+    if (daemonState?.pid) {
+      console.log(chalk.green("  \u2713 Running"));
+      console.log(chalk.dim(`    PID: ${daemonState.pid}`));
+      if (daemonState.httpPort) {
+        console.log(chalk.dim(`    Port: ${daemonState.httpPort}`));
+      }
+      if (daemonState.startTime) {
+        const uptime = Math.floor((Date.now() - new Date(daemonState.startTime).getTime()) / 1e3 / 60);
+        console.log(chalk.dim(`    Uptime: ${uptime} minutes`));
+      }
+    } else {
+      console.log(chalk.yellow("  \u25CB Not running"));
+      console.log(chalk.dim("    Start with: zenflo"));
+    }
+    console.log("");
+    console.log(chalk.white.bold("Available Commands:"));
+    if (mode === "task") {
+      console.log(chalk.dim("  \u2022 View in Task Scheduler: ") + chalk.white("taskschd.msc"));
+      console.log(chalk.dim("  \u2022 Stop task: ") + chalk.white(`schtasks /End /TN "${TASK_NAME}"`));
+      console.log(chalk.dim("  \u2022 Start task: ") + chalk.white(`schtasks /Run /TN "${TASK_NAME}"`));
+      console.log(chalk.dim("  \u2022 Uninstall: ") + chalk.white("zenflo daemon uninstall"));
+    } else {
+      console.log(chalk.dim("  \u2022 Install as task: ") + chalk.white("zenflo daemon install"));
+      console.log(chalk.dim("  \u2022 Start daemon: ") + chalk.white("zenflo"));
+    }
+    console.log("");
+  } catch (error) {
+    console.error(chalk.red("\u274C Status check failed:"), error instanceof Error ? error.message : error);
+    logger.debug("Failed to check daemon status:", error);
+    throw error;
+  }
+}
+
+export { status };

package/dist/status-DVIDR-sx.mjs

@@ -0,0 +1,99 @@
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { r as readDaemonState, l as logger } from './types-CTT5Uja5.mjs';
+import os from 'os';
+import path from 'path';
+import chalk from 'chalk';
+import 'axios';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:fs/promises';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'node:events';
+import 'socket.io-client';
+import 'util';
+import 'fs/promises';
+import 'crypto';
+import 'url';
+import 'expo-server-sdk';
+
+const SERVICE_NAME = "zenflo-daemon";
+const SYSTEMD_USER_DIR = path.join(os.homedir(), ".config", "systemd", "user");
+const SERVICE_FILE = path.join(SYSTEMD_USER_DIR, `${SERVICE_NAME}.service`);
+async function status() {
+  try {
+    console.log(chalk.cyan.bold("\u{1F50D} ZenFlo Daemon Status\n"));
+    const isServiceInstalled = existsSync(SERVICE_FILE);
+    let serviceStatus = "Unknown";
+    let isServiceRunning = false;
+    if (isServiceInstalled) {
+      try {
+        const output = execSync(`systemctl --user is-active ${SERVICE_NAME}`, {
+          encoding: "utf-8",
+          stdio: "pipe"
+        }).trim();
+        serviceStatus = output;
+        isServiceRunning = output === "active";
+      } catch (error) {
+        serviceStatus = "inactive";
+      }
+    }
+    const daemonState = await readDaemonState();
+    let mode;
+    if (isServiceInstalled) {
+      mode = "systemd";
+    } else if (daemonState?.pid) {
+      mode = "autostart";
+    } else {
+      mode = "none";
+    }
+    console.log(chalk.white.bold("Configuration:"));
+    if (mode === "systemd") {
+      console.log(chalk.green("  \u2713 systemd Service: Installed"));
+      console.log(chalk.dim(`    Service Status: ${serviceStatus}`));
+      console.log(chalk.dim("    Runs automatically at login"));
+    } else {
+      console.log(chalk.dim("  \u25CB systemd Service: Not installed"));
+      console.log(chalk.dim("    Using auto-start mode (starts with zenflo command)"));
+    }
+    console.log("");
+    console.log(chalk.white.bold("Daemon Status:"));
+    if (daemonState?.pid) {
+      console.log(chalk.green("  \u2713 Running"));
+      console.log(chalk.dim(`    PID: ${daemonState.pid}`));
+      if (daemonState.httpPort) {
+        console.log(chalk.dim(`    Port: ${daemonState.httpPort}`));
+      }
+      if (daemonState.startTime) {
+        const uptime = Math.floor((Date.now() - new Date(daemonState.startTime).getTime()) / 1e3 / 60);
+        console.log(chalk.dim(`    Uptime: ${uptime} minutes`));
+      }
+    } else {
+      console.log(chalk.yellow("  \u25CB Not running"));
+      console.log(chalk.dim("    Start with: zenflo"));
+    }
+    console.log("");
+    console.log(chalk.white.bold("Available Commands:"));
+    if (mode === "systemd") {
+      console.log(chalk.dim("  \u2022 Check service: ") + chalk.white(`systemctl --user status ${SERVICE_NAME}`));
+      console.log(chalk.dim("  \u2022 View logs: ") + chalk.white(`journalctl --user -u ${SERVICE_NAME} -f`));
+      console.log(chalk.dim("  \u2022 Stop service: ") + chalk.white(`systemctl --user stop ${SERVICE_NAME}`));
+      console.log(chalk.dim("  \u2022 Start service: ") + chalk.white(`systemctl --user start ${SERVICE_NAME}`));
+      console.log(chalk.dim("  \u2022 Restart: ") + chalk.white(`systemctl --user restart ${SERVICE_NAME}`));
+      console.log(chalk.dim("  \u2022 Uninstall: ") + chalk.white("zenflo daemon uninstall"));
+    } else {
+      console.log(chalk.dim("  \u2022 Install as service: ") + chalk.white("zenflo daemon install"));
+      console.log(chalk.dim("  \u2022 Start daemon: ") + chalk.white("zenflo"));
+    }
+    console.log("");
+  } catch (error) {
+    console.error(chalk.red("\u274C Status check failed:"), error instanceof Error ? error.message : error);
+    logger.debug("Failed to check daemon status:", error);
+    throw error;
+  }
+}
+
+export { status };

package/dist/status-QtPjWqoQ.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+var fs = require('fs');
+var child_process = require('child_process');
+var os = require('os');
+var path = require('path');
+var chalk = require('chalk');
+var types = require('./types-BNjAQcO4.cjs');
+require('axios');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('node:fs/promises');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('node:events');
+require('socket.io-client');
+require('util');
+require('fs/promises');
+require('crypto');
+require('url');
+require('expo-server-sdk');
+
+const PLIST_LABEL = "com.zenflo.daemon";
+const LAUNCH_AGENTS_DIR = path.join(os.homedir(), "Library", "LaunchAgents");
+const PLIST_FILE = path.join(LAUNCH_AGENTS_DIR, `${PLIST_LABEL}.plist`);
+async function status() {
+  console.log(chalk.cyan.bold("\u{1F4CA} ZenFlo Daemon Status\n"));
+  const isLaunchAgentInstalled = fs.existsSync(PLIST_FILE);
+  let isLaunchAgentLoaded = false;
+  if (isLaunchAgentInstalled) {
+    try {
+      const output = child_process.execSync("launchctl list", { encoding: "utf-8" });
+      isLaunchAgentLoaded = output.includes(PLIST_LABEL);
+    } catch (error) {
+    }
+  }
+  const daemonState = await types.readDaemonState();
+  const isDaemonRunning = daemonState !== null;
+  let mode;
+  if (isLaunchAgentInstalled && isLaunchAgentLoaded) {
+    mode = "launchagent";
+  } else if (isDaemonRunning) {
+    mode = "autostart";
+  } else {
+    mode = "none";
+  }
+  if (mode === "launchagent") {
+    console.log(chalk.green("\u2705 LaunchAgent Mode") + chalk.dim(" (installed & loaded)\n"));
+    console.log(chalk.cyan("Configuration:"));
+    console.log(chalk.dim("  \u2022 Mode: ") + chalk.white("LaunchAgent"));
+    console.log(chalk.dim("  \u2022 Location: ") + chalk.white(PLIST_FILE));
+    console.log(chalk.dim("  \u2022 Auto-start: ") + chalk.green("Yes") + chalk.dim(" (at login)"));
+    console.log(chalk.dim("  \u2022 System integration: ") + chalk.green("Enabled"));
+    if (isDaemonRunning && daemonState) {
+      console.log(chalk.dim("  \u2022 Status: ") + chalk.green("Running"));
+      console.log(chalk.dim("  \u2022 PID: ") + chalk.white(daemonState.pid.toString()));
+      console.log(chalk.dim("  \u2022 HTTP Port: ") + chalk.white(daemonState.httpPort.toString()));
+      console.log(chalk.dim("  \u2022 Started: ") + chalk.white(daemonState.startTime));
+      if (daemonState.lastHeartbeat) {
+        console.log(chalk.dim("  \u2022 Last heartbeat: ") + chalk.white(daemonState.lastHeartbeat));
+      }
+    } else {
+      console.log(chalk.dim("  \u2022 Status: ") + chalk.yellow("Not running"));
+    }
+  } else if (mode === "autostart") {
+    console.log(chalk.green("\u2705 Auto-Start Mode") + chalk.dim(" (default)\n"));
+    console.log(chalk.cyan("Configuration:"));
+    console.log(chalk.dim("  \u2022 Mode: ") + chalk.white("Auto-Start"));
+    console.log(chalk.dim("  \u2022 Auto-start: ") + chalk.green("Yes") + chalk.dim(" (when running zenflo)"));
+    console.log(chalk.dim("  \u2022 System integration: ") + chalk.yellow("Limited"));
+    if (daemonState) {
+      console.log(chalk.dim("  \u2022 Status: ") + chalk.green("Running"));
+      console.log(chalk.dim("  \u2022 PID: ") + chalk.white(daemonState.pid.toString()));
+      console.log(chalk.dim("  \u2022 HTTP Port: ") + chalk.white(daemonState.httpPort.toString()));
+      console.log(chalk.dim("  \u2022 Started: ") + chalk.white(daemonState.startTime));
+      if (daemonState.lastHeartbeat) {
+        console.log(chalk.dim("  \u2022 Last heartbeat: ") + chalk.white(daemonState.lastHeartbeat));
+      }
+    }
+  } else {
+    console.log(chalk.yellow("\u26A0\uFE0F  Daemon Not Running\n"));
+    console.log(chalk.cyan("Configuration:"));
+    console.log(chalk.dim("  \u2022 LaunchAgent: ") + chalk.red("Not installed"));
+    console.log(chalk.dim("  \u2022 Daemon: ") + chalk.red("Not running"));
+    console.log(chalk.dim("  \u2022 Mode: ") + chalk.white("Auto-Start") + chalk.dim(" (will start when you run zenflo)"));
+  }
+  console.log("\n" + chalk.cyan("Available Commands:"));
+  if (mode === "launchagent") {
+    console.log(chalk.dim("  \u2022 Uninstall: ") + chalk.white("zenflo daemon uninstall"));
+    console.log(chalk.dim("  \u2022 Stop daemon: ") + chalk.white("zenflo daemon stop"));
+    console.log(chalk.dim("  \u2022 View logs: ") + chalk.white("tail -f ~/.zenflo/daemon.log"));
+  } else if (mode === "autostart") {
+    console.log(chalk.dim("  \u2022 Install LaunchAgent: ") + chalk.white("zenflo daemon install"));
+    console.log(chalk.dim("  \u2022 Stop daemon: ") + chalk.white("zenflo daemon stop"));
+    console.log(chalk.dim("  \u2022 View logs: ") + chalk.white("tail -f ~/.zenflo/daemon.log"));
+  } else {
+    console.log(chalk.dim("  \u2022 Install LaunchAgent: ") + chalk.white("zenflo daemon install"));
+    console.log(chalk.dim("  \u2022 Start daemon manually: ") + chalk.white("zenflo daemon start"));
+    console.log(chalk.dim("  \u2022 Run ZenFlo: ") + chalk.white("zenflo"));
+  }
+  console.log("");
+}
+
+exports.status = status;

package/dist/{types-Dvhor4zW.cjs → types-BNjAQcO4.cjs}

@@ -42,7 +42,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "zenflo";
-var version = "0.11.7";
+var version = "0.11.9";
 var description = "Mobile and Web client for Claude Code and Codex - ZenFlo edition";
 var author = "Combined Memory";
 var license = "MIT";
@@ -1019,7 +1019,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-Dvhor4zW.cjs', document.baseURI).href))));
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-BNjAQcO4.cjs', document.baseURI).href))));
 function projectPath() {
   const path$1 = path.resolve(__dirname$1, "..");
   return path$1;

package/dist/{types-DJhJK2jD.mjs → types-CTT5Uja5.mjs}

@@ -21,7 +21,7 @@ import { platform } from 'os';
 import { Expo } from 'expo-server-sdk';
 
 var name = "zenflo";
-var version = "0.11.7";
+var version = "0.11.9";
 var description = "Mobile and Web client for Claude Code and Codex - ZenFlo edition";
 var author = "Combined Memory";
 var license = "MIT";
@@ -2182,4 +2182,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, packageJson as b, configuration as c, backoff as d, delay as e, AsyncLock as f, readDaemonState as g, clearDaemonState as h, readCredentials as i, encodeBase64 as j, encodeBase64Url as k, logger as l, decodeBase64 as m, writeCredentialsDataKey as n, acquireDaemonLock as o, projectPath as p, writeDaemonState as q, readSettings as r, releaseDaemonLock as s, clearCredentials as t, updateSettings as u, clearMachineId as v, writeCredentialsLegacy as w, getLatestDaemonLog as x };
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, readSettings as b, configuration as c, packageJson as d, backoff as e, delay as f, AsyncLock as g, clearDaemonState as h, readCredentials as i, encodeBase64 as j, encodeBase64Url as k, logger as l, decodeBase64 as m, writeCredentialsDataKey as n, acquireDaemonLock as o, projectPath as p, writeDaemonState as q, readDaemonState as r, releaseDaemonLock as s, clearCredentials as t, updateSettings as u, clearMachineId as v, writeCredentialsLegacy as w, getLatestDaemonLog as x };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenflo",
-  "version": "0.11.7",
+  "version": "0.11.9",
   "description": "Mobile and Web client for Claude Code and Codex - ZenFlo edition",
   "author": "Combined Memory",
   "license": "MIT",

package/scripts/ccr_launcher.cjs

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+// CCR launcher for ZenFlo
+// This script wraps ccr code to work within ZenFlo's session management
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+// Disable autoupdater
+process.env.DISABLE_AUTOUPDATER = '1';
+
+// Debug helper
+const DEBUG = process.env.DEBUG === '1' || process.env.DEBUG === 'true';
+function debug(...args) {
+    if (DEBUG) {
+        console.error(...args);
+    }
+}
+
+// Helper to write JSON messages to fd 3
+function writeMessage(message) {
+    try {
+        fs.writeSync(3, JSON.stringify(message) + '\n');
+    } catch (err) {
+        // fd 3 not available, ignore
+    }
+}
+
+// Check if being called from zenflo
+let isCalledFromZenflo = false;
+try {
+    fs.writeSync(3, '');
+    isCalledFromZenflo = true;
+} catch (err) {
+    isCalledFromZenflo = false;
+}
+
+// Track session IDs
+const capturedSessionIds = new Set();
+let daemonNotified = false;
+let sessionWatcher = null;
+
+// Helper to get project path
+function getProjectPath(workingDirectory) {
+    const { join, resolve } = require('path');
+    const { homedir } = require('os');
+
+    const projectId = resolve(workingDirectory).replace(/[\\\/\.:]/g, '-');
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+
+    return join(claudeConfigDir, 'projects', projectId);
+}
+
+// Helper to notify daemon about session
+async function notifyDaemon(sessionId) {
+    if (daemonNotified || capturedSessionIds.has(sessionId)) {
+        return;
+    }
+    capturedSessionIds.add(sessionId);
+
+    try {
+        const { readFileSync } = require('fs');
+        const { homedir } = require('os');
+
+        const daemonStatePath = path.join(
+            process.env.ZENFLO_HOME_DIR || path.join(homedir(), '.happy'),
+            'daemon.state.json'
+        );
+
+        let daemonState;
+        try {
+            daemonState = JSON.parse(readFileSync(daemonStatePath, 'utf8'));
+        } catch (err) {
+            return;
+        }
+
+        if (!daemonState.httpPort) {
+            return;
+        }
+
+        const metadata = {
+            path: process.cwd(),
+            host: require('os').hostname(),
+            hostPid: process.pid,
+            startedBy: 'zenflo-cli',
+            flavor: 'ccr'  // Mark this session as CCR flavor
+        };
+
+        const response = await fetch(`http://127.0.0.1:${daemonState.httpPort}/session-started`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ sessionId, metadata })
+        });
+
+        if (response.ok) {
+            daemonNotified = true;
+        }
+    } catch (err) {
+        // Ignore errors
+    }
+}
+
+// Handle detected session
+function handleSessionFile(sessionId) {
+    if (capturedSessionIds.has(sessionId)) {
+        return;
+    }
+    capturedSessionIds.add(sessionId);
+
+    if (isCalledFromZenflo) {
+        writeMessage({ type: 'uuid', value: sessionId });
+    }
+
+    if (!isCalledFromZenflo) {
+        notifyDaemon(sessionId).catch(() => {});
+    }
+}
+
+// Start session file watcher
+function startSessionWatcher() {
+    const { watch, mkdirSync } = require('fs');
+
+    try {
+        const cwd = process.cwd();
+        const projectDir = getProjectPath(cwd);
+        mkdirSync(projectDir, { recursive: true});
+
+        debug('[ccr-launcher] Working directory:', cwd);
+        debug('[ccr-launcher] Watching for sessions in:', projectDir);
+        debug('[ccr-launcher] Called from zenflo:', isCalledFromZenflo);
+
+        sessionWatcher = watch(projectDir, (eventType, filename) => {
+            if (typeof filename === 'string' && filename.toLowerCase().endsWith('.jsonl')) {
+                const sessionId = filename.replace('.jsonl', '');
+
+                if (eventType === 'change') {
+                    debug('[ccr-launcher] Active session detected:', sessionId);
+                    handleSessionFile(sessionId);
+                }
+            }
+        });
+    } catch (err) {
+        console.error('[ccr-launcher] Error starting session watcher:', err.message);
+    }
+}
+
+// Start watching
+startSessionWatcher();
+
+// Intercept crypto.randomUUID
+const originalRandomUUID = crypto.randomUUID;
+Object.defineProperty(global, 'crypto', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return {
+            randomUUID: () => {
+                const uuid = originalRandomUUID();
+                writeMessage({ type: 'uuid', value: uuid });
+                return uuid;
+            }
+        };
+    }
+});
+Object.defineProperty(crypto, 'randomUUID', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        return () => {
+            const uuid = originalRandomUUID();
+            writeMessage({ type: 'uuid', value: uuid });
+            return uuid;
+        }
+    }
+});
+
+// Intercept fetch to track activity
+const originalFetch = global.fetch;
+let fetchCounter = 0;
+
+global.fetch = function(...args) {
+    const id = ++fetchCounter;
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    const method = args[1]?.method || 'GET';
+
+    let hostname = '';
+    let pathname = '';
+    try {
+        const urlObj = new URL(url, 'http://localhost');
+        hostname = urlObj.hostname;
+        pathname = urlObj.pathname;
+    } catch (e) {
+        hostname = 'unknown';
+        pathname = url;
+    }
+
+    writeMessage({
+        type: 'fetch-start',
+        id,
+        hostname,
+        path: pathname,
+        method,
+        timestamp: Date.now()
+    });
+
+    const fetchPromise = originalFetch(...args);
+
+    const sendEnd = () => {
+        writeMessage({
+            type: 'fetch-end',
+            id,
+            timestamp: Date.now()
+        });
+    };
+
+    fetchPromise.then(sendEnd, sendEnd);
+
+    return fetchPromise;
+};
+
+Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
+Object.defineProperty(global.fetch, 'length', { value: originalFetch.length });
+
+if (!isCalledFromZenflo) {
+    // Start zenflo daemon in background
+    const scriptDir = __dirname;
+    const cliDir = path.resolve(scriptDir, '..');
+    const zenfloBin = path.resolve(cliDir, 'bin', 'zenflo.mjs');
+
+    try {
+        const daemonProcess = spawn(process.execPath, [zenfloBin, 'daemon', 'start'], {
+            detached: true,
+            stdio: 'ignore'
+        });
+        daemonProcess.unref();
+        setTimeout(() => {}, 500);
+    } catch (err) {
+        // Ignore errors
+    }
+}
+
+// Check if CCR is available
+try {
+    execSync('which ccr', { encoding: 'utf8', stdio: 'pipe' });
+} catch (err) {
+    console.error('❌ Claude Code Router (ccr) not found!');
+    console.error('');
+    console.error('Please install CCR first:');
+    console.error('  npm install -g @musistudio/claude-code-router');
+    console.error('');
+    console.error('Or use the local installation at:');
+    console.error('  /Users/quinnmay/claude-code-router/ccr-claude');
+    process.exit(1);
+}
+
+// Check if CCR is running
+try {
+    const status = execSync('ccr status', { encoding: 'utf8', stdio: 'pipe' });
+    if (!status.includes('Running')) {
+        debug('[ccr-launcher] Starting CCR service...');
+        execSync('ccr start', { stdio: 'ignore' });
+        // Give it a moment to start
+        const start = Date.now();
+        while (Date.now() - start < 5000) {
+            try {
+                const check = execSync('ccr status', { encoding: 'utf8', stdio: 'pipe' });
+                if (check.includes('Running')) {
+                    break;
+                }
+            } catch (e) {
+                // Keep waiting
+            }
+            // Sleep for 100ms
+            execSync('sleep 0.1', { stdio: 'ignore' });
+        }
+    }
+} catch (err) {
+    console.error('[ccr-launcher] Failed to start CCR:', err.message);
+    process.exit(1);
+}
+
+// Set environment to route through CCR
+process.env.ANTHROPIC_BASE_URL = 'http://localhost:3456';
+process.env.ANTHROPIC_API_KEY = 'ccr-proxy-key';
+
+debug('[ccr-launcher] CCR is running, launching Claude Code...');
+debug('[ccr-launcher] ANTHROPIC_BASE_URL:', process.env.ANTHROPIC_BASE_URL);
+
+// Find Claude Code binary
+let claudeCodePath;
+try {
+    const claudePath = execSync('which claude', { encoding: 'utf8', stdio: 'pipe' }).trim();
+    claudeCodePath = fs.realpathSync(claudePath);
+} catch (err) {
+    console.error('Failed to find Claude Code CLI');
+    console.error('Make sure claude is installed: npm install -g @anthropic-ai/claude-code');
+    process.exit(1);
+}
+
+// Load Claude Code
+try {
+    debug('[ccr-launcher] Loading Claude Code from:', claudeCodePath);
+    require(claudeCodePath);
+} catch (err) {
+    console.error('Failed to load Claude Code CLI:', err.message);
+    process.exit(1);
+}

package/scripts/unpack-tools.cjs

@@ -17,17 +17,18 @@ const os = require('os');
 function getPlatformDir() {
     const platform = os.platform();
     const arch = os.arch();
-    
+
     if (platform === 'darwin') {
         if (arch === 'arm64') return 'arm64-darwin';
         if (arch === 'x64') return 'x64-darwin';
-    } else if (platform === 'linux') {
+    } else if (platform === 'linux' || platform === 'android') {
+        // Android uses Linux binaries
         if (arch === 'arm64') return 'arm64-linux';
         if (arch === 'x64') return 'x64-linux';
     } else if (platform === 'win32') {
         if (arch === 'x64') return 'x64-win32';
     }
-    
+
     throw new Error(`Unsupported platform: ${arch}-${platform}`);
 }