@vividcodeai/embeddedcowork 0.0.8 → 0.0.10

package/dist/server/routes/plugin.js

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

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

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

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

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

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

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