@vividcodeai/embeddedcowork 0.0.22 → 0.0.24

package/dist/settings/migrate.js

@@ -0,0 +1,238 @@
+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 logLevel = preferences.logLevel;
+        if (typeof logLevel === "string") {
+            serverConfig.logLevel = logLevel;
+        }
+        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",
+            "logLevel",
+            "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/public-config.js

@@ -0,0 +1,33 @@
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeServerOwner(value) {
+    const next = { ...value };
+    const speech = isPlainObject(next.speech) ? { ...next.speech } : null;
+    if (!speech) {
+        return next;
+    }
+    const rawApiKey = typeof speech.apiKey === "string" ? speech.apiKey.trim() : "";
+    if (rawApiKey) {
+        delete speech.apiKey;
+        speech.hasApiKey = true;
+    }
+    else if (!("hasApiKey" in speech)) {
+        speech.hasApiKey = false;
+    }
+    next.speech = speech;
+    return next;
+}
+export function sanitizeConfigOwner(owner, value) {
+    if (owner !== "server") {
+        return value;
+    }
+    return sanitizeServerOwner(value);
+}
+export function sanitizeConfigDoc(value) {
+    const next = { ...value };
+    if (isPlainObject(next.server)) {
+        next.server = sanitizeServerOwner(next.server);
+    }
+    return next;
+}

