@nemus-cli/nemus 0.2.9 → 0.2.11

package/dist/utils/branch-operations.js

@@ -38,7 +38,10 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs/promises"));
 const git_status_1 = require("./git-status");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// execFile (no shell): git args are passed as an argv array, so a branch name
+// containing shell metacharacters can never be interpreted as a command.
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const git = (args, opts) => execFileAsync('git', args, opts);
 const GIT_TIMEOUT = 30000;
 const switchBranch = async (repoPath, repoName, targetBranch) => {
     try {
@@ -55,7 +58,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
         }
         // Check if it's a git repository
         try {
-            await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+            await git(['rev-parse', '--git-dir'], { cwd: repoPath });
         }
         catch {
             return {
@@ -65,7 +68,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             };
         }
         // Get current branch
-        const { stdout: currentBranchOutput } = await execAsync('git branch --show-current', { cwd: repoPath });
+        const { stdout: currentBranchOutput } = await git(['branch', '--show-current'], { cwd: repoPath });
         const currentBranch = currentBranchOutput.trim();
         if (currentBranch === targetBranch) {
             return {
@@ -76,7 +79,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             };
         }
         // Check for uncommitted changes
-        const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: repoPath });
+        const { stdout: statusOutput } = await git(['status', '--porcelain'], { cwd: repoPath });
         if (statusOutput.trim().length > 0) {
             return {
                 repo: repoName,
@@ -86,17 +89,17 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             };
         }
         // Fetch to ensure we have latest branches
