upfynai-code 2.8.5 → 2.9.0

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';
@@ -55,7 +55,7 @@ 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')
+  .option('--key <token>', 'Connection token — get from Settings > Keys & Connect')
   .action(async (options) => {
     await connect(options);
   });

package/dist/agents/claude.js

@@ -5,12 +5,14 @@
  * These are STREAMING actions — they use ctx.stream() to send chunks
  * and return a Promise that resolves when the process completes.
  *
- * Two modes:
- * - stream-json (connect.js) — full structured streaming with session tracking
+ * Three modes:
+ * - sdk (connect.js default) — full SDK streaming with rich messages (tool_use, text, result)
  * - simple --print (relay-client.js) — basic stdout streaming
  *
  * The caller chooses the mode via ctx.streamMode ('structured' | 'simple').
+ * 'structured' now maps to SDK mode for rich message forwarding.
  */
+import { query } from '@anthropic-ai/claude-agent-sdk';
 import { spawn } from 'child_process';
 import os from 'os';
 
@@ -20,137 +22,183 @@ export default {
     'claude-query': async (params, ctx) => {
       const { command, options } = params;
       const mode = ctx.streamMode || 'structured';
-      const resolveBinary = ctx.resolveBinary || ((name) => name);
 
       if (mode === 'simple') {
+        const resolveBinary = ctx.resolveBinary || ((name) => name);
         return runSimpleClaudeQuery(command, options, ctx, resolveBinary);
       }
-      return runStructuredClaudeQuery(command, options, ctx, resolveBinary);
+      return runSDKClaudeQuery(command, options, ctx);
     },
 
     'claude-task-query': async (params, ctx) => {
       const { command, options } = params;
-      const resolveBinary = ctx.resolveBinary || ((name) => name);
-      return runClaudeTaskQuery(command, options, ctx, resolveBinary);
+      return runSDKClaudeTaskQuery(command, options, ctx);
     },
   },
 };
 
 /**
- * Structured streaming mode (stream-json).
- * Parses NDJSON events, computes text deltas, tracks session ID.
+ * Build SDK options from relay command options.
+ * Maps the relay format to SDK Options type.
  */
-function runStructuredClaudeQuery(command, options, ctx, resolveBinary) {
-  return new Promise((resolve) => {
-    const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
-    if (options?.sessionId) args.push('--continue', options.sessionId);
+function buildSDKOptions(options = {}) {
+  const sdkOptions = {
+    cwd: options.projectPath || os.homedir(),
+    systemPrompt: { type: 'preset', preset: 'claude_code' },
+    settingSources: ['project', 'user', 'local'],
+  };
 
-    const proc = spawn(resolveBinary('claude'), [...args, command || ''], {
-      shell: true,
-      cwd: options?.projectPath || os.homedir(),
-      env: process.env,
-    });
+  if (options.sessionId) {
+    sdkOptions.resume = options.sessionId;
+  }
 
-    if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'claude-query' });
+  if (options.model) {
+    sdkOptions.model = options.model;
+  }
 
-    let stdoutBuffer = '';
-    let capturedSessionId = null;
-    let lastTextLength = 0;
+  if (options.maxBudgetUsd) {
+    sdkOptions.maxBudgetUsd = options.maxBudgetUsd;
+  }
 
-    proc.stdout.on('data', (chunk) => {
-      stdoutBuffer += chunk.toString();
-      const lines = stdoutBuffer.split('\n');
-      stdoutBuffer = lines.pop();
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const evt = JSON.parse(line);
-
-          if (evt.type === 'system' && evt.subtype === 'init') {
-            if (evt.session_id) capturedSessionId = evt.session_id;
-            lastTextLength = 0;
-            ctx.stream({ type: 'claude-system', sessionId: evt.session_id, model: evt.model, cwd: evt.cwd });
-          } else if (evt.type === 'assistant' && evt.message?.content?.length) {
-            const fullText = evt.message.content[0].text || '';
-            const delta = fullText.slice(lastTextLength);
-            lastTextLength = fullText.length;
-            if (delta) {
-              ctx.stream({ type: 'claude-response', content: delta });
-            }
-          } else if (evt.type === 'result') {
-            lastTextLength = 0;
-            ctx.stream({ type: 'claude-result', sessionId: capturedSessionId, subtype: evt.subtype });
-          }
-        } catch {
-          if (line.trim() && !line.startsWith('%') && !line.includes('claude query')) {
-            ctx.stream({ type: 'claude-response', content: line });
-          }
-        }
-      }
-    });
+  if (options.permissionMode && options.permissionMode !== 'default') {
+    sdkOptions.permissionMode = options.permissionMode;
+  }
 
