@vividcodeai/embeddedcowork 0.0.5 → 0.0.8

package/dist/config/schema.js

@@ -24,6 +24,7 @@ const PreferencesSchema = z
     autoCleanupBlankSessions: z.boolean().default(true),
     listeningMode: z.enum(["local", "all"]).default("local"),
     logLevel: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).default("DEBUG"),
+    sessionStorageMode: z.enum(["project", "global"]).default("project"),
     // OS notifications
     osNotificationsEnabled: z.boolean().default(false),
     osNotificationsAllowWhenVisible: z.boolean().default(false),

package/dist/events/bus.js

@@ -16,6 +16,7 @@ export class EventBus extends EventEmitter {
     onEvent(listener) {
         const handler = (event) => listener(event);
         this.on("workspace.created", handler);
+        this.on("workspace.update", handler);
         this.on("workspace.started", handler);
         this.on("workspace.error", handler);
         this.on("workspace.stopped", handler);
@@ -29,6 +30,7 @@ export class EventBus extends EventEmitter {
         this.on("instance.eventStatus", handler);
         return () => {
             this.off("workspace.created", handler);
+            this.off("workspace.update", handler);
             this.off("workspace.started", handler);
             this.off("workspace.error", handler);
             this.off("workspace.stopped", handler);

package/dist/index.js

@@ -29,6 +29,7 @@ import { ClientConnectionManager } from "./clients/connection-manager";
 import { PluginChannelManager } from "./plugins/channel";
 import { VoiceModeManager } from "./plugins/voice-mode";
 import { readServerPackageVersion, resolveServerPublicDir } from "./runtime-paths";
+import { isBinaryAvailable, triggerBinaryDownload } from "./opencode-paths";
 const require = createRequire(import.meta.url);
 const packageJson = { version: readServerPackageVersion(import.meta.url) };
 const __filename = fileURLToPath(import.meta.url);
@@ -390,6 +391,15 @@ async function main() {
     else {
         serverMeta.addresses = [];
     }
+    if (!isBinaryAvailable()) {
+        logger.info("OpenCode binary not found, triggering auto-download in background");
+        triggerBinaryDownload(logger)
+            .then(() => logger.info("OpenCode auto-download completed"))
+            .catch((err) => logger.error({ err }, "OpenCode auto-download failed"));
+    }
+    else {
+        logger.info("OpenCode binary found, skipping auto-download");
+    }
     console.log(`Local Connection URL : ${serverMeta.localUrl}`);
     if (serverMeta.remoteUrl) {
         console.log(`Remote Connection URL : ${serverMeta.remoteUrl}`);
@@ -461,6 +471,26 @@ async function main() {
 }
 main().catch((error) => {
     const logger = createLogger({ component: "app" });
+    const message = error?.message ?? "";
+    if (message.includes("No server password configured")) {
+        const friendlyMsg = `\
+[ERROR] [auth] EmbeddedCowork cannot start: no server password configured.
+
+  To fix this, choose one of the following options:
+
+  1. Set a password via the command line:
+     npx @vividcodeai/embeddedcowork --password <your-password>
+
+  2. Set the EMBEDDEDCOWORK_SERVER_PASSWORD environment variable
+
+  3. Create an auth.json configuration file (see path in the error above)
+
+  4. Use --dangerously-skip-auth to disable authentication (not recommended for production)
+`;
+        console.error(friendlyMsg);
+        process.exit(1);
+        return;
+    }
     logger.error({ err: error }, "CLI server crashed");
     process.exit(1);
 });

package/dist/opencode-downloader.js

@@ -0,0 +1,295 @@
+import { createWriteStream, existsSync, mkdirSync, chmodSync, readFileSync, createReadStream, renameSync } from "fs";
+import { stat, mkdir } from "fs/promises";
+import path from "path";
+import os from "os";
+import { spawnSync } from "child_process";
+import yauzl from "yauzl";
+import tar from "tar";
+import { BIN_DIR, BINARY_NAME } from "./opencode-paths";
+const GITHUB_API = "https://api.github.com/repos/anomalyco/opencode/releases/latest";
+const GITHUB_DL = "https://github.com/anomalyco/opencode/releases/latest/download";
+export class OpencodeDownloader {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    getDownloadTarget() {
+        const platform = process.platform;
+        const arch = process.arch;
+        let osName;
+        switch (platform) {
+            case "win32":
+                osName = "windows";
+                break;
+            case "darwin":
+                osName = "darwin";
+                break;
+            case "linux":
+                osName = "linux";
+                break;
+            default:
+                throw new Error(`Unsupported platform: ${platform}`);
+        }
+        let archName;
+        switch (arch) {
+            case "x64":
+                archName = "x64";
+                break;
+            case "arm64":
+                archName = "arm64";
+                break;
+            default:
+                throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        let target = `${osName}-${archName}`;
+        if (arch === "x64" && !this.hasAvx2()) {
+            target += "-baseline";
+        }
+        if (platform === "linux" && this.isMusl()) {
+            target += "-musl";
+        }
+        const archiveExt = platform === "linux" ? ".tar.gz" : ".zip";
+        return { filename: `opencode-${target}${archiveExt}`, archiveExt };
+    }
+    hasAvx2() {
+        if (process.platform === "win32") {
+            try {
+                const ps = `(Add-Type -MemberDefinition "[DllImport(\"kernel32.dll\")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)`;
+                const result = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps], { encoding: "utf8", timeout: 5000 });
+                const out = result.stdout?.trim()?.toLowerCase();
+                return out === "true" || out === "1";
+            }
+            catch {
+                return true;
+            }
+        }
+        if (process.platform === "darwin") {
+            try {
+                const result = spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], { encoding: "utf8" });
+                return result.status === 0 && result.stdout.trim() === "1";
+            }
+            catch {
+                return true;
+            }
+        }
+        if (process.platform === "linux") {
+            try {
+                const cpuinfo = readFileSync("/proc/cpuinfo", "utf8");
+                return /avx2/i.test(cpuinfo);
+            }
+            catch {
+                return true;
+            }
+        }
+        return true;
+    }
+    isMusl() {
+        try {
+            const result = spawnSync("ldd", ["--version"], { encoding: "utf8" });
+            return result.stderr?.toLowerCase().includes("musl") ?? false;
+        }
+        catch {
+            return existsSync("/etc/alpine-release");
+        }
+    }
+    async getLatestVersion() {
+        const now = Date.now();
+        if (OpencodeDownloader.versionCache && now < OpencodeDownloader.versionCache.expiry) {
+            return OpencodeDownloader.versionCache.version;
+        }
+        const res = await fetch(GITHUB_API, {
+            headers: { Accept: "application/json", "User-Agent": "embeddedcowork" },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch latest version: HTTP ${res.status}`);
+        const data = (await res.json());
+        const version = data.tag_name.replace(/^v/, "");
+        OpencodeDownloader.versionCache = { version, expiry: now + 30000 };
+        return version;
+    }
+    async downloadWithRetry(url, dest, progressCb, retries = 5) {
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            let writer = null;
+            try {
+                const res = await fetch(url);
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+                const total = Number(res.headers.get("content-length") ?? 0);
+                let current = 0;
+                const reader = res.body?.getReader();
+                if (!reader)
+                    throw new Error("Response body is not readable");
+                writer = createWriteStream(dest);
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    current += value.length;
+                    progressCb?.(current, total);
+                    writer.write(value);
+                }
+                await new Promise((resolve, reject) => {
+                    writer.end((err) => (err ? reject(err) : resolve()));
+                });
+                return;
+            }
+            catch (err) {
+                if (writer) {
+                    writer.destroy();
+                    writer = null;
+                }
+                try {
+                    import("fs/promises").then((fs) => fs.unlink(dest)).catch(() => { });
+                }
+                catch { }
+                if (attempt === retries)
+                    throw err;
+                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
+                this.logger?.warn({ attempt, retries, err }, `Download attempt ${attempt} failed, retrying in ${delay}ms`);
+                await new Promise((r) => setTimeout(r, delay));
+            }
+        }
+    }
+    async extractZip(zipPath, outDir) {
+        return new Promise((resolve, reject) => {
+            yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+                if (err || !zipfile)
+                    return reject(err ?? new Error("Failed to open zip"));
+                zipfile.readEntry();
+                zipfile.on("entry", (entry) => {
+                    if (entry.fileName === BINARY_NAME || entry.fileName.endsWith(`/${BINARY_NAME}`)) {
+                        zipfile.openReadStream(entry, (err2, readStream) => {
+                            if (err2 || !readStream)
+                                return reject(err2 ?? new Error("Failed to open read stream"));
+                            const tmpPath = path.join(outDir, BINARY_NAME + ".tmp");
+                            const destPath = path.join(outDir, BINARY_NAME);
+                            const writer = createWriteStream(tmpPath);
+                            readStream.pipe(writer);
+                            writer.on("finish", () => {
+                                chmodSync(tmpPath, 0o755);
+                                renameSync(tmpPath, destPath);
+                                resolve();
+                            });
+                            writer.on("error", (e) => {
+                                try {
+                                    import("fs/promises").then((fs) => fs.unlink(tmpPath)).catch(() => { });
+                                }
+                                catch { }
+                                reject(e);
+                            });
+                        });
+                    }
+                    else {
+                        zipfile.readEntry();
+                    }
+                });
+                zipfile.on("error", reject);
+                zipfile.on("end", () => reject(new Error("Binary not found in archive")));
+            });
+        });
+    }
+    async extractTarGz(tarPath, outDir) {
+        const extractPath = path.join(outDir, "extracted");
+        await mkdir(extractPath, { recursive: true });
+        await tar.extract({
+            file: tarPath,
+            cwd: extractPath,
+            filter: (filePath) => filePath === BINARY_NAME || filePath.endsWith(`/${BINARY_NAME}`),
+        });
+        const binarySrc = path.join(extractPath, BINARY_NAME);
+        const tmpPath = path.join(outDir, BINARY_NAME + ".tmp");
+        const binaryDest = path.join(outDir, BINARY_NAME);
+        await new Promise((resolve, reject) => {
+            const src = createReadStream(binarySrc);
+            const dst = createWriteStream(tmpPath);
+            src.pipe(dst);
+            dst.on("finish", () => {
+                chmodSync(tmpPath, 0o755);
+                renameSync(tmpPath, binaryDest);
+                resolve();
+            });
+            dst.on("error", (e) => {
+                try {
+                    import("fs/promises").then((fs) => fs.unlink(tmpPath)).catch(() => { });
+                }
+                catch { }
+                reject(e);
+            });
+            src.on("error", (e) => {
+                try {
+                    import("fs/promises").then((fs) => fs.unlink(tmpPath)).catch(() => { });
+                }
+                catch { }
+                reject(e);
+            });
+        });
+    }
+    getInstalledPath() {
+        return path.join(BIN_DIR, BINARY_NAME);
+    }
+    async verifyBinary(binaryPath) {
+        if (!existsSync(binaryPath))
+            return null;
+        try {
+            const result = spawnSync(binaryPath, ["--version"], { encoding: "utf8", timeout: 5000 });
+            if (result.status === 0) {
+                return (result.stdout ?? result.stderr ?? "").trim();
+            }
+        }
+        catch { }
+        this.logger?.warn({ path: binaryPath }, "Binary exists but --version failed, proceeding anyway");
+        return binaryPath;
+    }
+    async ensureDownloaded(statusCb) {
+        const target = this.getDownloadTarget();
+        const binaryPath = this.getInstalledPath();
+        const existingVersion = await this.verifyBinary(binaryPath);
+        try {
+            const latestVersion = await this.getLatestVersion();
+            if (existingVersion && existingVersion.includes(latestVersion)) {
+                this.logger?.info({ version: latestVersion, path: binaryPath }, "OpenCode binary is up to date");
+                return binaryPath;
+            }
+        }
+        catch (err) {
+            if (existingVersion) {
+                this.logger?.warn({ err }, "Failed to check latest version, using existing binary");
+                return binaryPath;
+            }
+        }
+        mkdirSync(BIN_DIR, { recursive: true });
+        const tmpDir = path.join(os.tmpdir(), "embeddedcowork-dl");
+        mkdirSync(tmpDir, { recursive: true });
+        const archivePath = path.join(tmpDir, target.filename);
+        const downloadUrl = `${GITHUB_DL}/${target.filename}`;
+        try {
+            statusCb?.({ type: "downloading", progress: { current: 0, total: 0 } });
+            await this.downloadWithRetry(downloadUrl, archivePath, (current, total) => {
+                statusCb?.({ type: "downloading", progress: { current, total } });
+            });
+            statusCb?.({ type: "extracting" });
+            if (target.archiveExt === ".zip") {
+                await this.extractZip(archivePath, BIN_DIR);
+            }
+            else {
+                await this.extractTarGz(archivePath, BIN_DIR);
+            }
+            statusCb?.({ type: "verifying" });
+            const version = await this.verifyBinary(binaryPath);
+            if (!version) {
+                throw new Error("Downloaded binary failed verification");
+            }
+            this.logger?.info({ version, path: binaryPath }, "OpenCode binary downloaded and verified");
+            statusCb?.({ type: "completed", binaryPath });
+            return binaryPath;
+        }
+        finally {
+            try {
+                await stat(archivePath);
+                await import("fs/promises").then((fs) => fs.unlink(archivePath));
+            }
+            catch { }
+        }
+    }
+}
+OpencodeDownloader.versionCache = null;

package/dist/opencode-paths.js

@@ -0,0 +1,167 @@
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import os from "os";
+import { OpencodeDownloader } from "./opencode-downloader";
+// ── Path constants ──────────────────────────────────────────
+export const BIN_DIR = path.join(os.homedir(), ".embeddedcowork", "bin");
+export const BINARY_NAME = process.platform === "win32" ? "opencode.exe" : "opencode";
+export const INSTALLED_BINARY_PATH = path.join(BIN_DIR, BINARY_NAME);
+// ── Shell helpers ───────────────────────────────────────────
+function defaultShellPath() {
+    const configured = process.env.SHELL?.trim();
+    if (configured)
+        return configured;
+    return process.platform === "darwin" ? "/bin/zsh" : "/bin/bash";
+}
+function shellEscape(input) {
+    if (!input)
+        return "''";
+    return `'${input.replace(/'/g, `'\\''`)}'`;
+}
+function wrapCommandForShell(command, shellPath) {
+    const shellName = path.basename(shellPath).toLowerCase();
+    if (shellName.includes("bash")) {
+        return `if [ -f ~/.bashrc ]; then source ~/.bashrc >/dev/null 2>&1; fi; ${command}`;
+    }
+    if (shellName.includes("zsh")) {
+        return `if [ -f ~/.zshrc ]; then source ~/.zshrc >/dev/null 2>&1; fi; ${command}`;
+    }
+    return command;
+}
+function buildShellArgs(shellPath, command) {
+    const shellName = path.basename(shellPath).toLowerCase();
+    if (shellName.includes("zsh"))
+        return ["-l", "-i", "-c", command];
+    return ["-l", "-c", command];
+}
+// ── Binary lookup ───────────────────────────────────────────
+export function resolveBinaryPathFromUserShell(identifier) {
+    if (process.platform === "win32")
+        return null;
+    const shellPath = defaultShellPath();
+    const lookupCommand = wrapCommandForShell(`command -v ${shellEscape(identifier)}`, shellPath);
+    const result = spawnSync(shellPath, buildShellArgs(shellPath, lookupCommand), {
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            npm_config_prefix: undefined,
+            NPM_CONFIG_PREFIX: undefined,
+        },
+    });
+    if (result.status !== 0)
+        return null;
+    const resolved = String(result.stdout ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return resolved ?? null;
+}
+/**
+ * Resolve an opencode binary identifier to an absolute path.
+ * Order: absolute/relative → which/where → shell command -v → installed path → raw identifier
+ */
+export function resolveBinary(identifier) {
+    if (!identifier)
+        return identifier;
+    if (path.isAbsolute(identifier) || identifier.includes("/") || identifier.includes("\\") || identifier.startsWith(".")) {
+        return identifier;
+    }
+    const locator = process.platform === "win32" ? "where" : "which";
+    try {
+        const result = spawnSync(locator, [identifier], { encoding: "utf8" });
+        if (result.status === 0 && result.stdout) {
+            const candidates = result.stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0)
+                .filter((line) => !/^INFO:/i.test(line));
+            if (candidates.length > 0) {
+                return candidates[0];
+            }
+        }
+    }
+    catch { }
+    const shellResolved = resolveBinaryPathFromUserShell(identifier);
+    if (shellResolved)
+        return shellResolved;
+    if (existsSync(INSTALLED_BINARY_PATH))
+        return INSTALLED_BINARY_PATH;
+    return identifier;
+}
+let downloadPhase = "idle";
+let downloadProgress = { current: 0, total: 0 };
+let downloadError;
+function setDownloadPhase(phase) {
+    downloadPhase = phase;
+    if (phase === "idle" || phase === "completed" || phase === "error") {
+        downloadProgress = { current: 0, total: 0 };
+    }
+}
+export function getDownloadProgress() {
+    return { ...downloadProgress };
+}
+export function getDownloadPhase() {
+    return downloadPhase;
+}
+export function getDownloadError() {
+    return downloadError;
+}
+/**
+ * Check whether opencode is available on this system.
+ * Uses the same lookup order as resolveBinary("opencode").
+ * Returns additional download progress info when not available.
+ */
+export function getOpencodeStatus() {
+    const resolved = resolveBinary("opencode");
+    const available = resolved !== "opencode" && existsSync(resolved);
+    if (available)
+        return { available: true };
+    return {
+        available: false,
+        status: downloadPhase,
+        progress: downloadPhase === "downloading" ? { ...downloadProgress } : undefined,
+        error: downloadError,
+    };
+}
+export function isBinaryAvailable() {
+    const resolved = resolveBinary("opencode");
+    return resolved !== "opencode" && existsSync(resolved);
+}
+// ── Download trigger (global singleton) ─────────────────────
+let downloadPromise = null;
+export function triggerBinaryDownload(logger) {
+    if (downloadPromise)
+        return downloadPromise;
+    setDownloadPhase("downloading");
+    downloadError = undefined;
+    const downloader = new OpencodeDownloader(logger);
+    downloadPromise = downloader
+        .ensureDownloaded((status) => {
+        if (status.type === "downloading") {
+            downloadPhase = "downloading";
+            downloadProgress = status.progress;
+        }
+        else if (status.type === "extracting") {
+            setDownloadPhase("extracting");
+        }
+        else if (status.type === "verifying") {
+            setDownloadPhase("verifying");
+        }
+        else if (status.type === "completed") {
+            setDownloadPhase("completed");
+        }
+    })
+        .then(() => {
+        logger.info("OpenCode auto-download completed");
+        setDownloadPhase("completed");
+        downloadPromise = null;
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error({ err }, "OpenCode auto-download failed");
+        downloadPhase = "error";
+        downloadError = message;
+    });
+    return downloadPromise;
+}

package/dist/server/http-server.js

@@ -19,6 +19,7 @@ import { registerEventRoutes } from "./routes/events";
 import { registerStorageRoutes } from "./routes/storage";
 import { registerPluginRoutes } from "./routes/plugin";
 import { registerBackgroundProcessRoutes } from "./routes/background-processes";
+import { registerOpencodeStatusRoutes } from "./routes/opencode-status";
 import { registerWorktreeRoutes } from "./routes/worktrees";
 import { registerSpeechRoutes } from "./routes/speech";
 import { registerRemoteServerRoutes } from "./routes/remote-servers";
@@ -194,6 +195,7 @@ export function createHttpServer(deps) {
     });
     registerWorkspaceRoutes(app, { workspaceManager: deps.workspaceManager });
     registerSettingsRoutes(app, { settings: deps.settings, logger: apiLogger });
+    registerOpencodeStatusRoutes(app, { settings: deps.settings, logger: apiLogger });
     registerFilesystemRoutes(app, { fileSystemBrowser: deps.fileSystemBrowser });
     registerMetaRoutes(app, { serverMeta: deps.serverMeta });
     registerEventRoutes(app, {

package/dist/server/routes/opencode-status.js

@@ -0,0 +1,10 @@
+import { getOpencodeStatus, triggerBinaryDownload } from "../../opencode-paths";
+export function registerOpencodeStatusRoutes(app, deps) {
+    app.get("/api/opencode/status", async (_request, reply) => {
+        const status = getOpencodeStatus();
+        if (!status.available) {
+            void triggerBinaryDownload(deps.logger);
+        }
+        return reply.send(status);
+    });
+}