@dyyz1993/codenomad 0.15.1 → 0.15.3

package/dist/auth/session-manager.js

@@ -1,7 +1,10 @@
 import crypto from "crypto";
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 30 * 60 * 1000;
 export class SessionManager {
     constructor() {
         this.sessions = new Map();
+        this.cleanupTimer = setInterval(() => this.cleanupExpired(), CLEANUP_INTERVAL_MS);
     }
     createSession(username) {
         const id = crypto.randomBytes(32).toString("base64url");
@@ -14,4 +17,29 @@ export class SessionManager {
             return undefined;
         return this.sessions.get(id);
     }
+    validateSession(sessionId) {
+        const info = this.sessions.get(sessionId);
+        if (!info)
+            return null;
+        if (Date.now() - info.createdAt > SESSION_TTL_MS) {
+            this.sessions.delete(sessionId);
+            return null;
+        }
+        return info;
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [id, info] of this.sessions) {
+            if (now - info.createdAt > SESSION_TTL_MS) {
+                this.sessions.delete(id);
+            }
+        }
+    }
+    shutdown() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        this.sessions.clear();
+    }
 }

package/dist/background-processes/manager.js

@@ -149,7 +149,7 @@ export class BackgroundProcessManager {
     }
     async readOutput(workspaceId, processId, options) {
         const outputPath = this.getOutputPath(workspaceId, processId);
-        if (!existsSync(outputPath)) {
+        if (!outputPath || !existsSync(outputPath)) {
             return { id: processId, content: "", truncated: false, sizeBytes: 0 };
         }
         const stats = await fs.stat(outputPath);
@@ -184,7 +184,7 @@ export class BackgroundProcessManager {
     }
     async streamOutput(workspaceId, processId, reply) {
         const outputPath = this.getOutputPath(workspaceId, processId);
-        if (!existsSync(outputPath)) {
+        if (!outputPath || !existsSync(outputPath)) {
             reply.code(404).send({ error: "Output not found" });
             return;
         }
@@ -356,6 +356,9 @@ export class BackgroundProcessManager {
     }
     async ensureProcessDir(workspaceId, processId) {
         const root = await this.ensureWorkspaceDir(workspaceId);
+        if (!root) {
+            throw new Error("Workspace not found");
+        }
         const processDir = path.join(root, processId);
         await fs.mkdir(processDir, { recursive: true });
         return processDir;
@@ -363,7 +366,7 @@ export class BackgroundProcessManager {
     async ensureWorkspaceDir(workspaceId) {
         const workspace = this.deps.workspaceManager.get(workspaceId);
         if (!workspace) {
-            throw new Error("Workspace not found");
+            return null;
         }
         const root = path.join(workspace.path, ROOT_DIR, workspaceId);
         await fs.mkdir(root, { recursive: true });
@@ -372,7 +375,7 @@ export class BackgroundProcessManager {
     getOutputPath(workspaceId, processId) {
         const workspace = this.deps.workspaceManager.get(workspaceId);
         if (!workspace) {
-            throw new Error("Workspace not found");
+            return null;
         }
         return path.join(workspace.path, ROOT_DIR, workspaceId, processId, OUTPUT_FILE);
     }
@@ -382,6 +385,8 @@ export class BackgroundProcessManager {
     }
     async readIndex(workspaceId) {
         const indexPath = await this.getIndexPath(workspaceId);
+        if (!indexPath)
+            return [];
         if (!existsSync(indexPath))
             return [];
         try {
@@ -411,13 +416,15 @@ export class BackgroundProcessManager {
     }
     async writeIndex(workspaceId, records) {
         const indexPath = await this.getIndexPath(workspaceId);
+        if (!indexPath)
+            return;
         await fs.mkdir(path.dirname(indexPath), { recursive: true });
         await fs.writeFile(indexPath, JSON.stringify(records, null, 2));
     }
     async getIndexPath(workspaceId) {
         const workspace = this.deps.workspaceManager.get(workspaceId);
         if (!workspace) {
-            throw new Error("Workspace not found");
+            return null;
         }
         return path.join(workspace.path, ROOT_DIR, workspaceId, INDEX_FILE);
     }
@@ -439,7 +446,7 @@ export class BackgroundProcessManager {
     }
     async getOutputSize(workspaceId, processId) {
         const outputPath = this.getOutputPath(workspaceId, processId);
-        if (!existsSync(outputPath)) {
+        if (!outputPath || !existsSync(outputPath)) {
             return 0;
         }
         try {
@@ -475,6 +482,11 @@ export class BackgroundProcessManager {
         };
     }
     async finalizeRecord(workspaceId, record, completion) {
+        if (!this.deps.workspaceManager.get(workspaceId)) {
+            this.deps.logger.debug({ workspaceId, processId: record.id }, "Skipping finalizeRecord: workspace already removed");
+            this.running.delete(record.id);
+            return;
+        }
         if (this.shouldSendCompletionPrompt(record, completion)) {
             try {
                 await this.sendCompletionPrompt(workspaceId, record);

package/dist/filesystem/__tests__/search-cache.test.js

@@ -5,10 +5,10 @@ describe("workspace search cache", () => {
     beforeEach(() => {
         clearWorkspaceSearchCache();
     });
-    it("expires cached candidates after the TTL", () => {
+    it("expires cached candidates after the TTL", async () => {
         const workspacePath = "/tmp/workspace";
         const startTime = 1000;
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
+        await refreshWorkspaceCandidates(workspacePath, async () => [createEntry("file-a")], startTime);
         const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
         assert.ok(beforeExpiry);
         assert.equal(beforeExpiry.length, 1);
@@ -16,13 +16,13 @@ describe("workspace search cache", () => {
         const afterExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS + 1);
         assert.equal(afterExpiry, undefined);
     });
-    it("replaces cached entries when manually refreshed", () => {
+    it("replaces cached entries when manually refreshed", async () => {
         const workspacePath = "/tmp/workspace";
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
+        await refreshWorkspaceCandidates(workspacePath, async () => [createEntry("file-a")], 5000);
         const initial = getWorkspaceCandidates(workspacePath, 5001);
         assert.ok(initial);
         assert.equal(initial[0].name, "file-a");
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
+        await refreshWorkspaceCandidates(workspacePath, async () => [createEntry("file-b")], 6000);
         const refreshed = getWorkspaceCandidates(workspacePath, 6001);
         assert.ok(refreshed);
         assert.equal(refreshed[0].name, "file-b");

package/dist/filesystem/search-cache.js

@@ -13,9 +13,9 @@ export function getWorkspaceCandidates(rootDir, now = Date.now()) {
     }
     return cloneEntries(cached.candidates);
 }
-export function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
+export async function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
     const key = normalizeKey(rootDir);
-    const freshCandidates = builder();
+    const freshCandidates = await builder();
     if (!freshCandidates || freshCandidates.length === 0) {
         workspaceCandidateCache.delete(key);
         return [];

package/dist/filesystem/search.js

@@ -1,4 +1,4 @@
-import fs from "fs";
+import { readdir, stat } from "node:fs/promises";
 import path from "path";
 import fuzzysort from "fuzzysort";
 import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates } from "./search-cache";
@@ -6,7 +6,7 @@ const DEFAULT_LIMIT = 100;
 const MAX_LIMIT = 200;
 const MAX_CANDIDATES = 8000;
 const IGNORED_DIRECTORIES = new Set([".git", ".hg", ".svn", "node_modules", "dist", "build", ".next", ".nuxt", ".turbo", ".cache", "coverage"].map((name) => name.toLowerCase()));
-export function searchWorkspaceFiles(rootDir, query, options = {}) {
+export async function searchWorkspaceFiles(rootDir, query, options = {}) {
     const trimmedQuery = query.trim();
     if (!trimmedQuery) {
         throw new Error("Search query is required");
@@ -21,7 +21,7 @@ export function searchWorkspaceFiles(rootDir, query, options = {}) {
             entries = getWorkspaceCandidates(normalizedRoot);
         }
         if (!entries) {
-            entries = refreshWorkspaceCandidates(normalizedRoot, () => collectCandidates(normalizedRoot));
+            entries = await refreshWorkspaceCandidates(normalizedRoot, () => collectCandidates(normalizedRoot));
         }
     }
     catch (error) {
@@ -45,7 +45,7 @@ export function searchWorkspaceFiles(rootDir, query, options = {}) {
     }
     return matches.map((match) => match.obj.entry);
 }
-function collectCandidates(rootDir) {
+async function collectCandidates(rootDir) {
     const queue = [""];
     const entries = [];
     while (queue.length > 0 && entries.length < MAX_CANDIDATES) {
@@ -53,7 +53,7 @@ function collectCandidates(rootDir) {
         const absoluteDir = relativeDir ? path.join(rootDir, relativeDir) : rootDir;
         let dirents;
         try {
-            dirents = fs.readdirSync(absoluteDir, { withFileTypes: true });
+            dirents = await readdir(absoluteDir, { withFileTypes: true });
         }
         catch {
             continue;
@@ -68,7 +68,7 @@ function collectCandidates(rootDir) {
             }
             let stats;
             try {
-                stats = fs.statSync(absolutePath);
+                stats = await stat(absolutePath);
             }
             catch {
                 continue;

package/dist/index.js

@@ -232,7 +232,7 @@ async function main() {
     });
     const instanceStore = new InstanceStore(configLocation.instancesDir);
     const speechService = new SpeechService(settings, logger.child({ component: "speech" }));
-    const sidecarManager = new SideCarManager({
+    const sidecarManager = await SideCarManager.create({
         settings,
         eventBus,
         logger: logger.child({ component: "sidecars" }),

package/dist/server/routes/events.js

@@ -3,6 +3,7 @@ let nextClientId = 0;
 const ConnectionQuerySchema = z.object({
     clientId: z.string().trim().min(1),
     connectionId: z.string().trim().min(1),
+    workspaceId: z.string().trim().optional(),
 });
 const PongBodySchema = ConnectionQuerySchema.extend({
     pingTs: z.number().optional(),
@@ -20,7 +21,32 @@ export function registerEventRoutes(app, deps) {
         reply.raw.setHeader("Connection", "keep-alive");
         reply.raw.flushHeaders?.();
         reply.hijack();
+        const filterWorkspaceId = connection.workspaceId;
+        const getEventWorkspaceId = (event) => {
+            switch (event.type) {
+                case "workspace.created":
+                case "workspace.started":
+                case "workspace.error":
+                    return event.workspace?.id;
+                case "workspace.stopped":
+                    return event.workspaceId;
+                case "workspace.log":
+                    return event.entry.workspaceId;
+                case "instance.event":
+                case "instance.eventStatus":
+                case "instance.dataChanged":
+                    return event.instanceId;
+                default:
+                    return undefined;
+            }
+        };
         const send = (event) => {
+            if (filterWorkspaceId) {
+                const eventWsId = getEventWorkspaceId(event);
+                if (eventWsId && eventWsId !== filterWorkspaceId) {
+                    return;
+                }
+            }
             deps.logger.debug({ clientId, type: event.type }, "SSE event dispatched");
             if (deps.logger.isLevelEnabled("trace")) {
                 deps.logger.trace({ clientId, event }, "SSE event payload");

package/dist/server/routes/settings.js

@@ -10,10 +10,10 @@ function validateBinaryPath(binaryPath) {
 }
 export function registerSettingsRoutes(app, deps) {
     // Full-document access
-    app.get("/api/storage/config", async () => sanitizeConfigDoc(deps.settings.getDoc("config")));
+    app.get("/api/storage/config", async () => sanitizeConfigDoc(await deps.settings.getDoc("config")));
     app.patch("/api/storage/config", async (request, reply) => {
         try {
-            return sanitizeConfigDoc(deps.settings.mergePatchDoc("config", request.body ?? {}));
+            return sanitizeConfigDoc(await deps.settings.mergePatchDoc("config", request.body ?? {}));
         }
         catch (error) {
             reply.code(400);
@@ -21,11 +21,11 @@ export function registerSettingsRoutes(app, deps) {
         }
     });
     app.get("/api/storage/config/:owner", async (request) => {
-        return sanitizeConfigOwner(request.params.owner, deps.settings.getOwner("config", request.params.owner));
+        return sanitizeConfigOwner(request.params.owner, await deps.settings.getOwner("config", request.params.owner));
     });
     app.patch("/api/storage/config/:owner", async (request, reply) => {
         try {
-            return sanitizeConfigOwner(request.params.owner, deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {}));
+            return sanitizeConfigOwner(request.params.owner, await deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {}));
         }
         catch (error) {
             reply.code(400);
@@ -35,7 +35,7 @@ export function registerSettingsRoutes(app, deps) {
     app.get("/api/storage/state", async () => deps.settings.getDoc("state"));
     app.patch("/api/storage/state", async (request, reply) => {
         try {
-            return deps.settings.mergePatchDoc("state", request.body ?? {});
+            return await deps.settings.mergePatchDoc("state", request.body ?? {});
         }
         catch (error) {
             reply.code(400);
@@ -47,7 +47,7 @@ export function registerSettingsRoutes(app, deps) {
     });
     app.patch("/api/storage/state/:owner", async (request, reply) => {
         try {
-            return deps.settings.mergePatchOwner("state", request.params.owner, request.body ?? {});
+            return await deps.settings.mergePatchOwner("state", request.params.owner, request.body ?? {});
         }
         catch (error) {
             reply.code(400);

package/dist/server/routes/speech.js

@@ -23,7 +23,7 @@ function getSpeechErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
 export function registerSpeechRoutes(app, deps) {
-    app.get("/api/speech/capabilities", async () => deps.speechService.getCapabilities());
+    app.get("/api/speech/capabilities", async () => await deps.speechService.getCapabilities());
     app.post("/api/speech/transcribe", async (request, reply) => {
         try {
             const body = TranscribeBodySchema.parse(request.body ?? {});

package/dist/server/routes/workspaces.js

@@ -77,7 +77,7 @@ export function registerWorkspaceRoutes(app, deps) {
     app.get("/api/workspaces/:id/files/search", async (request, reply) => {
         try {
             const query = WorkspaceFileSearchQuerySchema.parse(request.query ?? {});
-            return deps.workspaceManager.searchFiles(request.params.id, query.q, {
+            return await deps.workspaceManager.searchFiles(request.params.id, query.q, {
                 limit: query.limit,
                 type: query.type,
                 refresh: query.refresh,

package/dist/settings/binaries.js

@@ -3,15 +3,15 @@ function prettyLabel(p) {
     const last = parts[parts.length - 1] || p;
     return last || p;
 }
-function readUiBinaries(settings) {
-    const ui = settings.getOwner("state", "ui");
+async function readUiBinaries(settings) {
+    const ui = await settings.getOwner("state", "ui");
     const list = ui?.opencodeBinaries;
     if (!Array.isArray(list))
         return [];
     return list.filter((item) => item && typeof item === "object" && typeof item.path === "string");
 }
-function readDefaultBinaryPath(settings) {
-    const server = settings.getOwner("config", "server");
+async function readDefaultBinaryPath(settings) {
+    const server = await settings.getOwner("config", "server");
     const value = server?.opencodeBinary;
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
@@ -19,12 +19,12 @@ export class BinaryResolver {
     constructor(settings) {
         this.settings = settings;
     }
-    list() {
+    async list() {
         return readUiBinaries(this.settings);
     }
-    resolveDefault() {
-        const binaries = this.list();
-        const configuredDefault = readDefaultBinaryPath(this.settings);
+    async resolveDefault() {
+        const binaries = await this.list();
+        const configuredDefault = await readDefaultBinaryPath(this.settings);
         const fallback = binaries[0]?.path;
         const path = configuredDefault ?? fallback ?? "opencode";
         const entry = binaries.find((b) => b.path === path);

package/dist/settings/service.js

@@ -51,46 +51,46 @@ export class SettingsService {
         this.configStore = new YamlDocStore(location.configYamlPath, logger.child({ component: "settings-config" }));
         this.stateStore = new YamlDocStore(location.stateYamlPath, logger.child({ component: "settings-state" }));
     }
-    getDoc(kind) {
+    async getDoc(kind) {
         if (kind !== "config") {
             return this.stateStore.get();
         }
-        const current = this.configStore.get();
+        const current = await this.configStore.get();
         const normalized = normalizeConfigDoc(current);
         if (!isDeepEqual(current, normalized)) {
-            this.configStore.replace(normalized);
+            await this.configStore.replace(normalized);
         }
         return normalized;
     }
-    mergePatchDoc(kind, patch) {
+    async mergePatchDoc(kind, patch) {
         const updated = kind === "config"
-            ? this.configStore.replace(normalizeConfigDoc(this.configStore.mergePatch(patch)))
-            : this.stateStore.mergePatch(patch);
-        this.publish(kind, "*");
+            ? await this.configStore.replace(normalizeConfigDoc(await this.configStore.mergePatch(patch)))
+            : await this.stateStore.mergePatch(patch);
+        await this.publish(kind, "*");
         return updated;
     }
-    getOwner(kind, owner) {
+    async getOwner(kind, owner) {
         if (kind !== "config") {
             return this.stateStore.getOwner(owner);
         }
         return owner === "server"
-            ? normalizeServerConfigOwner(this.getDoc("config").server)
-            : this.getDoc("config")[owner];
+            ? normalizeServerConfigOwner((await this.getDoc("config")).server)
+            : (await this.getDoc("config"))[owner];
     }
-    mergePatchOwner(kind, owner, patch) {
+    async mergePatchOwner(kind, owner, patch) {
         const updated = kind === "config"
             ? owner === "server"
-                ? this.configStore.replaceOwner(owner, normalizeServerConfigOwner(this.configStore.mergePatchOwner(owner, patch)))
-                : this.configStore.mergePatchOwner(owner, patch)
-            : this.stateStore.mergePatchOwner(owner, patch);
-        this.publish(kind, owner, updated);
+                ? await this.configStore.replaceOwner(owner, normalizeServerConfigOwner(await this.configStore.mergePatchOwner(owner, patch)))
+                : await this.configStore.mergePatchOwner(owner, patch)
+            : await this.stateStore.mergePatchOwner(owner, patch);
+        await this.publish(kind, owner, updated);
         return updated;
     }
-    publish(kind, owner, value) {
+    async publish(kind, owner, value) {
         if (!this.eventBus)
             return;
         const type = kind === "config" ? "storage.configChanged" : "storage.stateChanged";
-        const nextValue = value ?? this.getOwner(kind, owner);
+        const nextValue = value ?? await this.getOwner(kind, owner);
         const payload = {
             type,
             owner,

package/dist/settings/yaml-doc-store.js

@@ -1,4 +1,5 @@
-import fs from "fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
 import path from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { applyMergePatch, isPlainObject } from "./merge-patch";
@@ -20,17 +21,20 @@ export class YamlDocStore {
         this.cache = {};
         this.loaded = false;
     }
-    load() {
+    async load() {
         if (this.loaded) {
             return this.cache;
         }
         try {
-            if (!fs.existsSync(this.filePath)) {
+            try {
+                await access(this.filePath, constants.F_OK);
+            }
+            catch {
                 this.cache = {};
                 this.loaded = true;
                 return this.cache;
             }
-            const content = fs.readFileSync(this.filePath, "utf-8");
+            const content = await readFile(this.filePath, "utf-8");
             const parsed = parseYaml(content);
             this.cache = normalizeDoc(parsed);
             this.loaded = true;
@@ -43,51 +47,51 @@ export class YamlDocStore {
             return this.cache;
         }
     }
-    get() {
+    async get() {
         return this.load();
     }
-    replace(next) {
+    async replace(next) {
         const normalized = normalizeDoc(next);
         this.cache = normalized;
         this.loaded = true;
-        this.persist();
+        await this.persist();
         return this.cache;
     }
-    mergePatch(patch) {
+    async mergePatch(patch) {
         if (!isPlainObject(patch)) {
             throw new Error("Patch must be a JSON object");
         }
-        const current = this.get();
+        const current = await this.get();
         const next = applyMergePatch(current, patch);
         return this.replace(next);
     }
-    getOwner(owner) {
-        const doc = this.get();
+    async getOwner(owner) {
+        const doc = await this.get();
         const value = doc?.[owner];
         return normalizeDoc(value);
     }
-    replaceOwner(owner, value) {
-        const doc = this.get();
+    async replaceOwner(owner, value) {
+        const doc = await this.get();
         const nextDoc = { ...doc, [owner]: normalizeDoc(value) };
-        this.replace(nextDoc);
+        await this.replace(nextDoc);
         return nextDoc[owner];
     }
-    mergePatchOwner(owner, patch) {
+    async mergePatchOwner(owner, patch) {
         if (!isPlainObject(patch)) {
             throw new Error("Patch must be a JSON object");
         }
-        const doc = this.get();
+        const doc = await this.get();
         const currentOwner = normalizeDoc(doc?.[owner]);
         const nextOwner = normalizeDoc(applyMergePatch(currentOwner, patch));
         const nextDoc = { ...doc, [owner]: nextOwner };
-        this.replace(nextDoc);
+        await this.replace(nextDoc);
         return nextOwner;
     }
-    persist() {
+    async persist() {
         try {
-            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            await mkdir(path.dirname(this.filePath), { recursive: true });
             const yaml = stringifyYaml(this.cache);
-            fs.writeFileSync(this.filePath, ensureTrailingNewline(yaml), "utf-8");
+            await writeFile(this.filePath, ensureTrailingNewline(yaml), "utf-8");
         }
         catch (error) {
             this.logger.warn({ err: error, filePath: this.filePath }, "Failed to persist YAML doc");

package/dist/sidecars/manager.js

@@ -4,17 +4,21 @@ export class SideCarManager {
         this.options = options;
         this.configs = new Map();
         this.runtime = new Map();
-        for (const record of this.loadConfiguredSideCars()) {
-            this.configs.set(record.id, record);
-            this.runtime.set(record.id, { status: "stopped" });
+    }
+    static async create(options) {
+        const instance = new SideCarManager(options);
+        for (const record of await instance.loadConfiguredSideCars()) {
+            instance.configs.set(record.id, record);
+            instance.runtime.set(record.id, { status: "stopped" });
         }
         queueMicrotask(() => {
-            for (const record of this.configs.values()) {
-                void this.refreshPortSideCar(record.id).catch((error) => {
-                    this.options.logger.warn({ sidecarId: record.id, err: error }, "Failed to probe sidecar port");
+            for (const record of instance.configs.values()) {
+                void instance.refreshPortSideCar(record.id).catch((error) => {
+                    instance.options.logger.warn({ sidecarId: record.id, err: error }, "Failed to probe sidecar port");
                 });
             }
         });
+        return instance;
     }
     async list() {
         await this.refreshPortStatuses();
@@ -45,7 +49,7 @@ export class SideCarManager {
         };
         this.configs.set(record.id, record);
         this.runtime.set(record.id, { status: "stopped" });
-        this.persistConfigs();
+        await this.persistConfigs();
         await this.refreshPortSideCar(record.id);
         return this.toSideCar(record);
     }
@@ -56,7 +60,7 @@ export class SideCarManager {
         record.insecure = typeof input.insecure === "boolean" ? input.insecure : record.insecure;
         record.prefixMode = typeof input.prefixMode === "string" ? input.prefixMode : record.prefixMode;
         record.updatedAt = new Date().toISOString();
-        this.persistConfigs();
+        await this.persistConfigs();
         await this.refreshPortSideCar(id);
         return this.toSideCar(record);
     }
@@ -66,7 +70,7 @@ export class SideCarManager {
             return false;
         this.configs.delete(id);
         this.runtime.delete(id);
-        this.persistConfigs();
+        await this.persistConfigs();
         this.options.eventBus.publish({ type: "sidecar.removed", sidecarId: id });
         return true;
     }
@@ -140,12 +144,12 @@ export class SideCarManager {
         }
         return record;
     }
-    persistConfigs() {
+    async persistConfigs() {
         const sidecars = Array.from(this.configs.values()).map((record) => ({ ...record }));
-        this.options.settings.mergePatchOwner("config", "server", { sidecars });
+        await this.options.settings.mergePatchOwner("config", "server", { sidecars });
     }
-    loadConfiguredSideCars() {
-        const serverConfig = this.options.settings.getOwner("config", "server");
+    async loadConfiguredSideCars() {
+        const serverConfig = await this.options.settings.getOwner("config", "server");
         const list = Array.isArray(serverConfig?.sidecars) ? serverConfig.sidecars : [];
         const records = [];
         for (const item of list) {

package/dist/speech/service.js

@@ -23,27 +23,27 @@ export class SpeechService {
         this.settings = settings;
         this.logger = logger;
     }
-    getCapabilities() {
-        return this.createProvider().getCapabilities();
+    async getCapabilities() {
+        return (await this.createProvider()).getCapabilities();
     }
     async transcribe(input) {
-        return this.createProvider().transcribe(input);
+        return (await this.createProvider()).transcribe(input);
     }
     async synthesize(input) {
-        return this.createProvider().synthesize(input);
+        return (await this.createProvider()).synthesize(input);
     }
     async synthesizeStream(input) {
-        return this.createProvider().synthesizeStream(input);
+        return (await this.createProvider()).synthesizeStream(input);
     }
-    createProvider() {
-        const settings = this.resolveSettings();
+    async createProvider() {
+        const settings = await this.resolveSettings();
         return new OpenAICompatibleSpeechProvider({
             settings,
             logger: this.logger.child({ provider: settings.provider }),
         });
     }
-    resolveSettings() {
-        const parsed = ServerSpeechSettingsSchema.parse(this.settings.getOwner("config", "server") ?? {});
+    async resolveSettings() {
+        const parsed = ServerSpeechSettingsSchema.parse(await this.settings.getOwner("config", "server") ?? {});
         const speech = parsed.speech ?? {};
         return {
             provider: speech.provider?.trim() || DEFAULT_PROVIDER,

package/dist/workspaces/instance-events.js

@@ -3,10 +3,12 @@ import { Agent as UndiciAgent } from "undici";
 const INSTANCE_HOST = "127.0.0.1";
 const STREAM_AGENT = new UndiciAgent({ bodyTimeout: 0, headersTimeout: 0 });
 const RECONNECT_DELAY_MS = 1000;
+const LOG_THROTTLE_MS = 50;
 export class InstanceEventBridge {
     constructor(options) {
         this.options = options;
         this.streams = new Map();
+        this.lastLogTime = new Map();
         const bus = this.options.eventBus;
         bus.on("workspace.started", (event) => this.startStream(event.workspace.id));
         bus.on("workspace.stopped", (event) => this.stopStream(event.workspaceId, "workspace stopped"));
@@ -46,6 +48,7 @@ export class InstanceEventBridge {
         }
         active.controller.abort();
         this.streams.delete(workspaceId);
+        this.lastLogTime.delete(workspaceId);
         this.publishStatus(workspaceId, "disconnected", reason);
     }
     async runStream(workspaceId, signal) {
@@ -151,6 +154,14 @@ export class InstanceEventBridge {
             if (this.options.logger.isLevelEnabled("trace")) {
                 this.options.logger.trace({ workspaceId, event }, "Instance SSE event payload");
             }
+            if (event.type === "workspace.log") {
+                const now = Date.now();
+                const last = this.lastLogTime.get(workspaceId) ?? 0;
+                if (now - last < LOG_THROTTLE_MS) {
+                    return;
+                }
+                this.lastLogTime.set(workspaceId, now);
+            }
             this.options.eventBus.publish({ type: "instance.event", instanceId: workspaceId, event });
         }
         catch (error) {

package/dist/workspaces/manager.js

@@ -1,6 +1,8 @@
 import path from "path";
-import { spawnSync } from "child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { connect } from "net";
+const execFileAsync = promisify(execFile);
 import { FileSystemBrowser } from "../filesystem/browser";
 import { searchWorkspaceFiles } from "../filesystem/search";
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache";
@@ -9,10 +11,30 @@ import { getOpencodeConfigDir } from "../opencode-config.js";
 import { OPENCODE_SERVER_BASE_URL_ENV, buildOpencodeBasicAuthHeader, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, resolveOpencodeServerAuth, } from "./opencode-auth";
 const STARTUP_STABILITY_DELAY_MS = 1500;
 export class WorkspaceManager {
+    async acquireStartupSlot() {
+        if (this.activeStartups < this.MAX_CONCURRENT_STARTUPS) {
+            this.activeStartups++;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.startupQueue.push(resolve);
+        });
+    }
+    releaseStartupSlot() {
+        this.activeStartups--;
+        const next = this.startupQueue.shift();
+        if (next) {
+            this.activeStartups++;
+            next();
+        }
+    }
     constructor(options) {
         this.options = options;
         this.workspaces = new Map();
         this.opencodeAuth = new Map();
+        this.MAX_CONCURRENT_STARTUPS = 3;
+        this.activeStartups = 0;
+        this.startupQueue = [];
         this.runtime = new WorkspaceRuntime(this.options.eventBus, this.options.logger);
         this.opencodeConfigDir = getOpencodeConfigDir();
     }
@@ -33,7 +55,7 @@ export class WorkspaceManager {
         const browser = new FileSystemBrowser({ rootDir: workspace.path });
         return browser.list(relativePath);
     }
-    searchFiles(workspaceId, query, options) {
+    async searchFiles(workspaceId, query, options) {
         const workspace = this.requireWorkspace(workspaceId);
         return searchWorkspaceFiles(workspace.path, query, options);
     }
@@ -53,9 +75,10 @@ export class WorkspaceManager {
         browser.writeFile(relativePath, contents);
     }
     async create(folder, name) {
+        await this.acquireStartupSlot();
         const id = `${Date.now().toString(36)}`;
-        const binary = this.options.binaryResolver.resolveDefault();
-        const resolvedBinaryPath = this.resolveBinaryPath(binary.path);
+        const binary = await this.options.binaryResolver.resolveDefault();
+        const resolvedBinaryPath = await this.resolveBinaryPath(binary.path);
         const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder);
         clearWorkspaceSearchCache(workspacePath);
         this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: resolvedBinaryPath }, "Creating workspace");
@@ -74,7 +97,7 @@ export class WorkspaceManager {
         };
         this.workspaces.set(id, descriptor);
         this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
-        const serverConfig = this.options.settings.getOwner("config", "server");
+        const serverConfig = await this.options.settings.getOwner("config", "server");
         const envVars = serverConfig?.environmentVariables;
         const userEnvironment = envVars && typeof envVars === "object" && !Array.isArray(envVars) ? envVars : {};
         const serverBaseUrl = this.options.getServerBaseUrl();
@@ -128,6 +151,9 @@ export class WorkspaceManager {
             this.options.logger.error({ workspaceId: id, err: error }, "Workspace failed to start");
             throw error;
         }
+        finally {
+            this.releaseStartupSlot();
+        }
     }
     async delete(id) {
         const workspace = this.workspaces.get(id);
@@ -175,7 +201,7 @@ export class WorkspaceManager {
         }
         return workspace;
     }
-    resolveBinaryPath(identifier) {
+    async resolveBinaryPath(identifier) {
         if (!identifier) {
             return identifier;
         }
@@ -185,9 +211,23 @@ export class WorkspaceManager {
         }
         const locator = process.platform === "win32" ? "where" : "which";
         try {
-            const result = spawnSync(locator, [identifier], { encoding: "utf8" });
-            if (result.status === 0 && result.stdout) {
-                const candidates = result.stdout
+            let stdout;
+            let stderr;
+            try {
+                const result = await execFileAsync(locator, [identifier], { encoding: "utf8" });
+                stdout = result.stdout;
+                stderr = result.stderr;
+            }
+            catch (err) {
+                stdout = err?.stdout ?? "";
+                stderr = err?.stderr ?? "";
+                if (!stdout && err?.code === "ENOENT") {
+                    this.options.logger.warn({ identifier, err }, "Failed to resolve binary path via locator command");
+                    return identifier;
+                }
+            }
+            if (stdout) {
+                const candidates = stdout
                     .split(/\r?\n/)
                     .map((line) => line.trim())
                     .filter((line) => line.length > 0)
@@ -198,8 +238,8 @@ export class WorkspaceManager {
                     return resolved;
                 }
             }
-            else if (result.error) {
-                this.options.logger.warn({ identifier, err: result.error }, "Failed to resolve binary path via locator command");
+            if (stderr) {
+                this.options.logger.warn({ identifier, stderr }, "Locator command reported errors");
             }
         }
         catch (error) {

package/dist/workspaces/runtime.js

@@ -1,5 +1,6 @@
 import { spawn, spawnSync } from "child_process";
-import { existsSync, statSync } from "fs";
+import { access, stat } from "node:fs/promises";
+import { constants } from "node:fs";
 import path from "path";
 import { buildSpawnSpec, buildWslSignalSpec } from "./spawn";
 const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET)/i;
@@ -22,7 +23,7 @@ export class WorkspaceRuntime {
         this.processes = new Map();
     }
     async launch(options) {
-        this.validateFolder(options.folder);
+        await this.validateFolder(options.folder);
         const logLevel = typeof options.logLevel === "string" ? options.logLevel.toUpperCase() : "DEBUG";
         const args = ["serve", "--port", "0", "--print-logs", "--log-level", logLevel];
         const env = { ...process.env, ...(options.environment ?? {}) };
@@ -353,12 +354,15 @@ export class WorkspaceRuntime {
         };
         this.eventBus.publish({ type: "workspace.log", entry });
     }
-    validateFolder(folder) {
+    async validateFolder(folder) {
         const resolved = path.resolve(folder);
-        if (!existsSync(resolved)) {
+        try {
+            await access(resolved, constants.F_OK);
+        }
+        catch {
             throw new Error(`Folder does not exist: ${resolved}`);
         }
-        const stats = statSync(resolved);
+        const stats = await stat(resolved);
         if (!stats.isDirectory()) {
             throw new Error(`Path is not a directory: ${resolved}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dyyz1993/codenomad",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {

package/public/index.html

@@ -30,8 +30,8 @@
     <link rel="modulepreload" crossorigin href="/assets/git-diff-vendor-CSgooKT_.js">
     <link rel="modulepreload" crossorigin href="/assets/monaco-viewer-YY9yfE-p.js">
     <link rel="modulepreload" crossorigin href="/assets/index-BCGPLzO4.js">
-    <link rel="stylesheet" crossorigin href="/assets/git-diff-vendor-HAZkIolJ.css">
     <link rel="stylesheet" crossorigin href="/assets/index-DXI9DoVB.css">
+    <link rel="stylesheet" crossorigin href="/assets/git-diff-vendor-HAZkIolJ.css">
   <link rel="manifest" href="/manifest.webmanifest"><script id="vite-plugin-pwa:register-sw" src="/registerSW.js"></script>
 <meta name="theme-color" content="#1a1a1a">
 <link rel="icon" href="/favicon.ico" sizes="48x48">

package/public/loading.html

@@ -20,8 +20,8 @@
     <link rel="modulepreload" crossorigin href="/assets/git-diff-vendor-CSgooKT_.js">
     <link rel="modulepreload" crossorigin href="/assets/monaco-viewer-YY9yfE-p.js">
     <link rel="modulepreload" crossorigin href="/assets/index-BCGPLzO4.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-DXI9DoVB.css">
     <link rel="stylesheet" crossorigin href="/assets/git-diff-vendor-HAZkIolJ.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-DXI9DoVB.css">
     <link rel="stylesheet" crossorigin href="/assets/loading-CmEVQgyj.css">
   <link rel="manifest" href="/manifest.webmanifest"><script id="vite-plugin-pwa:register-sw" src="/registerSW.js"></script>
 <meta name="theme-color" content="#1a1a1a">