@dyyz1993/codenomad 0.15.0

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

package/dist/speech/providers/openai-compatible.js

@@ -0,0 +1,189 @@
+import { Readable } from "node:stream";
+import OpenAI from "openai";
+import { toFile } from "openai/uploads";
+export class OpenAICompatibleSpeechProvider {
+    constructor(options) {
+        this.options = options;
+    }
+    getCapabilities() {
+        const { settings } = this.options;
+        return {
+            available: true,
+            configured: Boolean(settings.apiKey),
+            provider: settings.provider,
+            supportsStt: true,
+            supportsTts: true,
+            supportsStreamingTts: true,
+            baseUrl: settings.baseUrl,
+            sttModel: settings.sttModel,
+            ttsModel: settings.ttsModel,
+            ttsVoice: settings.ttsVoice,
+            ttsFormats: ["mp3", "wav", "opus", "aac"],
+            streamingTtsFormats: ["mp3", "wav", "opus", "aac"],
+        };
+    }
+    async transcribe(input) {
+        const client = this.createClient();
+        const startedAt = Date.now();
+        const extension = extensionForMime(input.mimeType);
+        const buffer = Buffer.from(input.audioBase64, "base64");
+        const filename = input.filename?.trim() || `prompt-input.${extension}`;
+        this.options.logger.info({
+            mimeType: input.mimeType,
+            bytes: buffer.byteLength,
+            language: input.language,
+            model: this.options.settings.sttModel,
+        }, "speech.transcribe");
+        const response = await this.requestTranscription(client, buffer, filename, input);
+        return {
+            text: typeof response?.text === "string" ? response.text : "",
+            language: typeof response?.language === "string" ? response.language : input.language,
+            durationMs: Number.isFinite(response?.duration) ? Math.round(Number(response.duration) * 1000) : Date.now() - startedAt,
+            segments: Array.isArray(response?.segments)
+                ? response.segments
+                    .filter((segment) => typeof segment?.text === "string")
+                    .map((segment) => ({
+                    startMs: Math.max(0, Math.round(Number(segment.start ?? 0) * 1000)),
+                    endMs: Math.max(0, Math.round(Number(segment.end ?? 0) * 1000)),
+                    text: String(segment.text),
+                }))
+                : undefined,
+        };
+    }
+    async requestTranscription(client, buffer, filename, input) {
+        const baseRequest = {
+            model: this.options.settings.sttModel,
+            ...(input.language ? { language: input.language } : {}),
+            ...(input.prompt ? { prompt: input.prompt } : {}),
+        };
+        try {
+            const file = await toFile(buffer, filename, { type: input.mimeType });
+            return (await client.audio.transcriptions.create({
+                ...baseRequest,
+                file,
+                response_format: "verbose_json",
+            }));
+        }
+        catch (error) {
+            this.options.logger.warn({ err: error }, "speech.transcribe verbose_json failed; retrying default format");
+            const retryFile = await toFile(buffer, filename, { type: input.mimeType });
+            return (await client.audio.transcriptions.create({
+                ...baseRequest,
+                file: retryFile,
+            }));
+        }
+    }
+    async synthesize(input) {
+        const format = input.format ?? this.options.settings.ttsFormat;
+        this.options.logger.info({
+            model: this.options.settings.ttsModel,
+            voice: this.options.settings.ttsVoice,
+            format,
+        }, "speech.synthesize");
+        const response = await this.requestSpeechAudio(input.text, format);
+        const mimeType = response.headers.get("content-type") || mimeTypeForFormat(format);
+        const audioBuffer = Buffer.from(await response.arrayBuffer());
+        return {
+            audioBase64: audioBuffer.toString("base64"),
+            mimeType,
+        };
+    }
+    async synthesizeStream(input) {
+        const format = input.format ?? this.options.settings.ttsFormat;
+        this.options.logger.info({
+            model: this.options.settings.ttsModel,
+            voice: this.options.settings.ttsVoice,
+            format,
+        }, "speech.synthesize.stream");
+        const response = await this.requestSpeechAudio(input.text, format);
+        if (!response.body) {
+            throw new Error("Speech provider did not return a stream.");
+        }
+        return {
+            stream: Readable.fromWeb(response.body),
+            mimeType: response.headers.get("content-type") || mimeTypeForFormat(format),
+        };
+    }
+    async requestSpeechAudio(text, format) {
+        const { settings } = this.options;
+        if (!settings.apiKey) {
+            throw new Error("Speech provider is not configured. Add an API key in Speech settings.");
+        }
+        const endpoint = new URL("audio/speech", ensureTrailingSlash(settings.baseUrl ?? "https://api.openai.com/v1"));
+        let response;
+        try {
+            response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${settings.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: settings.ttsModel,
+                    voice: settings.ttsVoice,
+                    input: text,
+                    response_format: format,
+                }),
+            });
+        }
+        catch (error) {
+            const detailedError = error;
+            this.options.logger.error({
+                err: error,
+                endpoint: endpoint.toString(),
+                baseUrl: settings.baseUrl,
+                model: settings.ttsModel,
+                voice: settings.ttsVoice,
+                format,
+                cause: detailedError.cause,
+                code: detailedError.code,
+                errno: detailedError.errno,
+                syscall: detailedError.syscall,
+                address: detailedError.address,
+                port: detailedError.port,
+            }, "speech.synthesize fetch failed");
+            throw error;
+        }
+        if (!response.ok) {
+            const detail = await response.text();
+            throw new Error(detail || `Speech synthesis failed with ${response.status}`);
+        }
+        return response;
+    }
+    createClient() {
+        const { settings } = this.options;
+        if (!settings.apiKey) {
+            throw new Error("Speech provider is not configured. Add an API key in Speech settings.");
+        }
+        return new OpenAI({
+            apiKey: settings.apiKey,
+            baseURL: settings.baseUrl,
+        });
+    }
+}
+function extensionForMime(mimeType) {
+    const normalized = mimeType.toLowerCase();
+    if (normalized.includes("webm"))
+        return "webm";
+    if (normalized.includes("ogg"))
+        return "ogg";
+    if (normalized.includes("wav"))
+        return "wav";
+    if (normalized.includes("mpeg") || normalized.includes("mp3"))
+        return "mp3";
+    if (normalized.includes("mp4") || normalized.includes("aac"))
+        return "m4a";
+    return "webm";
+}
+function mimeTypeForFormat(format) {
+    if (format === "wav")
+        return "audio/wav";
+    if (format === "opus")
+        return 'audio/ogg; codecs="opus"';
+    if (format === "aac")
+        return "audio/aac";
+    return "audio/mpeg";
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith("/") ? value : `${value}/`;
+}

