@vividcodeai/embeddedcowork 0.0.22 → 0.0.24

package/dist/server/routes/plugin.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { buildPingEvent, handlePluginEvent } from "../../plugins/handlers";
+const PluginEventSchema = z.object({
+    type: z.string().min(1),
+    properties: z.record(z.unknown()).optional(),
+});
+const VoiceModeStateSchema = z.object({
+    enabled: z.boolean(),
+    clientId: z.string().trim().min(1),
+    connectionId: z.string().trim().min(1),
+});
+export function registerPluginRoutes(app, deps) {
+    app.get("/workspaces/:id/plugin/events", (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace not found" });
+            return;
+        }
+        reply.raw.setHeader("Content-Type", "text/event-stream");
+        reply.raw.setHeader("Cache-Control", "no-cache");
+        reply.raw.setHeader("Connection", "keep-alive");
+        reply.raw.flushHeaders?.();
+        reply.hijack();
+        const registration = deps.channel.register(request.params.id, reply);
+        deps.voiceModeManager.syncInstance(request.params.id);
+        const heartbeat = setInterval(() => {
+            deps.channel.send(request.params.id, buildPingEvent());
+        }, 15000);
+        const close = () => {
+            clearInterval(heartbeat);
+            registration.close();
+            reply.raw.end?.();
+        };
+        request.raw.on("close", close);
+        request.raw.on("error", close);
+    });
+    app.post("/workspaces/:id/plugin/voice-mode", (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace not found" });
+            return;
+        }
+        const payload = VoiceModeStateSchema.parse(request.body ?? {});
+        const applied = deps.voiceModeManager.setEnabled(request.params.id, { clientId: payload.clientId, connectionId: payload.connectionId }, payload.enabled);
+        if (payload.enabled && !applied) {
+            reply.code(409).send({ error: "Client connection not active for voice mode enable" });
+            return;
+        }
+        return { enabled: payload.enabled };
+    });
+    const handleWildcard = async (request, reply) => {
+        const workspaceId = request.params.id;
+        const workspace = deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace not found" });
+            return;
+        }
+        const suffix = request.params["*"] ?? "";
+        const normalized = suffix.replace(/^\/+/, "");
+        if (normalized === "event" && request.method === "POST") {
+            const parsed = PluginEventSchema.parse(request.body ?? {});
+            handlePluginEvent(workspaceId, parsed, { workspaceManager: deps.workspaceManager, eventBus: deps.eventBus, logger: deps.logger });
+            reply.code(204).send();
+            return;
+        }
+        reply.code(404).send({ error: "Unknown plugin endpoint" });
+    };
+    app.all("/workspaces/:id/plugin/*", handleWildcard);
+    app.all("/workspaces/:id/plugin", handleWildcard);
+}

package/dist/server/routes/remote-proxy.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { isLoopbackAddress } from "../../auth/http-auth";
+const CreateSessionSchema = z.object({
+    baseUrl: z.string().min(1),
+    skipTlsVerify: z.boolean().optional(),
+});
+const SessionParamsSchema = z.object({
+    id: z.string().uuid(),
+});
+export function registerRemoteProxyRoutes(app, deps) {
+    app.post("/api/remote-proxy/sessions", async (request, reply) => {
+        try {
+            const body = CreateSessionSchema.parse(request.body ?? {});
+            return await deps.sessionManager.createSession(body.baseUrl, Boolean(body.skipTlsVerify));
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to create remote proxy session");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to create remote proxy session" };
+        }
+    });
+    app.delete("/api/remote-proxy/sessions/:id", async (request, reply) => {
+        if (!isLoopbackAddress(request.socket.remoteAddress)) {
+            reply.code(404);
+            return { error: "Not found" };
+        }
+        try {
+            const params = SessionParamsSchema.parse(request.params ?? {});
+            const deleted = await deps.sessionManager.deleteSession(params.id);
+            if (!deleted) {
+                reply.code(404);
+                return { error: "Remote proxy session not found" };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to delete remote proxy session");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to delete remote proxy session" };
+        }
+    });
+}

package/dist/server/routes/remote-servers.js

