upfyn-code 1.0.0

package/bin/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { login, logout, status } from '../src/auth.js';
+import { openHosted, startLocal } from '../src/launch.js';
+import { connect } from '../src/connect.js';
+import { mcp } from '../src/mcp.js';
+
+const program = new Command();
+
+program
+  .name('upfyn-code')
+  .description('Launch Upfyn AI coding environment from your terminal')
+  .version('1.0.0')
+  .option('--local', 'Start a local server instead of opening the hosted app')
+  .action(async (options) => {
+    if (options.local) {
+      await startLocal();
+    } else {
+      await openHosted();
+    }
+  });
+
+program
+  .command('login')
+  .description('Authenticate with your Upfyn account')
+  .action(async () => {
+    await login();
+  });
+
+program
+  .command('logout')
+  .description('Clear saved credentials')
+  .action(async () => {
+    await logout();
+  });
+
+program
+  .command('status')
+  .description('Show current auth status and config')
+  .action(async () => {
+    await status();
+  });
+
+program
+  .command('connect')
+  .description('Connect local machine to the remote server (bridges Claude Code, shell, files, git)')
+  .option('--server <url>', 'Server URL to connect to')
+  .option('--key <token>', 'Relay token (rt_xxx) — get from the web UI')
+  .action(async (options) => {
+    await connect(options);
+  });
+
+program
+  .command('mcp')
+  .description('Show MCP integration config for Claude / Cursor')
+  .option('--server <url>', 'Server URL')
+  .option('--key <token>', 'Relay token')
+  .action(async (options) => {
+    await mcp(options);
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "upfyn-code",
+  "version": "1.0.0",
+  "description": "Launch Upfyn AI coding environment from your terminal",
+  "type": "module",
+  "bin": {
+    "upfyn-code": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "dist/"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js",
+    "build-frontend": "cd ../../frontend && npm run build && cp -r dist ../../packages/cli/dist"
+  },
+  "keywords": [
+    "upfyn",
+    "ai",
+    "coding",
+    "cli",
+    "terminal"
+  ],
+  "author": "Upfyn",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "express": "^4.21.0",
+    "http-proxy-middleware": "^3.0.0",
+    "open": "^10.1.0",
+    "prompts": "^2.4.2",
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/auth.js

@@ -0,0 +1,115 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { readConfig, writeConfig, clearConfig } 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() {
+  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)}!\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n  Connection error: ${err.message}\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 `upfyn-code 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 `upfyn-code 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:       ${config.serverUrl}`));
+  console.log(chalk.dim(`  Local port:   ${config.localPort}\n`));
+}

package/src/config.js

@@ -0,0 +1,33 @@
+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.vercel.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');
+}
+
+export { CONFIG_PATH, DEFAULTS };

package/src/connect.js

@@ -0,0 +1,288 @@
+import WebSocket from 'ws';
+import os from 'os';
+import { spawn } from 'child_process';
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { readConfig, writeConfig } from './config.js';
+import { getToken, validateToken } from './auth.js';
+
+/**
+ * Execute a shell command and return stdout
+ */
+function execCommand(cmd, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, {
+      shell: true,
+      cwd: options.cwd || os.homedir(),
+      env: { ...process.env, ...options.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d; });
+    proc.stderr.on('data', (d) => { stderr += d; });
+
+    const timeout = setTimeout(() => {
+      proc.kill();
+      reject(new Error('Command timed out'));
+    }, options.timeout || 30000);
+
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `Exit code ${code}`));
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Build a file tree for a directory
+ */
+async function buildFileTree(dirPath, maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return [];
+  try {
+    const entries = await fsPromises.readdir(dirPath, { withFileTypes: true });
+    const items = [];
+    for (const entry of entries.slice(0, 100)) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const item = { name: entry.name, type: entry.isDirectory() ? 'directory' : 'file' };
+      if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+        item.children = await buildFileTree(path.join(dirPath, entry.name), maxDepth, currentDepth + 1);
+      }
+      items.push(item);
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Handle incoming relay commands from the server
+ */
+async function handleRelayCommand(data, ws) {
+  const { requestId, action } = data;
+
+  try {
+    switch (action) {
+      case 'claude-query': {
+        const { command, options } = data;
+        console.log(chalk.cyan(`  [relay] Claude query: ${command?.slice(0, 80)}...`));
+
+        const args = ['--print'];
+        if (options?.projectPath) args.push('--cwd', options.projectPath);
+        if (options?.sessionId) args.push('--continue', options.sessionId);
+
+        const proc = spawn('claude', [...args, command || ''], {
+          shell: true,
+          cwd: options?.projectPath || os.homedir(),
+          env: process.env,
+        });
+
+        proc.stdout.on('data', (chunk) => {
+          ws.send(JSON.stringify({
+            type: 'relay-stream',
+            requestId,
+            data: { type: 'claude-response', content: chunk.toString() },
+          }));
+        });
+
+        proc.stderr.on('data', (chunk) => {
+          ws.send(JSON.stringify({
+            type: 'relay-stream',
+            requestId,
+            data: { type: 'claude-error', content: chunk.toString() },
+          }));
+        });
+
+        proc.on('close', (code) => {
+          ws.send(JSON.stringify({
+            type: 'relay-complete',
+            requestId,
+            exitCode: code,
+          }));
+        });
+        break;
+      }
+
+      case 'shell-command': {
+        const { command: cmd, cwd } = data;
+        console.log(chalk.dim(`  [relay] Shell: ${cmd?.slice(0, 60)}`));
+        const result = await execCommand(cmd, [], { cwd: cwd || os.homedir(), timeout: 60000 });
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { stdout: result } }));
+        break;
+      }
+
+      case 'file-read': {
+        const { filePath } = data;
+        const content = await fsPromises.readFile(filePath, 'utf8');
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { content } }));
+        break;
+      }
+
+      case 'file-write': {
+        const { filePath: fp, content: fileContent } = data;
+        await fsPromises.writeFile(fp, fileContent, 'utf8');
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { success: true } }));
+        break;
+      }
+
+      case 'file-tree': {
+        const { dirPath, depth = 3 } = data;
+        const tree = await buildFileTree(dirPath || os.homedir(), depth);
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { tree } }));
+        break;
+      }
+
+      case 'git-operation': {
+        const { gitCommand, cwd: gitCwd } = data;
+        console.log(chalk.dim(`  [relay] Git: ${gitCommand}`));
+        const result = await execCommand('git', [gitCommand], { cwd: gitCwd });
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { stdout: result } }));
+        break;
+      }
+
+      default:
+        ws.send(JSON.stringify({
+          type: 'relay-response',
+          requestId,
+          error: `Unknown action: ${action}`,
+        }));
+    }
+  } 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 no key provided, fetch one using the auth token
+  if (!relayKey) {
+    const token = getToken();
+    if (!token) {
+      console.log(chalk.yellow('\n  No account found. Run `upfyn-code 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 `upfyn-code login` to re-authenticate.\n'));
+      process.exit(1);
+    }
+
+    // Fetch a relay token from the API
+    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: ${err.message}\n`));
+      process.exit(1);
+    }
+  }
+
+  // Save for future use
+  writeConfig({ relayKey });
+
+  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
+
+  console.log(chalk.bold('\n  Upfyn-Code Relay Client\n'));
+  console.log(`  Server:  ${chalk.cyan(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);
+
+    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 heartbeat = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'ping' }));
+        }
+      }, 30000);
+
+      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') {
+          handleRelayCommand(data, ws);
+          return;
+        }
+        if (data.type === 'pong') return;
+        if (data.type === 'error') {
+          console.error(chalk.red(`  Server error: ${data.error}`));
+          return;
+        }
+      } catch (e) {
+        console.error(chalk.red(`  Error: ${e.message}`));
+      }
+    });
+
+    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 ${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,54 @@
+import open from 'open';
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import { getToken, validateToken } from './auth.js';
+import { startServer } from './server.js';
+
+export async function openHosted() {
+  const token = getToken();
+
+  if (!token) {
+    console.log(chalk.yellow('\n  No account found. Run `upfyn-code 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 `upfyn-code 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 ${config.serverUrl} ...\n`));
+
+  await open(url);
+}
+
+export async function startLocal() {
+  const token = getToken();
+
+  if (!token) {
+    console.log(chalk.yellow('\n  No account found. Run `upfyn-code 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 `upfyn-code login` to re-authenticate.\n'));
+    process.exit(1);
+  }
+
+  const config = readConfig();
+  const name = user.first_name || user.username;
+  console.log(chalk.green(`  Welcome back, ${chalk.bold(name)}!`));
+
+  await startServer(config.localPort, config.serverUrl, token);
+}

package/src/mcp.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import { getToken, validateToken } from './auth.js';
+
+/**
+ * Print MCP configuration for Claude / Cursor / other AI tools.
+ * Optionally accepts --server and --key overrides.
+ */
+export async function mcp(options = {}) {
+  const config = readConfig();
+  const serverUrl = options.server || config.serverUrl;
+  let relayKey = options.key;
+
+  // If no key provided, fetch one using auth token
+  if (!relayKey) {
+    const token = getToken();
+    if (!token) {
+      console.log(chalk.yellow('\n  No account found. Run `upfyn-code login` first.\n'));
+      process.exit(1);
+    }
+
+    const user = await validateToken();
+    if (!user) {
+      console.log(chalk.yellow('\n  Session expired. Run `upfyn-code 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: ${err.message}\n`));
+      process.exit(1);
+    }
+  }
+
+  const mcpConfig = {
+    mcpServers: {
+      'upfyn-code': {
+        url: `${serverUrl}/mcp`,
+        headers: {
+          Authorization: `Bearer ${relayKey}`,
+        },
+      },
+    },
+  };
+
+  console.log(chalk.bold('\n  Upfyn-Code — MCP Integration\n'));
+  console.log(chalk.dim('  Add this to your Claude / Cursor MCP settings:\n'));
+  console.log(chalk.white(JSON.stringify(mcpConfig, null, 2)));
+  console.log('');
+  console.log(chalk.dim('  Or use the MCP URL directly:'));
+  console.log(chalk.cyan(`  ${serverUrl}/mcp`));
+  console.log(chalk.dim(`  Authorization: Bearer ${relayKey}\n`));
+}

package/src/server.js

@@ -0,0 +1,55 @@
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import express from 'express';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import open from 'open';
+import chalk from 'chalk';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DIST_DIR = join(__dirname, '..', 'dist');
+
+export async function startServer(port, serverUrl, token) {
+  if (!existsSync(DIST_DIR)) {
+    console.log(chalk.red('\n  Error: No built frontend found at dist/.'));
+    console.log(chalk.dim('  Run the build-frontend script first, or use the default mode (no --local flag).\n'));
+    process.exit(1);
+  }
+
+  const app = express();
+
+  // Proxy API calls to the remote Vercel backend
+  app.use('/api', createProxyMiddleware({
+    target: serverUrl,
+    changeOrigin: true,
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  }));
+
+  // Serve the built React frontend
+  app.use(express.static(DIST_DIR));
+
+  // SPA fallback — serve index.html for all non-API, non-static routes
+  app.get('*', (req, res) => {
+    res.sendFile(join(DIST_DIR, 'index.html'));
+  });
+
+  return new Promise((resolve) => {
+    const server = app.listen(port, async () => {
+      const url = `http://localhost:${port}?token=${encodeURIComponent(token)}`;
+      console.log(chalk.green(`\n  Local server running at ${chalk.bold(`http://localhost:${port}`)}`));
+      console.log(chalk.dim(`  Proxying API → ${serverUrl}`));
+      console.log(chalk.dim('  Press Ctrl+C to stop.\n'));
+      await open(url);
+      resolve(server);
+    });
+
+    const shutdown = () => {
+      console.log(chalk.dim('\n  Shutting down...'));
+      server.close(() => process.exit(0));
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+  });
+}