upfynai-code 2.3.0 → 2.4.1

package/server/cli.js

@@ -6,9 +6,10 @@
  * Visual AI coding interface with Upfyn-Canvas for AI coding assistants
  *
  * Commands:
- *   (no args)     - Start the server (default)
+ *   (no args)     - Launch Claude Code with Upfyn branding (default)
  *   start         - Start the server
  *   connect       - Connect to hosted server (relay bridge)
+ *   config        - View/set configuration (API key, server, etc.)
  *   status        - Show configuration and data locations
  *   help          - Show help information
  *   version       - Show version information
@@ -19,6 +20,7 @@ import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { execSync, spawn } from 'child_process';
 import {
     c,
     showStyledHelp,
@@ -26,8 +28,12 @@ import {
     showServerBanner,
     showConnectStartup,
     showConnectionBanner,
+    showLaunchScreen,
+    showConfig,
     logRelayEvent,
     createSpinner,
+    playRocketAnimation,
+    clearScreen,
 } from './cli-ui.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -37,6 +43,9 @@ const __dirname = dirname(__filename);
 const packageJsonPath = path.join(__dirname, '../package.json');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
 
+const CONFIG_DIR = path.join(os.homedir(), '.upfynai');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
 // Load environment variables from .env file if it exists
 function loadEnvFile() {
     try {
@@ -56,6 +65,26 @@ function loadEnvFile() {
     }
 }
 
+// Load saved config from ~/.upfynai/config.json
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        }
+    } catch (e) { /* ignore */ }
+    return {};
+}
+
+// Save config to ~/.upfynai/config.json
+function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // Don't save internal keys
+    const { _path, ...rest } = config;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(rest, null, 2));
+}
+
 // Get the database path (same logic as db.js)
 function getDatabasePath() {
     loadEnvFile();
@@ -67,8 +96,29 @@ function getInstallDir() {
     return path.join(__dirname, '..');
 }
 
-// Show status command — styled
+// --- OS Detection + Claude Binary Discovery ---
+
+function findClaudeBinary() {
+    const isWindows = process.platform === 'win32';
+    const candidates = isWindows
+        ? ['claude.exe', 'claude.cmd', 'claude']
+        : ['claude'];
+
+    for (const cmd of candidates) {
+        try {
+            const whichCmd = isWindows ? 'where' : 'which';
+            const result = execSync(`${whichCmd} ${cmd}`, { stdio: 'pipe', encoding: 'utf8' }).trim();
+            if (result) return cmd;
+        } catch {
+            // not found, try next
+        }
+    }
+    return null;
+}
+
+// --- Show status command ---
 function showStatus() {
+    const config = loadConfig();
     const installDir = getInstallDir();
     const dbPath = getDatabasePath();
     const dbExists = fs.existsSync(dbPath);
@@ -86,11 +136,12 @@ function showStatus() {
         dbSize,
         port: process.env.PORT || '3001',
         portDefault: !process.env.PORT,
-        claudeCli: process.env.CLAUDE_CLI_PATH || null,
+        claudeCli: findClaudeBinary() || null,
+        apiKey: config.anthropicApiKey || null,
     });
 }
 
-// Show help — styled
+// Show help
 function showHelp() {
     showStyledHelp(packageJson.version);
 }
