upfynai-code 2.8.5 → 2.8.6

package/README.md

@@ -2,35 +2,35 @@
 
 > Unified AI coding interface — access AI chat, terminal, file explorer, git, and visual canvas from any browser.
 
-**Upfyn-Code** connects your local development machine to a browser-based UI through a secure WebSocket relay. Write code with AI assistance, run shell commands, manage files, handle git operations, and plan on a visual canvas — all from any device, anywhere.
+**Upfyn-Code** connects your local development machine to a browser-based UI through a secure, encrypted connection. Write code with AI assistance, run shell commands, manage files, handle git operations, and plan on a visual canvas — all from any device, anywhere.
 
-Your source code **never leaves your machine**. All file operations, terminal commands, and git actions execute locally through the relay connection.
+Your source code **never leaves your machine**. All file operations, terminal commands, and git actions execute locally.
 
 ## Install
 
 ```bash
-npm install -g upfyn-code
+npm install -g upfynai-code
 ```
 
 Or run directly with npx:
 
 ```bash
-npx upfyn-code
+npx upfynai-code
 ```
 
-**Requirements:** Node.js 18 or later. Works on Windows, macOS, and Linux.
+**Requirements:** Node.js 22 or later. Works on Windows, macOS, and Linux.
 
 ## Quick Start
 
 ```bash
 # 1. Authenticate with your Upfyn account
-upfyn-code login
+uc login
 
 # 2. Connect your machine to the web interface
-upfyn-code connect
+uc connect
 
 # 3. Open the web UI (opens automatically)
-upfyn-code
+uc start
 ```
 
 Once connected, open [cli.upfyn.com](https://cli.upfyn.com) on any device to access your full development environment.
@@ -39,45 +39,22 @@ Once connected, open [cli.upfyn.com](https://cli.upfyn.com) on any device to acc
 
 | Command | Description |
 |---------|-------------|
-| `upfyn-code` | Open the hosted web interface (default) |
-| `upfyn-code --local` | Start a local server instead of the hosted app |
-| `upfyn-code login` | Authenticate with your Upfyn account |
-| `upfyn-code logout` | Clear saved credentials |
-| `upfyn-code status` | Show current auth status and configuration |
-| `upfyn-code connect` | Connect your local machine to the remote server |
-| `upfyn-code mcp` | Show MCP integration config for Claude / Cursor |
+| `uc` | Launch Claude Code with Upfyn web UI in background |
+| `uc start` | Start the web UI server |
+| `uc connect` | Connect your local machine to the cloud interface |
+| `uc login` | Authenticate with your Upfyn account |
+| `uc logout` | Clear saved credentials |
+| `uc status` | Show current configuration |
+| `uc config` | View or set configuration |
+| `uc help` | Show all available commands |
 
 ### Connect Options
 
 ```bash
-upfyn-code connect --server <url> --key <token>
+uc connect --key <token>
 ```
 
-- `--server <url>` — Server URL to connect to
-- `--key <token>` — Relay token (get from the web UI after signing in)
-
-### MCP Integration
-
-```bash
-upfyn-code mcp --server <url> --key <token>
-```
-
-Outputs the MCP (Model Context Protocol) configuration JSON for use with Claude Desktop, Cursor, or other MCP-compatible tools.
-
-**Example output:**
-
-```json
-{
-  "mcpServers": {
-    "upfyn-code": {
-      "url": "https://your-server.com/mcp",
-      "headers": {
-        "Authorization": "Bearer rt_xxxxx"
-      }
-    }
-  }
-}
-```
+- `--key <token>` — Your connection token (get from the web UI after signing in)
 
 ## Features
 
@@ -102,55 +79,18 @@ Connect external tools and services via the Model Context Protocol. Use Upfyn-Co
 ## How It Works
 
 1. **Install** the CLI on your development machine
-2. **Authenticate** with `upfyn-code login`
-3. **Connect** with `upfyn-code connect` — this creates a secure WebSocket tunnel
+2. **Authenticate** with `uc login`
+3. **Connect** with `uc connect` — creates a secure, encrypted connection
 4. **Open** [cli.upfyn.com](https://cli.upfyn.com) on any browser (desktop, tablet, or mobile)
 
-The CLI bridges your local filesystem, terminal, and git to the web interface. No ports are exposed and no firewall configuration is needed — the connection works through a secure relay.
-
-```
-┌─────────────┐    WebSocket     ┌──────────────┐     Browser      ┌──────────────┐
-│  Your Local  │ ──────────────▶ │  Upfyn Relay  │ ◀────────────── │   Web UI at  │
-│   Machine    │   (encrypted)   │    Server     │                  │ cli.upfyn.com│
-└─────────────┘                  └──────────────┘                  └──────────────┘
-```
+The CLI connects your local filesystem, terminal, and git to the web interface. No ports are exposed and no firewall configuration is needed.
 
 ## Security
 
-- All communication is encrypted with TLS
-- Source code is relayed in real-time and **never stored** on servers
-- Authentication uses JWT tokens with httpOnly cookies
-- The relay connection requires both a valid session and a connection token
-- Self-hosting is supported for full data sovereignty
-
-## Self-Hosting
-
-Upfyn-Code is open source under the GPL-3.0 license. You can deploy the entire stack on your own infrastructure:
-
-```bash
-git clone https://github.com/AnitChaudhry/UpfynAI-Code.git
-cd UpfynAI-Code
-
-# Install dependencies
-npm install
-
-# Start the backend
-cd backend && npm start
-
-# Start the frontend
-cd frontend && npm run dev
-```
-
-See the [repository](https://github.com/AnitChaudhry/UpfynAI-Code) for full deployment instructions.
-
-## Configuration
-
-Credentials and config are stored locally at:
-
-| Platform | Path |
-|----------|------|
-| macOS / Linux | `~/.config/upfyn-code/` |
-| Windows | `%APPDATA%\upfyn-code\` |
+- All communication is encrypted end-to-end
+- Source code is **never stored** on servers
+- Secure authentication with automatic session management
+- Each user's environment is fully isolated
 
 ## Links
 
@@ -163,4 +103,4 @@ Credentials and config are stored locally at:
 
 GPL-3.0 — see [LICENSE](https://github.com/AnitChaudhry/UpfynAI-Code/blob/main/LICENSE) for details.
 
-Built by [Thinqmesh Technologies](https://cli.upfyn.com).
+Built by [Upfynai-Code](https://cli.upfyn.com).

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Command } from 'commander';
 import { readFileSync } from 'fs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upfynai-code",
-  "version": "2.8.5",
+  "version": "2.8.6",
   "description": "Unified AI coding interface — access AI chat, terminal, file explorer, git, and visual canvas from any browser. Connect your local machine and code from anywhere.",
   "type": "module",
   "bin": {
@@ -67,6 +67,9 @@
     "prompts": "^2.4.2",
     "ws": "^8.18.0"
   },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0-beta34"
+  },
   "engines": {
     "node": ">=18.0.0"
   },

package/src/connect.js

@@ -11,6 +11,10 @@ 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'))
@@ -26,15 +30,17 @@ const activeShellSessions = new Map();
 
 /**
  * Start an interactive shell session on the local machine, relayed to the browser.
- * Spawns a PTY-like process and streams I/O via WebSocket.
+ * 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}`));
+  console.log(chalk.cyan(`  [relay] Starting shell session in ${projectPath}${pty ? ' (pty)' : ' (spawn)'}`));
 
   let shellCmd, shellArgs;
   const provider = data.provider || 'claude';
@@ -42,8 +48,8 @@ function handleShellSessionStart(data, ws) {
 
   function getInteractiveShell(projectDir) {
     if (isWin) {
-      if (shellType === 'cmd') return { cmd: 'cmd.exe', args: ['/K', `cd /d "${projectDir}"`] };
-      return { cmd: 'powershell.exe', args: ['-NoExit', '-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'`] };
+      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'] };
@@ -88,40 +94,68 @@ function handleShellSessionStart(data, ws) {
 
   ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: '' }));
 
-  const proc = spawn(shellCmd, shellArgs, {
-    cwd: isPlainShell && !data.initialCommand ? projectPath : undefined,
-    env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor', FORCE_COLOR: '3' },
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
+  // 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 });
+    activeShellSessions.set(shellSessionId, { proc, projectPath, isPty: true });
 
-  proc.stdout.on('data', (chunk) => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk.toString() }));
-    }
-  });
+    proc.onData((chunk) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk }));
+      }
+    });
 
-  proc.stderr.on('data', (chunk) => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk.toString() }));
-    }
-  });
+    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'],
+    });
 
-  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})`));
-  });
+    activeShellSessions.set(shellSessionId, { proc, projectPath, isPty: false });
 
-  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` }));
-    }
-  });
+    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` }));
+      }
+    });
+  }
 }
 
 /**
@@ -292,14 +326,30 @@ export async function connect(options = {}) {
         }
         if (data.type === 'relay-shell-input') {
           const session = activeShellSessions.get(data.shellSessionId);
-          if (session?.proc?.stdin?.writable) session.proc.stdin.write(data.data);
+          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-resize') return;
         if (data.type === 'relay-shell-kill') {
           const session = activeShellSessions.get(data.shellSessionId);
           if (session?.proc) {
-            session.proc.kill('SIGTERM');
+            if (session.isPty) {
+              session.proc.kill();
+            } else {
+              session.proc.kill('SIGTERM');
+            }
             activeShellSessions.delete(data.shellSessionId);
             console.log(chalk.dim('  [relay] Shell session killed'));
           }