package/dist/speech/service.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { OpenAICompatibleSpeechProvider } from "./providers/openai-compatible";
+const ServerSpeechSettingsSchema = z.object({
+    speech: z
+        .object({
+        provider: z.string().optional(),
+        apiKey: z.string().optional(),
+        baseUrl: z.string().optional(),
+        sttModel: z.string().optional(),
+        ttsModel: z.string().optional(),
+        ttsVoice: z.string().optional(),
+        ttsFormat: z.enum(["mp3", "wav", "opus", "aac"]).optional(),
+    })
+        .optional(),
+});
+const DEFAULT_PROVIDER = "openai-compatible";
+const DEFAULT_STT_MODEL = "gpt-4o-mini-transcribe";
+const DEFAULT_TTS_MODEL = "gpt-4o-mini-tts";
+const DEFAULT_TTS_VOICE = "alloy";
+const DEFAULT_TTS_FORMAT = "mp3";
+export class SpeechService {
+    constructor(settings, logger) {
+        this.settings = settings;
+        this.logger = logger;
+    }
+    getCapabilities() {
+        return this.createProvider().getCapabilities();
+    }
+    async transcribe(input) {
+        return this.createProvider().transcribe(input);
+    }
+    async synthesize(input) {
+        return this.createProvider().synthesize(input);
+    }
+    async synthesizeStream(input) {
+        return this.createProvider().synthesizeStream(input);
+    }
+    createProvider() {
+        const settings = this.resolveSettings();
+        return new OpenAICompatibleSpeechProvider({
+            settings,
+            logger: this.logger.child({ provider: settings.provider }),
+        });
+    }
+    resolveSettings() {
+        const parsed = ServerSpeechSettingsSchema.parse(this.settings.getOwner("config", "server") ?? {});
+        const speech = parsed.speech ?? {};
+        return {
+            provider: speech.provider?.trim() || DEFAULT_PROVIDER,
+            apiKey: speech.apiKey?.trim() || process.env.OPENAI_API_KEY,
+            baseUrl: speech.baseUrl?.trim() || process.env.OPENAI_BASE_URL || undefined,
+            sttModel: speech.sttModel?.trim() || DEFAULT_STT_MODEL,
+            ttsModel: speech.ttsModel?.trim() || DEFAULT_TTS_MODEL,
+            ttsVoice: speech.ttsVoice?.trim() || DEFAULT_TTS_VOICE,
+            ttsFormat: speech.ttsFormat ?? DEFAULT_TTS_FORMAT,
+        };
+    }
+}