@aipanel/provider-opencode 1.2.0-beta.0

package/es/system.js

@@ -0,0 +1,175 @@
+import { spawn } from "child_process";
+import { createLogger } from "@aipanel/core/node";
+const log = createLogger("OpenCodeSystem");
+async function checkOpenCodeInstalled() {
+  const timer = log.timer("checkOpenCodeInstalled");
+  return new Promise((resolve) => {
+    log.debug("Checking if OpenCode is installed...");
+    const proc = 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 = 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 = 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 = 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 = 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 = 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);
+  });
+}
+export {
+  checkOpenCodeInstalled,
+  getOpenCodeVersion,
+  killOrphanOpenCodeProcesses
+};

package/es/types.d.ts

@@ -0,0 +1,160 @@
+/**
+ * OpenCode Provider 专属类型
+ * 所有与 OpenCode Web 绑定的类型自包含于此，核心层不感知。
+ */
+import type { LogFileConfig } from "@aipanel/core";
+/**
+ * OpenCode 界面语言选项
+ */
+export type OpenCodeLanguage = "en" | "zh" | "zht" | "ko" | "ja" | "de" | "es" | "fr" | "da" | "pl" | "ru" | "bs" | "ar" | "no" | "br" | "th" | "tr";
+/**
+ * OpenCode 内部设置（与 localStorage settings.v3 对应）
+ * 用于配置 OpenCode Web 内部行为
+ */
+export interface OpenCodeSettings {
+    /** 通用设置 */
+    general?: {
+        /** 自动保存 */
+        autoSave?: boolean;
+        /** 显示更新说明 */
+        releaseNotes?: boolean;
+        /** 后续动作模式 */
+        followup?: "steer" | "suggest" | "none";
+        /** 显示推理摘要 */
+        showReasoningSummaries?: boolean;
+        /** 默认展开 shell 工具部分 */
+        shellToolPartsExpanded?: boolean;
+        /** 默认展开编辑工具部分 */
+        editToolPartsExpanded?: boolean;
+    };
+    /** 外观设置 */
+    appearance?: {
+        /** 界面字体大小 */
+        fontSize?: number;
+        /** 代码字体 */
+        mono?: string;
+        /** 界面字体 */
+        sans?: string;
+    };
+    /** 权限设置 */
+    permissions?: {
+        /** 自动批准权限请求 */
+        autoApprove?: boolean;
+    };
+    /** 通知设置 */
+    notifications?: {
+        /** 智能体完成时通知 */
+        agent?: boolean;
+        /** 权限请求时通知 */
+        permissions?: boolean;
+        /** 错误时通知 */
+        errors?: boolean;
+    };
+    /** 音效设置 */
+    sounds?: {
+        /** 启用智能体音效 */
+        agentEnabled?: boolean;
+        /** 智能体音效 */
+        agent?: string;
+        /** 启用权限音效 */
+        permissionsEnabled?: boolean;
+        /** 权限音效 */
+        permissions?: string;
+        /** 启用错误音效 */
+        errorsEnabled?: boolean;
+        /** 错误音效 */
+        errors?: string;
+    };
+}
+/**
+ * OpenCode Provider 专属配置（对应插件配置的 providerOptions 段）
+ * 保留字符串索引签名，以赋给 PluginOptions 的 Record<string, unknown> 泛型约束。
+ */
+export type OpenCodeProviderOptions = {
+    /** OpenCode 界面语言，默认跟随浏览器语言 */
+    language?: OpenCodeLanguage;
+    /** OpenCode 内部设置，直接映射到 localStorage settings.v3 */
+    settings?: OpenCodeSettings;
+    /** 自定义日志文件配置 */
+    logFiles?: LogFileConfig[];
+    /** 启用 LSP 诊断（TypeScript + ESLint），agent 编辑文件后自动返回错误信息，默认 false */
+    enableLsp?: boolean;
+    /** 启用 LSP 错误硬阻止：编辑后有错误则回滚文件并拒绝修改，默认 false */
+    enableBlockOnError?: boolean;
+    /** 启用代码格式化功能（prettier），默认 true */
+    enablePrettier?: boolean;
+    /** 允许 Provider 自定义扩展字段（schema 由具体 Provider 定义） */
+    [key: string]: unknown;
+};
+/**
+ * OpenCode Web 服务启动选项（进程管理内部类型）
+ */
+export interface WebOptions {
+    /** 服务端口 */
+    port: number;
+    /** 服务主机名 */
+    hostname: string;
+    /** 服务器 URL */
+    serverUrl: string;
+    /** 工作目录 */
+    cwd: string;
+    /** 配置目录路径 */
+    configDir?: string;
+    /** CORS 允许的源 */
+    corsOrigins?: string[];
+    /** 上下文 API URL */
+    contextApiUrl?: string;
+    /** 进程日志 API URL */
+    logsApiUrl?: string;
+    /** 日志文件配置（JSON 字符串） */
+    logFilesJson?: string;
+    /** 启用 LSP 错误硬阻止（环境变量透传给 OpenCode 插件） */
+    enableBlockOnError?: boolean;
+    /** 启用 verbose 模式（环境变量透传，调试日志输出） */
+    verbose?: boolean;
+    /** 启用 LSP / 质量门禁（环境变量透传，控制 block-on-error 插件运行） */
+    enableLsp?: boolean;
+    /** 启用代码格式化功能（prettier） */
+    enablePrettier?: boolean;
+    /** Vue DevTools API 地址（环境变量透传给 OpenCode 插件） */
+    vueDevtoolsApiUrl?: string;
+}
+/**
+ * OpenCode 会话信息（REST API 原始返回）
+ */
+export interface SessionInfo {
+    /** 会话 ID */
+    id: string;
+    /** 会话标识符 */
+    slug: string;
+    /** 项目 ID */
+    projectID: string;
+    /** 项目目录 */
+    directory: string;
+    /** 会话标题 */
+    title: string;
+    /** 版本号 */
+    version: string;
+    /** 会话 URL */
+    url?: string;
+    /** 父会话 ID（subagent 会话才有） */
+    parentID?: string;
+    /** 代码变更统计 */
+    summary: {
+        /** 新增行数 */
+        additions: number;
+        /** 删除行数 */
+        deletions: number;
+        /** 修改文件数 */
+        files: number;
+    };
+    /** 时间信息 */
+    time: {
+        /** 创建时间戳 */
+        created: number;
+        /** 更新时间戳 */
+        updated: number;
+        /** 归档时间戳（已归档会话才有） */
+        archived?: number;
+    };
+}