package/dist/settings/service.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { YamlDocStore } from "./yaml-doc-store";
+import { migrateSettingsLayout } from "./migrate";
+import { sanitizeConfigOwner } from "./public-config";
+const CanonicalLogLevelSchema = z.preprocess((value) => (typeof value === "string" ? value.trim().toUpperCase() : value), z.enum(["DEBUG", "INFO", "WARN", "ERROR"]));
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDeepEqual(a, b) {
+    if (a === b)
+        return true;
+    try {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeServerConfigOwner(value) {
+    if (!isPlainObject(value)) {
+        return {};
+    }
+    const next = { ...value };
+    const parsedLogLevel = CanonicalLogLevelSchema.safeParse(next.logLevel);
+    if (parsedLogLevel.success) {
+        next.logLevel = parsedLogLevel.data;
+    }
+    else if (next.logLevel !== undefined) {
+        next.logLevel = "DEBUG";
+    }
+    return next;
+}
+function normalizeConfigDoc(doc) {
+    if (!isPlainObject(doc)) {
+        return {};
+    }
+    if (!isPlainObject(doc.server)) {
+        return doc;
+    }
+    return {
+        ...doc,
+        server: normalizeServerConfigOwner(doc.server),
+    };
+}
+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) {
+        if (kind !== "config") {
+            return this.stateStore.get();
+        }
+        const current = this.configStore.get();
+        const normalized = normalizeConfigDoc(current);
+        if (!isDeepEqual(current, normalized)) {
+            this.configStore.replace(normalized);
+        }
+        return normalized;
+    }
+    mergePatchDoc(kind, patch) {
+        const updated = kind === "config"
+            ? this.configStore.replace(normalizeConfigDoc(this.configStore.mergePatch(patch)))
+            : this.stateStore.mergePatch(patch);
+        this.publish(kind, "*");
+        return updated;
+    }
+    getOwner(kind, owner) {
+        if (kind !== "config") {
+            return this.stateStore.getOwner(owner);
+        }
+        return owner === "server"
+            ? normalizeServerConfigOwner(this.getDoc("config").server)
+            : this.getDoc("config")[owner];
+    }
+    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);
+        return updated;
+    }
+    publish(kind, owner, value) {
+        if (!this.eventBus)
+            return;
+        const type = kind === "config" ? "storage.configChanged" : "storage.stateChanged";
+        const nextValue = value ?? this.getOwner(kind, owner);
+        const payload = {
+            type,
+            owner,
+            value: kind === "config" ? sanitizeConfigOwner(owner, nextValue) : nextValue,
+        };
+        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/sidecars/manager.js

@@ -0,0 +1,193 @@
+import { connect } from "net";
+export class SideCarManager {
+    constructor(options) {
+        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" });
+        }
+        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");
+                });
+            }
+        });
+    }
+    async list() {
+        await this.refreshPortStatuses();
+        return Array.from(this.configs.values()).map((record) => this.toSideCar(record));
+    }
+    async get(id) {
+        if (!this.configs.has(id))
+            return undefined;
+        await this.refreshPortSideCar(id);
+        return this.toSideCar(this.requireConfig(id));
+    }
+    async create(input) {
+        const normalizedName = input.name.trim();
+        const id = this.buildSideCarId(normalizedName);
+        if (this.configs.has(id)) {
+            throw new Error(`SideCar '${id}' already exists`);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            id,
+            kind: input.kind,
+            name: normalizedName,
+            port: input.port,
+            insecure: input.insecure,
+            prefixMode: input.prefixMode,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.configs.set(record.id, record);
+        this.runtime.set(record.id, { status: "stopped" });
+        this.persistConfigs();
+        await this.refreshPortSideCar(record.id);
+        return this.toSideCar(record);
+    }
+    async update(id, input) {
+        const record = this.requireConfig(id);
+        record.name = typeof input.name === "string" ? input.name.trim() : record.name;
+        record.port = typeof input.port === "number" ? input.port : record.port;
+        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.refreshPortSideCar(id);
+        return this.toSideCar(record);
+    }
+    async delete(id) {
+        const record = this.configs.get(id);
+        if (!record)
+            return false;
+        this.configs.delete(id);
+        this.runtime.delete(id);
+        this.persistConfigs();
+        this.options.eventBus.publish({ type: "sidecar.removed", sidecarId: id });
+        return true;
+    }
+    async shutdown() {
+        return;
+    }
+    buildTargetOrigin(sidecar) {
+        const protocol = sidecar.insecure ? "http" : "https";
+        return `${protocol}://127.0.0.1:${sidecar.port}`;
+    }
+    buildProxyBasePath(id) {
+        return `/sidecars/${encodeURIComponent(id)}`;
+    }
+    buildTargetPath(id, incomingPath, search = "") {
+        const record = this.requireConfig(id);
+        const publicBase = this.buildProxyBasePath(id);
+        const normalizedPath = incomingPath || publicBase;
+        if (record.prefixMode === "preserve") {
+            return `${normalizedPath}${search}`;
+        }
+        let stripped = normalizedPath.startsWith(publicBase) ? normalizedPath.slice(publicBase.length) : normalizedPath;
+        if (!stripped || stripped === "/") {
+            stripped = "/";
+        }
+        else if (!stripped.startsWith("/")) {
+            stripped = `/${stripped}`;
+        }
+        return `${stripped}${search}`;
+    }
+    async refreshPortStatuses() {
+        await Promise.all(Array.from(this.configs.values()).map((record) => this.refreshPortSideCar(record.id)));
+    }
+    async refreshPortSideCar(id) {
+        const record = this.configs.get(id);
+        if (!record)
+            return;
+        const isAvailable = await this.isPortAvailable(record.port);
+        const current = this.runtime.get(id);
+        const nextStatus = isAvailable ? "running" : "stopped";
+        if (current?.status === nextStatus) {
+            return;
+        }
+        this.runtime.set(id, { status: nextStatus });
+        record.updatedAt = new Date().toISOString();
+        this.publish(id);
+    }
+    publish(id) {
+        const record = this.configs.get(id);
+        if (!record)
+            return;
+        this.options.eventBus.publish({ type: "sidecar.updated", sidecar: this.toSideCar(record) });
+    }
+    toSideCar(record) {
+        const runtime = this.runtime.get(record.id);
+        return {
+            id: record.id,
+            kind: record.kind,
+            name: record.name,
+            port: record.port,
+            insecure: record.insecure,
+            prefixMode: record.prefixMode,
+            status: runtime?.status ?? "stopped",
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+    }
+    requireConfig(id) {
+        const record = this.configs.get(id);
+        if (!record) {
+            throw new Error("SideCar not found");
+        }
+        return record;
+    }
+    persistConfigs() {
+        const sidecars = Array.from(this.configs.values()).map((record) => ({ ...record }));
+        this.options.settings.mergePatchOwner("config", "server", { sidecars });
+    }
+    loadConfiguredSideCars() {
+        const serverConfig = this.options.settings.getOwner("config", "server");
+        const list = Array.isArray(serverConfig?.sidecars) ? serverConfig.sidecars : [];
+        const records = [];
+        for (const item of list) {
+            if (!item || typeof item !== "object")
+                continue;
+            const record = item;
+            const kind = record.kind === "port" ? "port" : null;
+            const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : null;
+            const name = typeof record.name === "string" && record.name.trim() ? record.name.trim() : null;
+            const port = typeof record.port === "number" && Number.isInteger(record.port) ? record.port : null;
+            if (!kind || !id || !name || !port)
+                continue;
+            const insecure = record.insecure === true;
+            const prefixMode = record.prefixMode === "preserve" ? "preserve" : "strip";
+            const createdAt = typeof record.createdAt === "string" && record.createdAt ? record.createdAt : new Date().toISOString();
+            const updatedAt = typeof record.updatedAt === "string" && record.updatedAt ? record.updatedAt : createdAt;
+            records.push({ id, kind, name, port, insecure, prefixMode, createdAt, updatedAt });
+        }
+        return records;
+    }
+    isPortAvailable(port) {
+        return new Promise((resolve) => {
+            const socket = connect({ port, host: "127.0.0.1" }, () => {
+                socket.end();
+                resolve(true);
+            });
+            socket.once("error", () => {
+                socket.destroy();
+                resolve(false);
+            });
+        });
+    }
+    buildSideCarId(name) {
+        const normalized = name
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/-{2,}/g, "-")
+            .replace(/^-|-$/g, "");
+        if (!normalized) {
+            throw new Error("SideCar name must include letters or numbers");
+        }
+        return normalized;
+    }
+}