@neuralnomads/codenomad 0.8.1 → 0.9.1

package/dist/config/schema.js

@@ -12,6 +12,7 @@ const PreferencesSchema = z.object({
     lastUsedBinary: z.string().optional(),
     environmentVariables: z.record(z.string()).default({}),
     modelRecents: z.array(ModelPreferenceSchema).default([]),
+    modelThinkingSelections: z.record(z.string(), z.string()).default({}),
     diffViewMode: z.enum(["split", "unified"]).default("split"),
     toolOutputExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
     diagnosticsExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),

package/dist/filesystem/browser.js

@@ -30,6 +30,26 @@ export class FileSystemBrowser {
         }
         return this.listRestrictedWithMetadata(targetPath, includeFiles);
     }
+    createFolder(parentPath, folderName) {
+        const name = this.normalizeFolderName(folderName);
+        if (this.unrestricted) {
+            const resolvedParent = this.resolveUnrestrictedPath(parentPath);
+            if (this.isWindows && resolvedParent === WINDOWS_DRIVES_ROOT) {
+                throw new Error("Cannot create folders at drive root");
+            }
+            this.assertDirectoryExists(resolvedParent);
+            const absolutePath = this.resolveAbsoluteChild(resolvedParent, name);
+            fs.mkdirSync(absolutePath);
+            return { path: absolutePath, absolutePath };
+        }
+        const normalizedParent = this.normalizeRelativePath(parentPath);
+        const parentAbsolute = this.toRestrictedAbsolute(normalizedParent);
+        this.assertDirectoryExists(parentAbsolute);
+        const relativePath = this.buildRelativePath(normalizedParent, name);
+        const absolutePath = this.toRestrictedAbsolute(relativePath);
+        fs.mkdirSync(absolutePath);
+        return { path: relativePath, absolutePath };
+    }
     readFile(relativePath) {
         if (this.unrestricted) {
             throw new Error("readFile is not available in unrestricted mode");
@@ -117,6 +137,34 @@ export class FileSystemBrowser {
         };
         return { entries, metadata };
     }
+    normalizeFolderName(input) {
+        const name = input.trim();
+        if (!name) {
+            throw new Error("Folder name is required");
+        }
+        if (name === "." || name === "..") {
+            throw new Error("Invalid folder name");
+        }
+        if (name.startsWith("~")) {
+            throw new Error("Invalid folder name");
+        }
+        if (name.includes("/") || name.includes("\\")) {
+            throw new Error("Folder name must not include path separators");
+        }
+        if (name.includes("\u0000")) {
+            throw new Error("Invalid folder name");
+        }
+        return name;
+    }
+    assertDirectoryExists(directory) {
+        if (!fs.existsSync(directory)) {
+            throw new Error(`Directory does not exist: ${directory}`);
+        }
+        const stats = fs.statSync(directory);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: ${directory}`);
+        }
+    }
     readDirectoryEntries(directory, options) {
         const dirents = fs.readdirSync(directory, { withFileTypes: true });
         const results = [];

package/dist/index.js

@@ -205,22 +205,32 @@ async function main() {
             return;
         }
         shuttingDown = true;
-        logger.info("Received shutdown signal, closing server");
-        try {
-            await server.stop();
-            logger.info("HTTP server stopped");
-        }
-        catch (error) {
-            logger.error({ err: error }, "Failed to stop HTTP server");
-        }
-        try {
-            instanceEventBridge.shutdown();
-            await workspaceManager.shutdown();
-            logger.info("Workspace manager shutdown complete");
-        }
-        catch (error) {
-            logger.error({ err: error }, "Workspace manager shutdown failed");
-        }
+        logger.info("Received shutdown signal, stopping workspaces and server");
+        const shutdownWorkspaces = (async () => {
+            try {
+                instanceEventBridge.shutdown();
+            }
+            catch (error) {
+                logger.warn({ err: error }, "Instance event bridge shutdown failed");
+            }
+            try {
+                await workspaceManager.shutdown();
+                logger.info("Workspace manager shutdown complete");
+            }
+            catch (error) {
+                logger.error({ err: error }, "Workspace manager shutdown failed");
+            }
+        })();
+        const shutdownHttp = (async () => {
+            try {
+                await server.stop();
+                logger.info("HTTP server stopped");
+            }
+            catch (error) {
+                logger.error({ err: error }, "Failed to stop HTTP server");
+            }
+        })();
+        await Promise.allSettled([shutdownWorkspaces, shutdownHttp]);
         // no-op: remote UI manifest replaces GitHub release monitor
         logger.info("Exiting process");
         process.exit(0);

package/dist/server/routes/filesystem.js

@@ -3,6 +3,10 @@ const FilesystemQuerySchema = z.object({
     path: z.string().optional(),
     includeFiles: z.coerce.boolean().optional(),
 });
+const FilesystemCreateFolderSchema = z.object({
+    parentPath: z.string().optional(),
+    name: z.string(),
+});
 export function registerFilesystemRoutes(app, deps) {
     app.get("/api/filesystem", async (request, reply) => {
         const query = FilesystemQuerySchema.parse(request.query ?? {});
@@ -16,4 +20,24 @@ export function registerFilesystemRoutes(app, deps) {
             return { error: error.message };
         }
     });
+    app.post("/api/filesystem/folders", async (request, reply) => {
+        const body = FilesystemCreateFolderSchema.parse(request.body ?? {});
+        try {
+            const created = deps.fileSystemBrowser.createFolder(body.parentPath, body.name);
+            reply.code(201);
+            return created;
+        }
+        catch (error) {
+            const err = error;
+            if (err?.code === "EEXIST") {
+                reply.code(409).type("text/plain").send("Folder already exists");
+                return;
+            }
+            if (err?.code === "EACCES" || err?.code === "EPERM") {
+                reply.code(403).type("text/plain").send("Permission denied");
+                return;
+            }
+            reply.code(400).type("text/plain").send(error.message);
+        }
+    });
 }

package/dist/workspaces/manager.js

@@ -136,16 +136,19 @@ export class WorkspaceManager {
     }
     async shutdown() {
         this.options.logger.info("Shutting down all workspaces");
+        const stopTasks = [];
         for (const [id, workspace] of this.workspaces) {
-            if (workspace.pid) {
-                this.options.logger.info({ workspaceId: id }, "Stopping workspace during shutdown");
-                await this.runtime.stop(id).catch((error) => {
-                    this.options.logger.error({ workspaceId: id, err: error }, "Failed to stop workspace during shutdown");
-                });
-            }
-            else {
+            if (!workspace.pid) {
                 this.options.logger.debug({ workspaceId: id }, "Workspace already stopped");
+                continue;
             }
+            this.options.logger.info({ workspaceId: id }, "Stopping workspace during shutdown");
+            stopTasks.push(this.runtime.stop(id).catch((error) => {
+                this.options.logger.error({ workspaceId: id, err: error }, "Failed to stop workspace during shutdown");
+            }));
+        }
+        if (stopTasks.length > 0) {
+            await Promise.allSettled(stopTasks);
         }
         this.workspaces.clear();
         this.opencodeAuth.clear();

package/dist/workspaces/runtime.js

@@ -1,4 +1,4 @@
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { existsSync, statSync } from "fs";
 import path from "path";
 export const WINDOWS_CMD_EXTENSIONS = new Set([".cmd", ".bat"]);
@@ -83,10 +83,12 @@ export class WorkspaceRuntime {
                 commandLine,
                 env: redactEnvironment(env),
             }, "Launching OpenCode process");
+            const detached = process.platform !== "win32";
             const child = spawn(spec.command, spec.args, {
                 cwd: options.folder,
                 env,
                 stdio: ["ignore", "pipe", "pipe"],
+                detached,
                 ...spec.options,
             });
             const managed = { child, requestedStop: false };
@@ -202,10 +204,90 @@ export class WorkspaceRuntime {
         managed.requestedStop = true;
         const child = managed.child;
         this.logger.info({ workspaceId }, "Stopping OpenCode process");
+        const pid = child.pid;
+        if (!pid) {
+            this.logger.warn({ workspaceId }, "Workspace process missing PID; cannot stop");
+            return;
+        }
+        const isAlreadyExited = () => child.exitCode !== null || child.signalCode !== null;
+        const tryKillPosixGroup = (signal) => {
+            try {
+                // Negative PID targets the process group (POSIX).
+                process.kill(-pid, signal);
+                return true;
+            }
+            catch (error) {
+                const err = error;
+                if (err?.code === "ESRCH") {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, err }, "Failed to signal POSIX process group");
+                return false;
+            }
+        };
+        const tryKillSinglePid = (signal) => {
+            try {
+                process.kill(pid, signal);
+                return true;
+            }
+            catch (error) {
+                const err = error;
+                if (err?.code === "ESRCH") {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, err }, "Failed to signal workspace PID");
+                return false;
+            }
+        };
+        const tryTaskkill = (force) => {
+            const args = ["/PID", String(pid), "/T"];
+            if (force) {
+                args.push("/F");
+            }
+            try {
+                const result = spawnSync("taskkill", args, { encoding: "utf8" });
+                const exitCode = result.status;
+                if (exitCode === 0) {
+                    return true;
+                }
+                // If the PID is already gone, treat it as success.
+                const stderr = (result.stderr ?? "").toString().toLowerCase();
+                const stdout = (result.stdout ?? "").toString().toLowerCase();
+                const combined = `${stdout}\n${stderr}`;
+                if (combined.includes("not found") || combined.includes("no running instance") || combined.includes("process") && combined.includes("not")) {
+                    return true;
+                }
+                this.logger.debug({ workspaceId, pid, exitCode, stderr: result.stderr, stdout: result.stdout }, "taskkill failed");
+                return false;
+            }
+            catch (error) {
+                this.logger.debug({ workspaceId, pid, err: error }, "taskkill failed to execute");
+                return false;
+            }
+        };
+        const sendStopSignal = (signal) => {
+            if (process.platform === "win32") {
+                // Best-effort: terminate the whole process tree rooted at pid.
+                // Use /F only for escalation.
+                tryTaskkill(signal === "SIGKILL");
+                return;
+            }
+            // Prefer process-group signaling so wrapper launchers (bun/node) don't orphan the real server.
+            const groupOk = tryKillPosixGroup(signal);
+            if (!groupOk) {
+                // Fallback to direct PID kill.
+                tryKillSinglePid(signal);
+            }
+        };
         await new Promise((resolve, reject) => {
+            let escalationTimer = null;
             const cleanup = () => {
                 child.removeListener("exit", onExit);
                 child.removeListener("error", onError);
+                if (escalationTimer) {
+                    clearTimeout(escalationTimer);
+                    escalationTimer = null;
+                }
             };
             const onExit = () => {
                 cleanup();
@@ -215,30 +297,24 @@ export class WorkspaceRuntime {
                 cleanup();
                 reject(error);
             };
-            const resolveIfAlreadyExited = () => {
-                if (child.exitCode !== null || child.signalCode !== null) {
-                    this.logger.debug({ workspaceId, exitCode: child.exitCode, signal: child.signalCode }, "Process already exited");
-                    cleanup();
-                    resolve();
-                    return true;
-                }
-                return false;
-            };
-            child.once("exit", onExit);
-            child.once("error", onError);
-            if (resolveIfAlreadyExited()) {
+            if (isAlreadyExited()) {
+                this.logger.debug({ workspaceId, exitCode: child.exitCode, signal: child.signalCode }, "Process already exited");
+                cleanup();
+                resolve();
                 return;
             }
-            this.logger.debug({ workspaceId }, "Sending SIGTERM to workspace process");
-            child.kill("SIGTERM");
-            setTimeout(() => {
-                if (!child.killed) {
-                    this.logger.warn({ workspaceId }, "Process did not stop after SIGTERM, force killing");
-                    child.kill("SIGKILL");
-                }
-                else {
-                    this.logger.debug({ workspaceId }, "Workspace process stopped gracefully before SIGKILL timeout");
+            child.once("exit", onExit);
+            child.once("error", onError);
+            this.logger.debug({ workspaceId, pid, detached: process.platform !== "win32" }, "Sending SIGTERM to workspace process (tree/group)");
+            sendStopSignal("SIGTERM");
+            escalationTimer = setTimeout(() => {
+                escalationTimer = null;
+                if (isAlreadyExited()) {
+                    this.logger.debug({ workspaceId, pid }, "Workspace exited before SIGKILL escalation");
+                    return;
                 }
+                this.logger.warn({ workspaceId, pid }, "Process did not stop after SIGTERM, escalating");
+                sendStopSignal("SIGKILL");
             }, 2000);
         });
     }

package/package.json

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