@aipanel/provider-opencode 1.2.0-beta.0

package/es/constants.d.ts

@@ -0,0 +1,32 @@
+/**
+ * OpenCode Provider 专属常量与默认值
+ * 与 OpenCode Web 绑定的常量自包含于此，核心层不感知。
+ */
+import type { OpenCodeProviderOptions } from "./types";
+/** ==================== OpenCode localStorage 键 ==================== */
+/** OpenCode localStorage 配置键 */
+export declare const OPENCODE_STORAGE_KEYS: {
+    /** 设置键 (settings.v3) */
+    readonly SETTINGS: "settings.v3";
+    /** 配色方案键 */
+    readonly COLOR_SCHEME: "opencode-color-scheme";
+    /** 主题 ID 键 */
+    readonly THEME_ID: "opencode-theme-id";
+};
+/** ==================== OpenCode 默认设置 ==================== */
+/** OpenCode 默认设置（与 OpenCode Web localStorage settings.v3 对应） */
+export declare const DEFAULT_OPENCODE_SETTINGS: {
+    general: {
+        showReasoningSummaries: boolean;
+        newLayoutDesigns: boolean;
+        showFileTree: boolean;
+        editToolPartsExpanded: boolean;
+        shellToolPartsExpanded: boolean;
+    };
+};
+/** ==================== 运行环境 ==================== */
+/** OpenCode 缓存目录（相对于项目根目录，存放 opencode.json 等运行状态） */
+export declare const OPENCODE_CACHE_DIR = "node_modules/.cache/opencode";
+/** ==================== Provider 专属配置默认值 ==================== */
+/** OpenCode Provider 专属配置默认值（插件组装 config 时使用） */
+export declare const DEFAULT_OPENCODE_PROVIDER_OPTIONS: OpenCodeProviderOptions;

package/es/constants.js

@@ -0,0 +1,29 @@
+const OPENCODE_STORAGE_KEYS = {
+  /** 设置键 (settings.v3) */
+  SETTINGS: "settings.v3",
+  /** 配色方案键 */
+  COLOR_SCHEME: "opencode-color-scheme",
+  /** 主题 ID 键 */
+  THEME_ID: "opencode-theme-id"
+};
+const DEFAULT_OPENCODE_SETTINGS = {
+  general: {
+    showReasoningSummaries: true,
+    newLayoutDesigns: true,
+    showFileTree: false,
+    editToolPartsExpanded: true,
+    shellToolPartsExpanded: true
+  }
+};
+const OPENCODE_CACHE_DIR = "node_modules/.cache/opencode";
+const DEFAULT_OPENCODE_PROVIDER_OPTIONS = {
+  enableLsp: true,
+  enableBlockOnError: false,
+  enablePrettier: true
+};
+export {
+  DEFAULT_OPENCODE_PROVIDER_OPTIONS,
+  DEFAULT_OPENCODE_SETTINGS,
+  OPENCODE_CACHE_DIR,
+  OPENCODE_STORAGE_KEYS
+};

package/es/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenCode Web Provider
+ * 实现 WebProvider 契约：进程管理、REST 会话 API、桥接脚本、CLI 环境检查。
+ * 所有 OpenCode 专属类型与常量自包含于此包。
+ */
+import type { ProviderInitContext, WebProvider } from "@aipanel/core";
+/** 约定工厂：核心层动态加载本包后调用，初始化动作完全由 Provider 定义 */
+export declare function createProvider(ctx: ProviderInitContext): WebProvider;
+export { OpenCodeAPI } from "./api";
+export type { DefaultWebProviderConfig, DefaultWebProviderDeps } from "./provider";
+export { prepareOpenCodeRuntime, startOpenCodeWeb } from "./opencode-web";
+export { generateBridgeScript, type BridgeScriptOptions } from "./bridge-script";
+export { checkOpenCodeInstalled, getOpenCodeVersion, killOrphanOpenCodeProcesses } from "./system";
+export { DEFAULT_OPENCODE_PROVIDER_OPTIONS } from "./constants";
+export type { OpenCodeProviderOptions, OpenCodeLanguage, OpenCodeSettings, SessionInfo, WebOptions, } from "./types";

package/es/index.js

