upfynai-code 3.0.4 → 3.2.0

package/src/persistent-shell.js

@@ -0,0 +1,261 @@
+/**
+ * Persistent Shell Singleton
+ * Ported from opencode-ai/opencode internal/llm/tools/shell/shell.go
+ *
+ * Maintains a single long-running shell process across commands.
+ * - Commands are queued and executed sequentially
+ * - Environment and cwd persist between commands
+ * - Child processes can be killed on abort
+ * - Shell respawns automatically if it dies
+ */
+import { spawn, execSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+import { promises as fs } from 'fs';
+
+let shellInstance = null;
+
+/**
+ * Get or create the persistent shell singleton.
+ * @param {string} workingDir - Initial working directory
+ * @returns {PersistentShell}
+ */
+export function getPersistentShell(workingDir) {
+  if (!shellInstance || !shellInstance.isAlive) {
+    shellInstance = new PersistentShell(workingDir || os.homedir());
+  }
+  return shellInstance;
+}
+
+class PersistentShell {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.isAlive = false;
+    this.commandQueue = [];
+    this.processing = false;
+    this.proc = null;
+    this.stdin = null;
+    this._start();
+  }
+
+  _start() {
+    const isWin = process.platform === 'win32';
+    const shellPath = isWin
+      ? process.env.COMSPEC || 'cmd.exe'
+      : process.env.SHELL || '/bin/bash';
+    const shellArgs = isWin ? ['/Q'] : ['-l'];
+
+    this.proc = spawn(shellPath, shellArgs, {
+      cwd: this.cwd,
+      env: { ...process.env, GIT_EDITOR: 'true' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: false,
+    });
+
+    this.stdin = this.proc.stdin;
+    this.isAlive = true;
+
+    this.proc.on('close', () => {
+      this.isAlive = false;
+      // Reject any queued commands
+      for (const queued of this.commandQueue) {
+        queued.reject(new Error('Shell process died'));
+      }
+      this.commandQueue = [];
+    });
+
+    this.proc.on('error', () => {
+      this.isAlive = false;
+    });
+  }
+
+  /**
+   * Execute a command in the persistent shell.
+   * Queued and executed sequentially (opencode pattern: commandQueue channel).
+   *
+   * @param {string} command - Shell command to execute
+   * @param {object} opts - { timeoutMs, abortSignal }
+   * @returns {Promise<{ stdout, stderr, exitCode, interrupted, cwd }>}
+   */
+  exec(command, opts = {}) {
+    return new Promise((resolve, reject) => {
+      this.commandQueue.push({ command, opts, resolve, reject });
+      this._processNext();
+    });
+  }
+
+  async _processNext() {
+    if (this.processing || this.commandQueue.length === 0) return;
+    this.processing = true;
+
+    const { command, opts, resolve, reject } = this.commandQueue.shift();
+
+    try {
+      const result = await this._execCommand(command, opts);
+      resolve(result);
+    } catch (err) {
+      reject(err);
+    } finally {
+      this.processing = false;
+      // Process next in queue
+      if (this.commandQueue.length > 0) {
+        this._processNext();
+      }
+    }
+  }
+
+  async _execCommand(command, { timeoutMs = 60000, abortSignal } = {}) {
+    if (!this.isAlive) {
+      throw new Error('Shell is not alive');
+    }
+
+    const isWin = process.platform === 'win32';
+    const tmpDir = os.tmpdir();
+    const ts = Date.now() + '-' + Math.random().toString(36).slice(2, 8);
+    const stdoutFile = path.join(tmpDir, `uc-stdout-${ts}`);
+    const stderrFile = path.join(tmpDir, `uc-stderr-${ts}`);
+    const statusFile = path.join(tmpDir, `uc-status-${ts}`);
+    const cwdFile = path.join(tmpDir, `uc-cwd-${ts}`);
+
+    try {
+      // Build the shell command that redirects output to temp files
+      // Exact same pattern as opencode's shell.go execCommand
+      let fullCommand;
+      if (isWin) {
+        // Windows cmd.exe variant
+        fullCommand = [
+          `${command} > "${stdoutFile}" 2> "${stderrFile}"`,
+          `echo %ERRORLEVEL% > "${statusFile}"`,
+          `cd > "${cwdFile}"`,
+        ].join(' & ');
+      } else {
+        // Unix bash variant (identical to opencode)
+        const escaped = command.replace(/'/g, "'\\''");
+        fullCommand = [
+          `eval '${escaped}' < /dev/null > '${stdoutFile}' 2> '${stderrFile}'`,
+          `EXEC_EXIT_CODE=$?`,
+          `pwd > '${cwdFile}'`,
+          `echo $EXEC_EXIT_CODE > '${statusFile}'`,
+        ].join('\n');
+      }
+
+      this.stdin.write(fullCommand + '\n');
+
+      // Poll for status file (same polling pattern as opencode)
+      let interrupted = false;
+      const startTime = Date.now();
+
+      await new Promise((done, fail) => {
+        const poll = setInterval(async () => {
+          // Check abort
+          if (abortSignal?.aborted) {
+            this.killChildren();
+            interrupted = true;
+            clearInterval(poll);
+            done();
+            return;
+          }
+
+          // Check timeout
+          if (timeoutMs > 0 && Date.now() - startTime > timeoutMs) {
+            this.killChildren();
+            interrupted = true;
+            clearInterval(poll);
+            done();
+            return;
+          }
+
+          // Check if status file exists and has content
+          try {
+            const stat = await fs.stat(statusFile);
+            if (stat.size > 0) {
+              clearInterval(poll);
+              done();
+            }
+          } catch {
+            // File doesn't exist yet
+          }
+        }, 50);
+      });
+
+      // Read results from temp files
+      const stdout = await this._readFileOrEmpty(stdoutFile);
+      const stderr = await this._readFileOrEmpty(stderrFile);
+      const exitCodeStr = await this._readFileOrEmpty(statusFile);
+      const newCwd = await this._readFileOrEmpty(cwdFile);
+
+      let exitCode = 0;
+      if (exitCodeStr.trim()) {
+        exitCode = parseInt(exitCodeStr.trim(), 10) || 0;
+      } else if (interrupted) {
+        exitCode = 143;
+      }
+
+      if (newCwd.trim()) {
+        this.cwd = newCwd.trim();
+      }
+
+      return {
+        stdout: stdout,
+        stderr: interrupted ? stderr + '\nCommand execution timed out or was interrupted' : stderr,
+        exitCode,
+        interrupted,
+        cwd: this.cwd,
+      };
+    } finally {
+      // Cleanup temp files
+      await Promise.all([
+        fs.unlink(stdoutFile).catch(() => {}),
+        fs.unlink(stderrFile).catch(() => {}),
+        fs.unlink(statusFile).catch(() => {}),
+        fs.unlink(cwdFile).catch(() => {}),
+      ]);
+    }
+  }
+
+  /**
+   * Kill child processes of the shell (opencode pattern: killChildren).
+   * On Unix: pgrep -P <pid> → SIGTERM each child.
+   * On Windows: taskkill /PID /T.
+   */
+  killChildren() {
+    if (!this.proc?.pid) return;
+    try {
+      if (process.platform === 'win32') {
+        execSync(`taskkill /PID ${this.proc.pid} /T /F`, { stdio: 'ignore', timeout: 5000 });
+        // Respawn since taskkill kills the parent too on Windows
+        this._start();
+      } else {
+        const output = execSync(`pgrep -P ${this.proc.pid}`, { encoding: 'utf8', timeout: 5000 });
+        for (const line of output.split('\n')) {
+          const pid = parseInt(line.trim(), 10);
+          if (pid > 0) {
+            try { process.kill(pid, 'SIGTERM'); } catch { /* already dead */ }
+          }
+        }
+      }
+    } catch {
+      // pgrep/taskkill failed — no children to kill
+    }
+  }
+
+  /**
+   * Close the persistent shell.
+   */
+  close() {
+    if (!this.isAlive) return;
+    try {
+      this.stdin.write('exit\n');
+      this.proc.kill('SIGTERM');
+    } catch { /* ignore */ }
+    this.isAlive = false;
+  }
+
+  async _readFileOrEmpty(filePath) {
+    try {
+      return await fs.readFile(filePath, 'utf8');
+    } catch {
+      return '';
+    }
+  }
+}

package/src/server.js

@@ -0,0 +1,54 @@
+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('  API proxy active. 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);
+  });
+}