upfynai-code 2.4.0 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upfynai-code",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Upfyn-Code — Visual AI coding interface with Upfyn-Canvas whiteboard for AI coding assistants by Thinqmesh Technologies",
   "type": "module",
   "main": "server/index.js",

package/server/cli.js

@@ -325,12 +325,17 @@ async function launchInteractive() {
         childEnv.ANTHROPIC_API_KEY = config.anthropicApiKey;
     }
 
-    // 8. Start background relay if config exists
+    // 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);
     }
 
-    // 9. Spawn Claude Code interactively
+    // 10. Spawn Claude Code interactively
     const child = spawn(claudeBin, [], {
         stdio: 'inherit',
         cwd: process.cwd(),
@@ -350,6 +355,29 @@ async function launchInteractive() {
     });
 }
 
+// --- 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)
@@ -366,17 +394,48 @@ function startBackgroundRelay(config) {
     });
 }
 
-// Start the server
+// 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

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;

package/server/index.js

@@ -70,9 +70,10 @@ import cliAuthRoutes from './routes/cli-auth.js';
 import userRoutes from './routes/user.js';
 import codexRoutes from './routes/codex.js';
 import paymentRoutes from './routes/payments.js';
-import { initializeDatabase, relayTokensDb, subscriptionDb, credentialsDb } from './database/db.js';
+import { initializeDatabase, relayTokensDb, subscriptionDb, credentialsDb, userDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
-import { IS_PLATFORM } from './constants/config.js';
+import { IS_PLATFORM, IS_LOCAL } from './constants/config.js';
+import { execSync } from 'child_process';
 
 // File system watchers for provider project/session folders
 const PROVIDER_WATCH_PATHS = [
@@ -539,12 +540,70 @@ app.get('/api/relay/status', authenticateToken, (req, res) => {
     });
 });
 
+/**
+ * Detect installed AI CLI agents on the local machine (server-side).
+ * Used in self-hosted/local mode where no relay is needed.
+ */
+let cachedLocalAgents = null;
+let localAgentsCacheTime = 0;
+function detectLocalAgents() {
+    // Cache for 60 seconds
+    if (cachedLocalAgents && Date.now() - localAgentsCacheTime < 60000) {
+        return cachedLocalAgents;
+    }
+    const isWindows = process.platform === 'win32';
+    const whichCmd = isWindows ? 'where' : 'which';
+    const agents = [
+        { name: 'claude', binary: 'claude', label: 'Claude Code' },
+        { name: 'codex', binary: 'codex', label: 'OpenAI Codex' },
+        { name: 'cursor', binary: 'cursor-agent', label: 'Cursor Agent' },
+    ];
+    const detected = {};
+    for (const agent of agents) {
+        try {
+            const result = execSync(`${whichCmd} ${agent.binary}`, { stdio: 'pipe', timeout: 5000 }).toString().trim();
+            detected[agent.name] = { installed: true, path: result.split('\n')[0].trim(), label: agent.label };
+        } catch {
+            detected[agent.name] = { installed: false, label: agent.label };
+        }
+    }
+    cachedLocalAgents = detected;
+    localAgentsCacheTime = Date.now();
+    return detected;
+}
+
 // Connection status — alias at path the frontend expects
 app.get('/api/auth/connection-status', authenticateToken, (req, res) => {
     const relay = relayConnections.get(Number(req.user.id));
+    const connected = !!(relay && relay.ws.readyState === 1);
+
+    // In local mode, always "connected" — SDK runs directly on this machine
+    if (IS_LOCAL) {
+        const agents = detectLocalAgents();
+        return res.json({
+            connected: true,
+            local: true,
+            connectedAt: Date.now(),
+            agents,
+            machine: {
+                hostname: os.hostname(),
+                platform: process.platform,
+                cwd: process.cwd(),
+            }
+        });
+    }
+
     res.json({
-        connected: !!(relay && relay.ws.readyState === 1),
-        connectedAt: relay?.connectedAt || null
+        connected,
+        local: false,
+        connectedAt: relay?.connectedAt || null,
+        agents: connected ? (relay.agents || null) : null,
+        machine: connected ? {
+            hostname: relay.machine,
+            platform: relay.platform,
+            cwd: relay.cwd,
+            version: relay.version,
+        } : null
     });
 });
 
@@ -1128,35 +1187,51 @@ function handleChatConnection(ws, request) {
                 }
                 if (sid) lockedSessionsForThisWs.add(sid);
 
