@snack-kit/porygon 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -0,0 +1,2192 @@
+"use strict";
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbstractAgentAdapter: () => AbstractAgentAdapter,
+  AdapterIncompatibleError: () => AdapterIncompatibleError,
+  AdapterNotAvailableError: () => AdapterNotAvailableError,
+  AdapterNotFoundError: () => AdapterNotFoundError,
+  AgentExecutionError: () => AgentExecutionError,
+  AgentTimeoutError: () => AgentTimeoutError,
+  ClaudeAdapter: () => ClaudeAdapter,
+  ConfigValidationError: () => ConfigValidationError,
+  InteractiveSession: () => InteractiveSession,
+  InterceptorRejectedError: () => InterceptorRejectedError,
+  OpenCodeAdapter: () => OpenCodeAdapter,
+  Porygon: () => Porygon,
+  PorygonError: () => PorygonError,
+  SessionNotFoundError: () => SessionNotFoundError,
+  createInputGuard: () => createInputGuard,
+  createOutputGuard: () => createOutputGuard,
+  createPorygon: () => createPorygon
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/porygon.ts
+var import_node_events2 = require("events");
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  defaultBackend: "claude",
+  backends: {},
+  defaults: {
+    timeoutMs: 3e5,
+    // 5 minutes
+    maxTurns: 50
+  },
+  proxy: void 0
+};
+
+// src/config/schema.ts
+var import_zod = require("zod");
+
+// src/errors/index.ts
+var PorygonError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "PorygonError";
+    this.code = code;
+  }
+};
+var AdapterNotFoundError = class extends PorygonError {
+  constructor(backend, options) {
+    super("ADAPTER_NOT_FOUND", `Adapter not found: ${backend}`, options);
+    this.name = "AdapterNotFoundError";
+  }
+};
+var AdapterNotAvailableError = class extends PorygonError {
+  constructor(backend, options) {
+    super("ADAPTER_NOT_AVAILABLE", `Adapter not available: ${backend}`, options);
+    this.name = "AdapterNotAvailableError";
+  }
+};
+var AdapterIncompatibleError = class extends PorygonError {
+  constructor(backend, version, options) {
+    super(
+      "ADAPTER_INCOMPATIBLE",
+      `Adapter incompatible: ${backend} version ${version}`,
+      options
+    );
+    this.name = "AdapterIncompatibleError";
+  }
+};
+var SessionNotFoundError = class extends PorygonError {
+  constructor(sessionId, options) {
+    super("SESSION_NOT_FOUND", `Session not found: ${sessionId}`, options);
+    this.name = "SessionNotFoundError";
+  }
+};
+var InterceptorRejectedError = class extends PorygonError {
+  constructor(reason, options) {
+    super("INTERCEPTOR_REJECTED", `Interceptor rejected: ${reason}`, options);
+    this.name = "InterceptorRejectedError";
+  }
+};
+var AgentExecutionError = class extends PorygonError {
+  constructor(message, options) {
+    super("AGENT_EXECUTION_ERROR", message, options);
+    this.name = "AgentExecutionError";
+  }
+};
+var AgentTimeoutError = class extends PorygonError {
+  constructor(timeoutMs, options) {
+    super("AGENT_TIMEOUT", `Agent timed out after ${timeoutMs}ms`, options);
+    this.name = "AgentTimeoutError";
+  }
+};
+var ConfigValidationError = class extends PorygonError {
+  constructor(message, options) {
+    super("CONFIG_VALIDATION_ERROR", message, options);
+    this.name = "ConfigValidationError";
+  }
+};
+
+// src/config/schema.ts
+var ProxyConfigSchema = import_zod.z.object({
+  url: import_zod.z.string().url(),
+  noProxy: import_zod.z.string().optional()
+});
+var BackendConfigSchema = import_zod.z.object({
+  model: import_zod.z.string().optional(),
+  appendSystemPrompt: import_zod.z.string().optional(),
+  proxy: ProxyConfigSchema.optional(),
+  cwd: import_zod.z.string().optional(),
+  serverUrl: import_zod.z.string().optional(),
+  apiKey: import_zod.z.string().optional(),
+  interactive: import_zod.z.boolean().optional(),
+  cliPath: import_zod.z.string().optional(),
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var PorygonConfigSchema = import_zod.z.object({
+  defaultBackend: import_zod.z.string().optional(),
+  backends: import_zod.z.record(import_zod.z.string(), BackendConfigSchema).optional(),
+  defaults: import_zod.z.object({
+    appendSystemPrompt: import_zod.z.string().optional(),
+    timeoutMs: import_zod.z.number().positive().optional(),
+    maxTurns: import_zod.z.number().int().positive().optional()
+  }).optional(),
+  proxy: ProxyConfigSchema.optional()
+});
+function validateConfig(config) {
+  const result = PorygonConfigSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }));
+    throw new ConfigValidationError(
+      `\u914D\u7F6E\u6821\u9A8C\u5931\u8D25: ${issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`
+    );
+  }
+  return result.data;
+}
+
+// src/config/config-loader.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal === void 0) {
+      continue;
+    }
+    if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function loadEnvOverrides() {
+  const config = {};
+  const defaultBackend = process.env["PORYGON_DEFAULT_BACKEND"];
+  if (defaultBackend) {
+    config.defaultBackend = defaultBackend;
+  }
+  const proxyUrl = process.env["PORYGON_PROXY_URL"];
+  if (proxyUrl) {
+    config.proxy = {
+      url: proxyUrl,
+      noProxy: process.env["PORYGON_PROXY_NO_PROXY"]
+    };
+  }
+  return config;
+}
+var ConfigLoader = class {
+  /**
+   * 加载并合并配置
+   * @param userConfig - 用户传入的配置（可选）
+   * @returns 校验通过的最终配置
+   * @throws ConfigValidationError 校验失败时抛出
+   */
+  static load(userConfig) {
+    let merged = { ...DEFAULT_CONFIG };
+    const envOverrides = loadEnvOverrides();
+    merged = deepMerge(merged, envOverrides);
+    if (userConfig) {
+      merged = deepMerge(merged, userConfig);
+    }
+    return validateConfig(merged);
+  }
+};
+
+// src/interceptor/interceptor.ts
+var InterceptorManager = class {
+  inputInterceptors = [];
+  outputInterceptors = [];
+  /**
+   * 注册拦截器
+   * @param direction - 拦截方向
+   * @param fn - 拦截器函数
+   * @returns 取消注册的函数
+   */
+  use(direction, fn) {
+    const list = direction === "input" ? this.inputInterceptors : this.outputInterceptors;
+    list.push(fn);
+    return () => {
+      const idx = list.indexOf(fn);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+      }
+    };
+  }
+  /**
+   * 执行输入拦截器流水线
+   * @param text - 原始输入文本
+   * @param context - 拦截器上下文（不含 direction）
+   * @returns 处理后的文本
+   * @throws InterceptorRejectedError 拦截器返回 false 时抛出
+   */
+  async processInput(text, context) {
+    return this.runPipeline(text, "input", context, this.inputInterceptors);
+  }
+  /**
+   * 执行输出拦截器流水线
+   * @param text - 原始输出文本
+   * @param context - 拦截器上下文（不含 direction）
+   * @returns 处理后的文本
+   * @throws InterceptorRejectedError 拦截器返回 false 时抛出
+   */
+  async processOutput(text, context) {
+    return this.runPipeline(text, "output", context, this.outputInterceptors);
+  }
+  /**
+   * 执行拦截器流水线
+   */
+  async runPipeline(text, direction, context, interceptors) {
+    const fullContext = { ...context, direction };
+    let current = text;
+    for (const fn of interceptors) {
+      const result = await fn(current, fullContext);
+      if (result === false) {
+        throw new InterceptorRejectedError(direction);
+      }
+      if (typeof result === "string") {
+        current = result;
+      }
+    }
+    return current;
+  }
+};
+
+// src/process/process-handle.ts
+var import_node_child_process = require("child_process");
+var import_node_events = require("events");
+var import_node_readline = require("readline");
+var GRACE_PERIOD_MS = 5e3;
+var EphemeralProcess = class {
+  childProcess = null;
+  aborted = false;
+  /**
+   * 执行命令并收集输出。支持 AbortController 进行取消操作。
+   * @param options 进程启动选项
+   * @param abortSignal 可选的中止信号
+   * @returns 进程执行结果
+   */
+  async execute(options, abortSignal) {
+    return new Promise((resolve, reject) => {
+      if (abortSignal?.aborted) {
+        reject(new Error("Process aborted before start"));
+        return;
+      }
+      this.aborted = false;
+      const child = (0, import_node_child_process.spawn)(options.command, options.args, {
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : void 0,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      this.childProcess = child;
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      child.stdout?.on("data", (chunk) => {
+        stdoutChunks.push(chunk);
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk);
+      });
+      let timeoutTimer;
+      if (options.timeoutMs !== void 0 && options.timeoutMs > 0) {
+        timeoutTimer = setTimeout(() => {
+          this.terminate();
+          reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+      }
+      const onAbort = () => {
+        this.terminate();
+        reject(new Error("Process aborted"));
+      };
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+      child.on("error", (err) => {
+        if (timeoutTimer) clearTimeout(timeoutTimer);
+        abortSignal?.removeEventListener("abort", onAbort);
+        this.childProcess = null;
+        reject(err);
+      });
+      child.on("close", (code, signal) => {
+        if (timeoutTimer) clearTimeout(timeoutTimer);
+        abortSignal?.removeEventListener("abort", onAbort);
+        this.childProcess = null;
+        resolve({
+          exitCode: code,
+          signal,
+          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+          stderr: Buffer.concat(stderrChunks).toString("utf-8")
+        });
+      });
+    });
+  }
+  /**
+   * 以流式方式执行命令，逐行输出 stdout 内容。
+   * @param options 进程启动选项
+   * @param abortSignal 可选的中止信号
+   */
+  async *executeStreaming(options, abortSignal) {
+    if (abortSignal?.aborted) {
+      throw new Error("Process aborted before start");
+    }
+    this.aborted = false;
+    const useStdin = options.stdinData !== void 0;
+    const child = (0, import_node_child_process.spawn)(options.command, options.args, {
+      cwd: options.cwd,
+      env: options.env ?? void 0,
+      stdio: [useStdin ? "pipe" : "ignore", "pipe", "pipe"]
+    });
+    this.childProcess = child;
+    if (useStdin && child.stdin) {
+      child.stdin.write(options.stdinData, () => {
+        child.stdin.end();
+      });
+    }
+    let timeoutTimer;
+    if (options.timeoutMs !== void 0 && options.timeoutMs > 0) {
+      timeoutTimer = setTimeout(() => {
+        this.terminate();
+      }, options.timeoutMs);
+    }
+    const onAbort = () => {
+      this.terminate();
+    };
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    const stderrChunks = [];
+    child.stderr?.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    let exitCode = null;
+    const exitPromise = new Promise((resolve) => {
+      child.on("close", (code) => {
+        exitCode = code;
+        resolve();
+      });
+    });
+    const rl = (0, import_node_readline.createInterface)({ input: child.stdout });
+    let yieldedLines = 0;
+    try {
+      for await (const line of rl) {
+        yieldedLines++;
+        yield line;
+      }
+      await exitPromise;
+      if (exitCode !== 0 && yieldedLines === 0 && !this.aborted) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        throw new Error(
+          stderr || `Process exited with code ${exitCode}`
+        );
+      }
+    } finally {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      abortSignal?.removeEventListener("abort", onAbort);
+      rl.close();
+      this.childProcess = null;
+    }
+  }
+  /** 获取底层子进程的 PID */
+  get pid() {
+    return this.childProcess?.pid;
+  }
+  /** 终止进程：先发送 SIGTERM，超时后发送 SIGKILL */
+  terminate() {
+    if (!this.childProcess || this.aborted) return;
+    this.aborted = true;
+    this.childProcess.kill("SIGTERM");
+    const ref = this.childProcess;
+    setTimeout(() => {
+      if (!ref.killed) {
+        ref.kill("SIGKILL");
+      }
+    }, GRACE_PERIOD_MS);
+  }
+};
+var PersistentProcess = class extends import_node_events.EventEmitter {
+  process = null;
+  restartCount = 0;
+  stopped = false;
+  healthCheckTimer = null;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /** 启动持久进程 */
+  async start() {
+    this.stopped = false;
+    const child = (0, import_node_child_process.spawn)(this.options.command, this.options.args, {
+      cwd: this.options.cwd,
+      env: this.options.env ? { ...process.env, ...this.options.env } : void 0,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.process = child;
+    child.on("error", (err) => {
+      this.emit("error", err);
+    });
+    child.on("exit", (code) => {
+      this.process = null;
+      this.stopHealthCheck();
+      this.handleCrash(code);
+    });
+    if (this.options.healthCheckFn && this.options.healthCheckIntervalMs > 0) {
+      this.healthCheckTimer = setInterval(() => {
+        this.options.healthCheckFn().catch((err) => {
+          this.emit("healthCheckFailed", err);
+        });
+      }, this.options.healthCheckIntervalMs);
+    }
+    this.emit("started", child.pid);
+  }
+  /** 处理进程崩溃，按指数退避策略重启 */
+  handleCrash(code) {
+    if (this.stopped) return;
+    this.emit("exit", code);
+    if (this.restartCount < this.options.maxRestarts) {
+      const delay = this.options.restartIntervalMs * Math.pow(2, this.restartCount);
+      this.restartCount++;
+      this.emit("restart", this.restartCount);
+      setTimeout(() => {
+        if (!this.stopped) {
+          this.start().catch((err) => {
+            this.emit("fatal", err);
+          });
+        }
+      }, delay);
+    } else {
+      this.emit(
+        "fatal",
+        new Error(
+          `Max restarts (${this.options.maxRestarts}) exceeded, last exit code: ${code}`
+        )
+      );
+    }
+  }
+  /** 停止健康检查定时器 */
+  stopHealthCheck() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+  /** 停止持久进程 */
+  async stop() {
+    this.stopped = true;
+    this.stopHealthCheck();
+    if (this.process) {
+      const child = this.process;
+      child.kill("SIGTERM");
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+          resolve();
+        }, GRACE_PERIOD_MS);
+        child.on("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+      this.process = null;
+    }
+  }
+  /** 获取底层子进程的 PID */
+  get pid() {
+    return this.process?.pid;
+  }
+  /** 当前进程是否正在运行 */
+  get isRunning() {
+    return this.process !== null && !this.process.killed;
+  }
+};
+
+// src/process/process-manager.ts
+var ProcessManager = class _ProcessManager {
+  ephemeral = /* @__PURE__ */ new Map();
+  persistent = /* @__PURE__ */ new Map();
+  /** 全局静态标记，确保信号处理器只注册一次 */
+  static cleanupRegistered = false;
+  /** 所有活跃的 ProcessManager 实例（弱引用避免阻止 GC） */
+  static instances = /* @__PURE__ */ new Set();
+  constructor() {
+    _ProcessManager.instances.add(this);
+    _ProcessManager.registerCleanup();
+  }
+  /** 注册进程退出清理钩子（仅清理资源，不劫持宿主退出行为） */
+  static registerCleanup() {
+    if (_ProcessManager.cleanupRegistered) return;
+    _ProcessManager.cleanupRegistered = true;
+    const cleanup = () => {
+      for (const instance of _ProcessManager.instances) {
+        instance.terminateAllSync();
+      }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("SIGINT", cleanup);
+  }
+  /**
+   * 创建一次性进程实例并注册到管理器
+   * @param sessionId 会话标识
+   * @returns 一次性进程实例
+   */
+  createEphemeral(sessionId) {
+    const proc = new EphemeralProcess();
+    this.ephemeral.set(sessionId, proc);
+    return proc;
+  }
+  /**
+   * 从管理器中移除一次性进程
+   * @param sessionId 会话标识
+   */
+  removeEphemeral(sessionId) {
+    this.ephemeral.delete(sessionId);
+  }
+  /**
+   * 启动或获取持久进程
+   * @param backend 后端标识
+   * @param options 持久进程选项
+   * @returns 持久进程实例
+   */
+  async startPersistent(backend, options) {
+    const existing = this.persistent.get(backend);
+    if (existing?.isRunning) return existing;
+    const proc = new PersistentProcess(options);
+    this.persistent.set(backend, proc);
+    await proc.start();
+    return proc;
+  }
+  /**
+   * 获取指定后端的持久进程
+   * @param backend 后端标识
+   */
+  getPersistent(backend) {
+    return this.persistent.get(backend);
+  }
+  /**
+   * 获取指定会话的一次性进程
+   * @param sessionId 会话标识
+   */
+  getEphemeral(sessionId) {
+    return this.ephemeral.get(sessionId);
+  }
+  /** 异步终止所有托管进程 */
+  async terminateAll() {
+    const promises = [];
+    for (const [, proc] of this.ephemeral) {
+      proc.terminate();
+    }
+    for (const [, proc] of this.persistent) {
+      promises.push(proc.stop());
+    }
+    this.ephemeral.clear();
+    await Promise.allSettled(promises);
+    this.persistent.clear();
+  }
+  /** 同步终止所有托管进程（用于 exit 钩子） */
+  terminateAllSync() {
+    for (const [, proc] of this.ephemeral) {
+      proc.terminate();
+    }
+    for (const [, proc] of this.persistent) {
+      const pid = proc.pid;
+      if (pid) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * 销毁实例，从全局实例列表中移除
+   */
+  destroy() {
+    _ProcessManager.instances.delete(this);
+  }
+};
+
+// src/session/session-manager.ts
+var SessionManager = class {
+  cache = /* @__PURE__ */ new Map();
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * 注册适配器用于会话管理
+   * @param backend 后端标识
+   * @param adapter 适配器实例
+   */
+  registerAdapter(backend, adapter) {
+    this.adapters.set(backend, adapter);
+  }
+  /**
+   * 注销适配器
+   * @param backend 后端标识
+   */
+  unregisterAdapter(backend) {
+    this.adapters.delete(backend);
+  }
+  /**
+   * 获取指定后端的适配器，不存在时抛出错误
+   * @param backend 后端标识
+   */
+  getAdapter(backend) {
+    const adapter = this.adapters.get(backend);
+    if (!adapter) {
+      throw new AdapterNotFoundError(backend);
+    }
+    return adapter;
+  }
+  /**
+   * 列出指定后端的会话，结果会写入缓存
+   * @param backend 后端标识
+   * @param options 查询选项
+   */
+  async list(backend, options) {
+    const adapter = this.getAdapter(backend);
+    const sessions = await adapter.listSessions(options);
+    for (const session of sessions) {
+      this.cache.set(session.sessionId, session);
+    }
+    return sessions;
+  }
+  /**
+   * 从缓存中获取会话信息
+   * @param sessionId 会话 ID
+   */
+  get(sessionId) {
+    return this.cache.get(sessionId);
+  }
+  /**
+   * 恢复会话，委托适配器以 resume 标志执行查询
+   * @param backend 后端标识
+   * @param sessionId 要恢复的会话 ID
+   * @param prompt 提示词
+   */
+  async *resume(backend, sessionId, prompt) {
+    const adapter = this.getAdapter(backend);
+    yield* adapter.query({ prompt, resume: sessionId });
+  }
+  /**
+   * 从缓存中移除指定会话
+   * @param sessionId 会话 ID
+   */
+  evict(sessionId) {
+    this.cache.delete(sessionId);
+  }
+  /**
+   * 清空全部会话缓存
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+
+// src/adapters/claude/index.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_crypto = require("crypto");
+
+// src/adapters/base.ts
+function satisfiesRange(version, range) {
+  const parseVersion = (v) => {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+    if (!match) return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+  };
+  const trimmed = range.trim();
+  if (trimmed.startsWith(">=")) {
+    const rangeVersion2 = parseVersion(trimmed.slice(2));
+    const currentVersion2 = parseVersion(version);
+    if (!rangeVersion2 || !currentVersion2) return false;
+    for (let i = 0; i < 3; i++) {
+      if (currentVersion2[i] > rangeVersion2[i]) return true;
+      if (currentVersion2[i] < rangeVersion2[i]) return false;
+    }
+    return true;
+  }
+  if (trimmed.startsWith("<=")) {
+    const rangeVersion2 = parseVersion(trimmed.slice(2));
+    const currentVersion2 = parseVersion(version);
+    if (!rangeVersion2 || !currentVersion2) return false;
+    for (let i = 0; i < 3; i++) {
+      if (currentVersion2[i] < rangeVersion2[i]) return true;
+      if (currentVersion2[i] > rangeVersion2[i]) return false;
+    }
+    return true;
+  }
+  const rangeVersion = parseVersion(trimmed);
+  const currentVersion = parseVersion(version);
+  if (!rangeVersion || !currentVersion) return false;
+  return currentVersion[0] === rangeVersion[0] && currentVersion[1] === rangeVersion[1] && currentVersion[2] === rangeVersion[2];
+}
+var AbstractAgentAdapter = class {
+  /** 活跃的 AbortController 映射，按 sessionId 索引 */
+  abortControllers = /* @__PURE__ */ new Map();
+  processManager;
+  config;
+  constructor(processManager, config) {
+    this.processManager = processManager;
+    this.config = config;
+  }
+  /**
+   * 默认兼容性检查：获取当前版本并与 testedVersionRange 进行比较
+   */
+  async checkCompatibility() {
+    const warnings = [];
+    let version;
+    try {
+      version = await this.getVersion();
+    } catch {
+      return {
+        version: "unknown",
+        supported: false,
+        warnings: [`\u65E0\u6CD5\u83B7\u53D6 ${this.backend} \u7248\u672C\u4FE1\u606F`]
+      };
+    }
+    const capabilities = this.getCapabilities();
+    const supported = satisfiesRange(version, capabilities.testedVersionRange);
+    if (!supported) {
+      warnings.push(
+        `${this.backend} \u7248\u672C ${version} \u4E0D\u5728\u6D4B\u8BD5\u8303\u56F4 ${capabilities.testedVersionRange} \u5185\uFF0C\u53EF\u80FD\u5B58\u5728\u517C\u5BB9\u6027\u95EE\u9898`
+      );
+    }
+    return { version, supported, warnings };
+  }
+  /**
+   * 中止指定会话的执行
+   * @param sessionId 会话标识
+   */
+  abort(sessionId) {
+    const controller = this.abortControllers.get(sessionId);
+    if (controller) {
+      controller.abort();
+      this.abortControllers.delete(sessionId);
+    }
+  }
+  /**
+   * 创建并注册 AbortController
+   * @param sessionId 会话标识
+   * @returns AbortController 实例
+   */
+  createAbortController(sessionId) {
+    const existing = this.abortControllers.get(sessionId);
+    if (existing) {
+      existing.abort();
+    }
+    const controller = new AbortController();
+    this.abortControllers.set(sessionId, controller);
+    return controller;
+  }
+  /**
+   * 清理指定会话的 AbortController
+   * @param sessionId 会话标识
+   */
+  removeAbortController(sessionId) {
+    this.abortControllers.delete(sessionId);
+  }
+};
+
+// src/adapters/claude/types.ts
+function isSystemEvent(event) {
+  if (typeof event !== "object" || event === null) return false;
+  return event["type"] === "system";
+}
+function isAssistantEvent(event) {
+  if (typeof event !== "object" || event === null) return false;
+  const obj = event;
+  return obj["type"] === "assistant" && typeof obj["message"] === "object" && obj["message"] !== null;
+}
+function isStreamEvent(event) {
+  if (typeof event !== "object" || event === null) return false;
+  const obj = event;
+  return obj["type"] === "stream_event" && typeof obj["event"] === "object" && obj["event"] !== null;
+}
+function isResultEvent(event) {
+  if (typeof event !== "object" || event === null) return false;
+  const obj = event;
+  return obj["type"] === "result" && "result" in obj;
+}
+
+// src/adapters/claude/message-mapper.ts
+function mapClaudeEvent(event, sessionId) {
+  const timestamp = Date.now();
+  const resolvedSessionId = event.session_id ?? sessionId;
+  const baseFields = { timestamp, sessionId: resolvedSessionId, raw: event };
+  if (isSystemEvent(event)) {
+    return [{
+      ...baseFields,
+      type: "system",
+      model: event.model,
+      tools: event.tools,
+      cwd: event.cwd
+    }];
+  }
+  if (isAssistantEvent(event)) {
+    const content = event.message.content;
+    return mapAssistantContent(content, baseFields);
+  }
+  if (isStreamEvent(event)) {
+    const delta = event.event.delta;
+    if (delta?.type === "text_delta" && delta.text) {
+      return [{
+        ...baseFields,
+        type: "stream_chunk",
+        text: delta.text
+      }];
+    }
+    return [];
+  }
+  if (isResultEvent(event)) {
+    return [{
+      ...baseFields,
+      type: "result",
+      text: event.result,
+      costUsd: event.cost_usd,
+      durationMs: event.duration_ms,
+      inputTokens: event.input_tokens,
+      outputTokens: event.output_tokens
+    }];
+  }
+  return [];
+}
+function mapAssistantContent(blocks, baseFields) {
+  if (!blocks || blocks.length === 0) return [];
+  const messages = [];
+  const textParts = [];
+  for (const block of blocks) {
+    if (block.type === "text" && block.text) {
+      textParts.push(block.text);
+      messages.push({
+        ...baseFields,
+        type: "stream_chunk",
+        text: block.text
+      });
+    }
+  }
+  if (textParts.length > 0) {
+    messages.push({
+      ...baseFields,
+      type: "assistant",
+      text: textParts.join("\n"),
+      turnComplete: true
+    });
+  }
+  for (const block of blocks) {
+    if (block.type === "tool_use") {
+      messages.push({
+        ...baseFields,
+        type: "tool_use",
+        toolName: block.name,
+        input: block.input
+      });
+    }
+    if (block.type === "tool_result") {
+      messages.push({
+        ...baseFields,
+        type: "tool_use",
+        toolName: block.tool_use_id,
+        input: {},
+        output: block.content
+      });
+    }
+  }
+  return messages;
+}
+
+// src/adapters/claude/index.ts
+var CLAUDE_SETTINGS_PATH = (0, import_node_path.join)((0, import_node_os.homedir)(), ".claude", "settings.json");
+var CLAUDE_MODELS = [
+  { id: "sonnet", name: "Sonnet", provider: "anthropic" },
+  { id: "opus", name: "Opus", provider: "anthropic" },
+  { id: "haiku", name: "Haiku", provider: "anthropic" }
+];
+var ClaudeAdapter = class extends AbstractAgentAdapter {
+  backend = "claude";
+  /** CLI 命令名或路径 */
+  get cliCommand() {
+    return this.config?.cliPath ?? "claude";
+  }
+  /**
+   * 检查 Claude CLI 是否可用
+   */
+  async isAvailable() {
+    try {
+      const proc = new EphemeralProcess();
+      const result = await proc.execute({
+        command: "which",
+        args: [this.cliCommand]
+      });
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 获取 Claude CLI 版本号
+   */
+  async getVersion() {
+    const proc = new EphemeralProcess();
+    const result = await proc.execute({
+      command: this.cliCommand,
+      args: ["--version"]
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`\u83B7\u53D6 Claude \u7248\u672C\u5931\u8D25: ${result.stderr}`);
+    }
+    const output = result.stdout.trim();
+    const match = /(\d+\.\d+\.\d+)/.exec(output);
+    if (!match) {
+      throw new Error(`\u65E0\u6CD5\u89E3\u6790 Claude \u7248\u672C\u53F7: ${output}`);
+    }
+    return match[1];
+  }
+  /**
+   * 获取 Claude 适配器能力声明
+   */
+  getCapabilities() {
+    return {
+      features: /* @__PURE__ */ new Set([
+        "streaming",
+        "session-resume",
+        "system-prompt",
+        "tool-restriction",
+        "mcp",
+        "subagents",
+        "worktree",
+        "interactive-session"
+      ]),
+      streamingMode: "chunked",
+      outputFormats: ["text", "json", "stream-json"],
+      testedVersionRange: ">=1.0.0"
+    };
+  }
+  /**
+   * 向 Claude 发送提示并以流式方式接收响应
+   * @param request 提示请求参数
+   */
+  async *query(request) {
+    const sessionId = request.resume ?? (0, import_node_crypto.randomUUID)();
+    const controller = this.createAbortController(sessionId);
+    const proc = this.processManager.createEphemeral(sessionId);
+    try {
+      const args = this.buildArgs(request);
+      const cwd = request.cwd ?? this.config?.cwd;
+      const cleanEnv = {};
+      for (const [k, v] of Object.entries(process.env)) {
+        if (k !== "CLAUDECODE" && v !== void 0) {
+          cleanEnv[k] = v;
+        }
+      }
+      const proxyUrl = this.config?.proxy?.url;
+      if (proxyUrl) {
+        this.applyProxyEnv(cleanEnv, proxyUrl, this.config?.proxy?.noProxy);
+      }
+      if (request.envVars) {
+        for (const [k, v] of Object.entries(request.envVars)) {
+          if (v) cleanEnv[k] = v;
+        }
+      }
+      const stdinData = this.buildStdinData(request);
+      const streamOptions = {
+        command: this.cliCommand,
+        args,
+        ...cwd ? { cwd } : {},
+        env: cleanEnv,
+        timeoutMs: request.timeoutMs,
+        stdinData
+      };
+      const cmdStr = [this.cliCommand, ...args.map((a) => /[\s"']/.test(a) ? JSON.stringify(a) : a)].join(" ");
+      const debugCmd = cwd ? `cd ${JSON.stringify(cwd)} && ${cmdStr}` : cmdStr;
+      yield {
+        type: "system",
+        timestamp: Date.now(),
+        sessionId,
+        cwd,
+        raw: { debug_command: debugCmd }
+      };
+      for await (const line of proc.executeStreaming(
+        streamOptions,
+        controller.signal
+      )) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        const messages = mapClaudeEvent(parsed, sessionId);
+        for (const message of messages) {
+          yield message;
+        }
+      }
+    } finally {
+      this.removeAbortController(sessionId);
+      this.processManager.removeEphemeral(sessionId);
+    }
+  }
+  /**
+   * 列出 Claude 会话
+   * @param options 查询选项
+   */
+  async listSessions(options) {
+    const proc = new EphemeralProcess();
+    const args = ["sessions", "list", "--output", "json"];
+    if (options?.limit) {
+      args.push("--limit", String(options.limit));
+    }
+    const result = await proc.execute({
+      command: this.cliCommand,
+      args,
+      cwd: options?.cwd
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`\u83B7\u53D6 Claude \u4F1A\u8BDD\u5217\u8868\u5931\u8D25: ${result.stderr}`);
+    }
+    const output = result.stdout.trim();
+    if (!output) return [];
+    let rawSessions;
+    try {
+      rawSessions = JSON.parse(output);
+    } catch {
+      throw new Error(`\u89E3\u6790 Claude \u4F1A\u8BDD\u5217\u8868\u5931\u8D25: ${output.slice(0, 200)}`);
+    }
+    if (!Array.isArray(rawSessions)) return [];
+    return rawSessions.map((session) => {
+      const s = session;
+      return {
+        sessionId: String(s["id"] ?? s["session_id"] ?? ""),
+        backend: this.backend,
+        summary: typeof s["summary"] === "string" ? s["summary"] : void 0,
+        lastModified: typeof s["last_modified"] === "number" ? s["last_modified"] : typeof s["last_modified"] === "string" ? new Date(s["last_modified"]).getTime() : Date.now(),
+        cwd: typeof s["cwd"] === "string" ? s["cwd"] : void 0,
+        metadata: s
+      };
+    });
+  }
+  /**
+   * 获取 Claude 可用模型列表。
+   * Claude CLI 支持使用简短别名（sonnet/opus/haiku）自动选择当前最新版本。
+   */
+  async listModels() {
+    return CLAUDE_MODELS;
+  }
+  /**
+   * 读取 Claude 设置
+   */
+  async getSettings() {
+    try {
+      const content = await (0, import_promises.readFile)(CLAUDE_SETTINGS_PATH, "utf-8");
+      const parsed = JSON.parse(content);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * 更新 Claude 设置（读取-合并-写入）
+   * @param settings 要合并的设置项
+   */
+  async updateSettings(settings) {
+    const current = await this.getSettings();
+    const merged = { ...current, ...settings };
+    await (0, import_promises.writeFile)(
+      CLAUDE_SETTINGS_PATH,
+      JSON.stringify(merged, null, 2),
+      "utf-8"
+    );
+  }
+  /**
+   * 释放适配器资源
+   */
+  async dispose() {
+    for (const [sessionId] of this.abortControllers) {
+      this.abort(sessionId);
+    }
+  }
+  /**
+   * 将代理配置注入到环境变量中
+   * @param env 环境变量对象
+   * @param proxyUrl 代理地址
+   * @param noProxy 不走代理的地址列表
+   */
+  applyProxyEnv(env, proxyUrl, noProxy) {
+    env["http_proxy"] = proxyUrl;
+    env["https_proxy"] = proxyUrl;
+    env["HTTP_PROXY"] = proxyUrl;
+    env["HTTPS_PROXY"] = proxyUrl;
+    env["all_proxy"] = proxyUrl;
+    env["ALL_PROXY"] = proxyUrl;
+    if (noProxy) {
+      env["no_proxy"] = noProxy;
+      env["NO_PROXY"] = noProxy;
+    }
+  }
+  /**
+   * 构建通过 stdin 传递给 Claude CLI 的数据。
+   * 使用 stdin 而非 CLI 参数传递 prompt，避免超长参数导致的 403 错误。
+   */
+  buildStdinData(request) {
+    return request.prompt;
+  }
+  buildArgs(request) {
+    const args = [
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ];
+    if (request.resume) {
+      args.push("--resume", request.resume);
+    }
+    const model = request.model ?? this.config?.model;
+    if (model) {
+      args.push("--model", model);
+    }
+    if (request.systemPrompt) {
+      args.push("--system-prompt", request.systemPrompt);
+    }
+    const appendPrompt = request.appendSystemPrompt ?? this.config?.appendSystemPrompt;
+    if (appendPrompt) {
+      args.push("--append-system-prompt", appendPrompt);
+    }
+    if (request.allowedTools && request.allowedTools.length > 0) {
+      for (const tool of request.allowedTools) {
+        args.push("--allowedTools", tool);
+      }
+    }
+    if (request.disallowedTools && request.disallowedTools.length > 0) {
+      for (const tool of request.disallowedTools) {
+        args.push("--disallowedTools", tool);
+      }
+    }
+    if (request.maxTurns !== void 0) {
+      args.push("--max-turns", String(request.maxTurns));
+    }
+    const interactive = this.config?.interactive;
+    const skipPerms = interactive === false || request.backendOptions?.dangerouslySkipPermissions || this.config?.options?.dangerouslySkipPermissions;
+    if (skipPerms) {
+      args.push("--dangerously-skip-permissions");
+    }
+    if (request.mcpServers) {
+      for (const [name, config] of Object.entries(request.mcpServers)) {
+        const serverSpec = {
+          command: config.command,
+          ...config.args ? { args: config.args } : {},
+          ...config.env ? { env: config.env } : {},
+          ...config.url ? { url: config.url } : {}
+        };
+        args.push("--mcp-server", `${name}=${JSON.stringify(serverSpec)}`);
+      }
+    }
+    return args;
+  }
+};
+
+// src/adapters/opencode/index.ts
+var import_promises2 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+
+// src/adapters/opencode/types.ts
+var OpenCodeApiError = class extends Error {
+  statusCode;
+  responseBody;
+  constructor(statusCode, responseBody) {
+    super(`OpenCode API error (${statusCode}): ${responseBody}`);
+    this.name = "OpenCodeApiError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+  }
+};
+
+// src/adapters/opencode/api-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var OpenCodeApiClient = class {
+  baseUrl;
+  apiKey;
+  /**
+   * @param baseUrl opencode serve 服务的基础 URL，例如 http://localhost:39393
+   * @param apiKey 可选的 API Key，用于 Basic Auth 认证（username: opencode, password: apiKey）
+   */
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+  /**
+   * 创建新会话
+   * @param cwd 可选的工作目录
+   * @returns 包含会话 ID 的对象
+   */
+  async createSession(cwd) {
+    const body = {};
+    if (cwd) {
+      body.cwd = cwd;
+    }
+    const response = await this.request(
+      "/api/session",
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+    return response;
+  }
+  /**
+   * 获取所有会话列表
+   * @returns 会话数组
+   */
+  async listSessions() {
+    const response = await this.request(
+      "/api/sessions",
+      { method: "GET" }
+    );
+    return response.sessions;
+  }
+  /**
+   * 向指定会话发送消息
+   * @param sessionId 会话 ID
+   * @param content 消息内容
+   */
+  async sendMessage(sessionId, content) {
+    await this.request(
+      `/api/session/${encodeURIComponent(sessionId)}/message`,
+      {
+        method: "POST",
+        body: JSON.stringify({ content })
+      }
+    );
+  }
+  /**
+   * 以 SSE 流式方式订阅会话事件
+   * @param sessionId 会话 ID
+   * @param abortSignal 可选的中止信号
+   * @yields OpenCode SSE 事件
+   */
+  async *streamEvents(sessionId, abortSignal) {
+    const url = `${this.baseUrl}/api/session/${encodeURIComponent(sessionId)}/events`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache",
+        ...this.buildAuthHeaders()
+      },
+      signal: abortSignal
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new OpenCodeApiError(response.status, body);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null, SSE streaming unavailable");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split("\n\n");
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+          const event = this.parseSseEvent(part);
+          if (event) {
+            yield event;
+            if (event.type === "done") {
+              return;
+            }
+          }
+        }
+      }
+      if (buffer.trim()) {
+        const event = this.parseSseEvent(buffer);
+        if (event) {
+          yield event;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * 健康检查：验证 opencode serve 服务是否可达
+   * @returns 服务是否健康
+   */
+  async healthCheck() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.baseUrl}/api/sessions`, {
+        method: "GET",
+        headers: this.buildAuthHeaders(),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 解析单个 SSE 事件文本块
+   * @param raw 原始 SSE 文本块
+   * @returns 解析后的事件对象，解析失败返回 null
+   */
+  parseSseEvent(raw) {
+    const lines = raw.split("\n");
+    let data = "";
+    for (const line of lines) {
+      if (line.startsWith(":")) continue;
+      if (line.startsWith("data: ")) {
+        data += line.slice(6);
+      } else if (line.startsWith("data:")) {
+        data += line.slice(5);
+      }
+    }
+    if (!data) return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 发送 HTTP 请求的通用方法
+   * @param path API 路径
+   * @param init fetch 请求选项
+   * @returns 解析后的 JSON 响应
+   */
+  /**
+   * 构建包含认证信息的请求 headers
+   */
+  buildAuthHeaders() {
+    const headers = {};
+    if (this.apiKey) {
+      const credentials = Buffer.from(`opencode:${this.apiKey}`).toString("base64");
+      headers["Authorization"] = `Basic ${credentials}`;
+    }
+    return headers;
+  }
+  async request(path, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.buildAuthHeaders(),
+          ...init.headers
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new OpenCodeApiError(response.status, body);
+      }
+      const text = await response.text();
+      if (!text) return {};
+      return JSON.parse(text);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/adapters/opencode/message-mapper.ts
+function mapOpenCodeEventToMessage(event) {
+  const base = {
+    timestamp: event.timestamp ?? Date.now(),
+    sessionId: event.sessionId,
+    raw: event
+  };
+  switch (event.type) {
+    case "session.created":
+      return {
+        ...base,
+        type: "system",
+        model: event.model,
+        tools: event.tools,
+        cwd: event.cwd
+      };
+    case "message.delta":
+      return {
+        ...base,
+        type: "stream_chunk",
+        text: event.text
+      };
+    case "message.complete":
+      return {
+        ...base,
+        type: "result",
+        text: event.text,
+        durationMs: event.durationMs,
+        costUsd: event.costUsd,
+        inputTokens: event.inputTokens,
+        outputTokens: event.outputTokens
+      };
+    case "tool_use.start":
+      return {
+        ...base,
+        type: "tool_use",
+        toolName: event.toolName,
+        input: event.input
+      };
+    case "tool_use.complete":
+      return {
+        ...base,
+        type: "tool_use",
+        toolName: event.toolName,
+        input: event.input,
+        output: event.output
+      };
+    case "error":
+      return {
+        ...base,
+        type: "error",
+        message: event.message,
+        code: event.code
+      };
+    // message.start / tool_use.delta / done 事件不需要映射为独立消息
+    case "message.start":
+    case "tool_use.delta":
+    case "done":
+      return null;
+    default:
+      return null;
+  }
+}
+
+// src/adapters/opencode/index.ts
+var DEFAULT_SERVE_PORT = 39393;
+var SERVE_READY_TIMEOUT_MS = 3e4;
+var SERVE_POLL_INTERVAL_MS = 500;
+var TESTED_VERSION_RANGE = ">=0.1.0";
+var MAX_RESTARTS = 3;
+var RESTART_INTERVAL_MS = 2e3;
+var HEALTH_CHECK_INTERVAL_MS = 3e4;
+var OpenCodeAdapter = class extends AbstractAgentAdapter {
+  backend = "opencode";
+  apiClient = null;
+  servePort;
+  /** 远程服务器 URL（提供时跳过自启 serve） */
+  remoteServerUrl;
+  /** API Key（用于 Basic Auth） */
+  apiKey;
+  /**
+   * @param processManager 进程管理器实例
+   * @param config 可选的后端配置
+   *   - serverUrl: 远程 OpenCode 服务地址，提供时跳过自启 serve
+   *   - apiKey: API Key，用于 Basic Auth 认证
+   *   - options.servePort: 本地 serve 端口（仅自启模式）
+   */
+  constructor(processManager, config) {
+    super(processManager, config);
+    const opts = config?.options ?? {};
+    this.remoteServerUrl = config?.serverUrl ?? opts.serverUrl;
+    this.apiKey = config?.apiKey ?? opts.apiKey;
+    this.servePort = opts.servePort ?? DEFAULT_SERVE_PORT;
+  }
+  /**
+   * 检查 opencode 命令是否可用
+   */
+  async isAvailable() {
+    if (this.remoteServerUrl) {
+      try {
+        const client = new OpenCodeApiClient(this.remoteServerUrl, this.apiKey);
+        return await client.healthCheck();
+      } catch {
+        return false;
+      }
+    }
+    try {
+      const proc = new EphemeralProcess();
+      const result = await proc.execute({
+        command: "opencode",
+        args: ["--version"],
+        timeoutMs: 1e4
+      });
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 获取 opencode 版本号
+   */
+  async getVersion() {
+    const proc = new EphemeralProcess();
+    const result = await proc.execute({
+      command: "opencode",
+      args: ["version"],
+      timeoutMs: 1e4
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to get opencode version: ${result.stderr}`);
+    }
+    return result.stdout.trim();
+  }
+  /**
+   * 获取适配器能力声明
+   */
+  getCapabilities() {
+    return {
+      features: /* @__PURE__ */ new Set([
+        "streaming",
+        "session-resume",
+        "system-prompt",
+        "serve-mode"
+      ]),
+      streamingMode: "delta",
+      outputFormats: ["text"],
+      testedVersionRange: TESTED_VERSION_RANGE
+    };
+  }
+  /**
+   * 执行查询：启动 serve 进程（如未启动），创建/恢复会话，发送消息并流式返回结果
+   * @param request 请求参数
+   * @yields AgentMessage 统一消息流
+   */
+  async *query(request) {
+    const client = await this.ensureServeRunning();
+    let sessionId;
+    if (request.resume) {
+      sessionId = request.resume;
+    } else {
+      const session = await client.createSession(request.cwd);
+      sessionId = session.id;
+    }
+    const controller = this.createAbortController(sessionId);
+    try {
+      await client.sendMessage(sessionId, request.prompt);
+      for await (const event of client.streamEvents(
+        sessionId,
+        controller.signal
+      )) {
+        const message = mapOpenCodeEventToMessage(event);
+        if (message) {
+          yield message;
+        }
+      }
+    } finally {
+      this.removeAbortController(sessionId);
+    }
+  }
+  /**
+   * 列出历史会话
+   * @param options 查询选项
+   */
+  async listSessions(options) {
+    const client = await this.ensureServeRunning();
+    const sessions = await client.listSessions();
+    let filtered = sessions;
+    if (options?.cwd) {
+      filtered = filtered.filter((s) => s.cwd === options.cwd);
+    }
+    if (options?.limit !== void 0 && options.limit > 0) {
+      filtered = filtered.slice(0, options.limit);
+    }
+    return filtered.map((s) => ({
+      sessionId: s.id,
+      backend: this.backend,
+      summary: s.title,
+      lastModified: s.updatedAt,
+      cwd: s.cwd
+    }));
+  }
+  /**
+   * 获取 OpenCode 可用模型列表（通过 `opencode models` 命令）
+   */
+  async listModels() {
+    try {
+      const proc = new EphemeralProcess();
+      const result = await proc.execute({
+        command: "opencode",
+        args: ["models"],
+        timeoutMs: 15e3
+      });
+      if (result.exitCode !== 0) return [];
+      const lines = result.stdout.trim().split("\n").filter(Boolean);
+      return lines.map((line) => {
+        const trimmed = line.trim();
+        const slashIndex = trimmed.indexOf("/");
+        if (slashIndex >= 0) {
+          return {
+            id: trimmed,
+            name: trimmed.slice(slashIndex + 1),
+            provider: trimmed.slice(0, slashIndex)
+          };
+        }
+        return { id: trimmed, name: trimmed };
+      });
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * 读取 opencode 配置文件
+   */
+  async getSettings() {
+    const configPath = this.getConfigPath();
+    try {
+      const content = await (0, import_promises2.readFile)(configPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * 更新 opencode 配置文件（读取-合并-写入）
+   * @param settings 要合并的配置项
+   */
+  async updateSettings(settings) {
+    const configPath = this.getConfigPath();
+    const configDir = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".config", "opencode");
+    let existing;
+    try {
+      const content = await (0, import_promises2.readFile)(configPath, "utf-8");
+      existing = JSON.parse(content);
+    } catch {
+      existing = {};
+    }
+    const merged = { ...existing, ...settings };
+    await (0, import_promises2.mkdir)(configDir, { recursive: true });
+    await (0, import_promises2.writeFile)(configPath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  /**
+   * 释放资源：停止 serve 进程，中止所有活跃流
+   */
+  async dispose() {
+    for (const [sessionId] of this.abortControllers) {
+      this.abort(sessionId);
+    }
+    const persistent = this.processManager.getPersistent(this.backend);
+    if (persistent) {
+      await persistent.stop();
+    }
+    this.apiClient = null;
+  }
+  /**
+   * 确保 opencode serve 进程已启动并可用
+   * @returns 可用的 API 客户端
+   */
+  async ensureServeRunning() {
+    if (this.apiClient) {
+      const healthy = await this.apiClient.healthCheck();
+      if (healthy) return this.apiClient;
+    }
+    if (this.remoteServerUrl) {
+      const client2 = new OpenCodeApiClient(this.remoteServerUrl, this.apiKey);
+      const healthy = await client2.healthCheck();
+      if (!healthy) {
+        throw new Error(
+          `\u65E0\u6CD5\u8FDE\u63A5\u8FDC\u7A0B OpenCode \u670D\u52A1: ${this.remoteServerUrl}`
+        );
+      }
+      this.apiClient = client2;
+      return client2;
+    }
+    const client = new OpenCodeApiClient(
+      `http://localhost:${this.servePort}`,
+      this.apiKey
+    );
+    const alreadyRunning = await client.healthCheck();
+    if (alreadyRunning) {
+      this.apiClient = client;
+      return client;
+    }
+    await this.processManager.startPersistent(this.backend, {
+      command: "opencode",
+      args: ["serve", "--port", String(this.servePort)],
+      maxRestarts: MAX_RESTARTS,
+      restartIntervalMs: RESTART_INTERVAL_MS,
+      healthCheckIntervalMs: HEALTH_CHECK_INTERVAL_MS,
+      healthCheckFn: () => client.healthCheck().then((ok) => {
+        if (!ok) throw new Error("Health check failed");
+        return ok;
+      })
+    });
+    await this.waitForServeReady(client);
+    this.apiClient = client;
+    return client;
+  }
+  /**
+   * 轮询等待 serve 服务可达
+   * @param client API 客户端
+   */
+  async waitForServeReady(client) {
+    const deadline = Date.now() + SERVE_READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      const healthy = await client.healthCheck();
+      if (healthy) return;
+      await this.delay(SERVE_POLL_INTERVAL_MS);
+    }
+    throw new Error(
+      `opencode serve did not become ready within ${SERVE_READY_TIMEOUT_MS}ms`
+    );
+  }
+  /**
+   * 延迟指定毫秒
+   * @param ms 毫秒数
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 获取 opencode 配置文件路径
+   */
+  getConfigPath() {
+    return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".config", "opencode", "config.json");
+  }
+};
+
+// src/session/interactive-session.ts
+var InteractiveSession = class {
+  initialSessionId;
+  resolvedSessionId;
+  adapter;
+  baseRequest;
+  firstSent = false;
+  closed = false;
+  constructor(initialSessionId, adapter, baseRequest) {
+    this.initialSessionId = initialSessionId;
+    this.adapter = adapter;
+    this.baseRequest = baseRequest;
+  }
+  /** 当前生效的 sessionId（首次 send 后反映 CLI 返回的真实 ID） */
+  get sessionId() {
+    return this.resolvedSessionId ?? this.initialSessionId;
+  }
+  /** 会话是否仍然活跃 */
+  get isActive() {
+    return !this.closed;
+  }
+  /**
+   * 发送一条消息，返回流式响应。
+   * 首次调用使用 initialSessionId，后续自动附加 resume。
+   */
+  async *send(prompt) {
+    if (this.closed) {
+      throw new SessionNotFoundError(this.sessionId);
+    }
+    const request = {
+      ...this.baseRequest,
+      prompt,
+      ...this.firstSent ? { resume: this.sessionId } : {}
+    };
+    for await (const msg of this.adapter.query(request)) {
+      if (!this.firstSent && msg.sessionId) {
+        this.resolvedSessionId = msg.sessionId;
+      }
+      yield msg;
+    }
+    this.firstSent = true;
+  }
+  /** 关闭会话（仅清理内部状态，无进程需要释放） */
+  close() {
+    this.closed = true;
+  }
+};
+
+// src/porygon.ts
+var Porygon = class extends import_node_events2.EventEmitter {
+  config;
+  adapters = /* @__PURE__ */ new Map();
+  interceptors;
+  processManager;
+  sessionManager;
+  constructor(config) {
+    super();
+    this.config = ConfigLoader.load(config);
+    this.interceptors = new InterceptorManager();
+    this.processManager = new ProcessManager();
+    this.sessionManager = new SessionManager();
+    this.registerBuiltinAdapters();
+  }
+  /**
+   * 注册内置适配器
+   */
+  registerBuiltinAdapters() {
+    const claudeConfig = this.config.backends?.["claude"];
+    const mergedClaudeConfig = {
+      ...claudeConfig,
+      proxy: claudeConfig?.proxy ?? this.config.proxy
+    };
+    const claudeAdapter = new ClaudeAdapter(this.processManager, mergedClaudeConfig);
+    this.registerAdapter(claudeAdapter);
+    const opencodeConfig = this.config.backends?.["opencode"];
+    const mergedOpencodeConfig = {
+      ...opencodeConfig,
+      proxy: opencodeConfig?.proxy ?? this.config.proxy
+    };
+    const opencodeAdapter = new OpenCodeAdapter(this.processManager, mergedOpencodeConfig);
+    this.registerAdapter(opencodeAdapter);
+  }
+  /**
+   * 注册自定义适配器
+   * @param adapter 适配器实例
+   */
+  registerAdapter(adapter) {
+    this.adapters.set(adapter.backend, adapter);
+    this.sessionManager.registerAdapter(adapter.backend, adapter);
+  }
+  /**
+   * 获取指定后端的适配器
+   * @param backend 后端名称，默认使用配置中的 defaultBackend
+   */
+  getAdapter(backend) {
+    const name = backend ?? this.config.defaultBackend ?? "claude";
+    const adapter = this.adapters.get(name);
+    if (!adapter) throw new AdapterNotFoundError(name);
+    return adapter;
+  }
+  /**
+   * 流式查询，返回 AgentMessage 异步生成器。
+   * 作为与 LLM 后端交互的主要入口。
+   * @param request 提示请求参数
+   * @yields AgentMessage 消息流
+   */
+  async *query(request) {
+    const adapter = this.getAdapter(request.backend);
+    const backendName = adapter.backend;
+    const mergedRequest = this.mergeRequest(request, backendName);
+    const processedPrompt = await this.interceptors.processInput(
+      mergedRequest.prompt,
+      { backend: backendName, sessionId: mergedRequest.resume }
+    );
+    mergedRequest.prompt = processedPrompt;
+    for await (const message of adapter.query(mergedRequest)) {
+      if (message.type === "assistant" || message.type === "result") {
+        const processedText = await this.interceptors.processOutput(
+          message.text,
+          {
+            backend: backendName,
+            sessionId: message.sessionId,
+            messageType: message.type
+          }
+        );
+        yield { ...message, text: processedText };
+      } else {
+        yield message;
+      }
+    }
+  }
+  /**
+   * 简单运行模式，收集所有消息并返回最终结果文本
+   * @param request 提示请求参数
+   * @returns 最终结果文本
+   */
+  async run(request) {
+    let resultText = "";
+    for await (const msg of this.query(request)) {
+      if (msg.type === "result") {
+        resultText = msg.text;
+      } else if (msg.type === "assistant") {
+        resultText = msg.text;
+      }
+    }
+    return resultText;
+  }
+  /**
+   * 创建交互式多轮对话会话。
+   * 自动管理 sessionId 和 resume，对调用方透明。
+   */
+  session(options) {
+    const backend = options?.backend ?? this.config.defaultBackend ?? "claude";
+    const adapter = this.getAdapter(backend);
+    const merged = this.mergeRequest({ ...options, prompt: "" }, backend);
+    const { prompt: _, ...baseRequest } = merged;
+    return new InteractiveSession(
+      crypto.randomUUID(),
+      adapter,
+      baseRequest
+    );
+  }
+  /**
+   * 注册拦截器
+   * @param direction 拦截方向
+   * @param fn 拦截器函数
+   * @returns 取消注册的函数
+   */
+  use(direction, fn) {
+    return this.interceptors.use(direction, fn);
+  }
+  /**
+   * 获取后端能力声明
+   * @param backend 后端名称
+   */
+  getCapabilities(backend) {
+    return this.getAdapter(backend).getCapabilities();
+  }
+  /**
+   * 获取指定后端的可用模型列表
+   * @param backend 后端名称
+   */
+  async listModels(backend) {
+    return this.getAdapter(backend).listModels();
+  }
+  /**
+   * 检查单个后端的健康状态
+   * @param backend 后端名称
+   */
+  async checkBackend(backend) {
+    const adapter = this.getAdapter(backend);
+    try {
+      const available = await adapter.isAvailable();
+      if (!available) {
+        return { available: false };
+      }
+      const compat = await adapter.checkCompatibility();
+      const result = {
+        available: true,
+        version: compat.version,
+        supported: compat.supported
+      };
+      if (compat.warnings.length > 0) {
+        result.warnings = compat.warnings;
+      }
+      if (!compat.supported) {
+        this.emit("health:degraded", backend, compat.warnings.join("; "));
+      }
+      return result;
+    } catch (err) {
+      return {
+        available: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * 对所有已注册后端进行健康检查。
+   * 返回扁平化结构，包含 version/supported/warnings 等字段。
+   */
+  async healthCheck() {
+    const entries = Array.from(this.adapters.keys());
+    const checks = entries.map(async (name) => {
+      const result = await this.checkBackend(name);
+      return [name, result];
+    });
+    const settled = await Promise.allSettled(checks);
+    const results = {};
+    for (const item of settled) {
+      if (item.status === "fulfilled") {
+        const [name, result] = item.value;
+        results[name] = result;
+      }
+    }
+    return results;
+  }
+  /**
+   * 读取或更新后端设置
+   * @param backend 后端名称
+   * @param newSettings 要更新的设置项（可选）
+   * @returns 当前设置
+   */
+  async settings(backend, newSettings) {
+    const adapter = this.getAdapter(backend);
+    if (newSettings) {
+      await adapter.updateSettings(newSettings);
+    }
+    return adapter.getSettings();
+  }
+  /**
+   * 列出指定后端的会话
+   * @param backend 后端名称
+   * @param options 查询选项
+   */
+  async listSessions(backend, options) {
+    const name = backend ?? this.config.defaultBackend ?? "claude";
+    return this.sessionManager.list(name, options);
+  }
+  /**
+   * 中止正在运行的查询
+   * @param backend 后端名称
+   * @param sessionId 会话 ID
+   */
+  abort(backend, sessionId) {
+    this.getAdapter(backend).abort(sessionId);
+  }
+  /**
+   * 释放所有资源
+   */
+  async dispose() {
+    const promises = [];
+    for (const [, adapter] of this.adapters) {
+      promises.push(adapter.dispose());
+    }
+    await Promise.allSettled(promises);
+    await this.processManager.terminateAll();
+    this.adapters.clear();
+    this.sessionManager.clearCache();
+  }
+  /**
+   * 合并请求参数与配置默认值。
+   *
+   * 合并策略：
+   * - model: request > backendConfig > 不设置（后端使用自身默认值）
+   * - timeoutMs: request > defaults
+   * - maxTurns: request > defaults
+   * - cwd: request > backendConfig
+   * - appendSystemPrompt: **追加模式** — defaults + backendConfig + request 三层拼接（换行分隔）
+   *   但如果 request.systemPrompt 已设置（替换模式），则忽略所有 appendSystemPrompt
+   *
+   * @param request 原始请求
+   * @param backend 后端名称
+   * @returns 合并后的请求
+   */
+  mergeRequest(request, backend) {
+    const backendConfig = this.config.backends?.[backend];
+    const defaults = this.config.defaults;
+    const appendParts = [];
+    if (defaults?.appendSystemPrompt) {
+      appendParts.push(defaults.appendSystemPrompt);
+    }
+    if (backendConfig?.appendSystemPrompt) {
+      appendParts.push(backendConfig.appendSystemPrompt);
+    }
+    if (request.appendSystemPrompt) {
+      appendParts.push(request.appendSystemPrompt);
+    }
+    return {
+      ...request,
+      model: request.model ?? backendConfig?.model,
+      timeoutMs: request.timeoutMs ?? defaults?.timeoutMs,
+      maxTurns: request.maxTurns ?? defaults?.maxTurns,
+      cwd: request.cwd ?? backendConfig?.cwd,
+      appendSystemPrompt: request.systemPrompt ? void 0 : appendParts.length > 0 ? appendParts.join("\n") : void 0
+    };
+  }
+};
+function createPorygon(config) {
+  return new Porygon(config);
+}
+
+// src/interceptor/guard.ts
+var BUILTIN_INPUT_PATTERNS = [
+  // 中文
+  /忽略.{0,10}(之前|上面|以上|所有).{0,10}(指令|规则|提示|约束)/i,
+  /重复.{0,10}(系统|完整).{0,10}(提示|指令|prompt)/i,
+  /输出.{0,10}(系统|完整).{0,10}(提示|指令|prompt)/i,
+  /告诉我.{0,10}(系统|你的).{0,10}(提示|指令|prompt)/i,
+  /显示.{0,10}(系统|隐藏|完整).{0,10}(提示|指令|prompt)/i,
+  /你的(系统|初始).{0,10}(提示|指令|设定)/i,
+  // English
+  /ignore.{0,15}(previous|above|all|prior).{0,15}(instructions?|rules?|prompts?|constraints?)/i,
+  /repeat.{0,15}(system|full|entire|complete).{0,15}(prompt|instructions?|message)/i,
+  /reveal.{0,15}(system|hidden|full).{0,15}(prompt|instructions?)/i,
+  /show.{0,15}(system|hidden|full).{0,15}(prompt|instructions?)/i,
+  /what.{0,15}(is|are).{0,15}(your|the).{0,15}(system|initial).{0,15}(prompt|instructions?)/i,
+  /print.{0,15}(system|full|entire).{0,15}(prompt|instructions?|message)/i,
+  /disregard.{0,15}(previous|above|all|prior).{0,15}(instructions?|rules?)/i
+];
+function createInputGuard(options) {
+  const patterns = [
+    ...BUILTIN_INPUT_PATTERNS,
+    ...options?.blockedPatterns ?? []
+  ];
+  const action = options?.action ?? "reject";
+  const backends = options?.backends;
+  return (text, context) => {
+    if (backends && !backends.includes(context.backend)) {
+      return void 0;
+    }
+    for (const pattern of patterns) {
+      if (pattern.test(text)) {
+        if (action === "reject") {
+          return false;
+        }
+        return text.replace(pattern, "[REDACTED]");
+      }
+    }
+    if (options?.customCheck?.(text, context)) {
+      if (action === "reject") {
+        return false;
+      }
+      return "[REDACTED]";
+    }
+    return void 0;
+  };
+}
+function createOutputGuard(options) {
+  const keywords = options?.sensitiveKeywords ?? [];
+  const action = options?.action ?? "redact";
+  const backends = options?.backends;
+  return (text, context) => {
+    if (backends && !backends.includes(context.backend)) {
+      return void 0;
+    }
+    let matched = false;
+    let result = text;
+    for (const keyword of keywords) {
+      if (text.includes(keyword)) {
+        matched = true;
+        if (action === "redact") {
+          result = result.split(keyword).join("[REDACTED]");
+        }
+      }
+    }
+    if (!matched && options?.customCheck?.(text, context)) {
+      matched = true;
+      if (action === "redact") {
+        result = "[REDACTED]";
+      }
+    }
+    if (!matched) {
+      return void 0;
+    }
+    if (action === "reject") {
+      return false;
+    }
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractAgentAdapter,
+  AdapterIncompatibleError,
+  AdapterNotAvailableError,
+  AdapterNotFoundError,
+  AgentExecutionError,
+  AgentTimeoutError,
+  ClaudeAdapter,
+  ConfigValidationError,
+  InteractiveSession,
+  InterceptorRejectedError,
+  OpenCodeAdapter,
+  Porygon,
+  PorygonError,
+  SessionNotFoundError,
+  createInputGuard,
+  createOutputGuard,
+  createPorygon
+});
+//# sourceMappingURL=index.cjs.map