@vividcodeai/embeddedcowork 0.0.22 → 0.0.24

package/dist/plugins/channel.js

@@ -0,0 +1,40 @@
+export class PluginChannelManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.clients = new Set();
+    }
+    register(workspaceId, reply) {
+        const connection = { workspaceId, reply };
+        this.clients.add(connection);
+        this.logger.debug({ workspaceId }, "Plugin SSE client connected");
+        let closed = false;
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            this.clients.delete(connection);
+            this.logger.debug({ workspaceId }, "Plugin SSE client disconnected");
+        };
+        return { close };
+    }
+    send(workspaceId, event) {
+        for (const client of this.clients) {
+            if (client.workspaceId !== workspaceId)
+                continue;
+            this.write(client.reply, event);
+        }
+    }
+    broadcast(event) {
+        for (const client of this.clients) {
+            this.write(client.reply, event);
+        }
+    }
+    write(reply, event) {
+        try {
+            reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to write plugin SSE event");
+        }
+    }
+}

package/dist/plugins/handlers.js

@@ -0,0 +1,17 @@
+export function handlePluginEvent(workspaceId, event, deps) {
+    switch (event.type) {
+        case "embeddedcowork.pong":
+            deps.logger.debug({ workspaceId, properties: event.properties }, "Plugin pong received");
+            return;
+        default:
+            deps.logger.debug({ workspaceId, eventType: event.type }, "Unhandled plugin event");
+    }
+}
+export function buildPingEvent() {
+    return {
+        type: "embeddedcowork.ping",
+        properties: {
+            ts: Date.now(),
+        },
+    };
+}

package/dist/plugins/voice-mode.js

@@ -0,0 +1,78 @@
+export class VoiceModeManager {
+    constructor(options) {
+        this.options = options;
+        this.enabledConnectionsByInstance = new Map();
+        this.aggregateByInstance = new Map();
+        this.options.connections.subscribe((event) => {
+            if (event.type !== "disconnected")
+                return;
+            this.clearConnection(event.connection);
+        });
+    }
+    setEnabled(instanceId, connection, enabled) {
+        if (enabled && !this.options.connections.isConnected(connection)) {
+            this.options.logger.debug({ instanceId, clientId: connection.clientId, connectionId: connection.connectionId }, "Ignoring voice mode enable for disconnected client connection");
+            return false;
+        }
+        const key = getConnectionKey(connection);
+        const current = this.enabledConnectionsByInstance.get(instanceId) ?? new Set();
+        if (enabled) {
+            current.add(key);
+            this.enabledConnectionsByInstance.set(instanceId, current);
+        }
+        else if (current.delete(key)) {
+            if (current.size === 0) {
+                this.enabledConnectionsByInstance.delete(instanceId);
+            }
+            else {
+                this.enabledConnectionsByInstance.set(instanceId, current);
+            }
+        }
+        this.options.logger.debug({ instanceId, clientId: connection.clientId, connectionId: connection.connectionId, enabled }, "Voice mode updated for client connection");
+        this.publishIfChanged(instanceId);
+        return true;
+    }
+    syncInstance(instanceId) {
+        this.options.channel.send(instanceId, buildVoiceModeEvent(this.isEnabled(instanceId)));
+    }
+    isEnabled(instanceId) {
+        return this.aggregateByInstance.get(instanceId) === true;
+    }
+    clearConnection(connection) {
+        const key = getConnectionKey(connection);
+        for (const [instanceId, enabledConnections] of Array.from(this.enabledConnectionsByInstance.entries())) {
+            if (!enabledConnections.delete(key))
+                continue;
+            if (enabledConnections.size === 0) {
+                this.enabledConnectionsByInstance.delete(instanceId);
+            }
+            this.publishIfChanged(instanceId);
+        }
+    }
+    publishIfChanged(instanceId) {
+        const enabled = (this.enabledConnectionsByInstance.get(instanceId)?.size ?? 0) > 0;
+        const previous = this.aggregateByInstance.get(instanceId) === true;
+        if (enabled === previous)
+            return;
+        if (enabled) {
+            this.aggregateByInstance.set(instanceId, true);
+        }
+        else {
+            this.aggregateByInstance.delete(instanceId);
+        }
+        this.options.logger.debug({ instanceId, enabled }, "Broadcasting aggregate voice mode");
+        this.options.channel.send(instanceId, buildVoiceModeEvent(enabled));
+    }
+}
+function buildVoiceModeEvent(enabled) {
+    return {
+        type: "embeddedcowork.voiceMode",
+        properties: {
+            enabled,
+            formatVersion: "v1",
+        },
+    };
+}
+function getConnectionKey(connection) {
+    return `${connection.clientId}:${connection.connectionId}`;
+}

