@aipanel/provider-opencode 1.2.0-beta.0

package/lib/provider.cjs

@@ -0,0 +1,289 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var provider_exports = {};
+__export(provider_exports, {
+  DefaultWebProvider: () => DefaultWebProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_http = __toESM(require("http"));
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+var import_constants = require("./constants.cjs");
+var import_api = require("./api.cjs");
+var import_bridge_script = require("./bridge-script.cjs");
+var import_opencode_web = require("./opencode-web.cjs");
+var import_system = require("./system.cjs");
+const log = (0, import_node.createLogger)("DefaultWebProvider");
+class DefaultWebProvider {
+  constructor(config, deps, options) {
+    __publicField(this, "config", config);
+    __publicField(this, "id", "opencode");
+    __publicField(this, "displayName", "OpenCode Web");
+    /** 支持会话 URL 深链；支持代码审查面板（右上角 </> 按钮，由 bridge 渲染） */
+    __publicField(this, "capabilities", { deepLink: true, reviewPanel: true });
+    /** REST 会话 API（Provider 内部使用） */
+    __publicField(this, "api");
+    __publicField(this, "deps");
+    __publicField(this, "process", null);
+    __publicField(this, "bridgeOptions", {});
+    __publicField(this, "opts");
+    this.deps = deps;
+    this.opts = resolveOpenCodeOptions(options);
+    this.api = new import_api.OpenCodeAPI(
+      config.hostname,
+      deps.getWebPort,
+      deps.getProxyPort,
+      config.chromeDevtoolsPort
+    );
+  }
+  /** 代理注入到 HTML 的桥接脚本（Provider 资产） */
+  get bridgeScript() {
+    return (0, import_bridge_script.generateBridgeScript)(this.bridgeOptions);
+  }
+  /** 初始化桥接配置（主题/语言/设置） */
+  applyConfig(config) {
+    this.bridgeOptions = {
+      theme: config.theme,
+      language: this.opts.language,
+      settings: this.opts.settings
+    };
+  }
+  async checkEnvironment() {
+    if (!await (0, import_system.checkOpenCodeInstalled)()) {
+      return {
+        ok: false,
+        message: `OpenCode is not installed!
+
+Please install OpenCode first:
+
+  # YOLO
+  curl -fsSL https://opencode.ai/install | bash
+
+  # Package managers
+  npm i -g opencode-ai@latest        # or bun/pnpm/yarn
+  scoop install opencode             # Windows
+  choco install opencode             # Windows
+  brew install anomalyco/tap/opencode # macOS and Linux (recommended, always up to date)
+  brew install opencode              # macOS and Linux (official brew formula, updated less)
+  sudo pacman -S opencode            # Arch Linux (Stable)
+  paru -S opencode-bin               # Arch Linux (Latest from AUR)
+  mise use -g opencode               # Any OS
+  nix run nixpkgs#opencode           # or github:anomalyco/opencode for latest dev branch
+        `
+      };
+    }
+    const version = await (0, import_system.getOpenCodeVersion)();
+    return { ok: true, version: version ?? void 0 };
+  }
+  async start(options) {
+    log.debug("Preparing OpenCode runtime", { cwd: options.cwd, vitePort: options.vitePort });
+    const configDir = (0, import_opencode_web.prepareOpenCodeRuntime)(
+      options.cwd,
+      options.vitePort,
+      this.opts.enableLsp,
+      this.opts.enablePrettier
+    );
+    log.debug("Starting OpenCode Web process", {
+      port: options.port,
+      hostname: options.hostname,
+      configDir
+    });
+    const proc = (0, import_opencode_web.startOpenCodeWeb)({
+      port: options.port,
+      hostname: options.hostname,
+      serverUrl: "",
+      cwd: options.cwd,
+      configDir,
+      corsOrigins: options.corsOrigins,
+      contextApiUrl: options.contextApiUrl,
+      logsApiUrl: options.logsApiUrl,
+      logFilesJson: this.opts.logFiles ? JSON.stringify(this.opts.logFiles) : void 0,
+      enableBlockOnError: this.opts.enableBlockOnError,
+      verbose: options.verbose,
+      enableLsp: this.opts.enableLsp,
+      enablePrettier: this.opts.enablePrettier,
+      vueDevtoolsApiUrl: options.vueDevtoolsApiUrl
+    });
+    this.process = proc;
+    return { url: `http://${options.hostname}:${options.port}`, processHandle: proc };
+  }
+  async stop() {
+    if (this.process) {
+      log.debug("Killing web process", { pid: this.process.pid });
+      this.process.kill("SIGTERM");
+      this.process = null;
+    }
+  }
+  async killOrphans() {
+    return (0, import_system.killOrphanOpenCodeProcesses)();
+  }
+  async listSessions(projectDir) {
+    const sessions = await this.api.getSessions(projectDir);
+    return sessions.filter((s) => {
+      if (s.title === "__chrome_mcp_warmup__") return false;
+      if (s.parentID) return false;
+      if (s.time?.archived) return false;
+      return true;
+    }).map((s) => toChatSession(s));
+  }
+  async createSession(projectDir, title) {
+    const session = await this.api.createSession(projectDir, void 0, title);
+    return toChatSession(session);
+  }
+  async deleteSession(sessionId) {
+    await this.api.deleteSession(sessionId);
+  }
+  buildSessionUrl(projectDir, sessionId) {
+    return this.api.buildSessionProxyUrl(projectDir, sessionId);
+  }
+  subscribeEvents(handler) {
+    const port = this.deps.getWebPort();
+    const url = `http://${this.config.hostname}:${port}/global/event`;
+    log.debug("Subscribing to provider event stream", { url });
+    let aborted = false;
+    let currentReq = null;
+    let retryTimer = null;
+    const cleanup = () => {
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      currentReq?.destroy();
+      currentReq = null;
+    };
+    const scheduleReconnect = () => {
+      if (aborted) return;
+      cleanup();
+      retryTimer = setTimeout(connect, import_core.RETRY_DELAY);
+    };
+    const connect = () => {
+      if (aborted) return;
+      const req = import_http.default.get(url, (res) => {
+        res.setEncoding("utf-8");
+        let buffer = "";
+        res.on("data", (chunk) => {
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data:")) continue;
+            const data = trimmed.slice(5).trim();
+            if (!data) continue;
+            try {
+              const message = JSON.parse(data);
+              const event = mapEvent(message.payload);
+              if (event) handler(event);
+            } catch {
+            }
+          }
+        });
+        res.on("end", scheduleReconnect);
+        res.on("error", scheduleReconnect);
+      });
+      req.on("error", scheduleReconnect);
+      currentReq = req;
+    };
+    connect();
+    return () => {
+      aborted = true;
+      cleanup();
+    };
+  }
+}
+function mapEvent(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const msg = payload;
+  const props = msg.properties;
+  if (!props) return null;
+  switch (msg.type) {
+    case "session.updated": {
+      const info = props.info;
+      if (!info?.id) return null;
+      return {
+        type: "session.updated",
+        session: {
+          id: info.id,
+          title: info.title ?? "",
+          createdAt: info.time?.created,
+          updatedAt: info.time?.updated,
+          archived: info.time?.archived !== void 0
+        }
+      };
+    }
+    case "session.status": {
+      const sessionId = props.sessionID;
+      if (!sessionId) return null;
+      const status = props.status?.type ?? "idle";
+      return { type: "session.status", sessionId, status };
+    }
+    case "message.updated": {
+      const info = props.info;
+      if (info?.role !== "assistant" || !info.sessionID) return null;
+      const thinking = typeof info.time?.completed !== "number";
+      return { type: "thinking", sessionId: info.sessionID, thinking };
+    }
+    case "message.part.delta": {
+      const sessionId = props.sessionID;
+      if (!sessionId) return null;
+      return { type: "thinking", sessionId, thinking: true };
+    }
+    default:
+      return null;
+  }
+}
+function toChatSession(s) {
+  return {
+    id: s.id,
+    title: s.title,
+    createdAt: s.time?.created,
+    updatedAt: s.time?.updated,
+    archived: s.time?.archived !== void 0,
+    parentId: s.parentID,
+    url: s.url
+  };
+}
+function resolveOpenCodeOptions(options) {
+  if (!options) return { ...import_constants.DEFAULT_OPENCODE_PROVIDER_OPTIONS };
+  const po = options.providerOptions ?? {};
+  return {
+    ...import_constants.DEFAULT_OPENCODE_PROVIDER_OPTIONS,
+    language: po.language ?? options.language,
+    settings: po.settings ?? options.settings,
+    logFiles: options.logFiles,
+    enableLsp: po.enableLsp ?? options.enableLsp,
+    enableBlockOnError: po.enableBlockOnError ?? options.enableBlockOnError,
+    enablePrettier: po.enablePrettier ?? options.enablePrettier
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultWebProvider
+});

package/lib/provider.d.ts

@@ -0,0 +1,49 @@
+import type { ChatSession, ProviderConfig, ProviderEnvironmentInfo, ProviderEvent, ProviderStartOptions, ProviderStartResult, WebProvider } from "@aipanel/core";
+/** DefaultWebProvider 构造配置（核心层传入的运行时参数） */
+export interface DefaultWebProviderConfig {
+    /** 服务主机名 */
+    hostname: string;
+    /** Chrome DevTools Protocol 端口 */
+    chromeDevtoolsPort: number;
+}
+/** DefaultWebProvider 构造依赖（端口等运行时状态由编排层提供） */
+export interface DefaultWebProviderDeps {
+    /** 实际 Web 端口读取器 */
+    getWebPort: () => number;
+    /** 实际代理端口读取器 */
+    getProxyPort: () => number;
+}
+/**
+ * 默认 Web Provider
+ * 组合 CLI 进程管理、REST API、桥接脚本，向核心层暴露 WebProvider 契约。
+ */
+export declare class DefaultWebProvider implements WebProvider {
+    private config;
+    readonly id = "opencode";
+    readonly displayName = "OpenCode Web";
+    /** 支持会话 URL 深链；支持代码审查面板（右上角 </> 按钮，由 bridge 渲染） */
+    readonly capabilities: {
+        readonly deepLink: true;
+        readonly reviewPanel: true;
+    };
+    /** REST 会话 API（Provider 内部使用） */
+    private readonly api;
+    private deps;
+    private process;
+    private bridgeOptions;
+    private readonly opts;
+    constructor(config: DefaultWebProviderConfig, deps: DefaultWebProviderDeps, options?: Record<string, unknown>);
+    /** 代理注入到 HTML 的桥接脚本（Provider 资产） */
+    get bridgeScript(): string | undefined;
+    /** 初始化桥接配置（主题/语言/设置） */
+    applyConfig(config: ProviderConfig): void;
+    checkEnvironment(): Promise<ProviderEnvironmentInfo>;
+    start(options: ProviderStartOptions): Promise<ProviderStartResult>;
+    stop(): Promise<void>;
+    killOrphans(): Promise<number>;
+    listSessions(projectDir: string): Promise<ChatSession[]>;
+    createSession(projectDir: string, title?: string): Promise<ChatSession>;
+    deleteSession(sessionId: string): Promise<void>;
+    buildSessionUrl(projectDir: string, sessionId: string): string;
+    subscribeEvents(handler: (e: ProviderEvent) => void): () => void;
+}

package/lib/system.cjs

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var system_exports = {};
+__export(system_exports, {
+  checkOpenCodeInstalled: () => checkOpenCodeInstalled,
+  getOpenCodeVersion: () => getOpenCodeVersion,
+  killOrphanOpenCodeProcesses: () => killOrphanOpenCodeProcesses
+});
+module.exports = __toCommonJS(system_exports);
+var import_child_process = require("child_process");
+var import_node = require("@aipanel/core/node");
+const log = (0, import_node.createLogger)("OpenCodeSystem");
+async function checkOpenCodeInstalled() {
+  const timer = log.timer("checkOpenCodeInstalled");
+  return new Promise((resolve) => {
+    log.debug("Checking if OpenCode is installed...");
+    const proc = (0, import_child_process.spawn)("opencode", ["--version"], { stdio: "ignore", shell: true });
+    proc.on("close", (code) => {
+      const installed = code === 0;
+      timer.end(installed ? "\u2713 OpenCode is installed" : "\u274C OpenCode not found");
+      resolve(installed);
+    });
+    proc.on("error", (err) => {
+      log.debug("Failed to check OpenCode installation", { error: err.message });
+      timer.end("\u274C Check failed");
+      resolve(false);
+    });
+  });
+}
+function getOpenCodeVersion() {
+  return new Promise((resolve) => {
+    const proc = (0, import_child_process.spawn)("opencode", ["--version"], { stdio: "pipe", shell: true });
+    let output = "";
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0 && output.trim()) {
+        resolve(output.trim());
+      } else {
+        resolve(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+const KILL_ORPHAN_TIMEOUT = 5e3;
+async function killOrphanOpenCodeProcesses() {
+  const timer = log.timer("killOrphanOpenCodeProcesses");
+  log.debug("Looking for orphan OpenCode processes (PPID=1)");
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (count) => {
+      if (settled) return;
+      settled = true;
+      resolve(count);
+    };
+    const timeout = setTimeout(() => {
+      log.warn("Kill orphan processes timed out, skipping");
+      timer.end("\u26A0 Timeout, skipped");
+      done(0);
+    }, KILL_ORPHAN_TIMEOUT);
+    const wrappedResolve = (count) => {
+      clearTimeout(timeout);
+      done(count);
+    };
+    if (process.platform === "win32") {
+      killOrphanProcessesOnWindows(wrappedResolve, timer);
+    } else {
+      killOrphanProcessesOnUnix(wrappedResolve, timer);
+    }
+  });
+}
+function killOrphanProcessesOnWindows(resolve, timer) {
+  log.debug("Using Windows method to find orphan processes");
+  const proc = (0, import_child_process.spawn)(
+    "wmic",
+    ["process", "where", 'name="opencode.exe"', "get", "processid,parentprocessid"],
+    { stdio: "pipe" }
+  );
+  let output = "";
+  proc.stdout?.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const lines = output.split("\n").filter((line) => line.trim());
+    const pidsToKill = [];
+    lines.forEach((line) => {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const ppid = parts[0];
+        const pid = parts[1];
+        if (ppid === "1" && pid && !isNaN(Number(pid))) {
+          pidsToKill.push(pid);
+        }
+      }
+    });
+    if (pidsToKill.length > 0) {
+      log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+      let killedCount = 0;
+      let completedCount = 0;
+      pidsToKill.forEach((pid) => {
+        const killProc = (0, import_child_process.spawn)("taskkill", ["/F", "/PID", pid], { stdio: "ignore" });
+        killProc.on("close", (code) => {
+          completedCount++;
+          if (code === 0) {
+            killedCount++;
+            log.debug(`Killed orphan process ${pid}`);
+          }
+          if (completedCount === pidsToKill.length) {
+            timer.end(`\u2713 Killed ${killedCount} orphan processes`);
+            resolve(killedCount);
+          }
+        });
+      });
+    } else {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+    }
+  });
+  proc.on("error", (err) => {
+    log.debug("Failed to find orphan processes", { error: err.message });
+    timer.end("\u274C Failed to find orphan processes");
+    resolve(0);
+  });
+}
+function killOrphanProcessesOnUnix(resolve, timer) {
+  log.debug("Using Unix method to find orphan processes");
+  const proc = (0, import_child_process.spawn)("ps", ["-e", "-o", "pid,ppid,comm"], { stdio: "pipe" });
+  let output = "";
+  proc.stdout?.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const lines = output.split("\n");
+    const pidsToKill = [];
+    lines.forEach((line) => {
+      const trimmed = line.trim();
+      if (trimmed.includes("opencode")) {
+        const parts = trimmed.split(/\s+/);
+        if (parts.length >= 3) {
+          const pid = parts[0];
+          const ppid = parts[1];
+          const comm = parts.slice(2).join(" ");
+          if (ppid === "1" && comm.includes("opencode")) {
+            pidsToKill.push(pid);
+          }
+        }
+      }
+    });
+    if (pidsToKill.length > 0) {
+      log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+      const killProc = (0, import_child_process.spawn)("kill", ["-9", ...pidsToKill], { stdio: "ignore" });
+      killProc.on("close", (code) => {
+        const killedCount = code === 0 ? pidsToKill.length : 0;
+        timer.end(
+          killedCount > 0 ? `\u2713 Killed ${killedCount} orphan processes` : "\u274C Failed to kill processes"
+        );
+        resolve(killedCount);
+      });
+      killProc.on("error", () => {
+        timer.end("\u274C Failed to kill processes");
+        resolve(0);
+      });
+    } else {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+    }
+  });
+  proc.on("error", (err) => {
+    log.debug("Failed to find orphan processes", { error: err.message });
+    timer.end("\u274C Failed to find orphan processes");
+    resolve(0);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkOpenCodeInstalled,
+  getOpenCodeVersion,
+  killOrphanOpenCodeProcesses
+});

package/lib/system.d.ts

@@ -0,0 +1,3 @@
+export declare function checkOpenCodeInstalled(): Promise<boolean>;
+export declare function getOpenCodeVersion(): Promise<string | null>;
+export declare function killOrphanOpenCodeProcesses(): Promise<number>;

package/lib/types.cjs

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);