-    proc.stderr.on('data', (chunk) => {
-      ctx.stream({ type: 'claude-error', content: chunk.toString() });
-    });
+  if (options.allowedTools && options.allowedTools.length > 0) {
+    sdkOptions.allowedTools = options.allowedTools;
+  }
 
-    proc.on('close', (code) => {
-      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-      resolve({ exitCode: code, sessionId: capturedSessionId });
-    });
+  if (options.disallowedTools && options.disallowedTools.length > 0) {
+    sdkOptions.disallowedTools = options.disallowedTools;
+  }
 
-    proc.on('error', () => {
-      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-      resolve({ exitCode: 1, sessionId: capturedSessionId });
-    });
-  });
+  if (options.maxTurns) {
+    sdkOptions.maxTurns = options.maxTurns;
+  }
+
+  // Pass through tools preset to make all Claude Code tools available
+  sdkOptions.tools = { type: 'preset', preset: 'claude_code' };
+
+  return sdkOptions;
 }
 
 /**
- * Simple streaming mode (--print).
- * Just pipes stdout/stderr chunks.
+ * SDK-based structured streaming mode.
+ * Forwards rich SDK messages (tool_use, tool_result, text, system, result)
+ * through ctx.stream() for the relay to forward to the frontend.
  */
-function runSimpleClaudeQuery(command, options, ctx, resolveBinary) {
-  return new Promise((resolve) => {
-    const args = ['--print'];
-    if (options?.sessionId) args.push('--continue', options.sessionId);
-
-    const proc = spawn(resolveBinary('claude'), [...args, command || ''], {
-      shell: true,
-      cwd: options?.projectPath || os.homedir(),
-      env: process.env,
+async function runSDKClaudeQuery(command, options, ctx) {
+  const sdkOptions = buildSDKOptions(options);
+
+  // Set stream-close timeout for interactive tools
+  const prevStreamTimeout = process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
+  process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = '300000';
+
+  let queryInstance;
+  try {
+    queryInstance = query({
+      prompt: command || '',
+      options: sdkOptions,
     });
+  } finally {
+    // Restore immediately — Query constructor already captured the value
+    if (prevStreamTimeout !== undefined) {
+      process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = prevStreamTimeout;
+    } else {
+      delete process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
+    }
+  }
+
+  // Track the query instance for abort support (uses .interrupt() instead of .kill())
+  if (ctx.trackProcess) {
+    ctx.trackProcess(ctx.requestId, { instance: queryInstance, action: 'claude-query' });
+  }
+
+  let capturedSessionId = null;
+
+  try {
+    for await (const message of queryInstance) {
+      // Capture session ID from first message that has one
+      if (message.session_id && !capturedSessionId) {
+        capturedSessionId = message.session_id;
+      }
 
-    if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'claude-query' });
+      // Forward the full SDK message — the backend routeViaRelay() will
+      // detect 'claude-sdk-message' type and forward directly to frontend,
+      // matching the same format as queryClaudeSDK() in claude-sdk.js
+      ctx.stream({
+        type: 'claude-sdk-message',
+        data: message,
+        sessionId: capturedSessionId,
+      });
+    }
+
+    return { exitCode: 0, sessionId: capturedSessionId };
+  } catch (error) {
+    ctx.stream({ type: 'claude-error', content: error.message || 'SDK query failed' });
+    return { exitCode: 1, sessionId: capturedSessionId };
+  } finally {
+    if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
+  }
+}
 
-    proc.stdout.on('data', (chunk) => {
-      ctx.stream({ type: 'claude-response', content: chunk.toString() });
-    });
+/**
+ * SDK-based sub-agent for read-only research tasks.
+ * Restricts tools to read-only operations.
+ */
+async function runSDKClaudeTaskQuery(command, options, ctx) {
+  const sdkOptions = buildSDKOptions(options);
 
-    proc.stderr.on('data', (chunk) => {
-      ctx.stream({ type: 'claude-error', content: chunk.toString() });
-    });
+  // Restrict to read-only tools
+  sdkOptions.allowedTools = ['View', 'Glob', 'Grep', 'LS', 'Read'];
 
-    proc.on('close', (code) => {
-      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-      resolve({ exitCode: code });
+  let queryInstance;
+  try {
+    queryInstance = query({
+      prompt: command || '',
+      options: sdkOptions,
     });
+  } catch (error) {
+    ctx.stream({ type: 'claude-error', content: error.message || 'SDK task query failed' });
+    return { exitCode: 1 };
+  }
 
-    proc.on('error', () => {
-      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-      resolve({ exitCode: 1 });
-    });
-  });
+  if (ctx.trackProcess) {
+    ctx.trackProcess(ctx.requestId, { instance: queryInstance, action: 'claude-task-query' });
+  }
+
+  let capturedSessionId = null;
+
+  try {
+    for await (const message of queryInstance) {
+      if (message.session_id && !capturedSessionId) {
+        capturedSessionId = message.session_id;
+      }
+
+      ctx.stream({
+        type: 'claude-sdk-message',
+        data: message,
+        sessionId: capturedSessionId,
+      });
+    }
+
+    return { exitCode: 0, sessionId: capturedSessionId };
+  } catch (error) {
+    ctx.stream({ type: 'claude-error', content: error.message || 'SDK task query failed' });
+    return { exitCode: 1, sessionId: capturedSessionId };
+  } finally {
+    if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
+  }
 }
 
 /**
- * Sub-agent for read-only research tasks.
- * Uses --allowedTools to restrict to read-only operations.
+ * Simple streaming mode (--print).
+ * Just pipes stdout/stderr chunks. Kept for backward compat with relay-client.js.
  */
-function runClaudeTaskQuery(command, options, ctx, resolveBinary) {
+function runSimpleClaudeQuery(command, options, ctx, resolveBinary) {
   return new Promise((resolve) => {
-    const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
-    args.push('--allowedTools', 'View,Glob,Grep,LS,Read');
+    const args = ['--print'];
+    if (options?.sessionId) args.push('--continue', options.sessionId);
 
     const proc = spawn(resolveBinary('claude'), [...args, command || ''], {
       shell: true,
@@ -158,26 +206,10 @@ function runClaudeTaskQuery(command, options, ctx, resolveBinary) {
       env: process.env,
     });
 
-    if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'claude-task-query' });
-    let taskBuffer = '';
+    if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'claude-query' });
 
     proc.stdout.on('data', (chunk) => {
-      taskBuffer += chunk.toString();
-      const lines = taskBuffer.split('\n');
-      taskBuffer = lines.pop();
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const evt = JSON.parse(line);
-          if (evt.type === 'assistant' && evt.message?.content?.length) {
-            ctx.stream({ type: 'claude-response', content: evt.message.content[0].text || '' });
-          }
-        } catch {
-          if (line.trim()) {
-            ctx.stream({ type: 'claude-response', content: line });
-          }
-        }
-      }
+      ctx.stream({ type: 'claude-response', content: chunk.toString() });
     });
 
     proc.stderr.on('data', (chunk) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upfynai-code",
-  "version": "2.8.5",
+  "version": "2.9.0",
   "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": {
@@ -58,6 +58,7 @@
     "url": "https://github.com/AnitChaudhry/UpfynAI-Code/issues"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.71",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "express": "^4.21.0",
@@ -67,6 +68,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` }));
+      }
+    });
+  }
 }
 
 /**
@@ -241,6 +275,9 @@ export async function connect(options = {}) {
       },
     });
 
+    // 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.'));
@@ -255,8 +292,11 @@ export async function connect(options = {}) {
       console.log(chalk.dim(`  Default project: ${cwd}\n`));
 
       const heartbeat = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'ping' }));
-      }, 30000);
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'ping' }));
+          try { ws.ping(); } catch { /* ignore */ }
+        }
+      }, 20000);
       ws.on('close', () => clearInterval(heartbeat));
     });
 
@@ -278,7 +318,14 @@ export async function connect(options = {}) {
         }
         if (data.type === 'relay-abort') {
           const entry = activeProcesses.get(data.requestId);
-          if (entry?.proc) {
+          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 }));
@@ -292,20 +339,42 @@ 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'));
           }
           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;