@@ -0,0 +1,142 @@
+import { Agent, fetch } from "undici";
+import { z } from "zod";
+const ProbeSchema = z.object({
+    baseUrl: z.string().min(1),
+    skipTlsVerify: z.boolean().optional(),
+});
+const PROBE_TIMEOUT_MS = 8000;
+export function registerRemoteServerRoutes(app, deps) {
+    app.post("/api/remote-servers/probe", async (request, reply) => {
+        try {
+            const body = ProbeSchema.parse(request.body ?? {});
+            return await probeRemoteServer(body.baseUrl, Boolean(body.skipTlsVerify));
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to probe remote server");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Invalid request" };
+        }
+    });
+}
+async function probeRemoteServer(baseUrl, skipTlsVerify) {
+    const normalizedUrl = normalizeBaseUrl(baseUrl);
+    const probeUrl = new URL("./api/auth/status", `${normalizedUrl}/`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    const dispatcher = skipTlsVerify ? new Agent({ connect: { rejectUnauthorized: false } }) : undefined;
+    try {
+        const response = await fetch(probeUrl, {
+            method: "GET",
+            dispatcher,
+            signal: controller.signal,
+            headers: {
+                Accept: "application/json",
+            },
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                reachable: true,
+                normalizedUrl,
+                skipTlsVerify,
+                requiresAuth: false,
+                authenticated: false,
+                error: `Remote server returned HTTP ${response.status}`,
+                errorCode: "http_error",
+            };
+        }
+        const payload = (await response.json());
+        if (typeof payload?.authenticated !== "boolean") {
+            return {
+                ok: false,
+                reachable: true,
+                normalizedUrl,
+                skipTlsVerify,
+                requiresAuth: false,
+                authenticated: false,
+                error: "Remote server did not return a valid EmbeddedCowork auth response",
+                errorCode: "invalid_server",
+            };
+        }
+        return {
+            ok: true,
+            reachable: true,
+            normalizedUrl,
+            skipTlsVerify,
+            requiresAuth: !payload.authenticated,
+            authenticated: payload.authenticated,
+        };
+    }
+    catch (error) {
+        const message = describeProbeError(error);
+        return {
+            ok: false,
+            reachable: false,
+            normalizedUrl,
+            skipTlsVerify,
+            requiresAuth: false,
+            authenticated: false,
+            error: message.message,
+            errorCode: message.code,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+        await dispatcher?.close().catch(() => { });
+    }
+}
+function normalizeBaseUrl(input) {
+    const parsed = new URL(input.trim());
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Server URL must use http:// or https://");
+    }
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname === "/" ? "/" : parsed.pathname.replace(/\/+$/, "") || "/";
+    const value = parsed.toString();
+    return parsed.pathname === "/" ? value.replace(/\/$/, "") : value.replace(/\/$/, "");
+}
+function describeProbeError(error) {
+    const chain = unwrapErrorChain(error);
+    const detailed = chain.find((entry) => {
+        const code = (entry?.code ?? "").toString();
+        return Boolean(code) && code !== "UND_ERR_RESPONSE_STATUS_CODE";
+    }) ?? chain[0];
+    const code = (detailed?.code ?? "").toString();
+    const exactMessage = detailed?.message?.trim() || chain.find((entry) => entry.message?.trim())?.message?.trim();
+    if (code === "DEPTH_ZERO_SELF_SIGNED_CERT" || code === "SELF_SIGNED_CERT_IN_CHAIN" || code === "CERT_HAS_EXPIRED") {
+        return {
+            code: "tls_error",
+            message: "Certificate check failed while connecting to the remote server.",
+        };
+    }
+    return {
+        code: code === "ERR_INVALID_URL"
+            ? "invalid_url"
+            : code === "ECONNREFUSED"
+                ? "connection_refused"
+                : code === "ENOTFOUND"
+                    ? "dns_error"
+                    : code === "UND_ERR_CONNECT_TIMEOUT" || code === "ABORT_ERR"
+                        ? "timeout"
+                        : code
+                            ? code.toLowerCase()
+                            : "probe_failed",
+        message: exactMessage || "Failed to connect to the remote server.",
+    };
+}
+function unwrapErrorChain(error) {
+    const results = [];
+    let current = error;
+    const seen = new Set();
+    while (current && typeof current === "object" && !seen.has(current)) {
+        seen.add(current);
+        const entry = current;
+        results.push({ code: entry.code, message: entry.message });
+        current = entry.cause;
+    }
+    if (results.length === 0 && error instanceof Error) {
+        results.push({ message: error.message });
+    }
+    return results;
+}

package/dist/server/routes/settings.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { probeBinaryVersion } from "../../workspaces/spawn";
+import { sanitizeConfigDoc, sanitizeConfigOwner } from "../../settings/public-config";
+const ValidateBinarySchema = z.object({
+    path: z.string(),
+});
+function validateBinaryPath(binaryPath) {
+    const result = probeBinaryVersion(binaryPath);
+    return { valid: result.valid, version: result.version, error: result.error };
+}
+export function registerSettingsRoutes(app, deps) {
+    // Full-document access
+    app.get("/api/storage/config", async () => sanitizeConfigDoc(deps.settings.getDoc("config")));
+    app.patch("/api/storage/config", async (request, reply) => {
+        try {
+            return sanitizeConfigDoc(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 sanitizeConfigOwner(request.params.owner, deps.settings.getOwner("config", request.params.owner));
+    });
+    app.patch("/api/storage/config/:owner", async (request, reply) => {
+        try {
+            return sanitizeConfigOwner(request.params.owner, 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/server/routes/sidecars.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const SideCarCreateSchema = z.object({
+    kind: z.literal("port").default("port"),
+    name: z.string().trim().min(1),
+    port: z.number().int().min(1).max(65535),
+    insecure: z.boolean().default(false),
+    prefixMode: z.enum(["strip", "preserve"]).default("strip"),
+});
+const SideCarUpdateSchema = SideCarCreateSchema.omit({ kind: true }).partial().refine((value) => Object.keys(value).length > 0, {
+    message: "At least one field is required",
+});
+export function registerSideCarRoutes(app, deps) {
+    app.get("/api/sidecars", async () => {
+        return { sidecars: await deps.sidecarManager.list() };
+    });
+    app.post("/api/sidecars", async (request, reply) => {
+        try {
+            const body = SideCarCreateSchema.parse(request.body ?? {});
+            const sidecar = await deps.sidecarManager.create(body);
+            reply.code(201);
+            return sidecar;
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to create SideCar" };
+        }
+    });
+    app.put("/api/sidecars/:id", async (request, reply) => {
+        try {
+            const body = SideCarUpdateSchema.parse(request.body ?? {});
+            return await deps.sidecarManager.update(request.params.id, body);
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to update SideCar" };
+        }
+    });
+    app.delete("/api/sidecars/:id", async (request, reply) => {
+        const removed = await deps.sidecarManager.delete(request.params.id);
+        if (!removed) {
+            reply.code(404);
+            return { error: "SideCar not found" };
+        }
+        reply.code(204);
+    });
+}

package/dist/server/routes/speech.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const TranscribeBodySchema = z.object({
+    audioBase64: z.string().min(1, "Audio payload is required"),
+    mimeType: z.string().min(1, "Audio MIME type is required"),
+    filename: z.string().optional(),
+    language: z.string().optional(),
+    prompt: z.string().optional(),
+});
+const SynthesizeBodySchema = z.object({
+    text: z.string().trim().min(1, "Text is required"),
+    format: z.enum(["mp3", "wav", "opus", "aac"]).optional(),
+});
+function getSpeechErrorStatus(error) {
+    if (error instanceof z.ZodError) {
+        return 400;
+    }
+    if (error instanceof Error && /not configured/i.test(error.message)) {
+        return 503;
+    }
+    return 502;
+}
+function getSpeechErrorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+export function registerSpeechRoutes(app, deps) {
+    app.get("/api/speech/capabilities", async () => deps.speechService.getCapabilities());
+    app.post("/api/speech/transcribe", async (request, reply) => {
+        try {
+            const body = TranscribeBodySchema.parse(request.body ?? {});
+            return await deps.speechService.transcribe(body);
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to transcribe audio");
+            reply.code(getSpeechErrorStatus(error));
+            return { error: getSpeechErrorMessage(error, "Failed to transcribe audio") };
+        }
+    });
+    app.post("/api/speech/synthesize", async (request, reply) => {
+        try {
+            const body = SynthesizeBodySchema.parse(request.body ?? {});
+            return await deps.speechService.synthesize(body);
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to synthesize audio");
+            reply.code(getSpeechErrorStatus(error));
+            return { error: getSpeechErrorMessage(error, "Failed to synthesize audio") };
+        }
+    });
+    app.post("/api/speech/synthesize/stream", async (request, reply) => {
+        try {
+            const body = SynthesizeBodySchema.parse(request.body ?? {});
+            const result = await deps.speechService.synthesizeStream(body);
+            reply.header("Content-Type", result.mimeType);
+            reply.header("Cache-Control", "no-store");
+            return reply.send(result.stream);
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to stream synthesized audio");
+            reply.code(getSpeechErrorStatus(error));
+            return { error: getSpeechErrorMessage(error, "Failed to stream synthesized audio") };
+        }
+    });
+}

package/dist/server/routes/storage.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { ModelPreferenceSchema } from "../../config/schema";
+const InstanceDataSchema = z.object({
+    messageHistory: z.array(z.string()).default([]),
+    agentModelSelections: z.record(z.string(), ModelPreferenceSchema).default({}),
+});
+const EMPTY_INSTANCE_DATA = {
+    messageHistory: [],
+    agentModelSelections: {},
+};
+export function registerStorageRoutes(app, deps) {
+    const resolveStorageKey = (instanceId) => {
+        const workspace = deps.workspaceManager.get(instanceId);
+        return workspace?.path ?? instanceId;
+    };
+    app.get("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const storageId = resolveStorageKey(request.params.id);
+            const data = await deps.instanceStore.read(storageId);
+            return data;
+        }
+        catch (error) {
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "Failed to read instance data" };
+        }
+    });
+    app.put("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const body = InstanceDataSchema.parse(request.body ?? {});
+            const storageId = resolveStorageKey(request.params.id);
+            await deps.instanceStore.write(storageId, body);
+            deps.eventBus.publish({ type: "instance.dataChanged", instanceId: request.params.id, data: body });
+            reply.code(204);
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to save instance data" };
+        }
+    });
+    app.delete("/api/storage/instances/:id", async (request, reply) => {
+        try {
+            const storageId = resolveStorageKey(request.params.id);
+            await deps.instanceStore.delete(storageId);
+            deps.eventBus.publish({ type: "instance.dataChanged", instanceId: request.params.id, data: EMPTY_INSTANCE_DATA });
+            reply.code(204);
+        }
+        catch (error) {
+            reply.code(500);
+            return { error: error instanceof Error ? error.message : "Failed to delete instance data" };
+        }
+    });
+}