zenflo 0.11.8 → 0.11.10

package/dist/status-DT-lQ5z3.mjs

@@ -0,0 +1,99 @@
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { r as readDaemonState, l as logger } from './types-Kg2WtK0J.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-EIRGrJzv.mjs

@@ -0,0 +1,92 @@
+import { execSync } from 'child_process';
+import { r as readDaemonState, l as logger } from './types-Kg2WtK0J.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-a3Xws-4m.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var child_process = require('child_process');
+var types = require('./types-CVUeTsiC.cjs');
+var chalk = require('chalk');
+require('axios');
+require('fs');
+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('path');
+require('url');
+require('os');
+require('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 = child_process.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 types.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);
+    types.logger.debug("Failed to check daemon status:", error);
+    throw error;
+  }
+}
+
+exports.status = status;

package/dist/{types-uaIx8ab0.cjs → types-CVUeTsiC.cjs}

@@ -42,7 +42,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "zenflo";
-var version = "0.11.8";
+var version = "0.11.10";
 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-uaIx8ab0.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-CVUeTsiC.cjs', document.baseURI).href))));
 function projectPath() {
   const path$1 = path.resolve(__dirname$1, "..");
   return path$1;

package/dist/{types-qQzfAnur.mjs → types-Kg2WtK0J.mjs}

@@ -21,7 +21,7 @@ import { platform } from 'os';
 import { Expo } from 'expo-server-sdk';
 
 var name = "zenflo";
-var version = "0.11.8";
+var version = "0.11.10";
 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.8",
+  "version": "0.11.10",
   "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);
+}