package/dist/releases/dev-release-monitor.js

@@ -0,0 +1,75 @@
+import { fetch } from "undici";
+import { compareVersionStrings, stripTagPrefix } from "./release-monitor";
+const DEFAULT_POLL_INTERVAL_MS = 15 * 60 * 1000;
+export function startDevReleaseMonitor(options) {
+    let stopped = false;
+    let timer = null;
+    const pollIntervalMs = Number.isFinite(options.pollIntervalMs) && (options.pollIntervalMs ?? 0) > 0
+        ? options.pollIntervalMs
+        : DEFAULT_POLL_INTERVAL_MS;
+    const refresh = async () => {
+        if (stopped)
+            return;
+        try {
+            const release = await fetchLatestPrerelease({
+                repo: options.repo,
+                currentVersion: options.currentVersion,
+            });
+            options.onUpdate(release);
+        }
+        catch (error) {
+            options.logger.debug({ err: error }, "Failed to refresh dev prerelease information");
+        }
+    };
+    void refresh();
+    timer = setInterval(() => void refresh(), pollIntervalMs);
+    return {
+        stop() {
+            stopped = true;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+    };
+}
+async function fetchLatestPrerelease(args) {
+    const normalizedRepo = args.repo.trim();
+    if (!/^[^/\s]+\/[^/\s]+$/.test(normalizedRepo)) {
+        throw new Error(`Invalid GitHub repo: ${args.repo}`);
+    }
+    const apiUrl = `https://api.github.com/repos/${normalizedRepo}/releases?per_page=20`;
+    const response = await fetch(apiUrl, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "EmbeddedCowork-CLI",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub releases API responded with ${response.status}`);
+    }
+    const list = (await response.json());
+    const latest = list.find((r) => r && r.prerelease === true && r.draft !== true);
+    if (!latest) {
+        return null;
+    }
+    const tag = latest.tag_name || latest.name;
+    if (!tag) {
+        return null;
+    }
+    const normalizedVersion = stripTagPrefix(tag);
+    if (!normalizedVersion) {
+        return null;
+    }
+    if (compareVersionStrings(normalizedVersion, args.currentVersion) <= 0) {
+        return null;
+    }
+    return {
+        version: normalizedVersion,
+        tag,
+        url: latest.html_url ?? `https://github.com/${normalizedRepo}/releases/tag/${encodeURIComponent(tag)}`,
+        channel: "dev",
+        publishedAt: latest.published_at ?? latest.created_at,
+        notes: latest.body,
+    };
+}

package/dist/releases/release-monitor.js

@@ -0,0 +1,107 @@
+import { fetch } from "undici";
+const RELEASES_API_URL = "https://api.github.com/repos/vividcode-ai/EmbeddedCowork/releases/latest";
+export function startReleaseMonitor(options) {
+    let stopped = false;
+    const refreshRelease = async () => {
+        if (stopped)
+            return;
+        try {
+            const release = await fetchLatestRelease(options);
+            options.onUpdate(release);
+        }
+        catch (error) {
+            options.logger.warn({ err: error }, "Failed to refresh release information");
+        }
+    };
+    void refreshRelease();
+    return {
+        stop() {
+            stopped = true;
+        },
+    };
+}
+export function compareVersionStrings(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    return compareVersions(left, right);
+}
+async function fetchLatestRelease(options) {
+    const response = await fetch(RELEASES_API_URL, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "EmbeddedCowork-CLI",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Release API responded with ${response.status}`);
+    }
+    const json = (await response.json());
+    const tagFromServer = json.tag_name || json.name;
+    if (!tagFromServer) {
+        return null;
+    }
+    const normalizedVersion = stripTagPrefix(tagFromServer);
+    if (!normalizedVersion) {
+        return null;
+    }
+    const current = parseVersion(options.currentVersion);
+    const remote = parseVersion(normalizedVersion);
+    if (compareVersions(remote, current) <= 0) {
+        return null;
+    }
+    return {
+        version: normalizedVersion,
+        tag: tagFromServer,
+        url: json.html_url ?? `https://github.com/vividcode-ai/EmbeddedCowork/releases/tag/${encodeURIComponent(tagFromServer)}`,
+        channel: json.prerelease || normalizedVersion.includes("-") ? "dev" : "stable",
+        publishedAt: json.published_at ?? json.created_at,
+        notes: json.body,
+    };
+}
+export function stripTagPrefix(tag) {
+    if (!tag)
+        return null;
+    const trimmed = tag.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.replace(/^v/i, "");
+}
+function parseVersion(value) {
+    const normalized = stripTagPrefix(value) ?? "0.0.0";
+    const dashIndex = normalized.indexOf("-");
+    const core = dashIndex >= 0 ? normalized.slice(0, dashIndex) : normalized;
+    const prerelease = dashIndex >= 0 ? normalized.slice(dashIndex + 1) : null;
+    const [major = 0, minor = 0, patch = 0] = core.split(".").map((segment) => {
+        const parsed = Number.parseInt(segment, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    return {
+        major,
+        minor,
+        patch,
+        prerelease,
+    };
+}
+function compareVersions(a, b) {
+    if (a.major !== b.major) {
+        return a.major > b.major ? 1 : -1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor > b.minor ? 1 : -1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch > b.patch ? 1 : -1;
+    }
+    const aPre = a.prerelease && a.prerelease.length > 0 ? a.prerelease : null;
+    const bPre = b.prerelease && b.prerelease.length > 0 ? b.prerelease : null;
+    if (aPre === bPre) {
+        return 0;
+    }
+    if (!aPre) {
+        return 1;
+    }
+    if (!bPre) {
+        return -1;
+    }
+    return aPre.localeCompare(bPre);
+}

package/dist/releases/rollback.js

@@ -0,0 +1,54 @@
+/**
+ * rollback.ts - Shared rollback state machine types and helpers.
+ *
+ * This module defines the update-meta.json schema and helper functions.
+ * Used by both Electron and Tauri rollback implementations.
+ */
+/** Create a fresh UpdateMeta for a backup operation */
+export function createBackupMeta(oldVersion, backupPath) {
+    return {
+        state: "backed_up",
+        oldVersion,
+        newVersion: "",
+        backupPath,
+        createdAt: new Date().toISOString(),
+    };
+}
+/** Transition: update download is complete and about to be installed */
+export function markInstalling(meta, newVersion) {
+    return { ...meta, state: "installing", newVersion };
+}
+/** Transition: app started successfully after update */
+export function markStarted(meta) {
+    return { ...meta, state: "started" };
+}
+/** Transition: update confirmed (health window passed or clean exit) */
+export function markConfirmed(meta) {
+    return { ...meta, state: "confirmed" };
+}
+/** Transition: rollback performed */
+export function markRolledBack(meta) {
+    return { ...meta, state: "rolled_back" };
+}
+/** Check if the state indicates a rollback is needed */
+export function needsRollback(meta) {
+    return meta.state === "started" || meta.state === "failed";
+}
+/** Check if update is in progress (should not be interrupted) */
+export function isUpdateInProgress(meta) {
+    return ["backed_up", "installing", "started"].includes(meta.state);
+}
+/** Check if this is a fresh install that needs the health window */
+export function isNewInstall(meta) {
+    return meta.state === "installing";
+}
+/** Default path components for the update meta directory */
+export function getUpdaterDirName() {
+    return "embeddedcowork-updater";
+}
+export function getMetaFileName() {
+    return "update-meta.json";
+}
+export function getBackupDirName() {
+    return "backup";
+}

package/dist/runtime-paths.js

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function safeModuleDir(importMetaUrl) {
+    try {
+        return path.dirname(fileURLToPath(importMetaUrl));
+    }
+    catch {
+        return null;
+    }
+}
+function firstExistingPath(candidates, predicate) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (predicate(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function getPackagedDistDir() {
+    return path.dirname(process.execPath);
+}
+export function resolveServerPackageRoot(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const configuredRoot = process.env.EMBEDDEDCOWORK_SERVER_ROOT?.trim();
+    const candidates = [
+        configuredRoot ? path.resolve(configuredRoot) : null,
+        moduleDir ? path.resolve(moduleDir, "..") : null,
+        path.resolve(getPackagedDistDir(), ".."),
+    ];
+    return (firstExistingPath(candidates, (value) => fs.existsSync(path.join(value, "package.json"))) ??
+        candidates.find((value) => Boolean(value)) ??
+        process.cwd());
+}
+export function resolveServerPublicDir(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const candidates = [moduleDir ? path.resolve(moduleDir, "../public") : null, path.join(resolveServerPackageRoot(importMetaUrl), "public")];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[candidates.length - 1];
+}
+export function resolveAuthTemplatePath(importMetaUrl, fileName) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const distDir = getPackagedDistDir();
+    const candidates = [
+        moduleDir ? path.join(moduleDir, "auth-pages", fileName) : null,
+        path.join(distDir, "auth-pages", fileName),
+        path.join(distDir, "server", "routes", "auth-pages", fileName),
+    ];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[0];
+}
+export function resolveOpencodeTemplateDir(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const resourcesPath = process.resourcesPath;
+    const candidates = [
+        moduleDir ? path.resolve(moduleDir, "../../opencode-config") : null,
+        resourcesPath ? path.resolve(resourcesPath, "opencode-config") : null,
+        moduleDir ? path.resolve(moduleDir, "opencode-config") : null,
+        path.join(getPackagedDistDir(), "opencode-config"),
+    ];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[candidates.length - 1];
+}
+export function readServerPackageVersion(importMetaUrl) {
+    const packageJsonPath = path.join(resolveServerPackageRoot(importMetaUrl), "package.json");
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version : "0.0.0";
+}

package/dist/server/__tests__/network-addresses.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import os from "node:os";
+import { describe, it } from "node:test";
+import { resolveNetworkAddresses, resolveRemoteAddresses } from "../network-addresses";
+describe("resolveNetworkAddresses", () => {
+    it("preserves interface order among external addresses", () => {
+        const addresses = [
+            { address: "172.24.0.1", family: "IPv4", internal: false },
+            { address: "192.168.1.128", family: "IPv4", internal: false },
+            { address: "10.0.0.8", family: 4, internal: false },
+            { address: "127.0.0.1", family: "IPv4", internal: true },
+            { address: "169.254.10.20", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveNetworkAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.map((entry) => entry.ip), ["172.24.0.1", "192.168.1.128", "10.0.0.8", "169.254.10.20", "127.0.0.1"]);
+        });
+    });
+});
+describe("resolveRemoteAddresses", () => {
+    it("keeps all external addresses user-visible while preferring non-link-local addresses for the primary URL", () => {
+        const addresses = [
+            { address: "169.254.10.20", family: "IPv4", internal: false },
+            { address: "192.168.1.128", family: "IPv4", internal: false },
+            { address: "172.24.0.1", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveRemoteAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.userVisible.map((entry) => entry.ip), ["192.168.1.128", "172.24.0.1", "169.254.10.20"]);
+            assert.equal(result.primaryRemoteUrl, "https://192.168.1.128:9898");
+        });
+    });
+    it("prefers private LAN addresses over public addresses", () => {
+        const addresses = [
+            { address: "203.0.113.40", family: "IPv4", internal: false },
+            { address: "192.168.1.128", family: "IPv4", internal: false },
+            { address: "8.8.8.8", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveRemoteAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.userVisible.map((entry) => entry.ip), ["192.168.1.128", "203.0.113.40", "8.8.8.8"]);
+            assert.equal(result.primaryRemoteUrl, "https://192.168.1.128:9898");
+        });
+    });
+    it("uses a public address when no private LAN address is available", () => {
+        const addresses = [
+            { address: "169.254.10.20", family: "IPv4", internal: false },
+            { address: "203.0.113.40", family: "IPv4", internal: false },
+        ];
+        usingMockedNetworkInterfaces(addresses, () => {
+            const result = resolveRemoteAddresses({ host: "0.0.0.0", protocol: "https", port: 9898 });
+            assert.deepEqual(result.userVisible.map((entry) => entry.ip), ["203.0.113.40", "169.254.10.20"]);
+            assert.equal(result.primaryRemoteUrl, "https://203.0.113.40:9898");
+        });
+    });
+});
+function usingMockedNetworkInterfaces(addresses, callback) {
+    const original = os.networkInterfaces;
+    os.networkInterfaces = (() => ({
+        ethernet0: addresses,
+    }));
+    try {
+        callback();
+    }
+    finally {
+        os.networkInterfaces = original;
+    }
+}