package/lib/api.cjs

@@ -0,0 +1,251 @@
+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 api_exports = {};
+__export(api_exports, {
+  OpenCodeAPI: () => OpenCodeAPI
+});
+module.exports = __toCommonJS(api_exports);
+var import_http = __toESM(require("http"));
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+const log = (0, import_node.createLogger)("API");
+class OpenCodeAPI {
+  constructor(hostname, getPort, getProxyPort, chromeDevtoolsPort = import_core.CHROME_DEVTOOLS_PORT) {
+    __publicField(this, "hostname", hostname);
+    __publicField(this, "getPort", getPort);
+    __publicField(this, "getProxyPort", getProxyPort);
+    __publicField(this, "chromeDevtoolsPort", chromeDevtoolsPort);
+  }
+  /** 构建代理 iframe URL（旧版格式：/{base64(projectDir)}/session/{id}） */
+  buildSessionProxyUrl(projectDir, sessionId) {
+    return `http://${this.hostname}:${this.getProxyPort()}/${(0, import_core.base64Encode)(projectDir)}/session/${sessionId}`;
+  }
+  createHttpRequest(options, body, timeout) {
+    const timer = new import_node.PerformanceTimer("HTTP Request", {
+      operation: `${options.method || "GET"} ${options.path}`
+    });
+    return new Promise((resolve, reject) => {
+      const req = import_http.default.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => {
+          try {
+            const result = JSON.parse(data);
+            timer.end(`\u2713 Status: ${res.statusCode}`);
+            resolve(result);
+          } catch {
+            timer.end("\u274C JSON parse error");
+            reject(new Error(`JSON parse error: ${data.substring(0, 100)}`));
+          }
+        });
+      });
+      req.on("error", (e) => {
+        timer.end("\u274C Request failed");
+        reject(e);
+      });
+      if (timeout) {
+        req.setTimeout(timeout, () => {
+          timer.end("\u274C Request timeout");
+          req.destroy();
+          reject(new Error(`Request timeout after ${timeout}ms`));
+        });
+      }
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+  async getSessions(projectDir, retries = import_core.DEFAULT_RETRIES) {
+    const timer = log.timer("getSessions", { retries, projectDir });
+    let lastError = null;
+    for (let i = 0; i < retries; i++) {
+      try {
+        log.debug(`Attempt ${i + 1}/${retries}`, { operation: "getSessions", projectDir });
+        const sessions = await this.createHttpRequest({
+          hostname: this.hostname,
+          port: this.getPort(),
+          path: `/session?directory=${encodeURIComponent(projectDir)}`
+        });
+        const sessionsWithUrl = sessions.map((s) => ({
+          ...s,
+          url: s.directory && s.id ? this.buildSessionProxyUrl(s.directory, s.id) : ""
+        }));
+        timer.end(`Found ${sessions.length} sessions`);
+        return sessionsWithUrl;
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+        log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+          operation: "getSessions"
+        });
+        if (i < retries - 1) {
+          log.debug(`Retrying in ${import_core.RETRY_DELAY}ms...`, {
+            operation: "getSessions"
+          });
+          await (0, import_core.sleep)(import_core.RETRY_DELAY);
+        }
+      }
+    }
+    timer.end("\u274C All retries exhausted");
+    throw lastError;
+  }
+  async createSession(projectDir, retries = import_core.DEFAULT_RETRIES, title) {
+    const timer = log.timer("createSession", { retries, title, projectDir });
+    let lastError = null;
+    for (let i = 0; i < retries; i++) {
+      try {
+        log.debug(`Attempt ${i + 1}/${retries}`, {
+          operation: "createSession",
+          title,
+          projectDir
+        });
+        const requestBody = title ? JSON.stringify({ title }) : void 0;
+        const session = await this.createHttpRequest(
+          {
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: "/session",
+            method: "POST",
+            headers: {
+              ...requestBody ? { "Content-Type": "application/json" } : {}
+            }
+          },
+          requestBody
+        );
+        const sessionWithUrl = {
+          ...session,
+          url: this.buildSessionProxyUrl(projectDir, session.id)
+        };
+        timer.end(`Created session: ${session.id}`);
+        return sessionWithUrl;
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+        log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+          operation: "createSession"
+        });
+        if (i < retries - 1) {
+          log.debug(`Retrying in ${import_core.RETRY_DELAY}ms...`, {
+            operation: "createSession"
+          });
+          await (0, import_core.sleep)(import_core.RETRY_DELAY);
+        }
+      }
+    }
+    timer.end("\u274C All retries exhausted");
+    throw lastError;
+  }
+  async deleteSession(sessionId, retries = import_core.DEFAULT_RETRIES) {
+    const timer = log.timer("deleteSession", { sessionId, retries });
+    let lastError = null;
+    for (let i = 0; i < retries; i++) {
+      try {
+        log.debug(`Attempt ${i + 1}/${retries}`, {
+          operation: "deleteSession",
+          sessionId
+        });
+        await this.createHttpRequest({
+          hostname: this.hostname,
+          port: this.getPort(),
+          path: `/session/${sessionId}`,
+          method: "DELETE"
+        });
+        timer.end(`Deleted session: ${sessionId}`);
+        return;
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+        log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+          operation: "deleteSession",
+          sessionId
+        });
+        if (i < retries - 1) {
+          log.debug(`Retrying in ${import_core.RETRY_DELAY}ms...`, {
+            operation: "deleteSession",
+            sessionId
+          });
+          await (0, import_core.sleep)(import_core.RETRY_DELAY);
+        }
+      }
+    }
+    timer.end("\u274C All retries exhausted");
+    throw lastError;
+  }
+  async getToolIds(retries = import_core.DEFAULT_RETRIES) {
+    const timer = log.timer("getToolIds", { retries });
+    let lastError = null;
+    for (let i = 0; i < retries; i++) {
+      try {
+        log.debug(`Attempt ${i + 1}/${retries}`, {
+          operation: "getToolIds"
+        });
+        const toolIds = await this.createHttpRequest({
+          hostname: this.hostname,
+          port: this.getPort(),
+          path: "/experimental/tool/ids"
+        });
+        timer.end(`Found ${toolIds.length} tools`);
+        return toolIds;
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+        log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+          operation: "getToolIds"
+        });
+        if (i < retries - 1) {
+          log.debug(`Retrying in ${import_core.RETRY_DELAY}ms...`, {
+            operation: "getToolIds"
+          });
+          await (0, import_core.sleep)(import_core.RETRY_DELAY);
+        }
+      }
+    }
+    timer.end("\u274C All retries exhausted");
+    throw lastError;
+  }
+  async getOrCreateSession(projectDir) {
+    const timer = log.timer("getOrCreateSession", { projectDir });
+    log.debug("Getting sessions...", { projectDir });
+    const sessions = await this.getSessions(projectDir);
+    log.debug(`Found ${sessions.length} sessions`, {
+      sessions: sessions.map((s) => ({ id: s.id, directory: s.directory }))
+    });
+    const matchingSession = sessions.find((s) => s.directory === projectDir);
+    if (matchingSession) {
+      const url2 = this.buildSessionProxyUrl(projectDir, matchingSession.id);
+      timer.end(`Using existing session: ${matchingSession.id}`);
+      return url2;
+    }
+    log.debug("Creating new session...", { projectDir });
+    const newSession = await this.createSession(projectDir);
+    const url = this.buildSessionProxyUrl(projectDir, newSession.id);
+    timer.end(`Created new session: ${newSession.id}`);
+    return url;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenCodeAPI
+});

package/lib/api.d.ts

@@ -0,0 +1,16 @@
+import type { SessionInfo } from "./types";
+export declare class OpenCodeAPI {
+    private hostname;
+    private getPort;
+    private getProxyPort;
+    private chromeDevtoolsPort;
+    constructor(hostname: string, getPort: () => number, getProxyPort: () => number, chromeDevtoolsPort?: number);
+    /** 构建代理 iframe URL（旧版格式：/{base64(projectDir)}/session/{id}） */
+    buildSessionProxyUrl(projectDir: string, sessionId: string): string;
+    private createHttpRequest;
+    getSessions(projectDir: string, retries?: number): Promise<SessionInfo[]>;
+    createSession(projectDir: string, retries?: number, title?: string): Promise<SessionInfo>;
+    deleteSession(sessionId: string, retries?: number): Promise<void>;
+    getToolIds(retries?: number): Promise<string[]>;
+    getOrCreateSession(projectDir: string): Promise<string>;
+}