@vividcodeai/embeddedcowork 0.0.8 → 0.0.10

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

@@ -1,189 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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");
-    });
-});