@vividcodeai/embeddedcowork 0.0.21 → 0.0.23

package/dist/opencode-config/plugin/lib/request.ts

@@ -0,0 +1,214 @@
+import http from "http"
+import https from "https"
+import { Readable } from "stream"
+
+export type PluginEvent = {
+  type: string
+  properties?: Record<string, unknown>
+}
+
+export type EmbeddedCoworkConfig = {
+  instanceId: string
+  baseUrl: string
+}
+
+export function getEmbeddedCoworkConfig(): EmbeddedCoworkConfig {
+  return {
+    instanceId: requireEnv("EMBEDDEDCOWORK_INSTANCE_ID"),
+    baseUrl: requireEnv("EMBEDDEDCOWORK_BASE_URL"),
+  }
+}
+
+export function createEmbeddedCoworkRequester(config: EmbeddedCoworkConfig) {
+  const rawBaseUrl = (config.baseUrl ?? "").trim()
+  const baseUrl = rawBaseUrl.replace(/\/+$/, "")
+  const pluginBase = `${baseUrl}/workspaces/${encodeURIComponent(config.instanceId)}/plugin`
+  const authorization = buildInstanceAuthorizationHeader()
+
+  const buildUrl = (path: string) => {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path
+    }
+    const normalized = path.startsWith("/") ? path : `/${path}`
+    return `${pluginBase}${normalized}`
+  }
+
+  const buildHeaders = (headers: HeadersInit | undefined, hasBody: boolean): Record<string, string> => {
+    const output: Record<string, string> = normalizeHeaders(headers)
+    output.Authorization = authorization
+    if (hasBody) {
+      output["Content-Type"] = output["Content-Type"] ?? "application/json"
+    }
+    return output
+  }
+
+  const fetchWithAuth = async (path: string, init?: RequestInit): Promise<Response> => {
+    const url = buildUrl(path)
+    const hasBody = init?.body !== undefined
+    const headers = buildHeaders(init?.headers, hasBody)
+
+    // The EmbeddedCowork plugin only talks to the local EmbeddedCowork server.
+    // Use a single request implementation that tolerates custom/self-signed certs
+    // without disabling TLS verification for the whole Node process.
+    return nodeFetch(url, { ...init, headers }, { rejectUnauthorized: false })
+  }
+
+  const requestJson = async <T>(path: string, init?: RequestInit): Promise<T> => {
+    const response = await fetchWithAuth(path, init)
+    if (!response.ok) {
+      const message = await response.text().catch(() => "")
+      throw new Error(message || `Request failed with ${response.status}`)
+    }
+
+    if (response.status === 204) {
+      return undefined as T
+    }
+
+    return (await response.json()) as T
+  }
+
+  const requestVoid = async (path: string, init?: RequestInit): Promise<void> => {
+    const response = await fetchWithAuth(path, init)
+    if (!response.ok) {
+      const message = await response.text().catch(() => "")
+      throw new Error(message || `Request failed with ${response.status}`)
+    }
+  }
+
+  const requestSseBody = async (path: string): Promise<ReadableStream<Uint8Array>> => {
+    const response = await fetchWithAuth(path, { headers: { Accept: "text/event-stream" } })
+    if (!response.ok || !response.body) {
+      throw new Error(`SSE unavailable (${response.status})`)
+    }
+    return response.body as ReadableStream<Uint8Array>
+  }
+
+  return {
+    buildUrl,
+    fetch: fetchWithAuth,
+    requestJson,
+    requestVoid,
+    requestSseBody,
+  }
+}
+
+async function nodeFetch(
+  url: string,
+  init: RequestInit & { headers?: Record<string, string> },
+  tls: { rejectUnauthorized: boolean },
+): Promise<Response> {
+  const parsed = new URL(url)
+  const isHttps = parsed.protocol === "https:"
+  const requestFn = isHttps ? https.request : http.request
+
+  const method = (init.method ?? "GET").toUpperCase()
+  const headers = init.headers ?? {}
+  const body = init.body
+
+  return await new Promise<Response>((resolve, reject) => {
+    const req = requestFn(
+      {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port ? Number(parsed.port) : undefined,
+        path: `${parsed.pathname}${parsed.search}`,
+        method,
+        headers,
+        ...(isHttps ? { rejectUnauthorized: tls.rejectUnauthorized } : {}),
+      },
+      (res) => {
+        const responseHeaders = new Headers()
+        for (const [key, value] of Object.entries(res.headers)) {
+          if (value === undefined) continue
+          if (Array.isArray(value)) {
+            responseHeaders.set(key, value.join(", "))
+          } else {
+            responseHeaders.set(key, String(value))
+          }
+        }
+
+        // Convert Node stream -> Web ReadableStream for Response.
+        const webBody = Readable.toWeb(res) as unknown as ReadableStream<Uint8Array>
+        resolve(new Response(webBody, { status: res.statusCode ?? 0, headers: responseHeaders }))
+      },
+    )
+
+    const signal = init.signal
+    const abort = () => {
+      const err = new Error("Request aborted")
+      ;(err as any).name = "AbortError"
+      req.destroy(err)
+      reject(err)
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        abort()
+        return
+      }
+      signal.addEventListener("abort", abort, { once: true })
+      req.once("close", () => signal.removeEventListener("abort", abort))
+    }
+
+    req.once("error", reject)
+
+    if (body === undefined || body === null) {
+      req.end()
+      return
+    }
+
+    if (typeof body === "string") {
+      req.end(body)
+      return
+    }
+
+    if (body instanceof Uint8Array) {
+      req.end(Buffer.from(body))
+      return
+    }
+
+    if (body instanceof ArrayBuffer) {
+      req.end(Buffer.from(new Uint8Array(body)))
+      return
+    }
+
+    // Fallback for less common BodyInit types.
+    req.end(String(body))
+  })
+}
+
+function requireEnv(key: string): string {
+  const value = process.env[key]
+  if (!value || !value.trim()) {
+    throw new Error(`[EmbeddedCoworkPlugin] Missing required env var ${key}`)
+  }
+  return value
+}
+
+function buildInstanceAuthorizationHeader(): string {
+  const username = requireEnv("OPENCODE_SERVER_USERNAME")
+  const password = requireEnv("OPENCODE_SERVER_PASSWORD")
+  const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64")
+  return `Basic ${token}`
+}
+
+function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> {
+  const output: Record<string, string> = {}
+  if (!headers) return output
+
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      output[key] = value
+    })
+    return output
+  }
+
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      output[key] = value
+    }
+    return output
+  }
+
+  return { ...headers }
+}

package/dist/opencode-config.js

@@ -0,0 +1,15 @@
+import { existsSync } from "fs";
+import { createLogger } from "./logger";
+import { resolveOpencodeTemplateDir } from "./runtime-paths";
+const log = createLogger({ component: "opencode-config" });
+const templateDir = resolveOpencodeTemplateDir(import.meta.url);
+const isDevBuild = Boolean(process.env.EMBEDDEDCOWORK_DEV ?? process.env.CLI_UI_DEV_SERVER);
+export function getOpencodeConfigDir() {
+    if (!existsSync(templateDir)) {
+        throw new Error(`EmbeddedCowork Opencode config template missing at ${templateDir}`);
+    }
+    if (isDevBuild) {
+        log.debug({ templateDir }, "Using Opencode config template directly (dev mode)");
+    }
+    return templateDir;
+}

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;
+}