dr-claw 1.1.2 → 1.1.4

package/server/routes/commands.js

@@ -126,6 +126,12 @@ const builtInCommands = [
     description: 'Rewind the conversation to a previous state',
     namespace: 'builtin',
     metadata: { type: 'builtin' }
+  },
+  {
+    name: '/btw',
+    description: 'Ask a quick side question in an overlay (Claude only; does not add to chat history)',
+    namespace: 'builtin',
+    metadata: { type: 'builtin' }
   }
 ];
 
@@ -396,7 +402,25 @@ Custom commands can be created in:
         message: `Rewinding conversation by ${steps} step${steps > 1 ? 's' : ''}...`
       }
     };
-  }
+  },
+
+  '/btw': async (args) => {
+    const question = args.join(' ').trim();
+    if (!question) {
+      return {
+        type: 'builtin',
+        action: 'btw',
+        data: {
+          error: 'Usage: /btw <your question>',
+        },
+      };
+    }
+    return {
+      type: 'builtin',
+      action: 'btw',
+      data: { question },
+    };
+  },
 };
 
 /**

package/server/routes/community-tools.js

@@ -0,0 +1,398 @@
+import express from 'express';
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadAllNodes, loadNodeConfig, ComputeNode } from '../compute-node.js';
+
+const router = express.Router();
+
+// Ensure ~/.local/bin and common paths are on PATH for spawned processes
+const EXTENDED_ENV = {
+  ...process.env,
+  HOME: os.homedir(),
+  PATH: [
+    path.join(os.homedir(), '.local', 'bin'),
+    path.join(os.homedir(), '.npm-global', 'bin'),
+    '/usr/local/bin',
+    process.env.PATH || '',
+  ].join(':'),
+};
+
+function spawnAsync(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      ...options,
+      shell: false,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+        return;
+      }
+      const error = new Error(`Command failed: ${command} ${args.join(' ')}`);
+      error.code = code;
+      error.stdout = stdout;
+      error.stderr = stderr;
+      reject(error);
+    });
+  });
+}
+
+// POST /api/community-tools/configure
+// Body: { projectPath, mcpBackend, apiKeys, gpuConfig }
+router.post('/configure', async (req, res) => {
+  try {
+    if (!req.body || typeof req.body !== 'object') {
+      return res.status(400).json({ error: 'Invalid request body' });
+    }
+    const { projectPath, mcpBackend, apiKeys, gpuConfig } = req.body;
+
+    // Resolve project path: use provided path, or fall back to server's working directory
+    // (which is typically the VibeLab install directory)
+    let resolvedPath;
+    if (projectPath && projectPath !== '.') {
+      resolvedPath = path.resolve(projectPath);
+    } else {
+      // Use __dirname parent (VibeLab root) as default
+      // community-tools.js is in server/routes/ — go up 2 levels to VibeLab root
+      resolvedPath = path.resolve(path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..'));
+    }
+
+    const results = { steps: [], errors: [] };
+
+    // ── Step 1: Write API keys to ~/.openclaw/community-tools.json ──
+    // (NOT project .env — writing .env triggers Vite restart and kills the fetch)
+    if (apiKeys && Object.keys(apiKeys).length > 0) {
+      try {
+        const configDir = path.join(os.homedir(), '.openclaw');
+        const configPath = path.join(configDir, 'community-tools.json');
+        await fs.mkdir(configDir, { recursive: true });
+
+        let existing = {};
+        try {
+          existing = JSON.parse(await fs.readFile(configPath, 'utf8'));
+        } catch {
+          // file doesn't exist yet
+        }
+
+        // Merge keys into config
+        const envKeys = existing.envKeys || {};
+        for (const [key, value] of Object.entries(apiKeys)) {
+          if (value && value.trim()) {
+            envKeys[key] = value.trim();
+          }
+        }
+        existing.envKeys = envKeys;
+
+        await fs.writeFile(configPath, JSON.stringify(existing, null, 2), { mode: 0o600 });
+
+        // Also write a shell-sourceable file for convenience
+        // Escape values: replace \ with \\, " with \", $ with \$, ` with \`
+        const shellEscape = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
+        const rcPath = path.join(configDir, 'community-tools.env');
+        const rcContent = Object.entries(envKeys)
+          .map(([k, v]) => `export ${k}="${shellEscape(v)}"`)
+          .join('\n') + '\n';
+        await fs.writeFile(rcPath, rcContent, { mode: 0o600 });
+
+        results.steps.push({ step: 'env', status: 'ok', message: `Saved ${Object.keys(apiKeys).length} key(s) to ~/.openclaw/community-tools.json` });
+      } catch (err) {
+        results.errors.push({ step: 'env', error: err.message });
+      }
+    }
+
+    // ── Step 2: Register MCP server ──
+    if (mcpBackend) {
+      try {
+        const mcpCommands = {
+          codex: ['mcp', 'add', 'codex', '-s', 'user', '--', 'codex', 'mcp-server'],
+          'llm-chat': ['mcp', 'add', 'llm-chat', '-s', 'user', '--', 'python3', path.join(resolvedPath, 'skills/aris-infra/mcp-servers/llm-chat/server.py')],
+          gemini: ['mcp', 'add', 'gemini-review', '-s', 'user', '--', 'python3', path.join(resolvedPath, 'skills/aris-infra/mcp-servers/gemini-review/server.py')],
+        };
+
+        const ENV_ONLY_BACKENDS = ['gemini-figure'];
+        const args = mcpCommands[mcpBackend];
+        if (!args) {
+          if (ENV_ONLY_BACKENDS.includes(mcpBackend)) {
+            results.steps.push({ step: 'mcp', status: 'skipped', message: `No MCP server needed for ${mcpBackend}` });
+          } else {
+            results.errors.push({ step: 'mcp', error: `Unknown backend: ${mcpBackend}` });
+          }
+        } else {
+          // Check if already registered
+          let alreadyRegistered = false;
+          try {
+            const { stdout } = await spawnAsync('claude', ['mcp', 'list'], { env: EXTENDED_ENV });
+            alreadyRegistered = stdout.includes(mcpBackend);
+          } catch {
+            // claude mcp list failed, proceed with registration
+          }
+
+          if (alreadyRegistered) {
+            results.steps.push({ step: 'mcp', status: 'skipped', message: `${mcpBackend} MCP already registered` });
+          } else {
+            await spawnAsync('claude', args, { env: EXTENDED_ENV });
+            results.steps.push({ step: 'mcp', status: 'ok', message: `Registered ${mcpBackend} MCP server` });
+          }
+        }
+
+        // Install codex CLI if needed
+        if (mcpBackend === 'codex') {
+          try {
+            await spawnAsync('which', ['codex']);
+            results.steps.push({ step: 'codex-cli', status: 'skipped', message: 'Codex CLI already installed' });
+          } catch {
+            try {
+              await spawnAsync('npm', ['install', '-g', '@openai/codex'], { env: EXTENDED_ENV });
+              results.steps.push({ step: 'codex-cli', status: 'ok', message: 'Installed Codex CLI' });
+            } catch (err) {
+              results.errors.push({ step: 'codex-cli', error: `Failed to install codex: ${err.message}` });
+            }
+          }
+        }
+      } catch (err) {
+        results.errors.push({ step: 'mcp', error: err.message });
+      }
+    }
+
+    // ── Step 3: Write GPU config to CLAUDE.md ──
+    if (gpuConfig) {
+      try {
+        const claudeMdPath = path.join(resolvedPath, 'CLAUDE.md');
+        let claudeContent = '';
+        try {
+          claudeContent = await fs.readFile(claudeMdPath, 'utf8');
+        } catch {
+          // CLAUDE.md doesn't exist
+        }
+
+        // Check if GPU section already exists
+        if (claudeContent.includes('gpu:')) {
+          results.steps.push({ step: 'gpu', status: 'skipped', message: 'GPU config already exists in CLAUDE.md' });
+        } else {
+          const separator = claudeContent.trim() ? '\n\n' : '';
+          await fs.writeFile(claudeMdPath, claudeContent + separator + gpuConfig.trim() + '\n', 'utf8');
+          results.steps.push({ step: 'gpu', status: 'ok', message: 'Added GPU config to CLAUDE.md' });
+        }
+      } catch (err) {
+        results.errors.push({ step: 'gpu', error: err.message });
+      }
+    }
+
+    // ── Step 4: Symlink skills ──
+    try {
+      const skillsDir = path.join(resolvedPath, 'skills');
+      const claudeSkillsDir = path.join(os.homedir(), '.claude', 'skills');
+      await fs.mkdir(claudeSkillsDir, { recursive: true });
+
+      let linked = 0;
+      const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && (entry.name.startsWith('aris-') || entry.name.startsWith('inno-') || entry.name === 'autoresearch')) {
+          const target = path.join(claudeSkillsDir, entry.name);
+          try {
+            await fs.access(target);
+            // already exists
+          } catch {
+            await fs.symlink(path.join(skillsDir, entry.name), target);
+            linked++;
+          }
+        }
+      }
+      results.steps.push({ step: 'skills', status: 'ok', message: `${linked} new skill(s) linked` });
+    } catch (err) {
+      results.errors.push({ step: 'skills', error: err.message });
+    }
+
+    const success = results.errors.length === 0;
+    res.json({ success, ...results });
+  } catch (error) {
+    console.error('Community tools configure error:', error);
+    res.status(500).json({ error: 'Configuration failed. Check server logs for details.' });
+  }
+});
+
+// GET /api/community-tools/status
+router.get('/status', async (req, res) => {
+  try {
+    const projectPath = req.query.path;
+    if (!projectPath) {
+      return res.status(400).json({ error: 'path query param required' });
+    }
+
+    const resolvedPath = path.resolve(projectPath);
+    // Validate path is within home directory to prevent path traversal
+    if (!resolvedPath.startsWith(os.homedir())) {
+      return res.status(403).json({ error: 'Invalid path' });
+    }
+    const status = {
+      mcpRegistered: {},
+      envKeys: {},
+      gpuConfigured: false,
+      skillsLinked: 0,
+    };
+
+    // Check MCP servers
+    try {
+      const { stdout } = await spawnAsync('claude', ['mcp', 'list'], { env: EXTENDED_ENV });
+      status.mcpRegistered.codex = stdout.includes('codex');
+      status.mcpRegistered['llm-chat'] = stdout.includes('llm-chat');
+      status.mcpRegistered.gemini = stdout.includes('gemini-review');
+    } catch {
+      // claude CLI not available
+    }
+
+    // Check .env keys
+    try {
+      const envContent = await fs.readFile(path.join(resolvedPath, '.env'), 'utf8');
+      status.envKeys.OPENAI_API_KEY = envContent.includes('OPENAI_API_KEY=') && !envContent.includes('OPENAI_API_KEY=\n');
+      status.envKeys.LLM_API_KEY = envContent.includes('LLM_API_KEY=') && !envContent.includes('LLM_API_KEY=\n');
+      status.envKeys.GEMINI_API_KEY = envContent.includes('GEMINI_API_KEY=') && !envContent.includes('GEMINI_API_KEY=\n');
+    } catch {
+      // no .env
+    }
+
+    // Check CLAUDE.md GPU config
+    try {
+      const claudeContent = await fs.readFile(path.join(resolvedPath, 'CLAUDE.md'), 'utf8');
+      status.gpuConfigured = claudeContent.includes('gpu:');
+    } catch {
+      // no CLAUDE.md
+    }
+
+    // Check skill symlinks
+    try {
+      const claudeSkillsDir = path.join(os.homedir(), '.claude', 'skills');
+      const entries = await fs.readdir(claudeSkillsDir);
+      status.skillsLinked = entries.filter((e) => e.startsWith('aris-')).length;
+    } catch {
+      // no skills dir
+    }
+
+    res.json(status);
+  } catch (error) {
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// GET /api/community-tools/compute-nodes — list available compute nodes for GPU config
+router.get('/compute-nodes', async (req, res) => {
+  try {
+    const config = await loadAllNodes();
+    const nodes = (config.nodes || []).map((n) => ({
+      id: n.id,
+      name: n.name || n.host,
+      host: n.host,
+      user: n.user,
+      port: n.port || 22,
+      workDir: n.workDir || '~',
+      type: n.type || 'direct',
+      gpuInfo: n.gpuInfo || null,
+    }));
+    res.json({ nodes, activeNodeId: config.activeNodeId });
+  } catch (error) {
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// POST /api/community-tools/detect-gpu — detect GPU info from a compute node and return CLAUDE.md template
+router.post('/detect-gpu', async (req, res) => {
+  try {
+    const { nodeId } = req.body;
+    if (!nodeId) {
+      return res.status(400).json({ error: 'nodeId is required' });
+    }
+
+    const node = await loadNodeConfig(nodeId);
+    let gpuOutput = '';
+
+    try {
+      gpuOutput = await ComputeNode.run({
+        nodeId,
+        command: 'nvidia-smi --query-gpu=index,name,memory.total --format=csv,noheader 2>/dev/null || echo "NO_GPU"',
+      });
+    } catch (err) {
+      gpuOutput = 'NO_GPU';
+    }
+
+    // Parse GPU info
+    let gpuLine = 'No GPU detected';
+    const gpuLines = gpuOutput.trim().split('\n').filter((l) => l && !l.includes('NO_GPU'));
+
+    if (gpuLines.length > 0) {
+      // Parse: "0, NVIDIA A100-SXM4-80GB, 81920 MiB"
+      const gpus = gpuLines.map((line) => {
+        const parts = line.split(',').map((s) => s.trim());
+        const name = (parts[1] || 'GPU').replace('NVIDIA ', '');
+        const memMb = parseInt(parts[2]) || 0;
+        const memGb = Math.round(memMb / 1024);
+        return { name, memGb };
+      });
+      const firstName = gpus[0]?.name || 'GPU';
+      const firstMem = gpus[0]?.memGb || 0;
+      gpuLine = `${gpus.length}x ${firstName}${firstMem ? ` (${firstMem}GB)` : ''}`;
+    }
+
+    // Detect conda
+    let condaEnv = '';
+    try {
+      const condaOut = await ComputeNode.run({
+        nodeId,
+        command: 'conda info --envs 2>/dev/null | grep "\\*" | head -1 || echo ""',
+      });
+      const match = condaOut.trim().match(/^(\S+)/);
+      if (match && match[1] !== '') {
+        condaEnv = match[1];
+      }
+    } catch {
+      // no conda
+    }
+
+    // Build SSH command — sanitize user/host to prevent shell injection
+    const safeStr = (s) => String(s || '').replace(/[^a-zA-Z0-9._@\-]/g, '');
+    const sshCmd = node.port && node.port !== 22
+      ? `ssh -p ${parseInt(node.port) || 22} ${safeStr(node.user)}@${safeStr(node.host)}`
+      : `ssh ${safeStr(node.user)}@${safeStr(node.host)}`;
+
+    // Generate CLAUDE.md template
+    const template = [
+      '## Remote Server',
+      '- gpu: remote',
+      `- SSH: \`${sshCmd}\``,
+      `- GPU: ${gpuLine}`,
+      condaEnv ? `- Conda: \`conda activate ${condaEnv}\`` : '- Conda: `conda activate your_env`',
+      `- Code dir: \`${node.workDir || '~/experiments'}\``,
+      '- code_sync: rsync',
+    ].join('\n');
+
+    res.json({
+      success: true,
+      nodeId: node.id,
+      nodeName: node.name || node.host,
+      gpuLine,
+      template,
+    });
+  } catch (error) {
+    console.error('GPU detect error:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+export default router;

package/server/routes/compute.js

@@ -185,6 +185,79 @@ router.post('/nodes/:id/run', async (req, res) => {
   }
 });
 
+// GET /api/compute/nodes/:id/monitor - Get GPU and CPU usage
+router.get('/nodes/:id/monitor', async (req, res) => {
+  try {
+    const monitorCmd = [
+      'echo "===GPU_START==="',
+      '(nvidia-smi --query-gpu=index,name,utilization.gpu,utilization.memory,memory.used,memory.total,temperature.gpu,power.draw --format=csv,noheader,nounits 2>/dev/null || echo "NO_GPU")',
+      'echo "===GPU_END==="',
+      'echo "===CPU_START==="',
+      'nproc 2>/dev/null || echo "0"',
+      'echo "---"',
+      // 1-second load averages; top is more portable than mpstat
+      '(cat /proc/loadavg 2>/dev/null || uptime | sed "s/.*load average[s]*: //" | cut -d, -f1)',
+      'echo "---"',
+      // Memory info in MB
+      '(free -m 2>/dev/null | grep Mem || echo "Mem: 0 0 0 0 0 0")',
+      'echo "===CPU_END==="',
+    ].join(' && ');
+
+    const output = await ComputeNode.run({
+      nodeId: req.params.id,
+      command: monitorCmd,
+      skipSync: true,
+    });
+
+    const gpuSection = (output.match(/===GPU_START===\n([\s\S]*?)===GPU_END===/) || [])[1]?.trim() || '';
+    const cpuSection = (output.match(/===CPU_START===\n([\s\S]*?)===CPU_END===/) || [])[1]?.trim() || '';
+
+    const gpus = [];
+    if (gpuSection && gpuSection !== 'NO_GPU') {
+      for (const line of gpuSection.split('\n')) {
+        const parts = line.split(',').map(s => s.trim());
+        if (parts.length >= 7) {
+          gpus.push({
+            index: parseInt(parts[0]) || 0,
+            name: parts[1] || 'Unknown',
+            gpuUtil: parseFloat(parts[2]) || 0,
+            memUtil: parseFloat(parts[3]) || 0,
+            memUsedMB: parseFloat(parts[4]) || 0,
+            memTotalMB: parseFloat(parts[5]) || 0,
+            tempC: parseFloat(parts[6]) || 0,
+            powerW: parseFloat(parts[7]) || 0,
+          });
+        }
+      }
+    }
+
+    const cpuParts = cpuSection.split('---').map(s => s.trim());
+    const cpuCount = parseInt(cpuParts[0]) || 0;
+    const loadAvg = parseFloat(cpuParts[1]) || 0;
+    const memLine = cpuParts[2] || '';
+    const memTokens = memLine.split(/\s+/);
+    const memTotalMB = parseInt(memTokens[1]) || 0;
+    const memUsedMB = parseInt(memTokens[2]) || 0;
+
+    res.json({
+      success: true,
+      gpus,
+      cpu: {
+        cores: cpuCount,
+        loadAvg,
+        utilPercent: cpuCount > 0 ? Math.min(100, Math.round((loadAvg / cpuCount) * 100)) : 0,
+        memTotalMB,
+        memUsedMB,
+        memUtilPercent: memTotalMB > 0 ? Math.round((memUsedMB / memTotalMB) * 100) : 0,
+      },
+      timestamp: Date.now(),
+    });
+  } catch (error) {
+    console.error('Error monitoring compute node:', error);
+    res.json({ success: false, error: error.message, gpus: [], cpu: null, timestamp: Date.now() });
+  }
+});
+
 // ─── Slurm endpoints ───
 
 // GET /api/compute/nodes/:id/slurm/info - Get partition info
@@ -340,6 +413,88 @@ router.post('/run', async (req, res) => {
   }
 });
 
+// GET /api/compute/local/monitor - Monitor the local machine's CPU and GPU
+router.get('/local/monitor', async (_req, res) => {
+  const { exec } = await import('child_process');
+  const os = await import('os');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+
+  const platform = os.default.platform();
+
+  const run = async (cmd) => {
+    try {
+      const { stdout } = await execAsync(cmd, { timeout: 10000 });
+      return stdout.trim();
+    } catch {
+      return '';
+    }
+  };
+
+  try {
+    // --- GPU ---
+    const gpus = [];
+    const gpuRaw = await run(
+      'nvidia-smi --query-gpu=index,name,utilization.gpu,utilization.memory,memory.used,memory.total,temperature.gpu,power.draw --format=csv,noheader,nounits'
+    );
+    if (gpuRaw) {
+      for (const line of gpuRaw.split('\n')) {
+        const p = line.split(',').map(s => s.trim());
+        if (p.length >= 7) {
+          gpus.push({
+            index: parseInt(p[0]) || 0,
+            name: p[1] || 'Unknown',
+            gpuUtil: parseFloat(p[2]) || 0,
+            memUtil: parseFloat(p[3]) || 0,
+            memUsedMB: parseFloat(p[4]) || 0,
+            memTotalMB: parseFloat(p[5]) || 0,
+            tempC: parseFloat(p[6]) || 0,
+            powerW: parseFloat(p[7]) || 0,
+          });
+        }
+      }
+    }
+
+    // --- CPU ---
+    const cpuCores = os.default.cpus().length;
+    const loadAvg = os.default.loadavg()[0]; // 1-min
+    const totalMemMB = Math.round(os.default.totalmem() / (1024 * 1024));
+    const freeMemMB = Math.round(os.default.freemem() / (1024 * 1024));
+    const usedMemMB = totalMemMB - freeMemMB;
+
+    let cpuUtilPercent = Math.min(100, Math.round((loadAvg / cpuCores) * 100));
+
+    // On macOS, try to get a more accurate CPU usage from top
+    if (platform === 'darwin') {
+      const topOut = await run("top -l 1 -n 0 | head -4");
+      const cpuMatch = topOut.match(/CPU usage:\s+(\d+(?:\.\d+)?)% user,\s+(\d+(?:\.\d+)?)% sys/);
+      if (cpuMatch) {
+        cpuUtilPercent = Math.round(parseFloat(cpuMatch[1]) + parseFloat(cpuMatch[2]));
+      }
+    }
+
+    res.json({
+      success: true,
+      hostname: os.default.hostname(),
+      platform,
+      gpus,
+      cpu: {
+        cores: cpuCores,
+        model: os.default.cpus()[0]?.model || 'Unknown',
+        loadAvg,
+        utilPercent: cpuUtilPercent,
+        memTotalMB: totalMemMB,
+        memUsedMB: usedMemMB,
+        memUtilPercent: totalMemMB > 0 ? Math.round((usedMemMB / totalMemMB) * 100) : 0,
+      },
+      timestamp: Date.now(),
+    });
+  } catch (error) {
+    console.error('Error monitoring local machine:', error);
+    res.json({ success: false, error: error.message, gpus: [], cpu: null, timestamp: Date.now() });
+  }
+});
+
 router.get('/status', async (req, res) => {
   try {
     const node = await getActiveNode();

package/server/routes/git.js

@@ -1,6 +1,5 @@
 import express from 'express';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
+import { spawn } from 'child_process';
 import path from 'path';
 import { promises as fs } from 'fs';
 import { extractProjectDirectory } from '../projects.js';
@@ -8,7 +7,6 @@ import { queryClaudeSDK } from '../claude-sdk.js';
 import { spawnCursor } from '../cursor-cli.js';
 
 const router = express.Router();
-const execAsync = promisify(exec);
 
 function spawnAsync(command, args, options = {}) {
   return new Promise((resolve, reject) => {
@@ -98,14 +96,14 @@ async function validateGitRepository(projectPath) {
 
   try {
     // Allow any directory that is inside a work tree (repo root or nested folder).
-    const { stdout: insideWorkTreeOutput } = await execAsync('git rev-parse --is-inside-work-tree', { cwd: projectPath });
+    const { stdout: insideWorkTreeOutput } = await spawnAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: projectPath });
     const isInsideWorkTree = insideWorkTreeOutput.trim() === 'true';
     if (!isInsideWorkTree) {
       throw new Error('Not inside a git work tree');
     }
 
     // Ensure git can resolve the repository root for this directory.
-    await execAsync('git rev-parse --show-toplevel', { cwd: projectPath });
+    await spawnAsync('git', ['rev-parse', '--show-toplevel'], { cwd: projectPath });
   } catch {
     throw new Error('Not a git repository. This directory does not contain a .git folder. Initialize a git repository with "git init" to use source control features.');
   }
@@ -274,7 +272,7 @@ router.get('/status', async (req, res) => {
     }
 
     // Get git status
-    const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: projectPath });
+    const { stdout: statusOutput } = await spawnAsync('git', ['status', '--porcelain'], { cwd: projectPath });
 
     const modified = [];
     const added = [];
@@ -565,7 +563,7 @@ router.get('/branches', async (req, res) => {
     }
     
     // Get all branches
-    const { stdout } = await execAsync('git branch -a', { cwd: projectPath });
+    const { stdout } = await spawnAsync('git', ['branch', '-a'], { cwd: projectPath });
     
     // Parse branches
     const branches = stdout
@@ -676,8 +674,8 @@ router.get('/commits', async (req, res) => {
     // Get stats for each commit
     for (const commit of commits) {
       try {
-        const { stdout: stats } = await execAsync(
-          `git show --stat --format='' ${commit.hash}`,
+        const { stdout: stats } = await spawnAsync(
+          'git', ['show', '--stat', '--format=', commit.hash],
           { cwd: projectPath }
         );
         commit.stats = stats.trim().split('\n').pop(); // Get the summary line
@@ -705,8 +703,8 @@ router.get('/commit-diff', async (req, res) => {
     const projectPath = await getActualProjectPath(project);
     
     // Get diff for the commit
-    const { stdout } = await execAsync(
-      `git show ${commit}`,
+    const { stdout } = await spawnAsync(
+      'git', ['show', commit],
       { cwd: projectPath }
     );