@neuralnomads/codenomad 0.7.1 → 0.7.3

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/index.js

@@ -77,10 +77,16 @@ function parsePort(input) {
     return value;
 }
 function resolveHost(input) {
-    if (input && input.trim() === "0.0.0.0") {
+    const trimmed = input?.trim();
+    if (!trimmed)
+        return DEFAULT_HOST;
+    if (trimmed === "0.0.0.0") {
         return "0.0.0.0";
     }
-    return DEFAULT_HOST;
+    if (trimmed === "localhost") {
+        return DEFAULT_HOST;
+    }
+    return trimmed;
 }
 async function main() {
     const options = parseCliOptions(process.argv.slice(2));
@@ -94,11 +100,12 @@ async function main() {
     };
     logger.info({ options: logOptions }, "Starting CodeNomad CLI server");
     const eventBus = new EventBus(eventLogger);
+    const isLoopbackHost = (host) => host === "127.0.0.1" || host === "::1" || host.startsWith("127.");
     const serverMeta = {
         httpBaseUrl: `http://${options.host}:${options.port}`,
         eventsUrl: `/api/events`,
         host: options.host,
-        listeningMode: options.host === "0.0.0.0" ? "all" : "local",
+        listeningMode: isLoopbackHost(options.host) ? "local" : "all",
         port: options.port,
         hostLabel: options.host,
         workspaceRoot: options.rootDir,

package/dist/server/http-server.js

@@ -56,6 +56,7 @@ export function createHttpServer(deps) {
         done();
     });
     const allowedDevOrigins = new Set(["http://localhost:3000", "http://127.0.0.1:3000"]);
+    const isLoopbackHost = (host) => host === "127.0.0.1" || host === "::1" || host.startsWith("127.");
     app.register(cors, {
         origin: (origin, cb) => {
             if (!origin) {
@@ -77,6 +78,11 @@ export function createHttpServer(deps) {
                 cb(null, true);
                 return;
             }
+            // When we bind to a non-loopback host (e.g., 0.0.0.0 or LAN IP), allow cross-origin UI access.
+            if (deps.host === "0.0.0.0" || !isLoopbackHost(deps.host)) {
+                cb(null, true);
+                return;
+            }
             cb(null, false);
         },
         credentials: true,
@@ -212,12 +218,12 @@ export function createHttpServer(deps) {
                     actualPort = address.port;
                 }
             }
-            const displayHost = deps.host === "0.0.0.0" ? "127.0.0.1" : deps.host === "127.0.0.1" ? "localhost" : deps.host;
+            const displayHost = deps.host === "127.0.0.1" ? "localhost" : deps.host;
             const serverUrl = `http://${displayHost}:${actualPort}`;
             deps.serverMeta.httpBaseUrl = serverUrl;
             deps.serverMeta.host = deps.host;
             deps.serverMeta.port = actualPort;
-            deps.serverMeta.listeningMode = deps.host === "0.0.0.0" ? "all" : "local";
+            deps.serverMeta.listeningMode = deps.host === "0.0.0.0" || !isLoopbackHost(deps.host) ? "all" : "local";
             deps.logger.info({ port: actualPort, host: deps.host }, "HTTP server listening");
             console.log(`CodeNomad Server is ready at ${serverUrl}`);
             return { port: actualPort, url: serverUrl, displayHost };

package/dist/server/routes/meta.js

@@ -8,7 +8,7 @@ function buildMetaResponse(meta) {
     return {
         ...meta,
         port,
-        listeningMode: meta.host === "0.0.0.0" ? "all" : "local",
+        listeningMode: meta.host === "0.0.0.0" || !isLoopbackHost(meta.host) ? "all" : "local",
         addresses,
     };
 }
@@ -25,6 +25,9 @@ function resolvePort(meta) {
         return 0;
     }
 }
+function isLoopbackHost(host) {
+    return host === "127.0.0.1" || host === "::1" || host.startsWith("127.");
+}
 function resolveAddresses(port, host) {
     const interfaces = os.networkInterfaces();
     const seen = new Set();

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.3",
   "description": "CodeNomad Server",
   "author": {
     "name": "Neural Nomads",