upfynai-code 3.0.4 → 3.1.0

package/src/auth.js

@@ -0,0 +1,142 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { readConfig, writeConfig, clearConfig, displayUrl } from './config.js';
+
+async function apiCall(path, options = {}) {
+  const config = readConfig();
+  const url = `${config.serverUrl}${path}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+  return res;
+}
+
+export function getToken() {
+  const config = readConfig();
+  return config.token || null;
+}
+
+export async function validateToken() {
+  const token = getToken();
+  if (!token) return null;
+
+  try {
+    const res = await apiCall('/api/auth/user', {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.user || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function login(options = {}) {
+  // Allow --server flag to override the server URL
+  if (options.server) {
+    writeConfig({ serverUrl: options.server.replace(/\/+$/, '') });
+  }
+
+  console.log(chalk.bold('\n  Upfyn Code — Login\n'));
+
+  const response = await prompts([
+    {
+      type: 'text',
+      name: 'username',
+      message: 'Username',
+      validate: v => (v.trim() ? true : 'Username is required'),
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Password',
+      validate: v => (v ? true : 'Password is required'),
+    },
+  ], {
+    onCancel: () => {
+      console.log(chalk.dim('\n  Login cancelled.\n'));
+      process.exit(0);
+    },
+  });
+
+  const { username, password } = response;
+
+  try {
+    const res = await apiCall('/api/auth/login', {
+      method: 'POST',
+      body: JSON.stringify({ username: username.trim(), password }),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      console.log(chalk.red(`\n  Login failed: ${data.error || 'Unknown error'}\n`));
+      process.exit(1);
+    }
+
+    writeConfig({
+      token: data.token,
+      user: data.user,
+    });
+
+    const name = data.user.first_name || data.user.username;
+    console.log(chalk.green(`\n  Logged in as ${chalk.bold(name)}!`));
+
+    // Auto-fetch and save relay token for one-command connect
+    try {
+      const config = readConfig();
+      const tokenRes = await fetch(`${config.serverUrl}/api/auth/connect-token`, {
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${data.token}` },
+      });
+      if (tokenRes.ok) {
+        const tokenData = await tokenRes.json();
+        if (tokenData.token) {
+          writeConfig({ relayKey: tokenData.token });
+          console.log(chalk.dim('  Relay token saved.'));
+          console.log(chalk.cyan(`\n  Run ${chalk.bold('uc web connect')} to bridge your machine to the web UI.\n`));
+        }
+      }
+    } catch { /* best-effort — relay token fetch is optional */ }
+
+    if (!readConfig().relayKey) {
+      console.log('');
+    }
+  } catch (err) {
+    const config = readConfig();
+    console.log(chalk.red(`\n  Connection error. Could not reach ${displayUrl(config.serverUrl)}.`));
+    console.log(chalk.dim('  Check your network and try again.\n'));
+    process.exit(1);
+  }
+}
+
+export async function logout() {
+  clearConfig();
+  console.log(chalk.green('\n  Logged out. Credentials cleared.\n'));
+}
+
+export async function status() {
+  const config = readConfig();
+
+  if (!config.token) {
+    console.log(chalk.yellow('\n  Not logged in. Run `uc login` to authenticate.\n'));
+    return;
+  }
+
+  console.log(chalk.dim('\n  Checking session...'));
+  const user = await validateToken();
+
+  if (!user) {
+    console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
+    return;
+  }
+
+  const name = user.first_name || user.username;
+  console.log(chalk.bold(`  Logged in as: ${chalk.cyan(name)} (${chalk.dim(user.username)})`));
+  console.log(chalk.dim(`  Server:       ${displayUrl(config.serverUrl)}`));
+  console.log(chalk.dim(`  Local port:   ${config.localPort}\n`));
+}

package/src/config.js

