@neuralnomads/codenomad-dev 0.10.3-dev-20260215-4f6c8523 → 0.11.1-dev-20260216-e16c5752

package/dist/events/bus.js

@@ -20,8 +20,8 @@ export class EventBus extends EventEmitter {
         this.on("workspace.error", handler);
         this.on("workspace.stopped", handler);
         this.on("workspace.log", handler);
-        this.on("config.appChanged", handler);
-        this.on("config.binariesChanged", handler);
+        this.on("storage.configChanged", handler);
+        this.on("storage.stateChanged", handler);
         this.on("instance.dataChanged", handler);
         this.on("instance.event", handler);
         this.on("instance.eventStatus", handler);
@@ -31,8 +31,8 @@ export class EventBus extends EventEmitter {
             this.off("workspace.error", handler);
             this.off("workspace.stopped", handler);
             this.off("workspace.log", handler);
-            this.off("config.appChanged", handler);
-            this.off("config.binariesChanged", handler);
+            this.off("storage.configChanged", handler);
+            this.off("storage.stateChanged", handler);
             this.off("instance.dataChanged", handler);
             this.off("instance.event", handler);
             this.off("instance.eventStatus", handler);

package/dist/index.js

@@ -8,9 +8,9 @@ import { fileURLToPath } from "url";
 import { createRequire } from "module";
 import { createHttpServer } from "./server/http-server";
 import { WorkspaceManager } from "./workspaces/manager";
-import { ConfigStore } from "./config/store";
 import { resolveConfigLocation } from "./config/location";
-import { BinaryRegistry } from "./config/binaries";
+import { SettingsService } from "./settings/service";
+import { BinaryResolver } from "./settings/binaries";
 import { FileSystemBrowser } from "./filesystem/browser";
 import { EventBus } from "./events/bus";
 import { InstanceStore } from "./storage/instance-store";
@@ -188,20 +188,12 @@ async function main() {
         logger: logger.child({ component: "tls" }),
     });
     const nodeExtraCaCertsPath = !options.http ? tlsResolution?.caCertPath : undefined;
-    const configStore = new ConfigStore(configLocation, eventBus, configLogger);
-    // Eagerly load config at boot so migrations run immediately
-    // (instead of waiting for the first /api/config request).
-    try {
-        configStore.get();
-    }
-    catch (error) {
-        configLogger.warn({ err: error }, "Failed to load config at boot; continuing with defaults");
-    }
-    const binaryRegistry = new BinaryRegistry(configStore, eventBus, configLogger);
+    const settings = new SettingsService(configLocation, eventBus, configLogger);
+    const binaryResolver = new BinaryResolver(settings);
     const workspaceManager = new WorkspaceManager({
         rootDir: options.rootDir,
-        configStore,
-        binaryRegistry,
+        settings,
+        binaryResolver,
         eventBus,
         logger: workspaceLogger,
         getServerBaseUrl: () => serverMeta.localUrl,
@@ -276,8 +268,7 @@ async function main() {
             defaultPort: options.httpPort,
             protocol: "http",
             workspaceManager,
-            configStore,
-            binaryRegistry,
+            settings,
             fileSystemBrowser,
             eventBus,
             serverMeta,
@@ -296,8 +287,7 @@ async function main() {
             protocol: "https",
             httpsOptions: tlsResolution?.httpsOptions,
             workspaceManager,
-            configStore,
-            binaryRegistry,
+            settings,
             fileSystemBrowser,
             eventBus,
             serverMeta,

package/dist/opencode-config/package.json

@@ -4,6 +4,6 @@
   "private": true,
   "license": "MIT",
   "dependencies": {
-    "@opencode-ai/plugin": "1.1.53"
+    "@opencode-ai/plugin": "1.2.4"
   }
-}
+}

package/dist/server/http-server.js

@@ -7,7 +7,7 @@ import path from "path";
 import { fetch } from "undici";
 import { isValidWorktreeSlug, listWorktrees, resolveRepoRoot } from "../workspaces/git-worktrees";
 import { registerWorkspaceRoutes } from "./routes/workspaces";
-import { registerConfigRoutes } from "./routes/config";
+import { registerSettingsRoutes } from "./routes/settings";
 import { registerFilesystemRoutes } from "./routes/filesystem";
 import { registerMetaRoutes } from "./routes/meta";
 import { registerEventRoutes } from "./routes/events";
@@ -181,7 +181,7 @@ export function createHttpServer(deps) {
         reply.code(404).send({ message: "UI bundle missing" });
     });
     registerWorkspaceRoutes(app, { workspaceManager: deps.workspaceManager });
-    registerConfigRoutes(app, { configStore: deps.configStore, binaryRegistry: deps.binaryRegistry });
+    registerSettingsRoutes(app, { settings: deps.settings, logger: apiLogger });
     registerFilesystemRoutes(app, { fileSystemBrowser: deps.fileSystemBrowser });
     registerMetaRoutes(app, { serverMeta: deps.serverMeta });
     registerEventRoutes(app, { eventBus: deps.eventBus, registerClient: registerSseClient, logger: sseLogger });

package/dist/server/routes/settings.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { spawnSync } from "child_process";
+import { buildSpawnSpec } from "../../workspaces/runtime";
+const ValidateBinarySchema = z.object({
+    path: z.string(),
+});
+function validateBinaryPath(binaryPath) {
+    if (!binaryPath) {
+        return { valid: false, error: "Missing binary path" };
+    }
+    const spec = buildSpawnSpec(binaryPath, ["--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) };
+    }
+}
+export function registerSettingsRoutes(app, deps) {
+    // Full-document access
+    app.get("/api/storage/config", async () => deps.settings.getDoc("config"));
+    app.patch("/api/storage/config", async (request, reply) => {
+        try {
+            return deps.settings.mergePatchDoc("config", request.body ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    app.get("/api/storage/config/:owner", async (request) => {
+        return deps.settings.getOwner("config", request.params.owner);
+    });
+    app.patch("/api/storage/config/:owner", async (request, reply) => {
+        try {
+            return deps.settings.mergePatchOwner("config", request.params.owner, request.body ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    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 ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    app.get("/api/storage/state/:owner", async (request) => {
+        return deps.settings.getOwner("state", request.params.owner);
+    });
+    app.patch("/api/storage/state/:owner", async (request, reply) => {
+        try {
+            return deps.settings.mergePatchOwner("state", request.params.owner, request.body ?? {});
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid patch" };
+        }
+    });
+    // Binary validation helper (used by UI when adding binaries)
+    app.post("/api/storage/binaries/validate", async (request, reply) => {
+        try {
+            const body = ValidateBinarySchema.parse(request.body ?? {});
+            return validateBinaryPath(body.path);
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to validate binary");
+            reply.code(400);
+            return { valid: false, error: error instanceof Error ? error.message : "Invalid request" };
+        }
+    });
+}

package/dist/settings/binaries.js

@@ -0,0 +1,37 @@
+function prettyLabel(p) {
+    const parts = p.split(/[\\/]/);
+    const last = parts[parts.length - 1] || p;
+    return last || p;
+}
+function readUiBinaries(settings) {
+    const ui = 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");
+    const value = server?.opencodeBinary;
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export class BinaryResolver {
+    constructor(settings) {
+        this.settings = settings;
+    }
+    list() {
+        return readUiBinaries(this.settings);
+    }
+    resolveDefault() {
+        const binaries = this.list();
+        const configuredDefault = readDefaultBinaryPath(this.settings);
+        const fallback = binaries[0]?.path;
+        const path = configuredDefault ?? fallback ?? "opencode";
+        const entry = binaries.find((b) => b.path === path);
+        return {
+            path,
+            label: entry?.label ?? prettyLabel(path),
+            version: entry?.version,
+        };
+    }
+}

package/dist/settings/merge-patch.js

@@ -0,0 +1,33 @@
+export function isPlainObject(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * RFC 7396-ish merge patch with explicit null deletes.
+ * - Objects merge recursively
+ * - Arrays/scalars replace
+ * - null deletes keys
+ */
+export function applyMergePatch(current, patch) {
+    if (!isPlainObject(patch)) {
+        return patch;
+    }
+    const base = isPlainObject(current) ? { ...current } : {};
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete base[key];
+            continue;
+        }
+        const existing = base[key];
+        if (isPlainObject(value) && isPlainObject(existing)) {
+            base[key] = applyMergePatch(existing, value);
+            continue;
+        }
+        base[key] = value;
+    }
+    return base;
+}

package/dist/settings/migrate.js

@@ -0,0 +1,233 @@
+import fs from "fs";
+import path from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { isPlainObject } from "./merge-patch";
+function ensureTrailingNewline(content) {
+    if (!content)
+        return "\n";
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function safeReadYaml(filePath, logger) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return parseYaml(content);
+    }
+    catch (error) {
+        logger.warn({ err: error, filePath }, "Failed to read YAML file during migration");
+        return null;
+    }
+}
+function safeReadJson(filePath, logger) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        logger.warn({ err: error, filePath }, "Failed to read JSON file during migration");
+        return null;
+    }
+}
+function writeYaml(filePath, doc, logger) {
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const yaml = stringifyYaml(doc);
+        fs.writeFileSync(filePath, ensureTrailingNewline(yaml), "utf-8");
+    }
+    catch (error) {
+        logger.warn({ err: error, filePath }, "Failed to write YAML file during migration");
+    }
+}
+function pickBackupPath(filePath) {
+    const preferred = `${filePath}.bak`;
+    if (!fs.existsSync(preferred)) {
+        return preferred;
+    }
+    return `${filePath}.bak.${Date.now()}`;
+}
+function normalizeDoc(value) {
+    return isPlainObject(value) ? value : {};
+}
+function looksLikeNewOwnerDoc(value) {
+    const doc = normalizeDoc(value);
+    // Heuristic: owner-bucket docs have at least one of these roots.
+    return Boolean(doc.ui || doc.server || doc.app || doc.legacy);
+}
+function looksLikeLegacyConfig(value) {
+    const doc = normalizeDoc(value);
+    return Boolean(doc.preferences || doc.opencodeBinaries || doc.theme || doc.recentFolders);
+}
+function looksLikeLegacyState(value) {
+    const doc = normalizeDoc(value);
+    return Boolean(doc.recentFolders);
+}
+function omitKeys(source, keys) {
+    const out = {};
+    for (const [k, v] of Object.entries(source)) {
+        if (keys.has(k))
+            continue;
+        out[k] = v;
+    }
+    return out;
+}
+function mapLegacyToOwnerDocs(legacyConfig, legacyState) {
+    const cfg = normalizeDoc(legacyConfig);
+    const st = normalizeDoc(legacyState);
+    const outConfig = {};
+    const outState = {};
+    const uiConfig = {};
+    const uiSettings = {};
+    const serverConfig = {};
+    const uiState = {};
+    // theme -> config.ui.theme
+    if (typeof cfg.theme === "string") {
+        uiConfig.theme = cfg.theme;
+    }
+    const preferences = normalizeDoc(cfg.preferences);
+    if (Object.keys(preferences).length > 0) {
+        // Server-owned stable keys
+        const envVars = preferences.environmentVariables;
+        if (isPlainObject(envVars)) {
+            serverConfig.environmentVariables = envVars;
+        }
+        const listeningMode = preferences.listeningMode;
+        if (typeof listeningMode === "string") {
+            serverConfig.listeningMode = listeningMode;
+        }
+        const lastUsedBinary = preferences.lastUsedBinary;
+        if (typeof lastUsedBinary === "string") {
+            serverConfig.opencodeBinary = lastUsedBinary;
+        }
+        // UI-owned state keys (drop preferences)
+        const modelRecents = preferences.modelRecents;
+        const modelFavorites = preferences.modelFavorites;
+        const modelThinkingSelections = preferences.modelThinkingSelections;
+        const models = {};
+        if (Array.isArray(modelRecents)) {
+            models.recents = modelRecents;
+        }
+        if (Array.isArray(modelFavorites)) {
+            models.favorites = modelFavorites;
+        }
+        if (isPlainObject(modelThinkingSelections)) {
+            models.thinkingSelections = modelThinkingSelections;
+        }
+        if (Object.keys(models).length > 0) {
+            uiState.models = models;
+        }
+        // Remaining preferences are treated as stable UI settings.
+        const moved = new Set([
+            "environmentVariables",
+            "listeningMode",
+            "lastUsedBinary",
+            "modelRecents",
+            "modelFavorites",
+            "modelThinkingSelections",
+        ]);
+        Object.assign(uiSettings, omitKeys(preferences, moved));
+    }
+    // recentFolders lives in legacy state (yaml) or legacy config.json
+    const recentFolders = (st.recentFolders ?? cfg.recentFolders);
+    if (Array.isArray(recentFolders)) {
+        uiState.recentFolders = recentFolders;
+    }
+    // opencodeBinaries -> state.ui.opencodeBinaries
+    if (Array.isArray(cfg.opencodeBinaries)) {
+        uiState.opencodeBinaries = cfg.opencodeBinaries;
+    }
+    if (Object.keys(uiSettings).length > 0) {
+        uiConfig.settings = uiSettings;
+    }
+    if (Object.keys(uiConfig).length > 0) {
+        outConfig.ui = uiConfig;
+    }
+    if (Object.keys(serverConfig).length > 0) {
+        outConfig.server = serverConfig;
+    }
+    if (Object.keys(uiState).length > 0) {
+        outState.ui = uiState;
+    }
+    // Unknown top-level keys -> legacy.unknown
+    const knownConfigKeys = new Set(["preferences", "opencodeBinaries", "theme", "recentFolders"]);
+    const unknownConfig = omitKeys(cfg, knownConfigKeys);
+    if (Object.keys(unknownConfig).length > 0) {
+        outConfig.legacy = { unknown: unknownConfig };
+    }
+    const knownStateKeys = new Set(["recentFolders"]);
+    const unknownState = omitKeys(st, knownStateKeys);
+    if (Object.keys(unknownState).length > 0) {
+        outState.legacy = { unknown: unknownState };
+    }
+    return { config: outConfig, state: outState };
+}
+/**
+ * Migrate older config/state layouts into owner-bucket YAML docs.
+ *
+ * Legacy inputs supported:
+ * - config.yaml with { preferences, opencodeBinaries, theme }
+ * - state.yaml with { recentFolders }
+ * - legacy config.json with full ConfigFile schema
+ */
+export function migrateSettingsLayout(location, logger) {
+    const configYamlPath = location.configYamlPath;
+    const stateYamlPath = location.stateYamlPath;
+    const legacyJsonPath = location.legacyJsonPath;
+    const configExists = fs.existsSync(configYamlPath);
+    const stateExists = fs.existsSync(stateYamlPath);
+    const configDoc = configExists ? safeReadYaml(configYamlPath, logger) : null;
+    const stateDoc = stateExists ? safeReadYaml(stateYamlPath, logger) : null;
+    const configIsNew = configExists && looksLikeNewOwnerDoc(configDoc) && !looksLikeLegacyConfig(configDoc);
+    const stateIsNew = stateExists && looksLikeNewOwnerDoc(stateDoc) && !looksLikeLegacyState(stateDoc);
+    if (configIsNew && stateIsNew) {
+        return;
+    }
+    const legacyJsonExists = fs.existsSync(legacyJsonPath);
+    const hasLegacyYaml = (configExists && looksLikeLegacyConfig(configDoc)) || (stateExists && looksLikeLegacyState(stateDoc));
+    const shouldMigrateFromJson = !configExists && legacyJsonExists;
+    if (!hasLegacyYaml && !shouldMigrateFromJson) {
+        // Either fresh install or partially written docs; let stores create on first write.
+        return;
+    }
+    const sourceConfig = shouldMigrateFromJson ? safeReadJson(legacyJsonPath, logger) : configDoc;
+    const sourceState = shouldMigrateFromJson ? sourceConfig : stateDoc;
+    const { config, state } = mapLegacyToOwnerDocs(sourceConfig, sourceState);
+    try {
+        fs.mkdirSync(location.baseDir, { recursive: true });
+    }
+    catch (error) {
+        logger.warn({ err: error, baseDir: location.baseDir }, "Failed to create base directory during migration");
+    }
+    // Backup legacy files before rewriting.
+    if (configExists) {
+        try {
+            const bak = pickBackupPath(configYamlPath);
+            fs.renameSync(configYamlPath, bak);
+            logger.info({ configYamlPath, bak }, "Backed up legacy config.yaml");
+        }
+        catch (error) {
+            logger.warn({ err: error, configYamlPath }, "Failed to backup legacy config.yaml");
+        }
+    }
+    if (stateExists) {
+        try {
+            const bak = pickBackupPath(stateYamlPath);
+            fs.renameSync(stateYamlPath, bak);
+            logger.info({ stateYamlPath, bak }, "Backed up legacy state.yaml");
+        }
+        catch (error) {
+            logger.warn({ err: error, stateYamlPath }, "Failed to backup legacy state.yaml");
+        }
+    }
+    if (shouldMigrateFromJson) {
+        try {
+            const bak = pickBackupPath(legacyJsonPath);
+            fs.renameSync(legacyJsonPath, bak);
+            logger.info({ legacyJsonPath, bak }, "Moved legacy config.json to backup");
+        }
+        catch (error) {
+            logger.warn({ err: error, legacyJsonPath }, "Failed to move legacy config.json to backup");
+        }
+    }
+    writeYaml(configYamlPath, config, logger);
+    writeYaml(stateYamlPath, state, logger);
+    logger.info({ configYamlPath, stateYamlPath }, "Migrated settings docs to owner-bucket layout");
+}

package/dist/settings/service.js

@@ -0,0 +1,39 @@
+import { YamlDocStore } from "./yaml-doc-store";
+import { migrateSettingsLayout } from "./migrate";
+export class SettingsService {
+    constructor(location, eventBus, logger) {
+        this.location = location;
+        this.eventBus = eventBus;
+        this.logger = logger;
+        migrateSettingsLayout(location, logger);
+        this.configStore = new YamlDocStore(location.configYamlPath, logger.child({ component: "settings-config" }));
+        this.stateStore = new YamlDocStore(location.stateYamlPath, logger.child({ component: "settings-state" }));
+    }
+    getDoc(kind) {
+        return kind === "config" ? this.configStore.get() : this.stateStore.get();
+    }
+    mergePatchDoc(kind, patch) {
+        const updated = kind === "config" ? this.configStore.mergePatch(patch) : this.stateStore.mergePatch(patch);
+        this.publish(kind, "*");
+        return updated;
+    }
+    getOwner(kind, owner) {
+        return kind === "config" ? this.configStore.getOwner(owner) : this.stateStore.getOwner(owner);
+    }
+    mergePatchOwner(kind, owner, patch) {
+        const updated = kind === "config" ? this.configStore.mergePatchOwner(owner, patch) : this.stateStore.mergePatchOwner(owner, patch);
+        this.publish(kind, owner, updated);
+        return updated;
+    }
+    publish(kind, owner, value) {
+        if (!this.eventBus)
+            return;
+        const type = kind === "config" ? "storage.configChanged" : "storage.stateChanged";
+        const payload = {
+            type,
+            owner,
+            value: value ?? this.getOwner(kind, owner),
+        };
+        this.eventBus.publish(payload);
+    }
+}

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

@@ -0,0 +1,96 @@
+import fs from "fs";
+import path from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { applyMergePatch, isPlainObject } from "./merge-patch";
+function ensureTrailingNewline(content) {
+    if (!content)
+        return "\n";
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function normalizeDoc(input) {
+    if (!isPlainObject(input)) {
+        return {};
+    }
+    return input;
+}
+export class YamlDocStore {
+    constructor(filePath, logger) {
+        this.filePath = filePath;
+        this.logger = logger;
+        this.cache = {};
+        this.loaded = false;
+    }
+    load() {
+        if (this.loaded) {
+            return this.cache;
+        }
+        try {
+            if (!fs.existsSync(this.filePath)) {
+                this.cache = {};
+                this.loaded = true;
+                return this.cache;
+            }
+            const content = fs.readFileSync(this.filePath, "utf-8");
+            const parsed = parseYaml(content);
+            this.cache = normalizeDoc(parsed);
+            this.loaded = true;
+            return this.cache;
+        }
+        catch (error) {
+            this.logger.warn({ err: error, filePath: this.filePath }, "Failed to read YAML doc; using empty object");
+            this.cache = {};
+            this.loaded = true;
+            return this.cache;
+        }
+    }
+    get() {
+        return this.load();
+    }
+    replace(next) {
+        const normalized = normalizeDoc(next);
+        this.cache = normalized;
+        this.loaded = true;
+        this.persist();
+        return this.cache;
+    }
+    mergePatch(patch) {
+        if (!isPlainObject(patch)) {
+            throw new Error("Patch must be a JSON object");
+        }
+        const current = this.get();
+        const next = applyMergePatch(current, patch);
+        return this.replace(next);
+    }
+    getOwner(owner) {
+        const doc = this.get();
+        const value = doc?.[owner];
+        return normalizeDoc(value);
+    }
+    replaceOwner(owner, value) {
+        const doc = this.get();
+        const nextDoc = { ...doc, [owner]: normalizeDoc(value) };
+        this.replace(nextDoc);
+        return nextDoc[owner];
+    }
+    mergePatchOwner(owner, patch) {
+        if (!isPlainObject(patch)) {
+            throw new Error("Patch must be a JSON object");
+        }
+        const doc = this.get();
+        const currentOwner = normalizeDoc(doc?.[owner]);
+        const nextOwner = normalizeDoc(applyMergePatch(currentOwner, patch));
+        const nextDoc = { ...doc, [owner]: nextOwner };
+        this.replace(nextDoc);
+        return nextOwner;
+    }
+    persist() {
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            const yaml = stringifyYaml(this.cache);
+            fs.writeFileSync(this.filePath, ensureTrailingNewline(yaml), "utf-8");
+        }
+        catch (error) {
+            this.logger.warn({ err: error, filePath: this.filePath }, "Failed to persist YAML doc");
+        }
+    }
+}

package/dist/workspaces/manager.js

@@ -49,7 +49,7 @@ export class WorkspaceManager {
     }
     async create(folder, name) {
         const id = `${Date.now().toString(36)}`;
-        const binary = this.options.binaryRegistry.resolveDefault();
+        const binary = this.options.binaryResolver.resolveDefault();
         const resolvedBinaryPath = this.resolveBinaryPath(binary.path);
         const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder);
         clearWorkspaceSearchCache(workspacePath);
@@ -72,8 +72,9 @@ export class WorkspaceManager {
         }
         this.workspaces.set(id, descriptor);
         this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
-        const preferences = this.options.configStore.get().preferences ?? {};
-        const userEnvironment = preferences.environmentVariables ?? {};
+        const serverConfig = this.options.settings.getOwner("config", "server");
+        const envVars = serverConfig?.environmentVariables;
+        const userEnvironment = envVars && typeof envVars === "object" && !Array.isArray(envVars) ? envVars : {};
         const opencodeUsername = DEFAULT_OPENCODE_USERNAME;
         const opencodePassword = generateOpencodeServerPassword();
         const authorization = buildOpencodeBasicAuthHeader({ username: opencodeUsername, password: opencodePassword });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad-dev",
-  "version": "0.10.3-dev-20260215-4f6c8523",
+  "version": "0.11.1-dev-20260216-e16c5752",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {