upfynai-code 2.8.6 → 2.9.1

package/bin/cli.js

@@ -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.6",
+  "version": "2.9.1",
   "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",

package/src/connect.js

@@ -275,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.'));
@@ -289,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));
     });
 
@@ -312,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 }));
@@ -356,6 +369,12 @@ export async function connect(options = {}) {
           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;