@@ -0,0 +1,24 @@
+import { DefaultWebProvider } from "./provider.js";
+function createProvider(ctx) {
+  return new DefaultWebProvider(
+    { hostname: ctx.hostname, chromeDevtoolsPort: ctx.chromeDevtoolsPort },
+    { getWebPort: ctx.getWebPort, getProxyPort: ctx.getProxyPort },
+    ctx.options
+  );
+}
+import { OpenCodeAPI } from "./api.js";
+import { prepareOpenCodeRuntime, startOpenCodeWeb } from "./opencode-web.js";
+import { generateBridgeScript } from "./bridge-script.js";
+import { checkOpenCodeInstalled, getOpenCodeVersion, killOrphanOpenCodeProcesses } from "./system.js";
+import { DEFAULT_OPENCODE_PROVIDER_OPTIONS } from "./constants.js";
+export {
+  DEFAULT_OPENCODE_PROVIDER_OPTIONS,
+  OpenCodeAPI,
+  checkOpenCodeInstalled,
+  createProvider,
+  generateBridgeScript,
+  getOpenCodeVersion,
+  killOrphanOpenCodeProcesses,
+  prepareOpenCodeRuntime,
+  startOpenCodeWeb
+};

package/es/opencode-web.d.ts

@@ -0,0 +1,4 @@
+import type { ResultPromise } from "execa";
+import type { WebOptions } from "./types";
+export declare function prepareOpenCodeRuntime(cwd: string, vitePort: number, enableLsp?: boolean, enablePrettier?: boolean): string;
+export declare function startOpenCodeWeb(options: WebOptions): ResultPromise;

package/es/opencode-web.js

