@neuralnomads/codenomad-dev 0.10.3-dev-20260215-35ff359c → 0.10.3-dev-20260215-f3b9ee4e

package/README.md

@@ -31,6 +31,12 @@ You can run CodeNomad directly without installing it:
 npx @neuralnomads/codenomad --launch
 ```
 
+To list all CLI options:
+
+```sh
+npx @neuralnomads/codenomad --help
+```
+
 On startup, CodeNomad prints two URLs:
 
 - `Local Connection URL : ...` (used by desktop shells)
@@ -44,6 +50,16 @@ npm install -g @neuralnomads/codenomad
 codenomad --launch
 ```
 
+### Install Locally (per-project)
+If you prefer to install CodeNomad into a project and run the local binary:
+
+```sh
+npm install @neuralnomads/codenomad
+npx codenomad --launch
+```
+
+(`npx codenomad ...` will use `./node_modules/.bin/codenomad` when present.)
+
 ### Common Flags
 You can configure the server using flags or environment variables:
 
@@ -63,10 +79,30 @@ You can configure the server using flags or environment variables:
 | `--config <path>` | `CLI_CONFIG` | Config file location |
 | `--launch` | `CLI_LAUNCH` | Open the UI in a Chromium-based browser |
 | `--log-level <level>` | `CLI_LOG_LEVEL` | Logging level (trace, debug, info, warn, error) |
+| `--log-destination <path>` | `CLI_LOG_DESTINATION` | Log destination file (defaults to stdout) |
 | `--username <username>` | `CODENOMAD_SERVER_USERNAME` | Username for CodeNomad's internal auth (default `codenomad`) |
 | `--password <password>` | `CODENOMAD_SERVER_PASSWORD` | Password for CodeNomad's internal auth |
 | `--generate-token` | `CODENOMAD_GENERATE_TOKEN` | Emit a one-time local bootstrap token for desktop flows |
 | `--dangerously-skip-auth` | `CODENOMAD_SKIP_AUTH` | Disable CodeNomad's internal auth (use only behind a trusted perimeter) |
+| `--ui-dir <path>` | `CLI_UI_DIR` | Directory containing the built UI bundle |
+| `--ui-dev-server <url>` | `CLI_UI_DEV_SERVER` | Proxy UI requests to a running dev server (requires `--https=false --http=true`) |
+| `--ui-no-update` | `CLI_UI_NO_UPDATE` | Disable remote UI updates |
+| `--ui-auto-update <enabled>` | `CLI_UI_AUTO_UPDATE` | Enable remote UI updates (true|false) |
+| `--ui-manifest-url <url>` | `CLI_UI_MANIFEST_URL` | Remote UI manifest URL |
+
+### Dev Releases (Advanced)
+If you want the latest bleeding-edge builds (published as GitHub pre-releases), use the dev package:
+
+```sh
+npx @neuralnomads/codenomad-dev --launch
+```
+
+These environment variables control how CodeNomad checks for dev updates:
+
+| Env Variable | Description |
+|-------------|-------------|
+| `CODENOMAD_UPDATE_CHANNEL` | Update channel (use `dev` to enable dev build update checks) |
+| `CODENOMAD_GITHUB_REPO` | GitHub repo used for dev release checks (default `NeuralNomadsAI/CodeNomad`) |
 
 ### HTTP vs HTTPS
 

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);
+    }
+}