@@ -0,0 +1,40 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+
+const CONFIG_PATH = join(homedir(), '.upfynrc');
+
+const DEFAULTS = {
+  serverUrl: 'https://upfynai-code-production.up.railway.app',
+  localPort: 4200,
+};
+
+export function readConfig() {
+  try {
+    const raw = readFileSync(CONFIG_PATH, 'utf-8');
+    return { ...DEFAULTS, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function writeConfig(data) {
+  const existing = readConfig();
+  const merged = { ...existing, ...data };
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+  return merged;
+}
+
+export function clearConfig() {
+  writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULTS, null, 2) + '\n', 'utf-8');
+}
+
+/** Display-friendly server label — masks the internal URL */
+export function displayUrl(url) {
+  if (!url || url === DEFAULTS.serverUrl) return 'Upfyn Cloud';
+  // Custom server — show the hostname only
+  try { return new URL(url).host; } catch { return url; }
+}
+
+export { CONFIG_PATH, DEFAULTS };

package/src/connect.js

@@ -0,0 +1,416 @@
+import WebSocket from 'ws';
+import os from 'os';
+import { spawn } from 'child_process';
+import { promises as fsPromises, existsSync } from 'fs';
+import path, { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { readConfig, writeConfig, displayUrl } from './config.js';
+import { getToken, validateToken } from './auth.js';
+import { getPersistentShell } from './persistent-shell.js';
+import { needsPermission, requestPermission, handlePermissionResponse } from './permissions.js';
+import { playConnectAnimation } from './animation.js';
+
+// Optional node-pty for proper terminal emulation (graceful fallback to spawn)
+let pty;
+try { pty = (await import('node-pty')).default; } catch { pty = null; }
+
+// Resolve agents: dist/agents/ (npm package) or ../../shared/agents/ (monorepo)
+const __connectDir = dirname(fileURLToPath(import.meta.url));
+const _agentsPath = existsSync(join(__connectDir, '../dist/agents/index.js'))
+  ? '../dist/agents/index.js'
+  : '../../shared/agents/index.js';
+const { executeAction, isStreamingAction } = await import(_agentsPath);
+
+// Active process tracking (opencode pattern: activeRequests sync.Map)
+const activeProcesses = new Map(); // requestId → { proc, action }
+
+// Active shell sessions for relay terminal (shellSessionId → { proc })
+const activeShellSessions = new Map();
+
+/**
+ * Start an interactive shell session on the local machine, relayed to the browser.
+ * Uses node-pty for proper terminal emulation when available, falls back to spawn.
+ */
+function handleShellSessionStart(data, ws) {
+  const shellSessionId = data.requestId;
+  const projectPath = data.projectPath || process.cwd();
+  const isWin = process.platform === 'win32';
+  const shellType = data.shellType;
+  const cols = data.cols || 80;
+  const rows = data.rows || 24;
+
+  console.log(chalk.cyan(`  [relay] Starting shell session in ${projectPath}${pty ? ' (pty)' : ' (spawn)'}`));
+
+  let shellCmd, shellArgs;
+  const provider = data.provider || 'claude';
+  const isPlainShell = data.isPlainShell || (!!data.initialCommand && !data.hasSession) || provider === 'plain-shell';
+
+  function getInteractiveShell(projectDir) {
+    if (isWin) {
+      if (shellType === 'cmd') return { cmd: 'cmd.exe', args: [] };
+      return { cmd: 'powershell.exe', args: ['-NoExit'] };
+    }
+    const sh = shellType || process.env.SHELL || 'bash';
+    return { cmd: sh, args: ['--login'] };
+  }
+
+  function wrapCommand(command, projectDir) {
+    if (isWin) {
+      if (shellType === 'cmd') return { cmd: 'cmd.exe', args: ['/C', `cd /d "${projectDir}" && ${command}`] };
+      return { cmd: 'powershell.exe', args: ['-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'; ${command}`] };
+    }
+    const sh = shellType || 'bash';
+    return { cmd: sh, args: ['-c', `cd "${projectDir}" && ${command}`] };
+  }
+
+  if (isPlainShell && data.initialCommand) {
+    const s = wrapCommand(data.initialCommand, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  } else if (isPlainShell) {
+    const s = getInteractiveShell(projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  } else if (provider === 'cursor') {
+    const cursorCmd = data.hasSession && data.sessionId
+      ? `cursor-agent --resume="${data.sessionId}"`
+      : 'cursor-agent';
+    const s = wrapCommand(cursorCmd, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  } else {
+    const command = data.initialCommand || 'claude';
+    let claudeCmd;
+    if (isWin) {
+      claudeCmd = data.hasSession && data.sessionId
+        ? `claude --resume ${data.sessionId}`
+        : command;
+    } else {
+      claudeCmd = data.hasSession && data.sessionId
+        ? `claude --resume ${data.sessionId} || claude`
+        : command;
+    }
+    const s = wrapCommand(claudeCmd, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  }
+
+  ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: '' }));
+
+  // Use node-pty for proper terminal emulation (resize, isatty, line discipline)
+  if (pty) {
+    const proc = pty.spawn(shellCmd, shellArgs, {
+      name: 'xterm-256color',
+      cols,
+      rows,
+      cwd: projectPath,
+      env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor', FORCE_COLOR: '3' },
+    });
+
+    activeShellSessions.set(shellSessionId, { proc, projectPath, isPty: true });
+
+    proc.onData((chunk) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk }));
+      }
+    });
+
+    proc.onExit(({ exitCode }) => {
+      activeShellSessions.delete(shellSessionId);
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-exited', shellSessionId, exitCode }));
+      }
+      console.log(chalk.dim(`  [relay] Shell session ended (code ${exitCode})`));
+    });
+  } else {
+    // Fallback: spawn without PTY (text wrapping may be incorrect)
+    const proc = spawn(shellCmd, shellArgs, {
+      cwd: projectPath,
+      env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor', FORCE_COLOR: '3', COLUMNS: String(cols), LINES: String(rows) },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    activeShellSessions.set(shellSessionId, { proc, projectPath, isPty: false });
+
+    proc.stdout.on('data', (chunk) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk.toString() }));
+      }
+    });
+
+    proc.stderr.on('data', (chunk) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk.toString() }));
+      }
+    });
+
+    proc.on('close', (code) => {
+      activeShellSessions.delete(shellSessionId);
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-exited', shellSessionId, exitCode: code }));
+      }
+      console.log(chalk.dim(`  [relay] Shell session ended (code ${code})`));
+    });
+
+    proc.on('error', (err) => {
+      activeShellSessions.delete(shellSessionId);
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: `\r\n\x1b[31mError: ${err.message}\x1b[0m\r\n` }));
+      }
+    });
+  }
+}
+
+/**
+ * Build execution context for shared agents.
+ * Provides CLI-specific capabilities (persistent shell, process tracking, streaming).
+ */
+function buildAgentContext(requestId, ws) {
+  return {
+    requestId,
+    streamMode: 'structured',
+    getPersistentShell,
+    trackProcess: (id, entry) => activeProcesses.set(id, entry),
+    untrackProcess: (id) => activeProcesses.delete(id),
+    stream: (data) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-stream', requestId, data }));
+      }
+    },
+  };
+}
+
+/**
+ * Handle incoming relay commands from the server.
+ * Delegates to shared agent modules for action execution.
+ */
+async function handleRelayCommand(data, ws) {
+  const { requestId, action } = data;
+
+  try {
+    // Permission gate (opencode pattern: dangerous actions require browser approval)
+    if (needsPermission(action, data)) {
+      const approved = await requestPermission(ws, requestId, action, data);
+      if (!approved) {
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, error: 'Permission denied by user' }));
+        return;
+      }
+    }
+
+    const ctx = buildAgentContext(requestId, ws);
+
+    // For the exec action, params come from data.options in the old format
+    const params = action === 'exec'
+      ? { command: data.options?.command || data.command, timeout: data.options?.timeout || data.timeout, cwd: data.options?.cwd || data.cwd }
+      : data;
+
+    if (isStreamingAction(action)) {
+      // Streaming actions: agent calls ctx.stream() for chunks, returns on completion
+      const result = await executeAction(action, params, ctx);
+      ws.send(JSON.stringify({ type: 'relay-complete', requestId, exitCode: result.exitCode, sessionId: result.sessionId }));
+    } else {
+      // Sync actions: agent returns data directly
+      const result = await executeAction(action, params, ctx);
+      ws.send(JSON.stringify({ type: 'relay-response', requestId, data: result }));
+    }
+  } catch (err) {
+    ws.send(JSON.stringify({ type: 'relay-response', requestId, error: err.message }));
+  }
+}
+
+/**
+ * Connect to the remote server via WebSocket relay.
+ * Bridges local Claude Code, shell, filesystem, and git to the web UI.
+ */
+export async function connect(options = {}) {
+  const config = readConfig();
+  const serverUrl = options.server || config.serverUrl;
+  let relayKey = options.key;
+
+  if (!relayKey) {
+    const token = getToken();
+    if (!token) {
+      console.log(chalk.yellow('\n  No account found. Run `uc login` first.\n'));
+      process.exit(1);
+    }
+
+    console.log(chalk.dim('\n  Validating session...'));
+    const user = await validateToken();
+    if (!user) {
+      console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
+      process.exit(1);
+    }
+
+    try {
+      const res = await fetch(`${serverUrl}/api/auth/connect-token`, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      if (!res.ok) throw new Error('Failed to get connect token');
+      const data = await res.json();
+      relayKey = data.token;
+    } catch (err) {
+      console.log(chalk.red('\n  Could not get connection token. Check your network and try again.\n'));
+      process.exit(1);
+    }
+  }
+
+  writeConfig({ relayKey });
+
+  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
+
+  // Play spaceship launch animation
+  try { await playConnectAnimation(); } catch { /* cosmetic — don't block connect */ }
+
+  console.log(chalk.bold('\n  Upfyn-Code Relay Client\n'));
+  console.log(`  Server:  ${chalk.cyan(displayUrl(serverUrl))}`);
+  console.log(`  Machine: ${chalk.dim(os.hostname())}`);
+  console.log(`  User:    ${chalk.dim(os.userInfo().username)}\n`);
+
+  let reconnectAttempts = 0;
+  const MAX_RECONNECT = 10;
+
+  function doConnect() {
+    const ws = new WebSocket(wsUrl, {
+      headers: {
+        'x-upfyn-machine': os.hostname(),
+        'x-upfyn-platform': process.platform,
+        'x-upfyn-cwd': process.cwd(),
+      },
+    });
+
+    // Respond to native WebSocket pings from server (Railway proxy keepalive)
+    ws.on('ping', () => { try { ws.pong(); } catch { /* ignore */ } });
+
+    ws.on('open', () => {
+      reconnectAttempts = 0;
+      console.log(chalk.green('  Connected! Your local machine is now bridged to the server.'));
+      console.log(chalk.dim('  Claude Code is the AI brain. Press Ctrl+C to disconnect.\n'));
+
+      const cwd = process.cwd();
+      const dirName = path.basename(cwd);
+      ws.send(JSON.stringify({
+        type: 'relay-init', cwd, dirName,
+        homedir: os.homedir(), platform: process.platform, hostname: os.hostname(),
+      }));
+      console.log(chalk.dim(`  Default project: ${cwd}\n`));
+
+      const heartbeat = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'ping' }));
+          try { ws.ping(); } catch { /* ignore */ }
+        }
+      }, 20000);
+      ws.on('close', () => clearInterval(heartbeat));
+    });
+
+    ws.on('message', (rawMessage) => {
+      try {
+        const data = JSON.parse(rawMessage);
+
+        if (data.type === 'relay-connected') {
+          console.log(chalk.green(`  ${data.message}`));
+          return;
+        }
+        if (data.type === 'relay-command') {
+          if (data.action === 'shell-session-start') {
+            handleShellSessionStart(data, ws);
+          } else {
+            handleRelayCommand(data, ws);
+          }
+          return;
+        }
+        if (data.type === 'relay-abort') {
+          const entry = activeProcesses.get(data.requestId);
+          if (entry?.instance?.interrupt) {
+            // SDK query instance — use interrupt()
+            entry.instance.interrupt().catch(() => {});
+            activeProcesses.delete(data.requestId);
+            ws.send(JSON.stringify({ type: 'relay-complete', requestId: data.requestId, exitCode: -1, aborted: true }));
+            console.log(chalk.yellow('  [relay] SDK session interrupted by user'));
+          } else if (entry?.proc) {
+            // Legacy subprocess — use kill()
+            entry.proc.kill('SIGTERM');
+            activeProcesses.delete(data.requestId);
+            ws.send(JSON.stringify({ type: 'relay-complete', requestId: data.requestId, exitCode: -1, aborted: true }));
+            console.log(chalk.yellow('  [relay] Process aborted by user'));
+          }
+          return;
+        }
+        if (data.type === 'relay-permission-response') {
+          handlePermissionResponse(data);
+          return;
+        }
+        if (data.type === 'relay-shell-input') {
+          const session = activeShellSessions.get(data.shellSessionId);
+          if (session) {
+            if (session.isPty) {
+              session.proc.write(data.data);
+            } else if (session.proc?.stdin?.writable) {
+              session.proc.stdin.write(data.data);
+            }
+          }
+          return;
+        }
+        if (data.type === 'relay-shell-resize') {
+          const session = activeShellSessions.get(data.shellSessionId);
+          if (session?.isPty && session.proc?.resize) {
+            try { session.proc.resize(data.cols || 80, data.rows || 24); } catch { /* ignore resize errors */ }
+          }
+          return;
+        }
+        if (data.type === 'relay-shell-kill') {
+          const session = activeShellSessions.get(data.shellSessionId);
+          if (session?.proc) {
+            if (session.isPty) {
+              session.proc.kill();
+            } else {
+              session.proc.kill('SIGTERM');
+            }
+            activeShellSessions.delete(data.shellSessionId);
+            console.log(chalk.dim('  [relay] Shell session killed'));
+          }
+          return;
+        }
+        if (data.type === 'pong') return;
+        if (data.type === 'server-ping') {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: 'server-pong' }));
+          }
+          return;
+        }
+        if (data.type === 'error') {
+          console.error(chalk.red(`  Server error: ${data.error}`));
+          return;
+        }
+      } catch (e) {
+        // message parse error
+      }
+    });
+
+    ws.on('close', (code) => {
+      if (code === 1000) {
+        console.log(chalk.dim('  Disconnected.'));
+        process.exit(0);
+      }
+      reconnectAttempts++;
+      if (reconnectAttempts <= MAX_RECONNECT) {
+        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
+        console.log(chalk.dim(`  Connection lost. Reconnecting in ${delay / 1000}s... (${reconnectAttempts}/${MAX_RECONNECT})`));
+        setTimeout(doConnect, delay);
+      } else {
+        console.error(chalk.red('  Max reconnection attempts reached. Exiting.'));
+        process.exit(1);
+      }
+    });
+
+    ws.on('error', (err) => {
+      if (err.code === 'ECONNREFUSED') {
+        console.error(chalk.red(`  Cannot reach ${displayUrl(serverUrl)}. Is the server running?`));
+      }
+    });
+  }
+
+  doConnect();
+
+  process.on('SIGINT', () => {
+    console.log(chalk.dim('\n  Disconnecting...'));
+    process.exit(0);
+  });
+}

package/src/launch.js

@@ -0,0 +1,81 @@
+import open from 'open';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { readConfig } from './config.js';
+import { getToken, validateToken } from './auth.js';
+import { startServer } from './server.js';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export async function openHosted() {
+  const token = getToken();
+
+  if (!token) {
+    console.log(chalk.yellow('\n  No account found. Run `uc login` first.\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.dim('\n  Validating session...'));
+  const user = await validateToken();
+
+  if (!user) {
+    console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
+    process.exit(1);
+  }
+
+  const config = readConfig();
+  const url = `${config.serverUrl}?token=${encodeURIComponent(token)}`;
+
+  const name = user.first_name || user.username;
+  console.log(chalk.green(`  Welcome back, ${chalk.bold(name)}!`));
+  console.log(chalk.dim('  Opening Upfyn-Code in your browser...\n'));
+
+  await open(url);
+}
+
+export async function startLocal() {
+  const config = readConfig();
+  const port = config.localPort || 3001;
+
+  console.log(chalk.dim('\n  Starting local server...'));
+
+  // Try bundled local-server first (npm installs), then monorepo path
+  const bundledPath = join(__dirname, '../dist/local-server.js');
+  const monoRepoPath = join(__dirname, '../../local-server/index.js');
+  const localServerPath = existsSync(bundledPath) ? bundledPath : monoRepoPath;
+
+  try {
+    // Dynamically import the local server
+    process.env.PORT = String(port);
+    await import(localServerPath);
+
+    // Auto-open browser after server starts
+    setTimeout(async () => {
+      const url = `http://localhost:${port}/app/`;
+      console.log(chalk.dim(`  Opening ${url} in browser...\n`));
+      await open(url);
+    }, 2000);
+  } catch (err) {
+    // Fallback: if local-server fails (missing deps), use the old proxy approach
+    console.log(chalk.dim(`  Local server not available (${err.message}), falling back to proxy mode...`));
+
+    const token = getToken();
+    if (!token) {
+      console.log(chalk.yellow('\n  No account found. Run `uc login` first.\n'));
+      process.exit(1);
+    }
+
+    const user = await validateToken();
+    if (!user) {
+      console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
+      process.exit(1);
+    }
+
+    const name = user.first_name || user.username;
+    console.log(chalk.green(`  Welcome back, ${chalk.bold(name)}!`));
+    await startServer(port, config.serverUrl, token);
+  }
+}