@mrpatronz/nexusflow 0.2.11 → 0.2.13

package/src/orchestration/runner.ts

@@ -1,22 +1,19 @@
 /**
  * @module orchestration/runner
  * Manages the lifecycle of services — start, stop, status, and log streaming.
- * Spawns child processes and tracks them via a state file.
+ * Uses PM2 for process management.
  */
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { spawn, type ChildProcess } from 'node:child_process';
 import chalk from 'chalk';
+import { execa } from 'execa';
 
 import type { ServiceConfig, RunningService, RunningState } from '../types.js';
 
 /** Name of the state file that tracks running services. */
 const STATE_FILE = '.nexusflow-running.json';
 
-/** Active child processes tracked in memory. */
-const activeProcesses = new Map<string, ChildProcess>();
-
 /**
  * Returns the path to the running-state file for a workspace.
  */
@@ -25,12 +22,39 @@ function getStatePath(workspacePath: string): string {
 }
 
 /**
- * Loads the running state from disk.
+ * Loads the running state from disk, syncing active status with PM2.
  */
 export async function loadRunningState(workspacePath: string): Promise<RunningState | null> {
   try {
     const raw = await fs.readFile(getStatePath(workspacePath), 'utf-8');
-    return JSON.parse(raw) as RunningState;
+    const state = JSON.parse(raw) as RunningState;
+
+    try {
+      // Query current PM2 process list to verify actual running status
+      const { stdout } = await execa('npx', ['pm2', 'jlist']);
+      const pm2List = JSON.parse(stdout);
+      const workspaceId = path.basename(workspacePath);
+      const prefix = `nexusflow-${workspaceId}-`;
+
+      const activeServices = state.services.map((service) => {
+        const uniqueName = `${prefix}${service.name}`;
+        const pm2App = pm2List.find((app: any) => app.name === uniqueName);
+        const running = pm2App && pm2App.pm2_env?.status === 'online';
+        return {
+          ...service,
+          pid: running ? (pm2App.pid || service.pid) : 0,
+        };
+      }).filter((service) => service.pid > 0);
+
+      return {
+        ...state,
+        services: activeServices,
+        updatedAt: new Date().toISOString(),
+      };
+    } catch {
+      // Fallback to cached state on disk if PM2 query fails
+      return state;
+    }
   } catch {
     return null;
   }
@@ -56,20 +80,7 @@ async function clearRunningState(workspacePath: string): Promise<void> {
 }
 
 /**
- * Checks if a process with the given PID is still running.
- */
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Starts all services in the given list.
- * Each service is spawned as a detached child process.
+ * Starts all services in the given list using PM2.
  *
  * @param services      - Services to start.
  * @param workspacePath - Workspace root path.
@@ -84,63 +95,66 @@ export async function startServices(
   await fs.mkdir(logDir, { recursive: true });
 
   const runningServices: RunningService[] = [];
+  const workspaceId = path.basename(workspacePath);
 
   for (const service of services) {
     const logFile = path.join(logDir, `${service.name}.log`);
     const portStr = service.port ? ` on port ${service.port}` : '';
+    const uniqueName = `nexusflow-${workspaceId}-${service.name}`;
 
     console.log(
-      chalk.cyan(`  Starting ${chalk.bold(service.name)}${portStr}...`),
+      chalk.cyan(`  Starting ${chalk.bold(service.name)}${portStr} under PM2...`),
     );
     console.log(
       chalk.dim(`    ${service.command} ${service.args.join(' ')} (in ${service.cwd})`),
     );
 
     try {
-      // Ensure parent directory for this log file exists (supports nested names)
+      // Ensure parent directory for this log file exists
       await fs.mkdir(path.dirname(logFile), { recursive: true });
-      // Open log file for writing
-      const logFd = await fs.open(logFile, 'w');
-      const logStream = logFd.createWriteStream();
-
-      const child = spawn(service.command, service.args, {
-        cwd: service.cwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: true,
-        shell: true,
-      });
-
-      // Pipe stdout and stderr to log file
-      child.stdout?.pipe(logStream);
-      child.stderr?.pipe(logStream);
-
-      child.on('error', (err) => {
-        console.error(chalk.red(`  ✖ ${service.name} error: ${err.message}`));
-      });
-
-      child.on('exit', (code) => {
-        if (code !== null && code !== 0) {
-          console.log(chalk.yellow(`  ⚠ ${service.name} exited with code ${code}`));
-        }
-        activeProcesses.delete(service.name);
-      });
-
-      // Don't wait for the child to finish
-      child.unref();
-
-      if (child.pid) {
-        activeProcesses.set(service.name, child);
+
+      // Delete any existing PM2 configuration with the same name to avoid duplicate starts
+      await execa('npx', ['pm2', 'delete', uniqueName], { reject: false });
+
+      // Start the service using PM2 as a direct process execution
+      await execa('npx', [
+        'pm2',
+        'start',
+        service.command,
+        '--name',
+        uniqueName,
+        '--cwd',
+        service.cwd,
+        '-o',
+        logFile,
+        '-e',
+        logFile,
+        '--interpreter',
+        'none',
+        '--',
+        ...service.args
+      ]);
+
+      // Retrieve the real PID from PM2
+      const { stdout } = await execa('npx', ['pm2', 'jlist']);
+      const pm2List = JSON.parse(stdout);
+      const pm2App = pm2List.find((app: any) => app.name === uniqueName);
+      const pid = pm2App?.pid || 0;
+
+      if (pid) {
         runningServices.push({
           name: service.name,
-          pid: child.pid,
+          pid,
           config: service,
           startedAt: new Date().toISOString(),
         });
-        console.log(chalk.green(`  ✔ ${service.name} started (PID: ${child.pid})`));
+        console.log(chalk.green(`  ✔ ${service.name} started under PM2 (PID: ${pid})`));
+      } else {
+        console.warn(chalk.yellow(`  ⚠ Started ${service.name} but could not resolve PID from PM2.`));
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
-      console.error(chalk.red(`  ✖ Failed to start ${service.name}: ${msg}`));
+      console.error(chalk.red(`  ✖ Failed to start ${service.name} via PM2: ${msg}`));
     }
   }
 
@@ -155,79 +169,69 @@ export async function startServices(
 }
 
 /**
- * Stops all services for a workspace.
+ * Stops all services for a workspace under PM2.
  *
  * @param workspacePath - Workspace root path.
  */
 export async function stopServices(workspacePath: string): Promise<void> {
-  const state = await loadRunningState(workspacePath);
+  const workspaceId = path.basename(workspacePath);
+  const prefix = `nexusflow-${workspaceId}-`;
 
-  if (!state || state.services.length === 0) {
-    console.log(chalk.yellow('  No running services found.'));
-    return;
-  }
+  console.log(chalk.cyan(`  Stopping all services under PM2 for workspace: ${workspaceId}...`));
 
-  for (const service of state.services) {
-    // Try in-memory process first
-    const child = activeProcesses.get(service.name);
-    if (child && child.pid) {
-      try {
-        // Kill the process group (negative PID kills group on Unix, taskkill on Windows)
-        if (process.platform === 'win32') {
-          spawn('taskkill', ['/pid', String(child.pid), '/f', '/t'], { stdio: 'ignore' });
-        } else {
-          process.kill(-child.pid, 'SIGTERM');
-        }
-        console.log(chalk.green(`  ✔ Stopped ${service.name} (PID: ${service.pid})`));
-        activeProcesses.delete(service.name);
-        continue;
-      } catch {
-        // Fall through to PID-based kill
-      }
-    }
+  try {
+    const { stdout } = await execa('npx', ['pm2', 'jlist']);
+    const pm2List = JSON.parse(stdout);
+    const targetApps = pm2List.filter((app: any) => app.name && app.name.startsWith(prefix));
 
-    // Fall back to PID from state file
-    if (isProcessRunning(service.pid)) {
-      try {
-        if (process.platform === 'win32') {
-          spawn('taskkill', ['/pid', String(service.pid), '/f', '/t'], { stdio: 'ignore' });
-        } else {
-          process.kill(service.pid, 'SIGTERM');
-        }
-        console.log(chalk.green(`  ✔ Stopped ${service.name} (PID: ${service.pid})`));
-      } catch {
-        console.log(chalk.yellow(`  ⚠ Could not stop ${service.name} (PID: ${service.pid})`));
-      }
+    if (targetApps.length === 0) {
+      console.log(chalk.yellow('  No running services found for this workspace.'));
     } else {
-      console.log(chalk.dim(`  ${service.name} already stopped`));
+      for (const app of targetApps) {
+        console.log(chalk.dim(`    Stopping PM2 process: ${app.name}`));
+        await execa('npx', ['pm2', 'delete', app.name], { reject: false });
+      }
+      console.log(chalk.green(`  ✔ All services stopped.`));
     }
+  } catch (error: any) {
+    console.error(chalk.red(`  ✖ Failed to stop services via PM2: ${error.message}`));
   }
 
   await clearRunningState(workspacePath);
 }
 
 /**
- * Shows the status of all services in a workspace.
+ * Shows the status of all services in a workspace by querying PM2.
  *
  * @param workspacePath - Workspace root path.
  */
 export async function getServiceStatus(workspacePath: string): Promise<void> {
-  const state = await loadRunningState(workspacePath);
+  const workspaceId = path.basename(workspacePath);
+  const prefix = `nexusflow-${workspaceId}-`;
 
-  if (!state || state.services.length === 0) {
-    console.log(chalk.yellow('  No services tracked for this workspace.'));
-    return;
-  }
+  try {
+    const { stdout } = await execa('npx', ['pm2', 'jlist']);
+    const pm2List = JSON.parse(stdout);
+    const targetApps = pm2List.filter((app: any) => app.name && app.name.startsWith(prefix));
 
-  for (const service of state.services) {
-    const running = isProcessRunning(service.pid);
-    const status = running ? chalk.green('● running') : chalk.red('● stopped');
-    const portStr = service.config.port ? ` :${service.config.port}` : '';
-    const since = new Date(service.startedAt).toLocaleTimeString();
+    if (targetApps.length === 0) {
+      console.log(chalk.yellow('  No running services found for this workspace in PM2.'));
+      return;
+    }
 
-    console.log(
-      `  ${status} ${chalk.bold(service.name)}${chalk.dim(portStr)} (PID: ${service.pid}, since ${since})`,
-    );
+    for (const app of targetApps) {
+      const name = app.name.substring(prefix.length);
+      const running = app.pm2_env?.status === 'online';
+      const status = running ? chalk.green('● running') : chalk.red(`● ${app.pm2_env?.status || 'stopped'}`);
+      const pid = app.pid || 'N/A';
+      const uptime = app.pm2_env?.pm_uptime ? new Date(app.pm2_env.pm_uptime).toLocaleTimeString() : 'unknown';
+
+      console.log(
+        `  ${status} ${chalk.bold(name)} (PID: ${pid}, since ${uptime})`,
+      );
+    }
+  } catch (error: any) {
+    console.error(chalk.red(`  ✖ Failed to query PM2 status: ${error.message}`));
   }
 }
 

package/src/server.ts

@@ -46,7 +46,7 @@ const guiPath = path.join(__dirname, 'gui');
 export const app = new Hono();
 
 // Allowed editor binaries/scripts to prevent command injection
-const ALLOWED_EDITORS = new Set(['code', 'code-insiders', 'cursor', 'agy', 'idea', 'charm', 'webstorm', 'subl', 'nano', 'vim', 'nvim', 'emacs']);
+const ALLOWED_EDITORS = new Set(['code', 'code-insiders', 'cursor', 'antigravity', 'agy', 'idea', 'charm', 'webstorm', 'subl', 'nano', 'vim', 'nvim', 'emacs']);
 
 // Enable CORS for frontend dev server
 app.use('/api/*', cors());
@@ -700,6 +700,63 @@ app.get('/api/workspace/:id/changes', async (c) => {
   }
 });
 
+// 13_diff. Get git diff for a specific file in workspace sub-repositories
+app.get('/api/workspace/:id/changes/diff', async (c) => {
+  try {
+    const id = c.req.param('id');
+    const repoName = c.req.query('repo');
+    const filePath = c.req.query('file');
+
+    if (!repoName || !filePath) {
+      return c.json({ error: 'Missing repo or file query parameter.' }, 400);
+    }
+
+    const config = await loadConfig();
+    const workspacePath = path.join(config.workspacesDir, id);
+    const worktreePath = path.join(workspacePath, repoName);
+
+    // Security check: ensure path is within workspace directory
+    const resolvedPath = path.resolve(worktreePath);
+    if (!resolvedPath.startsWith(path.resolve(workspacePath))) {
+      return c.json({ error: 'Invalid repository path.' }, 400);
+    }
+
+    let diff = '';
+    
+    // Check git status for the file to know if it's untracked
+    try {
+      const { stdout: statusOut } = await execa('git', ['status', '--porcelain', '--', filePath], { cwd: worktreePath });
+      const statusLine = statusOut.trim();
+      const isUntracked = statusLine.startsWith('??');
+      
+      if (isUntracked) {
+        const result = await execa('git', ['diff', '--no-index', '--', '/dev/null', filePath], {
+          cwd: worktreePath,
+          reject: false
+        });
+        diff = result.stdout || result.stderr || '';
+      } else {
+        const result = await execa('git', ['diff', 'HEAD', '--', filePath], {
+          cwd: worktreePath,
+          reject: false
+        });
+        diff = result.stdout || result.stderr || '';
+      }
+    } catch (e) {
+      const result = await execa('git', ['diff', 'HEAD', '--', filePath], {
+        cwd: worktreePath,
+        reject: false
+      });
+      diff = result.stdout || result.stderr || '';
+    }
+
+    return c.json({ diff });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // 13a. Get workspace knowledge (nexusflow-knowledge.md)
 app.get('/api/workspace/:id/knowledge', async (c) => {
   try {
@@ -978,7 +1035,10 @@ app.post('/api/updates/install', async (c) => {
       return c.json({ error: 'Tool not found' }, 404);
     }
 
-    const result = await execa(target.cmd, target.args, { reject: false });
+    const result = await execa(target.cmd, target.args, {
+      reject: false,
+      shell: process.platform === 'win32',
+    });
     if (result.exitCode === 0) {
       return c.json({ success: true, output: result.stdout });
     } else {

package/src/utils/detect-ai.ts

@@ -13,7 +13,10 @@ import type { AIAssistant, DetectedAI } from '../types.js';
  */
 async function commandExists(command: string): Promise<boolean> {
   try {
-    const result = await execa(command, ['--version'], { reject: false });
+    const result = await execa(command, ['--version'], {
+      reject: false,
+      shell: process.platform === 'win32',
+    });
     return result.exitCode === 0;
   } catch {
     // The command could not be spawned at all (not in PATH).

package/src/utils/detect-editors.test.ts

@@ -23,13 +23,14 @@ describe('detectEditors', () => {
       { name: 'VS Code', command: 'code', detected: true },
       { name: 'VS Code Insiders', command: 'code-insiders', detected: false },
       { name: 'Cursor', command: 'cursor', detected: true },
-      { name: 'Antigravity', command: 'agy', detected: false },
+      { name: 'Antigravity', command: 'antigravity', detected: false },
     ]);
 
-    expect(execa).toHaveBeenCalledWith('code', ['--version'], { reject: false });
-    expect(execa).toHaveBeenCalledWith('code-insiders', ['--version'], { reject: false });
-    expect(execa).toHaveBeenCalledWith('cursor', ['--version'], { reject: false });
-    expect(execa).toHaveBeenCalledWith('agy', ['--version'], { reject: false });
+    const isWin = process.platform === 'win32';
+    expect(execa).toHaveBeenCalledWith('code', ['--version'], { reject: false, shell: isWin });
+    expect(execa).toHaveBeenCalledWith('code-insiders', ['--version'], { reject: false, shell: isWin });
+    expect(execa).toHaveBeenCalledWith('cursor', ['--version'], { reject: false, shell: isWin });
+    expect(execa).toHaveBeenCalledWith('antigravity', ['--version'], { reject: false, shell: isWin });
   });
 
   it('should return detected = false for all editors if execa throws an error', async () => {
@@ -41,7 +42,7 @@ describe('detectEditors', () => {
       { name: 'VS Code', command: 'code', detected: false },
       { name: 'VS Code Insiders', command: 'code-insiders', detected: false },
       { name: 'Cursor', command: 'cursor', detected: false },
-      { name: 'Antigravity', command: 'agy', detected: false },
+      { name: 'Antigravity', command: 'antigravity', detected: false },
     ]);
   });
 });

package/src/utils/detect-editors.ts

@@ -12,7 +12,7 @@ const EDITOR_CANDIDATES: ReadonlyArray<{ name: string; command: string }> = [
   { name: 'VS Code', command: 'code' },
   { name: 'VS Code Insiders', command: 'code-insiders' },
   { name: 'Cursor', command: 'cursor' },
-  { name: 'Antigravity', command: 'agy' },
+  { name: 'Antigravity', command: 'antigravity' },
 ];
 
 /**
@@ -21,7 +21,10 @@ const EDITOR_CANDIDATES: ReadonlyArray<{ name: string; command: string }> = [
  */
 async function commandExists(command: string): Promise<boolean> {
   try {
-    const result = await execa(command, ['--version'], { reject: false });
+    const result = await execa(command, ['--version'], {
+      reject: false,
+      shell: process.platform === 'win32',
+    });
     return result.exitCode === 0;
   } catch {
     return false;

package/src/utils/prompts.ts

@@ -3,7 +3,7 @@
  * Interactive CLI prompts for NexusFlow using @inquirer/prompts.
  */
 
-import { input, checkbox, confirm } from '@inquirer/prompts';
+import { input, checkbox, confirm, select, search } from '@inquirer/prompts';
 import chalk from 'chalk';
 
 import type { AIAssistant, DetectedAI, DetectedEditor, RepoInfo } from '../types.js';
@@ -57,26 +57,100 @@ export async function promptDescription(): Promise<string> {
 
 /**
  * Prompts the user to select repos from a list of discovered repos.
+ * Supports searching/filtering by term, viewing all, and incremental selection.
  */
 export async function promptSelectRepos(repos: RepoInfo[]): Promise<RepoInfo[]> {
   if (repos.length === 0) {
     return [];
   }
 
-  const selected = await checkbox({
-    message: 'Select projects to include:',
-    choices: repos.map((repo) => ({
-      name: `${repo.name} ${chalk.dim(`(${repo.path})`)}`,
-      value: repo.path,
-      checked: false,
-    })),
-    validate: (items) => {
-      if (items.length === 0) return 'Please select at least one project';
-      return true;
-    },
-  });
+  const selectedPaths = new Set<string>();
+
+  // If there are only a few repos (e.g. <= 10), we can just show a checkbox prompt directly to save time
+  if (repos.length <= 10) {
+    const toggled = await checkbox({
+      message: 'Select repositories to include in workspace:',
+      choices: repos.map((repo) => ({
+        name: `${repo.name} ${chalk.dim(`(${repo.path})`)}`,
+        value: repo.path,
+        checked: false,
+      })),
+    });
+    return repos.filter((r) => toggled.includes(r.path));
+  }
+
+  // Otherwise, use a loop with the search prompt to make it extremely easy to filter and toggle selection
+  while (true) {
+    console.log(chalk.bold(`\n📁 Selected Repositories (${selectedPaths.size}/${repos.length}):`));
+    if (selectedPaths.size === 0) {
+      console.log(chalk.dim('  (None selected yet)'));
+    } else {
+      repos.forEach((r) => {
+        if (selectedPaths.has(r.path)) {
+          console.log(`  ${chalk.green('✓')} ${r.name} ${chalk.dim(`(${r.path})`)}`);
+        }
+      });
+    }
+    console.log();
+
+    const result = await search({
+      message: 'Search and select repositories (type to filter, select to toggle, choose Done to finish):',
+      source: async (input) => {
+        const query = (input || '').toLowerCase();
+        const filtered = repos.filter(
+          (r) =>
+            r.name.toLowerCase().includes(query) ||
+            r.path.toLowerCase().includes(query)
+        );
+
+        const choices = [
+          {
+            name: chalk.green(`✅ Done selecting (${selectedPaths.size} repo(s) selected)`),
+            value: 'done',
+          },
+        ];
+
+        if (selectedPaths.size > 0) {
+          choices.push({
+            name: chalk.yellow('🧹 Clear all selections'),
+            value: 'clear',
+          });
+        }
+
+        filtered.forEach((r) => {
+          const isSelected = selectedPaths.has(r.path);
+          choices.push({
+            name: `${isSelected ? chalk.green('✓') : ' '} ${r.name} ${chalk.dim(`(${r.path})`)}`,
+            value: r.path,
+          });
+        });
+
+        return choices;
+      },
+    });
+
+    if (result === 'done') {
+      if (selectedPaths.size === 0) {
+        console.log(chalk.red('  Please select at least one repository.'));
+        continue;
+      }
+      break;
+    }
+
+    if (result === 'clear') {
+      selectedPaths.clear();
+      continue;
+    }
+
+    // Toggle selected state
+    if (selectedPaths.has(result)) {
+      selectedPaths.delete(result);
+    } else {
+      selectedPaths.add(result);
+    }
+  }
 
-  return repos.filter((r) => selected.includes(r.path));
+  return repos.filter((r) => selectedPaths.has(r.path));
 }
 
 /**

package/src/utils/update-check.ts

@@ -178,11 +178,17 @@ export async function getToolsStatus(force = false): Promise<ToolUpdateStatus[]>
       updateCmd: 'npm install -g repomix',
       getCurrent: async () => {
         try {
-          const res = await execa('repomix', ['--version'], { reject: false });
+          const res = await execa('repomix', ['--version'], {
+            reject: false,
+            shell: process.platform === 'win32',
+          });
           if (res.exitCode === 0) return res.stdout.trim();
         } catch {}
         try {
-          const res = await execa('npx', ['repomix', '--version'], { reject: false });
+          const res = await execa('npx', ['repomix', '--version'], {
+            reject: false,
+            shell: process.platform === 'win32',
+          });
           if (res.exitCode === 0) return res.stdout.trim();
         } catch {}
         return '';
@@ -196,7 +202,10 @@ export async function getToolsStatus(force = false): Promise<ToolUpdateStatus[]>
       updateCmd: 'agy update',
       getCurrent: async () => {
         try {
-          const res = await execa('agy', ['--version'], { reject: false });
+          const res = await execa('agy', ['--version'], {
+            reject: false,
+            shell: process.platform === 'win32',
+          });
           if (res.exitCode === 0) return res.stdout.trim();
         } catch {}
         return '';
@@ -210,7 +219,10 @@ export async function getToolsStatus(force = false): Promise<ToolUpdateStatus[]>
       updateCmd: 'npm install -g @anthropic-ai/claude-code',
       getCurrent: async () => {
         try {
-          const res = await execa('claude', ['--version'], { reject: false });
+          const res = await execa('claude', ['--version'], {
+            reject: false,
+            shell: process.platform === 'win32',
+          });
           if (res.exitCode === 0) return res.stdout.trim();
         } catch {}
         return '';