upfynai-code 2.7.0 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upfynai-code",
-  "version": "2.7.0",
+  "version": "2.7.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": {

package/src/connect.js

@@ -23,6 +23,8 @@ function handleShellSessionStart(data, ws) {
   const shellSessionId = data.requestId;
   const projectPath = data.projectPath || process.cwd();
   const isWin = process.platform === 'win32';
+  const isMac = process.platform === 'darwin';
+  const shellType = data.shellType; // 'cmd', 'powershell', 'bash', 'zsh', etc.
 
   console.log(chalk.cyan(`  [relay] Starting shell session in ${projectPath}`));
 
@@ -31,56 +33,76 @@ function handleShellSessionStart(data, ws) {
   const provider = data.provider || 'claude';
   const isPlainShell = data.isPlainShell || (!!data.initialCommand && !data.hasSession) || provider === 'plain-shell';
 
-  if (isPlainShell && data.initialCommand) {
-    // Run a specific command
+  /**
+   * Helper: get the right shell command + args for interactive shell based on platform + shellType.
+   * Returns { cmd, args } that cd into projectPath.
+   */
+  function getInteractiveShell(projectDir) {
     if (isWin) {
-      shellCmd = 'powershell.exe';
-      shellArgs = ['-Command', `Set-Location -Path "${projectPath}"; ${data.initialCommand}`];
-    } else {
-      shellCmd = 'bash';
-      shellArgs = ['-c', `cd "${projectPath}" && ${data.initialCommand}`];
+      if (shellType === 'cmd') {
+        return { cmd: 'cmd.exe', args: ['/K', `cd /d "${projectDir}"`] };
+      }
+      // Default to PowerShell on Windows
+      return { cmd: 'powershell.exe', args: ['-NoExit', '-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'`] };
     }
-  } else if (isPlainShell) {
-    // Interactive shell
+    // Unix: use shellType if specified, else $SHELL or bash
+    const sh = shellType || process.env.SHELL || 'bash';
+    return { cmd: sh, args: ['--login'] };
+  }
+
+  /**
+   * Helper: wrap a command to execute in the right shell for the platform + shellType.
+   * Returns { cmd, args }.
+   */
+  function wrapCommand(command, projectDir) {
     if (isWin) {
-      shellCmd = 'powershell.exe';
-      shellArgs = ['-NoExit', '-Command', `Set-Location -Path "${projectPath}"`];
-    } else {
-      shellCmd = process.env.SHELL || 'bash';
-      shellArgs = ['--login'];
+      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) {
+    // Run a specific command
+    const s = wrapCommand(data.initialCommand, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  } else if (isPlainShell) {
+    // Interactive shell
+    const s = getInteractiveShell(projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
   } else if (provider === 'cursor') {
-    if (isWin) {
-      shellCmd = 'powershell.exe';
-      const cursorCmd = data.hasSession && data.sessionId
-        ? `cursor-agent --resume="${data.sessionId}"`
-        : 'cursor-agent';
-      shellArgs = ['-Command', `Set-Location -Path "${projectPath}"; ${cursorCmd}`];
-    } else {
-      shellCmd = 'bash';
-      const cursorCmd = data.hasSession && data.sessionId
-        ? `cursor-agent --resume="${data.sessionId}"`
-        : 'cursor-agent';
-      shellArgs = ['-c', `cd "${projectPath}" && ${cursorCmd}`];
-    }
+    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 {
     // Claude (default)
     const command = data.initialCommand || 'claude';
+    let claudeCmd;
     if (isWin) {
-      shellCmd = 'powershell.exe';
-      const claudeCmd = data.hasSession && data.sessionId
+      claudeCmd = data.hasSession && data.sessionId
         ? `claude --resume ${data.sessionId}`
         : command;
-      shellArgs = ['-Command', `Set-Location -Path "${projectPath}"; ${claudeCmd}`];
     } else {
-      shellCmd = 'bash';
-      const claudeCmd = data.hasSession && data.sessionId
+      claudeCmd = data.hasSession && data.sessionId
         ? `claude --resume ${data.sessionId} || claude`
         : command;
-      shellArgs = ['-c', `cd "${projectPath}" && ${claudeCmd}`];
     }
+    const s = wrapCommand(claudeCmd, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
   }
 
+  // Send ack so browser knows spawn is starting
+  ws.send(JSON.stringify({
+    type: 'relay-shell-output',
+    shellSessionId,
+    data: '',
+  }));
+
   const proc = spawn(shellCmd, shellArgs, {
     cwd: isPlainShell && !data.initialCommand ? projectPath : undefined,
     env: {
@@ -183,11 +205,25 @@ async function buildFileTree(dirPath, maxDepth, currentDepth = 0) {
   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' };
+    for (const entry of entries.slice(0, 200)) {
+      // Skip heavy/hidden directories
+      if (entry.name === 'node_modules' || entry.name === '.git' ||
+          entry.name === 'dist' || entry.name === 'build' ||
+          entry.name === '.svn' || entry.name === '.hg') continue;
+      if (entry.name.startsWith('.') && currentDepth === 0) continue; // hide dotfiles at root only
+
+      const itemPath = path.join(dirPath, entry.name);
+      const item = { name: entry.name, path: itemPath, type: entry.isDirectory() ? 'directory' : 'file' };
+
+      // Get file stats for metadata (size, modified)
+      try {
+        const stats = await fsPromises.stat(itemPath);
+        item.size = stats.size;
+        item.modified = stats.mtime.toISOString();
+      } catch { /* ignore stat errors */ }
+
       if (entry.isDirectory() && currentDepth < maxDepth - 1) {
-        item.children = await buildFileTree(path.join(dirPath, entry.name), maxDepth, currentDepth + 1);
+        item.children = await buildFileTree(itemPath, maxDepth, currentDepth + 1);
       }
       items.push(item);
     }
@@ -326,21 +362,29 @@ async function handleRelayCommand(data, ws) {
       }
 
       case 'file-read': {
-        const { filePath } = data;
+        let { filePath, encoding } = data;
         if (!filePath || typeof filePath !== 'string') throw new Error('Invalid file path');
+        // Resolve ~ to home directory (routes send paths like ~/.cursor/config.json)
+        if (filePath === '~') filePath = os.homedir();
+        else if (filePath.startsWith('~/') || filePath.startsWith('~\\')) filePath = path.join(os.homedir(), filePath.slice(2));
         const normalizedPath = path.resolve(filePath);
         const normLower = normalizedPath.toLowerCase().replace(/\\/g, '/');
         const blockedRead = ['/etc/shadow', '/etc/passwd', '.ssh/id_rsa', '.ssh/id_ed25519', '/.env'];
         if (blockedRead.some(b => normLower.includes(b))) throw new Error('Access denied');
-        const content = await fsPromises.readFile(normalizedPath, 'utf8');
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { content } }));
+        const content = await fsPromises.readFile(normalizedPath, encoding === 'base64' ? null : 'utf8');
+        const result = encoding === 'base64' ? content.toString('base64') : content;
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { content: result } }));
         break;
       }
 
       case 'file-write': {
-        const { filePath: fp, content: fileContent } = data;
-        if (!fp || typeof fp !== 'string') throw new Error('Invalid file path');
-        const normalizedFp = path.resolve(fp);
+        let fp2 = data.filePath;
+        const fileContent = data.content;
+        if (!fp2 || typeof fp2 !== 'string') throw new Error('Invalid file path');
+        // Resolve ~ to home directory
+        if (fp2 === '~') fp2 = os.homedir();
+        else if (fp2.startsWith('~/') || fp2.startsWith('~\\')) fp2 = path.join(os.homedir(), fp2.slice(2));
+        const normalizedFp = path.resolve(fp2);
         const fpLower = normalizedFp.toLowerCase().replace(/\\/g, '/');
         const blockedWrite = [
           '/etc/', '/usr/bin/', '/usr/sbin/',
@@ -356,10 +400,11 @@ async function handleRelayCommand(data, ws) {
       }
 
       case 'file-tree': {
-        const { dirPath, depth = 3 } = data;
+        const { dirPath, depth, maxDepth } = data;
+        const treeDepth = depth || maxDepth || 3;
         const resolvedDir = dirPath ? path.resolve(dirPath) : process.cwd();
-        const tree = await buildFileTree(resolvedDir, depth);
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { tree } }));
+        const tree = await buildFileTree(resolvedDir, treeDepth);
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { files: tree } }));
         break;
       }
 
@@ -498,6 +543,24 @@ async function handleRelayCommand(data, ws) {
         break;
       }
 
+      case 'detect-agents': {
+        // Detect installed AI CLI agents on user's machine
+        const agents = {};
+        const checkCmd = process.platform === 'win32' ? 'where' : 'which';
+        const agentBins = { claude: 'claude', cursor: 'cursor-agent', codex: 'codex' };
+        for (const [name, bin] of Object.entries(agentBins)) {
+          try {
+            const { execSync } = await import('child_process');
+            execSync(`${checkCmd} ${bin}`, { encoding: 'utf8', timeout: 5000, stdio: 'pipe' });
+            agents[name] = true;
+          } catch {
+            agents[name] = false;
+          }
+        }
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { agents } }));
+        break;
+      }
+
       default:
         ws.send(JSON.stringify({
           type: 'relay-response',