-        await execAsync('git fetch', { cwd: repoPath, timeout: GIT_TIMEOUT });
+        await git(['fetch'], { cwd: repoPath, timeout: GIT_TIMEOUT });
         // Check if branch exists locally
         try {
-            await execAsync(`git rev-parse --verify ${targetBranch}`, { cwd: repoPath });
+            await git(['rev-parse', '--verify', targetBranch], { cwd: repoPath });
         }
         catch {
             // Branch doesn't exist locally, check remote
             try {
-                await execAsync(`git rev-parse --verify origin/${targetBranch}`, { cwd: repoPath });
+                await git(['rev-parse', '--verify', `origin/${targetBranch}`], { cwd: repoPath });
                 // Branch exists on remote, create local tracking branch
-                await execAsync(`git checkout -b ${targetBranch} origin/${targetBranch}`, { cwd: repoPath });
+                await git(['checkout', '-b', targetBranch, `origin/${targetBranch}`], { cwd: repoPath });
                 return {
                     repo: repoName,
                     status: 'success',
@@ -114,7 +117,7 @@ const switchBranch = async (repoPath, repoName, targetBranch) => {
             }
         }
         // Switch to existing local branch
-        await execAsync(`git checkout ${targetBranch}`, { cwd: repoPath });
+        await git(['checkout', targetBranch], { cwd: repoPath });
         return {
             repo: repoName,
             status: 'success',
@@ -147,16 +150,10 @@ const createBranch = async (repoPath, repoName, branchName, baseBranch, force) =
         }
         // Checkout base branch if specified
         if (baseBranch) {
-            await execAsync(`git checkout ${baseBranch}`, {
-                cwd: repoPath,
-                timeout: GIT_TIMEOUT,
-            });
+            await git(['checkout', baseBranch], { cwd: repoPath, timeout: GIT_TIMEOUT });
         }
         // Create and checkout new branch
-        await execAsync(`git checkout -b ${branchName}`, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
+        await git(['checkout', '-b', branchName], { cwd: repoPath, timeout: GIT_TIMEOUT });
         return {
             repo: repoName,
             success: true,
@@ -176,22 +173,16 @@ exports.createBranch = createBranch;
 const mergeBranch = async (repoPath, repoName, sourceBranch, targetBranch, options) => {
     try {
         // Checkout target branch
-        await execAsync(`git checkout ${targetBranch}`, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
-        // Build merge command
-        let mergeCmd = `git merge ${sourceBranch}`;
+        await git(['checkout', targetBranch], { cwd: repoPath, timeout: GIT_TIMEOUT });
+        // Build merge argv
+        const mergeArgs = ['merge', sourceBranch];
         if (options?.noFf)
-            mergeCmd += ' --no-ff';
+            mergeArgs.push('--no-ff');
         if (options?.ffOnly)
-            mergeCmd += ' --ff-only';
+            mergeArgs.push('--ff-only');
         if (options?.squash)
-            mergeCmd += ' --squash';
-        await execAsync(mergeCmd, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
+            mergeArgs.push('--squash');
+        await git(mergeArgs, { cwd: repoPath, timeout: GIT_TIMEOUT });
         return {
             repo: repoName,
             success: true,
@@ -210,10 +201,7 @@ const mergeBranch = async (repoPath, repoName, sourceBranch, targetBranch, optio
 exports.mergeBranch = mergeBranch;
 const rebaseBranch = async (repoPath, repoName, targetBranch) => {
     try {
-        await execAsync(`git rebase ${targetBranch}`, {
-            cwd: repoPath,
-            timeout: GIT_TIMEOUT,
-        });
+        await git(['rebase', targetBranch], { cwd: repoPath, timeout: GIT_TIMEOUT });
         return {
             repo: repoName,
             success: true,

package/dist/utils/cleanup-operations.js

@@ -38,10 +38,10 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const calculateDirSize = async (dirPath) => {
     try {
-        const { stdout } = await execAsync(`du -sk "${dirPath}"`);
+        const { stdout } = await execFileAsync('du', ['-sk', dirPath]);
         const sizeInKB = parseInt(stdout.split('\t')[0], 10);
         return sizeInKB;
     }
@@ -98,9 +98,9 @@ const removeBuildArtifacts = async (repoPath) => {
 exports.removeBuildArtifacts = removeBuildArtifacts;
 const gitClean = async (repoPath, dryRun = false) => {
     try {
-        const cmd = dryRun ? 'git clean -fdxn' : 'git clean -fdx';
-        const { stdout } = await execAsync(cmd, { cwd: repoPath });
-        const lines = stdout.split('\n').filter(l => l.trim());
+        const args = dryRun ? ['clean', '-fdxn'] : ['clean', '-fdx'];
+        const { stdout } = await execFileAsync('git', args, { cwd: repoPath });
+        const lines = stdout.split('\n').filter((l) => l.trim());
         return {
             operation: 'Git clean',
             filesRemoved: lines.length,

package/dist/utils/ghq-integration.js

@@ -47,10 +47,14 @@ exports.getGhqStatus = getGhqStatus;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
 const logger_1 = require("./logger");
 const colors_1 = require("./colors");
 const config_1 = require("./config");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// execFile (no shell): every value below (repo URLs, ghq paths, branch names)
+// is passed as an argv element, so none can be interpreted as a shell command.
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const git = (args, opts = {}) => execFileAsync('git', args, opts);
 /**
  * Turn a raw child-process clone failure (from exec or execFile) into an
  * actionable message. The child API discards the reason on timeout/buffer kill (you just get "Command
@@ -80,7 +84,7 @@ function describeCloneError(error, timeoutMs = config_1.CLONE_TIMEOUT_MS) {
  */
 async function isGhqInstalled() {
     try {
-        await execAsync('which ghq');
+        await execFileAsync('which', ['ghq']);
         return true;
     }
     catch {
@@ -106,7 +110,7 @@ async function warnIfGhqMissing() {
  */
 async function getGhqRoot() {
     try {
-        const { stdout } = await execAsync('ghq root');
+        const { stdout } = await execFileAsync('ghq', ['root']);
         return stdout.trim();
     }
     catch {
@@ -121,8 +125,8 @@ async function ghqRepoExists(repoUrl) {
         const repoPath = await getGhqRepoPath(repoUrl);
         if (!repoPath)
             return false;
-        await execAsync(`test -d "${repoPath}"`);
-        return true;
+        const stat = await fs.stat(repoPath);
+        return stat.isDirectory();
     }
     catch {
         return false;
@@ -154,7 +158,7 @@ async function getGhqRepoPath(repoUrl) {
 async function ghqGet(repoUrl) {
     try {
         (0, logger_1.logInfo)(`Using ghq to clone ${(0, colors_1.colorize)(repoUrl, 'cyan')}...`);
-        await execAsync(`ghq get "${repoUrl}"`, { timeout: config_1.CLONE_TIMEOUT_MS, maxBuffer: config_1.CLONE_MAX_BUFFER });
+        await execFileAsync('ghq', ['get', repoUrl], { timeout: config_1.CLONE_TIMEOUT_MS, maxBuffer: config_1.CLONE_MAX_BUFFER });
         const repoPath = await getGhqRepoPath(repoUrl);
         if (!repoPath) {
             return { success: false, error: 'Could not determine ghq path' };
@@ -172,7 +176,7 @@ async function ghqGet(repoUrl) {
  */
 async function ghqList() {
     try {
-        const { stdout } = await execAsync('ghq list');
+        const { stdout } = await execFileAsync('ghq', ['list']);
         return stdout.trim().split('\n').filter(line => line.length > 0);
     }
     catch {
@@ -227,15 +231,15 @@ async function cloneWithGhq(repoUrl, targetPath) {
                 // would serve stale state via hardlinks — user would open a workspace
                 // missing dozens of recent commits.
                 try {
-                    await execAsync(`git -C "${sourcePath}" fetch origin --quiet --prune`, { timeout: 90 * 1000 });
+                    await git(['-C', sourcePath, 'fetch', 'origin', '--quiet', '--prune'], { timeout: 90 * 1000 });
                 }
                 catch {
                     // Network failure or no upstream — fall through with stale cache,
                     // we'll log a warning after the local clone if we can't align to HEAD.
                 }
-                await execAsync(`git clone --local "${sourcePath}" "${targetPath}"`, { timeout: 60 * 1000 });
+                await git(['clone', '--local', sourcePath, targetPath], { timeout: 60 * 1000 });
                 // Reset remote to point to the original repo URL (not the local ghq path)
-                await execAsync(`git remote set-url origin "${repoUrl}"`, { cwd: targetPath });
+                await git(['remote', 'set-url', 'origin', repoUrl], { cwd: targetPath });
                 // Make sure the working tree is at origin's default-branch tip.
                 // Robust against:
                 //   - cache having a non-default branch checked out
@@ -244,20 +248,24 @@ async function cloneWithGhq(repoUrl, targetPath) {
                 let alignedToHead = false;
                 let alignError = null;
                 try {
-                    await execAsync(`git fetch origin --quiet`, { cwd: targetPath, timeout: 60 * 1000 });
+                    await git(['fetch', 'origin', '--quiet'], { cwd: targetPath, timeout: 60 * 1000 });
                     // Explicitly set refs/remotes/origin/HEAD by querying the remote.
                     // Without this, symbolic-ref may fail if the local symref wasn’t set.
-                    await execAsync(`git remote set-head origin --auto`, { cwd: targetPath, timeout: 30 * 1000 })
+                    await git(['remote', 'set-head', 'origin', '--auto'], { cwd: targetPath, timeout: 30 * 1000 })
                         .catch(() => { });
                     let defaultBranch = null;
                     try {
-                        const headRes = await execAsync(`git symbolic-ref --short refs/remotes/origin/HEAD`, { cwd: targetPath, timeout: 5000 });
+                        const headRes = await git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], {
+                            cwd: targetPath, timeout: 5000,
+                        });
                         defaultBranch = headRes.stdout.trim().replace(/^origin\//, '');
                     }
                     catch {
                         // Fall back to ls-remote query against the actual remote
                         try {
-                            const lsRes = await execAsync(`git ls-remote --symref origin HEAD`, { cwd: targetPath, timeout: 30 * 1000 });
+                            const lsRes = await git(['ls-remote', '--symref', 'origin', 'HEAD'], {
+                                cwd: targetPath, timeout: 30 * 1000,
+                            });
                             const match = lsRes.stdout.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m);
                             if (match)
                                 defaultBranch = match[1];
@@ -267,7 +275,9 @@ async function cloneWithGhq(repoUrl, targetPath) {
                     // Final fallback: try common default branches
                     if (!defaultBranch) {
                         for (const candidate of ['main', 'master']) {
-                            const exists = await execAsync(`git rev-parse --verify --quiet origin/${candidate}`, { cwd: targetPath, timeout: 5000 }).then(() => true).catch(() => false);
+                            const exists = await git(['rev-parse', '--verify', '--quiet', `origin/${candidate}`], {
+                                cwd: targetPath, timeout: 5000,
+                            }).then(() => true).catch(() => false);
                             if (exists) {
                                 defaultBranch = candidate;
                                 break;
@@ -277,8 +287,8 @@ async function cloneWithGhq(repoUrl, targetPath) {
                     if (!defaultBranch) {
                         throw new Error('could not determine default branch (no origin/HEAD, no main, no master)');
                     }
-                    await execAsync(`git checkout --quiet "${defaultBranch}"`, { cwd: targetPath, timeout: 10 * 1000 });
-                    await execAsync(`git reset --hard --quiet "origin/${defaultBranch}"`, { cwd: targetPath, timeout: 10 * 1000 });
+                    await git(['checkout', '--quiet', defaultBranch], { cwd: targetPath, timeout: 10 * 1000 });
+                    await git(['reset', '--hard', '--quiet', `origin/${defaultBranch}`], { cwd: targetPath, timeout: 10 * 1000 });
                     alignedToHead = true;
                 }
                 catch (error) {
@@ -298,7 +308,7 @@ async function cloneWithGhq(repoUrl, targetPath) {
                 (0, logger_1.logWarning)(`Local clone from ghq failed: ${errorMessage}`);
                 // Clean up partial clone before fallback
                 try {
-                    await execAsync(`rm -rf "${targetPath}"`);
+                    await fs.rm(targetPath, { recursive: true, force: true });
                 }
                 catch { /* ignore */ }
                 // Fall through to direct clone
@@ -307,7 +317,7 @@ async function cloneWithGhq(repoUrl, targetPath) {
     }
     // Fallback to direct git clone
     try {
-        await execAsync(`git clone "${repoUrl}" "${targetPath}"`, { timeout: config_1.CLONE_TIMEOUT_MS, maxBuffer: config_1.CLONE_MAX_BUFFER });
+        await git(['clone', repoUrl, targetPath], { timeout: config_1.CLONE_TIMEOUT_MS, maxBuffer: config_1.CLONE_MAX_BUFFER });
         return { success: true, usedGhq: false };
     }
     catch (error) {

package/dist/utils/git-operations.js

@@ -44,7 +44,6 @@ const ghq_integration_1 = require("./ghq-integration");
 const retry_1 = require("./retry");
 const progress_1 = require("./progress");
 const config_1 = require("./config");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const CONCURRENCY_LIMIT = 3;
 const CLONE_TIMEOUT = config_1.CLONE_TIMEOUT_MS;
@@ -119,13 +118,13 @@ async function cloneLocal(repo, sourcePath, workspacePath, directoryName) {
     const targetPath = path.join(workspacePath, directoryName);
     try {
         // git clone --local creates hardlinks for .git/objects — nearly instant
-        await execAsync(`git clone --local "${sourcePath}" "${targetPath}"`, {
+        await execFileAsync('git', ['clone', '--local', sourcePath, targetPath], {
             timeout: CLONE_TIMEOUT,
             maxBuffer: config_1.CLONE_MAX_BUFFER,
         });
         // Reset the remote to point to the original repo (not the local source)
         const remoteUrl = (0, config_1.getCloneUrl)(repo);
-        await execAsync(`git remote set-url origin "${remoteUrl}"`, {
+        await execFileAsync('git', ['remote', 'set-url', 'origin', remoteUrl], {
             cwd: targetPath,
         });
         return {

package/dist/utils/health-checks.js

@@ -40,6 +40,7 @@ const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const git_status_1 = require("./git-status");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const checkMissingRepositories = async (workspacePath, metadata) => {
     const missingRepos = [];
     for (const repo of metadata.repositories) {
@@ -221,7 +222,7 @@ exports.checkDependencies = checkDependencies;
 const checkDiskSpace = async (workspacePath) => {
     try {
         // Get disk usage for workspace
-        const { stdout } = await execAsync(`du -sh "${workspacePath}"`, { timeout: 30000 });
+        const { stdout } = await execFileAsync('du', ['-sh', workspacePath], { timeout: 30000 });
         const sizeStr = stdout.trim().split('\t')[0];
         // Parse size (rough check for > 10GB)
         const sizeValue = parseFloat(sizeStr);

package/dist/utils/logger.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logStep = exports.logWarning = exports.logError = exports.logSuccess = exports.logInfo = void 0;
 const colors_1 = require("./colors");
+// Diagnostics (info/success/error/warn/step) go to STDERR so stdout carries only
+// a command's actual data — required for clean `--json` piping (nemus list
+// --json | jq …) and for non-TTY consumers. Use `outputJson`/stdout for data.
+const logStream = (line) => console.error(line);
 const getTimestamp = () => {
     const now = new Date();
     return now.toLocaleTimeString('en-US', {
@@ -12,29 +16,29 @@ const getTimestamp = () => {
     });
 };
 const logInfo = (message) => {
-    console.log(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${message}`);
+    logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${message}`);
 };
 exports.logInfo = logInfo;
 const logSuccess = (message) => {
-    console.log(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('✓', 'green')} ${message}`);
+    logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('✓', 'green')} ${message}`);
 };
 exports.logSuccess = logSuccess;
 const logError = (message) => {
-    console.log(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('✗', 'red')} ${message}`);
+    logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('✗', 'red')} ${message}`);
 };
 exports.logError = logError;
 const logWarning = (message) => {
-    console.log(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('⚠', 'yellow')} ${message}`);
+    logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('⚠', 'yellow')} ${message}`);
 };
 exports.logWarning = logWarning;
 const logStep = (stepOrMessage, total, message) => {
     if (typeof stepOrMessage === 'string') {
         // Single parameter version: just a message
-        console.log(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('▸', 'cyan')} ${stepOrMessage}`);
+        logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)('▸', 'cyan')} ${stepOrMessage}`);
     }
     else {
         // Three parameter version: step, total, message
-        console.log(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)(`[${stepOrMessage}/${total}]`, 'cyan')} ${message}`);
+        logStream(`${colors_1.colors.gray}[${getTimestamp()}]${colors_1.colors.reset} ${(0, colors_1.colorize)(`[${stepOrMessage}/${total}]`, 'cyan')} ${message}`);
     }
 };
 exports.logStep = logStep;

package/dist/utils/output.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Machine-readable output helpers. The one rule: a command's DATA goes to
+ * stdout, diagnostics go to stderr (see logger.ts). In `--json` mode a command
+ * writes exactly one JSON document to stdout and nothing else, so it pipes
+ * cleanly into `jq` and is safe for scripts/CI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputJson = outputJson;
+exports.outputJsonError = outputJsonError;
+/** Write one pretty-printed JSON document to stdout (data channel). */
+function outputJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+}
+/**
+ * Emit a structured error as JSON to stdout for `--json` callers, so a script
+ * parsing stdout always gets a parseable object (`{ ok: false, error }`) rather
+ * than empty stdout + a human log line on stderr. The caller still signals
+ * failure with a non-zero exit code.
+ */
+function outputJsonError(message) {
+    outputJson({ ok: false, error: message });
+}

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@nemus-cli/nemus",
-  "version": "0.2.9",
+  "version": "0.2.11",
+  "workspaces": [
+    "packages/*"
+  ],
   "description": "Nemus — a CLI for managing multi-repository workspaces. Create, sync, and operate across dozens of repos with a single command, and wire them up to your favorite coding agent.",
   "keywords": [
     "workspace",

package/src/cli/ai-prompt.test.ts

@@ -2,12 +2,14 @@ import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
 
 const {
   mockExec,
+  mockExecFile,
   mockExecFileSync,
   mockSpawn,
   mockMkdirSync,
   mockWriteFileSync,
 } = vi.hoisted(() => ({
   mockExec: vi.fn(),
+  mockExecFile: vi.fn(),
   mockExecFileSync: vi.fn(),
   mockSpawn: vi.fn(),
   mockMkdirSync: vi.fn(),
@@ -16,6 +18,7 @@ const {
 
 vi.mock('child_process', () => ({
   exec: mockExec,
+  execFile: mockExecFile,
   execFileSync: mockExecFileSync,
   spawn: mockSpawn,
 }));
@@ -69,7 +72,8 @@ function setupSpawnMock(exitCode: number = 0) {
 }
 
 function setupExecMock(success: boolean) {
-  mockExec.mockImplementation((_cmd: string, cb: Function) => {
+  // isPrimaryAgentAvailable now uses execFile('which', [cmd], cb) — cb is the 3rd arg.
+  mockExecFile.mockImplementation((_file: string, _args: string[], cb: Function) => {
     if (success) {
       cb(null, { stdout: '/usr/local/bin/claude\n', stderr: '' });
     } else {

package/src/cli/ai-prompt.ts

@@ -1,4 +1,4 @@
-import { spawn, exec, execFileSync } from 'child_process';
+import { spawn, execFile, execFileSync } from 'child_process';
 import { promisify } from 'util';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -9,7 +9,7 @@ import { colorize } from '../utils/colors';
 import { getPrimaryAgent } from '../utils/agent-config';
 import { sanitizeWorkspaceName, checkWorkspaceExists, resolveWorkspaceNameConflict } from '../utils/validation';
 
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 export const AI_PROMPT_FILE = path.join(os.homedir(), '.workspace-ai-prompt');
 
@@ -97,7 +97,7 @@ export function buildInvestigationPreamble(
 export async function isPrimaryAgentAvailable(): Promise<boolean> {
   const agent = getPrimaryAgent();
   try {
-    await execAsync(`which ${agent.launchCommand}`);
+    await execFileAsync('which', [agent.launchCommand]);
     return true;
   } catch {
     return false;

package/src/commands/configure.ts

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import inquirer from 'inquirer';
@@ -117,7 +117,7 @@ async function handleConfigure() {
       logInfo('Installing MCP server...');
       try {
         const mcpInstallScript = path.join(__dirname, '..', '..', 'dist', 'mcp', 'install.js');
-        execSync(`node "${mcpInstallScript}" install`, { stdio: 'inherit' });
+        execFileSync('node', [mcpInstallScript, 'install'], { stdio: 'inherit' });
         mcpInstalled = true;
       } catch { logError('MCP install failed. You can retry later with: w mcp install'); }
     }
@@ -169,7 +169,7 @@ function installShellIntegration(): void {
   }
 
   try {
-    execSync(`bash "${scriptPath}" ${shellType}`, { stdio: 'inherit' });
+    execFileSync('bash', [scriptPath, shellType], { stdio: 'inherit' });
   } catch {
     logWarning('Shell integration install failed — you can run it manually:');
     logInfo(`  bash "${scriptPath}" ${shellType}`);