@@ -0,0 +1,276 @@
+import { execa } from "execa";
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { OPENCODE_CACHE_DIR } from "./constants.js";
+import {
+  MCP_API_PATH,
+  VSCODE_EXTENSION_PORT,
+  ENV_VSCODE_PORT,
+  createLogger,
+  getProcessLogBuffer,
+  createPackageRequire,
+  resolvePackageDir
+} from "@aipanel/core/node";
+const require2 = createPackageRequire();
+const packageDir = resolvePackageDir("@aipanel/opencode-plugins");
+const log = createLogger("OpenCodeWeb");
+function prepareOpenCodeRuntime(cwd, vitePort, enableLsp, enablePrettier) {
+  const cacheDir = path.join(cwd, OPENCODE_CACHE_DIR);
+  log.debug("Setting up OpenCode runtime", { cacheDir, enableLsp });
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+  const sourcePluginsDir = resolveSourcePluginsDir();
+  const plugins = resolvePluginEntries(sourcePluginsDir);
+  const formatterConfig = buildFormatterConfig(enablePrettier);
+  const opencodeConfigPath = path.join(cacheDir, "opencode.json");
+  const config = {
+    plugin: plugins,
+    formatter: formatterConfig,
+    mcp: {
+      "chrome-devtools": {
+        type: "remote",
+        url: `http://localhost:${vitePort}${MCP_API_PATH}`
+      }
+    }
+  };
+  fs.writeFileSync(opencodeConfigPath, JSON.stringify(config, null, 2));
+  log.debug("OpenCode runtime ready", {
+    cacheDir,
+    opencodeConfigPath,
+    pluginCount: plugins.length
+  });
+  return cacheDir;
+}
+function startOpenCodeWeb(options) {
+  const {
+    port,
+    hostname,
+    cwd,
+    configDir,
+    corsOrigins,
+    contextApiUrl,
+    logsApiUrl,
+    logFilesJson,
+    enableBlockOnError,
+    verbose,
+    enableLsp,
+    vueDevtoolsApiUrl
+  } = options;
+  const stateDir = createStateDirectory(cwd);
+  log.debug("Building process environment", {
+    stateDir,
+    configDir,
+    contextApiUrl,
+    logsApiUrl,
+    logFilesJson,
+    enableBlockOnError,
+    verbose,
+    enableLsp
+  });
+  const env = buildProcessEnv(
+    stateDir,
+    configDir,
+    contextApiUrl,
+    logsApiUrl,
+    logFilesJson,
+    enableBlockOnError,
+    verbose,
+    enableLsp,
+    vueDevtoolsApiUrl,
+    cwd
+  );
+  const args = ["serve", "--port", String(port), "--hostname", hostname];
+  if (corsOrigins && corsOrigins.length > 0) {
+    corsOrigins.forEach((origin) => {
+      args.push("--cors", origin);
+    });
+    log.debug("CORS origins added", { origins: corsOrigins });
+  }
+  log.debug("Spawning OpenCode process", {
+    command: "opencode",
+    args: args.join(" "),
+    cwd
+  });
+  const proc = execa("opencode", args, {
+    cwd,
+    env,
+    reject: false,
+    cleanup: true,
+    shell: true
+  });
+  proc.stdout?.on("data", (data) => {
+    const output = data.toString().trim();
+    if (output) {
+      log.debug("[OpenCode stdout]", { output });
+      getProcessLogBuffer().addProviderStdout(output);
+    }
+  });
+  proc.stderr?.on("data", (data) => {
+    const output = data.toString().trim();
+    if (output) {
+      if (output.includes("MaxListenersExceededWarning")) return;
+      log.warn("[OpenCode stderr]", { output });
+      getProcessLogBuffer().addProviderStderr(output);
+    }
+  });
+  return proc;
+}
+function createStateDirectory(cwd) {
+  const stateDir = path.join(cwd, OPENCODE_CACHE_DIR);
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+    log.debug("Created state directory", { stateDir });
+  }
+  return stateDir;
+}
+function buildFormatterConfig(enablePrettier) {
+  if (enablePrettier === false) {
+    log.debug("enablePrettier is false, formatter disabled");
+    return false;
+  }
+  const bridgePath = resolveFormatBridgePath();
+  if (!bridgePath) {
+    log.debug("format-bridge not found, using built-in formatters");
+    return true;
+  }
+  log.debug("Format bridge configured");
+  if (!isFormatServiceRunning()) {
+    log.debug("VS Code format service not running, using built-in formatters only");
+    return true;
+  }
+  log.debug("VS Code format service detected, enabling bridge");
+  log.info("\u5DF2\u8FDE\u63A5 VS Code \u683C\u5F0F\u5316\u670D\u52A1");
+  const extensions = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".vue",
+    ".svelte",
+    ".astro",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".pcss",
+    ".html",
+    ".htm",
+    ".xml",
+    ".svg",
+    ".json",
+    ".jsonc",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".md",
+    ".mdx",
+    ".graphql",
+    ".gql"
+  ];
+  return {
+    format_bridge: {
+      command: ["node", bridgePath, "$FILE"],
+      extensions
+    }
+  };
+}
+let _formatServiceRunning;
+function isFormatServiceRunning() {
+  if (_formatServiceRunning !== void 0) return _formatServiceRunning;
+  try {
+    require2("child_process").execSync(
+      `node -e "const h=require('http');h.get('http://127.0.0.1:${VSCODE_EXTENSION_PORT}/health',r=>{r.resume();process.exit(r.statusCode===200?0:1)}).on('error',()=>process.exit(1))"`,
+      { timeout: 500, stdio: "ignore" }
+    );
+    _formatServiceRunning = true;
+  } catch {
+    _formatServiceRunning = false;
+  }
+  return _formatServiceRunning;
+}
+function resolveFormatBridgePath() {
+  const viteEntry = require2.resolve("vite-plugin-aipanel");
+  const bridgePath = path.resolve(path.dirname(viteEntry), "utils", "format-bridge.cjs");
+  if (fs.existsSync(bridgePath)) return bridgePath;
+  return void 0;
+}
+function resolveSourcePluginsDir() {
+  const candidatePaths = [path.join(packageDir, "es", "plugins")];
+  for (const candidatePath of candidatePaths) {
+    if (fs.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return candidatePaths[0];
+}
+const MIGRATED_TO_MCP_PLUGINS = /* @__PURE__ */ new Set(["vue-devtools.js", "vite-logs.js", "service-logs.js"]);
+function resolvePluginEntries(sourceDir) {
+  const files = fs.readdirSync(sourceDir).filter((f) => f.endsWith(".js") && !MIGRATED_TO_MCP_PLUGINS.has(f));
+  const entries = files.map((file) => {
+    const absolutePath = path.join(sourceDir, file);
+    return pathToFileURL(absolutePath).href;
+  });
+  log.debug("Resolved plugin entries", { count: entries.length, entries });
+  return entries;
+}
+function buildProcessEnv(stateDir, configDir, contextApiUrl, logsApiUrl, logFilesJson, enableBlockOnError, verbose, enableLsp, vueDevtoolsApiUrl, workspace) {
+  const env = {
+    ...Object.fromEntries(
+      Object.entries(process.env).filter(([, v]) => v !== void 0)
+    ),
+    XDG_STATE_HOME: stateDir,
+    // 指向缓存目录，OpenCode 通过 opencode.json 中 plugins 字段加载插件
+    OPENCODE_CONFIG_DIR: stateDir
+  };
+  if (configDir) {
+    env.OPENCODE_CONFIG_DIR = configDir;
+    log.debug("Set OPENCODE_CONFIG_DIR", { configDir });
+  }
+  if (contextApiUrl) {
+    env.OPENCODE_CONTEXT_API_URL = contextApiUrl;
+    log.debug("Set OPENCODE_CONTEXT_API_URL", { contextApiUrl });
+  }
+  if (logsApiUrl) {
+    env.OPENCODE_VITE_LOGS_API_URL = logsApiUrl;
+    log.debug("Set OPENCODE_VITE_LOGS_API_URL", { logsApiUrl });
+  }
+  if (logFilesJson) {
+    env.OPENCODE_LOG_FILES_JSON = logFilesJson;
+    log.debug("Set OPENCODE_LOG_FILES_JSON", { logFilesJson });
+  }
+  if (enableBlockOnError) {
+    env.OPENCODE_BLOCK_ON_ERROR = "1";
+    log.debug("Set OPENCODE_BLOCK_ON_ERROR=1");
+  }
+  if (verbose) {
+    env.OPENCODE_VERBOSE = "1";
+    log.debug("Set OPENCODE_VERBOSE=1");
+  }
+  if (enableLsp) {
+    env.OPENCODE_ENABLE_LINT = "1";
+    log.debug("Set OPENCODE_ENABLE_LINT=1");
+  }
+  if (vueDevtoolsApiUrl) {
+    env.OPENCODE_VUE_DEVTOOLS_API_URL = vueDevtoolsApiUrl;
+    log.debug("Set OPENCODE_VUE_DEVTOOLS_API_URL", { vueDevtoolsApiUrl });
+  }
+  if (workspace) {
+    env.OPENCODE_WORKSPACE = workspace;
+    log.debug("Set OPENCODE_WORKSPACE", { workspace });
+  }
+  if (isFormatServiceRunning()) {
+    env[ENV_VSCODE_PORT] = String(VSCODE_EXTENSION_PORT);
+    log.debug("Set OPENCODE_VSCODE_PORT");
+  }
+  return env;
+}
+export {
+  prepareOpenCodeRuntime,
+  startOpenCodeWeb
+};

package/es/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/es/provider.js

@@ -0,0 +1,257 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import http from "http";
+import { RETRY_DELAY } from "@aipanel/core";
+import { createLogger } from "@aipanel/core/node";
+import { DEFAULT_OPENCODE_PROVIDER_OPTIONS } from "./constants.js";
+import { OpenCodeAPI } from "./api.js";
+import { generateBridgeScript } from "./bridge-script.js";
+import { prepareOpenCodeRuntime, startOpenCodeWeb } from "./opencode-web.js";
+import { checkOpenCodeInstalled, getOpenCodeVersion, killOrphanOpenCodeProcesses } from "./system.js";
+const log = 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 OpenCodeAPI(
+      config.hostname,
+      deps.getWebPort,
+      deps.getProxyPort,
+      config.chromeDevtoolsPort
+    );
+  }
+  /** 代理注入到 HTML 的桥接脚本（Provider 资产） */
+  get bridgeScript() {
+    return generateBridgeScript(this.bridgeOptions);
+  }
+  /** 初始化桥接配置（主题/语言/设置） */
+  applyConfig(config) {
+    this.bridgeOptions = {
+      theme: config.theme,
+      language: this.opts.language,
+      settings: this.opts.settings
+    };
+  }
+  async checkEnvironment() {
+    if (!await 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 getOpenCodeVersion();
+    return { ok: true, version: version ?? void 0 };
+  }
+  async start(options) {
+    log.debug("Preparing OpenCode runtime", { cwd: options.cwd, vitePort: options.vitePort });
+    const configDir = 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 = 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 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, RETRY_DELAY);
+    };
+    const connect = () => {
+      if (aborted) return;
+      const req = http.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 { ...DEFAULT_OPENCODE_PROVIDER_OPTIONS };
+  const po = options.providerOptions ?? {};
+  return {
+    ...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
+  };
+}
+export {
+  DefaultWebProvider
+};

package/es/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>;