@@ -114,18 +165,17 @@ function isNewerVersion(v1, v2) {
 // Check for updates
 async function checkForUpdates(silent = false) {
     try {
-        const { execSync } = await import('child_process');
         const latestVersion = execSync('npm show upfynai-code version', { encoding: 'utf8' }).trim();
         const currentVersion = packageJson.version;
 
         if (isNewerVersion(latestVersion, currentVersion)) {
             if (!silent) {
-                console.log(`\n  ${c.yellow('⬆')} New version available: ${c.bBright(latestVersion)} ${c.dim(`(current: ${currentVersion})`)}`);
+                console.log(`\n  ${c.yellow('!')} New version available: ${c.bBright(latestVersion)} ${c.dim(`(current: ${currentVersion})`)}`);
                 console.log(`    Run ${c.bright('uc update')} to update\n`);
             }
             return { hasUpdate: true, latestVersion, currentVersion };
         } else if (!silent) {
-            console.log(`  ${c.green('✓')} You are on the latest version (${currentVersion})`);
+            console.log(`  ${c.green('OK')} You are on the latest version (${currentVersion})`);
         }
         return { hasUpdate: false, latestVersion, currentVersion };
     } catch (e) {
@@ -139,7 +189,6 @@ async function checkForUpdates(silent = false) {
 // Update the package
 async function updatePackage() {
     try {
-        const { execSync } = await import('child_process');
         const spinner = createSpinner('Checking for updates...');
         spinner.start();
 
@@ -148,20 +197,20 @@ async function updatePackage() {
             spinner.stop(`Already on the latest version (${currentVersion})`);
             return;
         }
-        spinner.stop(`Update available: ${currentVersion} → ${latestVersion}`);
+        spinner.stop(`Update available: ${currentVersion} -> ${latestVersion}`);
 
         const installSpinner = createSpinner(`Updating to v${latestVersion}...`);
         installSpinner.start();
         execSync('npm update -g upfynai-code', { stdio: 'pipe' });
         installSpinner.stop(`Updated to v${latestVersion}! Restart uc to use the new version.`);
     } catch (e) {
-        console.log(`  ${c.red('✗')} Update failed: ${e.message}`);
+        console.log(`  ${c.red('FAIL')} Update failed: ${e.message}`);
         console.log(`  ${c.dim('Try running manually:')} ${c.bright('npm update -g upfynai-code')}`);
     }
 }
 
 // Install slash commands to ~/.claude/commands/
-async function installCommands() {
+async function installCommands(silent = false) {
     const commandsSource = path.join(__dirname, '..', 'commands');
     const commandsDest = path.join(os.homedir(), '.claude', 'commands');
 
@@ -170,8 +219,8 @@ async function installCommands() {
     }
 
     if (!fs.existsSync(commandsSource)) {
-        console.log(`  ${c.red('✗')} Commands directory not found`);
-        process.exit(1);
+        if (!silent) console.log(`  ${c.red('FAIL')} Commands directory not found`);
+        return 0;
     }
 
     const files = fs.readdirSync(commandsSource).filter(f => f.endsWith('.md'));
@@ -182,12 +231,17 @@ async function installCommands() {
             path.join(commandsSource, file),
             path.join(commandsDest, file)
         );
-        console.log(`  ${c.green('✓')} Installed ${c.violet('/' + file.replace('.md', ''))}`);
+        if (!silent) {
+            console.log(`  ${c.green('OK')} Installed ${c.violet('/' + file.replace('.md', ''))}`);
+        }
         count++;
     }
 
-    console.log(`\n  ${c.bBright(`${count} slash commands installed!`)}`);
-    console.log(`  ${c.dim('Available in your AI CLI as /upfynai-*')}\n`);
+    if (!silent) {
+        console.log(`\n  ${c.bBright(`${count} slash commands installed!`)}`);
+        console.log(`  ${c.dim('Available in your AI CLI as /upfynai-*')}\n`);
+    }
+    return count;
 }
 
 // Remove slash commands from ~/.claude/commands/
@@ -204,28 +258,189 @@ async function uninstallCommands() {
 
     for (const file of files) {
         fs.unlinkSync(path.join(commandsDest, file));
-        console.log(`  ${c.green('✓')} Removed ${c.violet('/' + file.replace('.md', ''))}`);
+        console.log(`  ${c.green('OK')} Removed ${c.violet('/' + file.replace('.md', ''))}`);
     }
 
     console.log(`\n  ${c.bBright(`${files.length} slash commands removed.`)}\n`);
 }
 
-// Start the server
+// --- Config command ---
+function handleConfig(options) {
+    const config = loadConfig();
+
+    if (options.apiKey) {
+        // Set API key
+        config.anthropicApiKey = options.apiKey;
+        saveConfig(config);
+        console.log(`\n  ${c.green('OK')} ${c.white('Anthropic API key saved')}`);
+        console.log(`  ${c.dim('Key:')} sk-ant-...${options.apiKey.slice(-4)}`);
+        console.log(`  ${c.dim('Stored in:')} ${CONFIG_FILE}\n`);
+        return;
+    }
+
+    if (options.clearApiKey) {
+        delete config.anthropicApiKey;
+        saveConfig(config);
+        console.log(`\n  ${c.green('OK')} ${c.white('Anthropic API key removed')}\n`);
+        return;
+    }
+
+    // Show current config
+    showConfig({ ...config, _path: CONFIG_FILE });
+}
+
+// --- Launch Interactive (default command) ---
+async function launchInteractive() {
+    // 1. Play rocket animation
+    await playRocketAnimation();
+    clearScreen();
+
+    // 2. Ensure slash commands are installed (silent)
+    await installCommands(true);
+
+    // 3. Find Claude Code binary
+    const claudeBin = findClaudeBinary();
+
+    // 4. Load config for relay + API key
+    const config = loadConfig();
+
+    // 5. Show launch screen
+    showLaunchScreen(packageJson.version, claudeBin, {
+        relayStatus: config.relayKey && config.server
+            ? `Auto-connecting to ${config.server}`
+            : null,
+        apiKey: config.anthropicApiKey || null,
+    });
+
+    // 6. If Claude Code not found, fall back to server mode
+    if (!claudeBin) {
+        console.log(`  ${c.dim('Falling back to server mode...')}\n`);
+        await startServer();
+        return;
+    }
+
+    // 7. Build environment for Claude Code
+    const childEnv = { ...process.env };
+    if (config.anthropicApiKey) {
+        childEnv.ANTHROPIC_API_KEY = config.anthropicApiKey;
+    }
+
+    // 8. Start the local web UI server in the background
+    const port = process.env.PORT || '3001';
+    process.env.VITE_IS_PLATFORM = 'true'; // local mode
+    startBackgroundServer(port);
+
+    // 9. Start background relay if config exists (for cloud mode)
+    if (config.relayKey && config.server) {
+        startBackgroundRelay(config);
+    }
+
+    // 10. Spawn Claude Code interactively
+    const child = spawn(claudeBin, [], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        shell: true,
+        env: childEnv,
+    });
+
+    child.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+
+    child.on('error', (err) => {
+        console.log(`\n  ${c.red('FAIL')} Failed to launch Claude Code: ${err.message}`);
+        console.log(`  ${c.dim('Make sure Claude Code is installed:')}`);
+        console.log(`    ${c.bright('npm install -g @anthropic-ai/claude-code')}\n`);
+        process.exit(1);
+    });
+}
+
+// --- Background server for local mode ---
+function startBackgroundServer(port) {
+    // Start the server in the background so the web UI is available
+    import('./index.js').then(() => {
+        // Server started successfully in background
+    }).catch(() => {
+        // Server failed to start — user still has Claude Code CLI
+    });
+
+    // Open browser after a short delay
+    setTimeout(() => {
+        const url = `http://localhost:${port}`;
+        try {
+            const openCmd = process.platform === 'win32' ? 'start'
+                : process.platform === 'darwin' ? 'open'
+                : 'xdg-open';
+            execSync(`${openCmd} ${url}`, { stdio: 'ignore' });
+        } catch {
+            // Browser open failed — not critical
+        }
+    }, 2000);
+}
+
+// --- Background relay connection ---
+function startBackgroundRelay(config) {
+    // Import and start relay in background (non-blocking)
+    import('./relay-client.js').then(({ connectToServerBackground }) => {
+        if (typeof connectToServerBackground === 'function') {
+            connectToServerBackground({
+                server: config.server,
+                key: config.relayKey,
+                silent: true,
+            });
+        }
+    }).catch(() => {
+        // Relay module not available or no background connect — that's ok
+    });
+}
+
+// Start the server (self-hosted local mode)
 async function startServer() {
     // Check for updates silently on startup
     checkForUpdates(true);
 
-    // Show server banner
     const port = process.env.PORT || '3001';
+
+    // Auto-detect local mode — set IS_PLATFORM flag
+    if (!process.env.RAILWAY_ENVIRONMENT && !process.env.VERCEL && !process.env.FORCE_HOSTED_MODE) {
+        process.env.VITE_IS_PLATFORM = 'true';
+    }
+
+    // Show server banner
     showServerBanner(port, packageJson.version);
 
+    // Detect local agents
+    const claudeBin = findClaudeBinary();
+    if (claudeBin) {
+        console.log(`  ${c.green('OK')} Claude Code detected: ${c.bright(claudeBin)}`);
+    } else {
+        console.log(`  ${c.yellow('!')} Claude Code not found. Install: ${c.bright('npm i -g @anthropic-ai/claude-code')}`);
+    }
+    console.log('');
+
     // Import and run the server
     await import('./index.js');
+
+    // Auto-open browser after server starts (local mode only)
+    if (!process.env.RAILWAY_ENVIRONMENT && !process.env.VERCEL) {
+        const url = `http://localhost:${port}`;
+        setTimeout(() => {
+            try {
+                const openCmd = process.platform === 'win32' ? 'start'
+                    : process.platform === 'darwin' ? 'open'
+                    : 'xdg-open';
+                execSync(`${openCmd} ${url}`, { stdio: 'ignore' });
+                console.log(`  ${c.green('OK')} Opened ${c.cyan(url)} in browser\n`);
+            } catch {
+                console.log(`  ${c.dim('Open in browser:')} ${c.cyan(url)}\n`);
+            }
+        }, 1500);
+    }
 }
 
 // Parse CLI arguments
 function parseArgs(args) {
-    const parsed = { command: 'start', options: {} };
+    const parsed = { command: null, options: {} };
 
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -246,15 +461,26 @@ function parseArgs(args) {
             parsed.options.key = args[++i];
         } else if (arg.startsWith('--key=')) {
             parsed.options.key = arg.split('=')[1];
+        } else if (arg === '--api-key') {
+            parsed.options.apiKey = args[++i];
+        } else if (arg.startsWith('--api-key=')) {
+            parsed.options.apiKey = arg.split('=')[1];
+        } else if (arg === '--clear-api-key') {
+            parsed.options.clearApiKey = true;
         } else if (arg === '--help' || arg === '-h') {
             parsed.command = 'help';
         } else if (arg === '--version' || arg === '-v') {
             parsed.command = 'version';
-        } else if (!arg.startsWith('-')) {
+        } else if (!arg.startsWith('-') && !parsed.command) {
             parsed.command = arg;
         }
     }
 
+    // Default command: launch interactive
+    if (!parsed.command) {
+        parsed.command = 'launch';
+    }
+
     return parsed;
 }
 
@@ -272,6 +498,9 @@ async function main() {
     }
 
     switch (command) {
+        case 'launch':
+            await launchInteractive();
+            break;
         case 'start':
             await startServer();
             break;
@@ -292,6 +521,9 @@ async function main() {
         case 'update':
             await updatePackage();
             break;
+        case 'config':
+            handleConfig(options);
+            break;
         case 'install-commands':
             await installCommands();
             break;
@@ -307,7 +539,7 @@ async function main() {
             break;
         }
         default:
-            console.error(`\n  ${c.red('✗')} Unknown command: ${command}`);
+            console.error(`\n  ${c.red('FAIL')} Unknown command: ${command}`);
             console.log(`    Run ${c.bright('"uc help"')} for usage information.\n`);
             process.exit(1);
     }
@@ -315,6 +547,6 @@ async function main() {
 
 // Run the CLI
 main().catch(error => {
-    console.error(`\n  ${c.red('✗')} Error: ${error.message}`);
+    console.error(`\n  ${c.red('FAIL')} Error: ${error.message}`);
     process.exit(1);
 });

package/server/constants/config.js

@@ -1,5 +1,31 @@
 /**
- * Environment Flag: Is Platform
- * Indicates if the app is running in Platform mode (hosted) or OSS mode (self-hosted)
+ * Environment Flag: Is Platform (Self-Hosted / Local Mode)
+ *
+ * When true, the app runs in single-user local mode:
+ * - Skips JWT authentication (uses first DB user)
+ * - Claude Code SDK runs directly on the machine
+ * - No relay connection needed
+ *
+ * Auto-detected when:
+ * - VITE_IS_PLATFORM=true is set, OR
+ * - Running locally (not on Railway/Vercel/cloud)
  */
-export const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true';
+const isCloudEnv = !!(
+    process.env.RAILWAY_ENVIRONMENT ||
+    process.env.VERCEL ||
+    process.env.RENDER ||
+    process.env.FLY_APP_NAME ||
+    process.env.HEROKU_APP_NAME
+);
+
+export const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true' || (!isCloudEnv && !process.env.FORCE_HOSTED_MODE);
+
+/**
+ * True when running on a cloud provider (Railway, Vercel, etc.)
+ */
+export const IS_CLOUD = isCloudEnv;
+
+/**
+ * True when running locally (self-hosted mode)
+ */
+export const IS_LOCAL = IS_PLATFORM && !isCloudEnv;