@vividcodeai/embeddedcowork 0.0.21 → 0.0.23

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

package/dist/storage/instance-store.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import { promises as fsp } from "fs";
+import os from "os";
+import path from "path";
+const DEFAULT_INSTANCE_DATA = {
+    messageHistory: [],
+    agentModelSelections: {},
+};
+export class InstanceStore {
+    constructor(baseDir = path.join(os.homedir(), ".config", "embeddedcowork", "instances")) {
+        this.instancesDir = baseDir;
+        fs.mkdirSync(this.instancesDir, { recursive: true });
+    }
+    async read(id) {
+        try {
+            const filePath = this.resolvePath(id);
+            const content = await fsp.readFile(filePath, "utf-8");
+            const parsed = JSON.parse(content);
+            return { ...DEFAULT_INSTANCE_DATA, ...parsed };
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return DEFAULT_INSTANCE_DATA;
+            }
+            throw error;
+        }
+    }
+    async write(id, data) {
+        const filePath = this.resolvePath(id);
+        await fsp.mkdir(path.dirname(filePath), { recursive: true });
+        await fsp.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    async delete(id) {
+        try {
+            const filePath = this.resolvePath(id);
+            await fsp.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    resolvePath(id) {
+        const filename = this.sanitizeId(id);
+        return path.join(this.instancesDir, `${filename}.json`);
+    }
+    sanitizeId(id) {
+        return id
+            .replace(/[\\/]/g, "_")
+            .replace(/[^a-zA-Z0-9_.-]/g, "_")
+            .replace(/_{2,}/g, "_")
+            .replace(/^_|_$/g, "")
+            .toLowerCase();
+    }
+}

package/dist/ui/__tests__/remote-ui.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { resolveUi } from "../remote-ui";
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    trace: () => { },
+    child: () => noopLogger,
+    isLevelEnabled: () => false,
+};
+let tempRoot;
+beforeEach(() => {
+    tempRoot = mkdtempSync(path.join(os.tmpdir(), "embeddedcowork-ui-test-"));
+});
+afterEach(() => {
+    rmSync(tempRoot, { recursive: true, force: true });
+});
+describe("resolveUi local version preference", () => {
+    it("prefers bundled when bundled version is higher", async () => {
+        const bundledDir = path.join(tempRoot, "bundled");
+        const configDir = path.join(tempRoot, "config");
+        const currentDir = path.join(configDir, "ui", "current");
+        await mkdir(bundledDir, { recursive: true });
+        await mkdir(currentDir, { recursive: true });
+        writeFileSync(path.join(bundledDir, "index.html"), "<html>bundled</html>");
+        writeFileSync(path.join(bundledDir, "ui-version.json"), JSON.stringify({ uiVersion: "0.8.1" }));
+        writeFileSync(path.join(currentDir, "index.html"), "<html>current</html>");
+        writeFileSync(path.join(currentDir, "ui-version.json"), JSON.stringify({ uiVersion: "0.8.0" }));
+        const result = await resolveUi({
+            serverVersion: "0.8.1",
+            bundledUiDir: bundledDir,
+            autoUpdate: false,
+            configDir,
+            logger: noopLogger,
+        });
+        assert.equal(result.source, "bundled");
+        assert.equal(result.uiStaticDir, bundledDir);
+        assert.equal(result.uiVersion, "0.8.1");
+    });
+    it("prefers bundled when bundled and downloaded versions are equal", async () => {
+        const bundledDir = path.join(tempRoot, "bundled");
+        const configDir = path.join(tempRoot, "config");
+        const currentDir = path.join(configDir, "ui", "current");
+        await mkdir(bundledDir, { recursive: true });
+        await mkdir(currentDir, { recursive: true });
+        writeFileSync(path.join(bundledDir, "index.html"), "<html>bundled</html>");
+        writeFileSync(path.join(bundledDir, "ui-version.json"), JSON.stringify({ uiVersion: "0.8.1" }));
+        writeFileSync(path.join(currentDir, "index.html"), "<html>current</html>");
+        writeFileSync(path.join(currentDir, "ui-version.json"), JSON.stringify({ uiVersion: "0.8.1" }));
+        const result = await resolveUi({
+            serverVersion: "0.8.1",
+            bundledUiDir: bundledDir,
+            autoUpdate: false,
+            configDir,
+            logger: noopLogger,
+        });
+        assert.equal(result.source, "bundled");
+        assert.equal(result.uiStaticDir, bundledDir);
+        assert.equal(result.uiVersion, "0.8.1");
+    });
+});