@neuralnomads/codenomad 0.7.1 → 0.7.2

package/dist/background-processes/manager.js

@@ -1,4 +1,4 @@
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { createWriteStream, existsSync, promises as fs } from "fs";
 import path from "path";
 import { randomBytes } from "crypto";
@@ -33,10 +33,12 @@ export class BackgroundProcessManager {
         const processDir = await this.ensureProcessDir(workspaceId, id);
         const outputPath = path.join(processDir, OUTPUT_FILE);
         const outputStream = createWriteStream(outputPath, { flags: "a" });
-        const child = spawn("bash", ["-c", command], {
+        const { shellCommand, shellArgs, spawnOptions } = this.buildShellSpawn(command);
+        const child = spawn(shellCommand, shellArgs, {
             cwd: workspace.path,
             stdio: ["ignore", "pipe", "pipe"],
             detached: process.platform !== "win32",
+            ...spawnOptions,
         });
         child.on("exit", () => {
             this.killProcessTree(child, "SIGTERM");
@@ -211,7 +213,17 @@ export class BackgroundProcessManager {
         const pid = child.pid;
         if (!pid)
             return;
-        if (process.platform !== "win32") {
+        if (process.platform === "win32") {
+            const args = this.buildWindowsTaskkillArgs(pid, signal);
+            try {
+                spawnSync("taskkill", args, { stdio: "ignore" });
+                return;
+            }
+            catch {
+                // Fall back to killing the direct child.
+            }
+        }
+        else {
             try {
                 process.kill(-pid, signal);
                 return;
@@ -254,6 +266,27 @@ export class BackgroundProcessManager {
             clearTimeout(killTimeout);
         }
     }
+    buildShellSpawn(command) {
+        if (process.platform === "win32") {
+            const comspec = process.env.ComSpec || "cmd.exe";
+            return {
+                shellCommand: comspec,
+                shellArgs: ["/d", "/s", "/c", command],
+                spawnOptions: { windowsVerbatimArguments: true },
+            };
+        }
+        // Keep bash for macOS/Linux.
+        return { shellCommand: "bash", shellArgs: ["-c", command] };
+    }
+    buildWindowsTaskkillArgs(pid, signal) {
+        // Default to graceful termination (no /F), then force kill when we escalate.
+        const force = signal === "SIGKILL";
+        const args = ["/PID", String(pid), "/T"];
+        if (force) {
+            args.push("/F");
+        }
+        return args;
+    }
     statusFromExit(code) {
         if (code === null)
             return "stopped";

package/dist/config/binaries.js

@@ -1,3 +1,5 @@
+import { spawnSync } from "child_process";
+import { buildSpawnSpec } from "../workspaces/runtime";
 export class BinaryRegistry {
     constructor(configStore, eventBus, logger) {
         this.configStore = configStore;
@@ -99,8 +101,36 @@ export class BinaryRegistry {
         this.eventBus?.publish({ type: "config.binariesChanged", binaries: this.mapRecords() });
     }
     validateRecord(record) {
-        // TODO: call actual binary -v check.
-        return { valid: true, version: record.version };
+        const inputPath = record.path;
+        if (!inputPath) {
+            return { valid: false, error: "Missing binary path" };
+        }
+        const spec = buildSpawnSpec(inputPath, ["--version"]);
+        try {
+            const result = spawnSync(spec.command, spec.args, {
+                encoding: "utf8",
+                windowsVerbatimArguments: Boolean(spec.options.windowsVerbatimArguments),
+            });
+            if (result.error) {
+                return { valid: false, error: result.error.message };
+            }
+            if (result.status !== 0) {
+                const stderr = result.stderr?.trim();
+                const stdout = result.stdout?.trim();
+                const combined = stderr || stdout;
+                const error = combined ? `Exited with code ${result.status}: ${combined}` : `Exited with code ${result.status}`;
+                return { valid: false, error };
+            }
+            const stdout = (result.stdout ?? "").trim();
+            const firstLine = stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
+            const normalized = firstLine?.trim();
+            const versionMatch = normalized?.match(/([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/);
+            const version = versionMatch?.[1];
+            return { valid: true, version };
+        }
+        catch (error) {
+            return { valid: false, error: error instanceof Error ? error.message : String(error) };
+        }
     }
     buildFallbackRecord(path) {
         return {

package/dist/workspaces/manager.js

@@ -170,12 +170,14 @@ export class WorkspaceManager {
         try {
             const result = spawnSync(locator, [identifier], { encoding: "utf8" });
             if (result.status === 0 && result.stdout) {
-                const resolved = result.stdout
+                const candidates = result.stdout
                     .split(/\r?\n/)
                     .map((line) => line.trim())
-                    .find((line) => line.length > 0);
-                if (resolved) {
-                    this.options.logger.debug({ identifier, resolved }, "Resolved binary path from system PATH");
+                    .filter((line) => line.length > 0)
+                    .filter((line) => !/^INFO:/i.test(line));
+                if (candidates.length > 0) {
+                    const resolved = this.pickBinaryCandidate(candidates);
+                    this.options.logger.debug({ identifier, resolved, candidates }, "Resolved binary path from system PATH");
                     return resolved;
                 }
             }
@@ -188,6 +190,19 @@ export class WorkspaceManager {
         }
         return identifier;
     }
+    pickBinaryCandidate(candidates) {
+        if (process.platform !== "win32") {
+            return candidates[0] ?? "";
+        }
+        const extensionPreference = [".exe", ".cmd", ".bat", ".ps1"];
+        for (const ext of extensionPreference) {
+            const match = candidates.find((candidate) => candidate.toLowerCase().endsWith(ext));
+            if (match) {
+                return match;
+            }
+        }
+        return candidates[0] ?? "";
+    }
     detectBinaryVersion(resolvedPath) {
         if (!resolvedPath) {
             return undefined;

package/dist/workspaces/runtime.js

@@ -1,6 +1,34 @@
 import { spawn } from "child_process";
 import { existsSync, statSync } from "fs";
 import path from "path";
+export const WINDOWS_CMD_EXTENSIONS = new Set([".cmd", ".bat"]);
+export const WINDOWS_POWERSHELL_EXTENSIONS = new Set([".ps1"]);
+export function buildSpawnSpec(binaryPath, args) {
+    if (process.platform !== "win32") {
+        return { command: binaryPath, args, options: {} };
+    }
+    const extension = path.extname(binaryPath).toLowerCase();
+    if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
+        const comspec = process.env.ComSpec || "cmd.exe";
+        // cmd.exe requires the full command as a single string.
+        // Using the ""<script> <args>"" pattern ensures paths with spaces are handled.
+        const commandLine = `""${binaryPath}" ${args.join(" ")}"`;
+        return {
+            command: comspec,
+            args: ["/d", "/s", "/c", commandLine],
+            options: { windowsVerbatimArguments: true },
+        };
+    }
+    if (WINDOWS_POWERSHELL_EXTENSIONS.has(extension)) {
+        // powershell.exe ships with Windows. (pwsh may not.)
+        return {
+            command: "powershell.exe",
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", binaryPath, ...args],
+            options: {},
+        };
+    }
+    return { command: binaryPath, args, options: {} };
+}
 const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET)/i;
 function redactEnvironment(env) {
     const redacted = {};
@@ -44,19 +72,22 @@ export class WorkspaceRuntime {
             return combined.join("\n");
         };
         return new Promise((resolve, reject) => {
-            const commandLine = [options.binaryPath, ...args].join(" ");
+            const spec = buildSpawnSpec(options.binaryPath, args);
+            const commandLine = [spec.command, ...spec.args].join(" ");
             this.logger.info({
                 workspaceId: options.workspaceId,
                 folder: options.folder,
                 binary: options.binaryPath,
-                args,
+                spawnCommand: spec.command,
+                spawnArgs: spec.args,
                 commandLine,
                 env: redactEnvironment(env),
             }, "Launching OpenCode process");
-            const child = spawn(options.binaryPath, args, {
+            const child = spawn(spec.command, spec.args, {
                 cwd: options.folder,
                 env,
                 stdio: ["ignore", "pipe", "pipe"],
+                ...spec.options,
             });
             const managed = { child, requestedStop: false };
             this.processes.set(options.workspaceId, managed);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "CodeNomad Server",
   "author": {
     "name": "Neural Nomads",