-                console.log('[DEBUG] User message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.projectPath || 'Unknown');
-
-                // BYOK: look up user's Anthropic API key, inject if available
-                const userAnthropicKey = wsUser?.userId
-                    ? await getUserProviderKey(wsUser.userId, 'anthropic_key')
-                    : null;
-
-                await withUserApiKey('ANTHROPIC_API_KEY', userAnthropicKey, () =>
-                    queryClaudeSDK(data.command, data.options, writer)
-                );
+                // Check if user has active relay → route to local machine
+                if (hasActiveRelay(wsUser?.userId)) {
+                    await routeViaRelay(wsUser.userId, 'claude-query', data, writer, {
+                        response: 'claude-response',
+                        complete: 'claude-complete',
+                        error: 'claude-error'
+                    });
+                } else {
+                    // Fall back to server-side SDK
+                    const userAnthropicKey = wsUser?.userId
+                        ? await getUserProviderKey(wsUser.userId, 'anthropic_key')
+                        : null;
+
+                    await withUserApiKey('ANTHROPIC_API_KEY', userAnthropicKey, () =>
+                        queryClaudeSDK(data.command, data.options, writer)
+                    );
+                }
             } else if (data.type === 'cursor-command') {
-                console.log('[DEBUG] Cursor message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.cwd || 'Unknown');
-                console.log('🤖 Model:', data.options?.model || 'default');
-                await spawnCursor(data.command, data.options, writer);
+                // Check if user has active relay → route to local machine
+                if (hasActiveRelay(wsUser?.userId)) {
+                    await routeViaRelay(wsUser.userId, 'cursor-query', data, writer, {
+                        response: 'cursor-response',
+                        complete: 'cursor-complete',
+                        error: 'cursor-error'
+                    });
+                } else {
+                    await spawnCursor(data.command, data.options, writer);
+                }
             } else if (data.type === 'codex-command') {
-                console.log('[DEBUG] Codex message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
-                console.log('🤖 Model:', data.options?.model || 'default');
-
-                // BYOK: look up user's OpenAI API key, inject if available
-                const userOpenaiKey = wsUser?.userId
-                    ? await getUserProviderKey(wsUser.userId, 'openai_key')
-                    : null;
+                // Check if user has active relay → route to local machine
+                if (hasActiveRelay(wsUser?.userId)) {
+                    await routeViaRelay(wsUser.userId, 'codex-query', data, writer, {
+                        response: 'codex-response',
+                        complete: 'codex-complete',
+                        error: 'codex-error'
+                    });
+                } else {
+                    const userOpenaiKey = wsUser?.userId
+                        ? await getUserProviderKey(wsUser.userId, 'openai_key')
+                        : null;
 
-                await withUserApiKey('OPENAI_API_KEY', userOpenaiKey, () =>
-                    queryCodex(data.command, data.options, writer)
-                );
+                    await withUserApiKey('OPENAI_API_KEY', userOpenaiKey, () =>
+                        queryCodex(data.command, data.options, writer)
+                    );
+                }
             } else if (data.type === 'openrouter-command') {
                 console.log('[DEBUG] OpenRouter message:', data.command?.slice(0, 60) || '[empty]');
                 console.log('🤖 Model:', data.options?.model || OPENROUTER_MODELS.DEFAULT);
@@ -1288,12 +1363,20 @@ async function handleRelayConnection(ws, token, request) {
     const userId = Number(tokenData.user_id);
     const username = tokenData.username;
 
-    // Extract optional Anthropic API key from relay handshake headers
+    // Extract optional headers from relay handshake
     const anthropicApiKey = request?.headers?.['x-anthropic-api-key'] || null;
+    const relayVersion = request?.headers?.['x-upfyn-version'] || null;
+    const relayMachine = request?.headers?.['x-upfyn-machine'] || null;
+    const relayPlatform = request?.headers?.['x-upfyn-platform'] || null;
+    const relayCwd = request?.headers?.['x-upfyn-cwd'] || null;
 
     // Store relay connection with API key in memory only (use Number() for consistent Map key type)
     // API key is held per-user in the relay connection, NOT in process.env
-    relayConnections.set(userId, { ws, user: tokenData, connectedAt: Date.now(), anthropicApiKey });
+    relayConnections.set(userId, {
+        ws, user: tokenData, connectedAt: Date.now(), anthropicApiKey,
+        version: relayVersion, machine: relayMachine, platform: relayPlatform, cwd: relayCwd,
+        agents: null // populated when client sends agent-capabilities
+    });
 
     ws.send(JSON.stringify({
         type: 'relay-connected',
@@ -1344,6 +1427,29 @@ async function handleRelayConnection(ws, token, request) {
                 return;
             }
 
+            // Agent capabilities report from relay client
+            if (data.type === 'agent-capabilities') {
+                const relay = relayConnections.get(userId);
+                if (relay) {
+                    relay.agents = data.agents || {};
+                    relay.machine = data.machine || relay.machine;
+                }
+                // Broadcast agent info to browser clients
+                for (const client of connectedClients) {
+                    try {
+                        if (client.readyState === 1) {
+                            client.send(JSON.stringify({
+                                type: 'relay-agents',
+                                userId,
+                                agents: data.agents || {},
+                                machine: data.machine || {}
+                            }));
+                        }
+                    } catch (e) { /* ignore */ }
+                }
+                return;
+            }
+
             // Heartbeat
             if (data.type === 'ping') {
                 ws.send(JSON.stringify({ type: 'pong' }));
@@ -1394,7 +1500,7 @@ function sendRelayCommand(userId, action, payload, onStream = null, timeoutMs =
     return new Promise((resolve, reject) => {
         const relay = relayConnections.get(userId);
         if (!relay || relay.ws.readyState !== 1) {
-            reject(new Error('No relay connection. Run "upfynai-code connect" on your local machine.'));
+            reject(new Error('No relay connection. Run "uc connect" on your local machine.'));
             return;
         }
 
@@ -1415,6 +1521,95 @@ function sendRelayCommand(userId, action, payload, onStream = null, timeoutMs =
     });
 }
 
+/**
+ * Check if a user has an active relay connection
+ */
+function hasActiveRelay(userId) {
+    if (!userId) return false;
+    const relay = relayConnections.get(Number(userId));
+    return relay && relay.ws.readyState === 1;
+}
+
+/**
+ * Route a chat command through the user's relay connection to their local machine.
+ * Translates relay-stream/relay-complete events into the format the frontend expects.
+ *
+ * @param {number} userId - User ID
+ * @param {string} action - Relay action (claude-query, codex-query, cursor-query)
+ * @param {object} data - Original command data from the browser
+ * @param {object} writer - WebSocket writer to send events to browser
+ * @param {object} eventMap - Maps relay stream data types to chat event types
+ */
+async function routeViaRelay(userId, action, data, writer, eventMap = {}) {
+    const sessionId = data.options?.sessionId || `relay-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+    // Send session-created so the frontend can track this query
+    writer.send({ type: 'session-created', sessionId });
+
+    // Determine event types from the provider
+    const responseType = eventMap.response || 'claude-response';
+    const completeType = eventMap.complete || 'claude-complete';
+    const errorType = eventMap.error || 'claude-error';
+
+    let fullContent = '';
+
+    try {
+        const result = await sendRelayCommand(
+            Number(userId),
+            action,
+            {
+                command: data.command,
+                options: data.options || {}
+            },
+            // onStream callback — translates relay events to chat events
+            (streamData) => {
+                if (streamData.type === 'claude-response' || streamData.type === 'codex-response' || streamData.type === 'cursor-response') {
+                    fullContent += streamData.content || '';
+                    writer.send({
+                        type: responseType,
+                        data: {
+                            type: 'assistant',
+                            message: {
+                                type: 'text',
+                                text: streamData.content || ''
+                            }
+                        },
+                        sessionId
+                    });
+                } else if (streamData.type === 'claude-error' || streamData.type === 'codex-error' || streamData.type === 'cursor-error') {
+                    writer.send({
+                        type: responseType,
+                        data: {
+                            type: 'assistant',
+                            message: {
+                                type: 'text',
+                                text: streamData.content || ''
+                            }
+                        },
+                        sessionId
+                    });
+                }
+            },
+            600000 // 10 minute timeout for AI queries
+        );
+
+        // Send completion event
+        writer.send({
+            type: completeType,
+            sessionId,
+            exitCode: result?.exitCode ?? 0,
+            isNewSession: !data.options?.sessionId,
+            viaRelay: true
+        });
+    } catch (error) {
+        writer.send({
+            type: errorType,
+            error: error.message,
+            sessionId
+        });
+    }
+}
+
 // Handle shell WebSocket connections
 function handleShellConnection(ws) {
     if (!pty) {
@@ -2274,6 +2469,18 @@ async function startServer() {
         // Initialize authentication database
         await initializeDatabase();
 
+        // In local mode, ensure a default user exists (no signup needed)
+        if (IS_LOCAL) {
+            const hasUsers = await userDb.hasUsers();
+            if (!hasUsers) {
+                const localUsername = os.userInfo().username || 'local';
+                const dummyHash = crypto.randomBytes(32).toString('hex');
+                await userDb.createUser(localUsername, dummyHash);
+                console.log(`${c.ok('[LOCAL]')} Created local user: ${c.bright(localUsername)}`);
+            }
+            console.log(`${c.info('[MODE]')} Running in ${c.bright('LOCAL')} mode (no login required)`);
+        }
+
         // Check if running in production mode (dist folder exists OR NODE_ENV/RAILWAY set)
         const distIndexPath = path.join(__dirname, '../dist/index.html');
         const isProduction = fs.existsSync(distIndexPath) || process.env.NODE_ENV === 'production' || !!process.env.RAILWAY_ENVIRONMENT;

package/server/mcp-server.js

@@ -31,7 +31,8 @@ import crypto from 'crypto';
 import jwt from 'jsonwebtoken';
 import { userDb, apiKeysDb, relayTokensDb } from './database/db.js';
 
-const JWT_SECRET = process.env.JWT_SECRET?.trim() || (() => { throw new Error('JWT_SECRET required'); })();
+import { IS_PLATFORM } from './constants/config.js';
+const JWT_SECRET = process.env.JWT_SECRET?.trim() || (IS_PLATFORM ? crypto.randomBytes(32).toString('hex') : (() => { throw new Error('JWT_SECRET required'); })());
 
 // In-memory canvas state (Excalidraw elements, synced via WebSocket with browser clients)
 let canvasElements = [];

package/server/middleware/auth.js

@@ -1,11 +1,17 @@
 import jwt from 'jsonwebtoken';
+import crypto from 'crypto';
 import { userDb, relayTokensDb } from '../database/db.js';
 import { IS_PLATFORM } from '../constants/config.js';
 
-const JWT_SECRET = process.env.JWT_SECRET?.trim();
+let JWT_SECRET = process.env.JWT_SECRET?.trim();
 if (!JWT_SECRET) {
-  console.error('[SECURITY] JWT_SECRET environment variable is required. Server cannot start without it.');
-  process.exit(1);
+  if (IS_PLATFORM) {
+    // In local/self-hosted mode, generate a random secret (auth is bypassed anyway)
+    JWT_SECRET = crypto.randomBytes(32).toString('hex');
+  } else {
+    console.error('[SECURITY] JWT_SECRET environment variable is required. Server cannot start without it.');
+    process.exit(1);
+  }
 }
 
 // Optional static API key middleware

package/server/relay-client.js

@@ -14,7 +14,7 @@ import WebSocket from 'ws';
 import os from 'os';
 import fs from 'fs';
 import path from 'path';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import { promises as fsPromises } from 'fs';
 import crypto from 'crypto';
 import {
@@ -137,6 +137,100 @@ async function handleRelayCommand(data, ws) {
         break;
       }
 
+      case 'codex-query': {
+        const { command, options } = data;
+        logRelayEvent('>', `Codex query: ${command?.slice(0, 60)}...`, 'cyan');
+
+        const codexArgs = ['--quiet'];
+        if (options?.projectPath || options?.cwd) {
+          codexArgs.push('--cwd', options.projectPath || options.cwd);
+        }
+        if (options?.model) codexArgs.push('--model', options.model);
+
+        const codexProc = spawn('codex', [...codexArgs, command || ''], {
+          shell: true,
+          cwd: options?.projectPath || options?.cwd || os.homedir(),
+          env: process.env,
+        });
+
+        codexProc.stdout.on('data', (chunk) => {
+          ws.send(JSON.stringify({
+            type: 'relay-stream',
+            requestId,
+            data: { type: 'codex-response', content: chunk.toString() }
+          }));
+        });
+
+        codexProc.stderr.on('data', (chunk) => {
+          ws.send(JSON.stringify({
+            type: 'relay-stream',
+            requestId,
+            data: { type: 'codex-error', content: chunk.toString() }
+          }));
+        });
+
+        codexProc.on('close', (code) => {
+          ws.send(JSON.stringify({
+            type: 'relay-complete',
+            requestId,
+            exitCode: code
+          }));
+        });
+        break;
+      }
+
+      case 'cursor-query': {
+        const { command, options } = data;
+        logRelayEvent('>', `Cursor query: ${command?.slice(0, 60)}...`, 'cyan');
+
+        const cursorArgs = [];
+        if (options?.projectPath || options?.cwd) {
+          cursorArgs.push('--cwd', options.projectPath || options.cwd);
+        }
+        if (options?.model) cursorArgs.push('--model', options.model);
+
+        const cursorProc = spawn('cursor-agent', [...cursorArgs, command || ''], {
+          shell: true,
+          cwd: options?.projectPath || options?.cwd || os.homedir(),
+          env: process.env,
+        });
+
+        cursorProc.stdout.on('data', (chunk) => {
+          ws.send(JSON.stringify({
+            type: 'relay-stream',
+            requestId,
+            data: { type: 'cursor-response', content: chunk.toString() }
+          }));
+        });
+
+        cursorProc.stderr.on('data', (chunk) => {
+          ws.send(JSON.stringify({
+            type: 'relay-stream',
+            requestId,
+            data: { type: 'cursor-error', content: chunk.toString() }
+          }));
+        });
+
+        cursorProc.on('close', (code) => {
+          ws.send(JSON.stringify({
+            type: 'relay-complete',
+            requestId,
+            exitCode: code
+          }));
+        });
+        break;
+      }
+
+      case 'detect-agents': {
+        const agents = detectInstalledAgents();
+        ws.send(JSON.stringify({
+          type: 'relay-response',
+          requestId,
+          data: { agents }
+        }));
+        break;
+      }
+
       case 'shell-command': {
         const { command: cmd, cwd } = data;
         // Block dangerous shell patterns
@@ -228,6 +322,39 @@ async function buildFileTree(dirPath, maxDepth, currentDepth = 0) {
   }
 }
 
+/**
+ * Detect which AI CLI agents are installed on this machine
+ * Returns an object with agent names and their availability
+ */
+function detectInstalledAgents() {
+  const isWindows = process.platform === 'win32';
+  const whichCmd = isWindows ? 'where' : 'which';
+
+  const agents = [
+    { name: 'claude', binary: 'claude', label: 'Claude Code' },
+    { name: 'codex', binary: 'codex', label: 'OpenAI Codex' },
+    { name: 'cursor', binary: 'cursor-agent', label: 'Cursor Agent' },
+  ];
+
+  const detected = {};
+  for (const agent of agents) {
+    try {
+      const result = execSync(`${whichCmd} ${agent.binary}`, { stdio: 'pipe', timeout: 5000 }).toString().trim();
+      detected[agent.name] = {
+        installed: true,
+        path: result.split('\n')[0].trim(),
+        label: agent.label,
+      };
+    } catch {
+      detected[agent.name] = {
+        installed: false,
+        label: agent.label,
+      };
+    }
+  }
+  return detected;
+}
+
 /**
  * Create WebSocket connection with optional API key in handshake
  */
@@ -239,6 +366,8 @@ function createRelayConnection(wsUrl, config = {}) {
   }
   headers['x-upfyn-version'] = VERSION;
   headers['x-upfyn-machine'] = os.hostname();
+  headers['x-upfyn-platform'] = process.platform;
+  headers['x-upfyn-cwd'] = process.cwd();
 
   return new WebSocket(wsUrl, { headers });
 }
@@ -302,6 +431,34 @@ export async function connectToServer(options = {}) {
           const nameMatch = data.message?.match(/Connected as (.+?)\./);
           const username = nameMatch ? nameMatch[1] : 'Unknown';
           showConnectionBanner(username, serverUrl);
+
+          // Detect and report installed agents
+          const agents = detectInstalledAgents();
+          const installed = Object.entries(agents)
+            .filter(([, info]) => info.installed)
+            .map(([name, info]) => info.label);
+          const missing = Object.entries(agents)
+            .filter(([, info]) => !info.installed)
+            .map(([name, info]) => info.label);
+
+          if (installed.length > 0) {
+            logRelayEvent('+', `Agents found: ${installed.join(', ')}`, 'green');
+          }
+          if (missing.length > 0) {
+            logRelayEvent('~', `Not found: ${missing.join(', ')} (install to enable)`, 'yellow');
+          }
+
+          // Send agent capabilities to server
+          ws.send(JSON.stringify({
+            type: 'agent-capabilities',
+            agents,
+            machine: {
+              hostname: os.hostname(),
+              platform: process.platform,
+              cwd: process.cwd(),
+            }
+          }));
+
           logRelayEvent('*', 'Relay active -- waiting for commands...', 'green');
           return;
         }

package/server/routes/commands.js

@@ -293,7 +293,7 @@ Custom commands can be created in:
     // Read version from package.json
     const packageJsonPath = path.join(path.dirname(__dirname), '..', 'package.json');
     let version = 'unknown';
-    let packageName = 'upfyn-code';
+    let packageName = 'upfynai-code';
 
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));