@ken-jo/agent-connector 0.1.0

package/dist/opencode-FZ33JKUZ.js

@@ -0,0 +1,734 @@
+#!/usr/bin/env node
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-TIIP3RG2.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildServeWrapperCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/opencode/index.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HOST = "opencode";
+var MCP_ROOT_KEY = "mcp";
+var EVENT_TO_OPENCODE = {
+  PreToolUse: "tool.execute.before",
+  PostToolUse: "tool.execute.after",
+  // OpenCode lacks a real SessionStart hook (#14808 / #5409). The verified
+  // surrogate is experimental.chat.system.transform, which receives the system
+  // prompt array; we inject additionalContext there.
+  SessionStart: "experimental.chat.system.transform"
+};
+var OpenCodeAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "OpenCode";
+  paradigm = "ts-plugin";
+  capabilities = {
+    preToolUse: true,
+    postToolUse: true,
+    // OpenCode's compaction hook is experimental and not wired here.
+    preCompact: false,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: false,
+    stop: false,
+    notification: false,
+    // tool.execute.before mutates output.args → input rewrite supported.
+    canModifyArgs: true,
+    // tool.execute.after mutates output.output → output rewrite supported.
+    canModifyOutput: true,
+    // injected via experimental.chat.system.transform at session start.
+    canInjectSessionContext: true,
+    transports: ["stdio", "sse", "http"],
+    // Content surfaces: OpenCode authors all three natively under <ocDir>.
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: true
+  };
+  // ── Detection ──────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userConfigDir = join(homedir(), ".config", "opencode");
+    const userConfig = join(userConfigDir, "opencode.json");
+    const projectConfig = join(projectDir, "opencode.json");
+    const userInstalled = existsSync(userConfigDir) || existsSync(userConfig);
+    const projInstalled = existsSync(projectConfig);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projectConfig : userConfig;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? scope === "project" ? `found project OpenCode config at ${projectConfig}` : `found OpenCode config under ${userConfigDir}` : `no OpenCode config at ${userConfigDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ───────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? ctx.projectDir : join(homedir(), ".config", "opencode");
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "opencode.json");
+  }
+  /**
+   * For ts-plugin hosts the "hook config path" is the generated plugin FILE.
+   * OpenCode auto-loads every file in the plugin dir; writing this file IS the
+   * registration.
+   */
+  getHookConfigPath(ctx) {
+    return join(this.pluginDir(ctx), this.pluginFileName(ctx));
+  }
+  /** Plugin directory OpenCode auto-loads modules from, per scope. */
+  pluginDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".opencode", "plugin") : join(homedir(), ".config", "opencode", "plugin");
+  }
+  /** Plugin module file name (one per connector, kebab-case id). */
+  pluginFileName(ctx) {
+    return `${ctx.connector.id}.js`;
+  }
+  // ── MCP server install / uninstall ─────────────────────────────────────
+  installServer(ctx) {
+    const server = this.effectiveServer(ctx);
+    const serverPath = this.getServerConfigPath(ctx);
+    if (!server) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: serverPath,
+          detail: ctx.connector.server ? "server registration disabled for opencode" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const entry = this.renderServerEntry(ctx, server);
+    return [
+      this.upsertServerInJson(
+        serverPath,
+        MCP_ROOT_KEY,
+        ctx.connector.id,
+        entry,
+        ctx.dryRun
+      )
+    ];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [
+      this.removeServerFromJson(
+        serverPath,
+        MCP_ROOT_KEY,
+        ctx.connector.id,
+        ctx.dryRun
+      )
+    ];
+  }
+  /** Resolve the per-platform server override into an effective ServerDef. */
+  effectiveServer(ctx) {
+    const override = ctx.connector.platforms[HOST]?.server;
+    if (override === false) return void 0;
+    const base = ctx.connector.server;
+    if (!base) return void 0;
+    return override && typeof override === "object" ? { ...base, ...override } : base;
+  }
+  /**
+   * Render a normalized ServerDef into OpenCode's native "mcp" entry.
+   *
+   * stdio  → { type: "local", command: [exe, ...args], environment }
+   * remote → { type: "remote", url }
+   *
+   * OpenCode flattens command+args into a single ARRAY. When telemetry wrapping
+   * applies, the wrapper's command+args (which already include the real command
+   * tail after `--`) become the head of that array.
+   */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      if (shouldWrapForTelemetry(server, ctx.connector.telemetry)) {
+        const wrapped = buildServeWrapperCommand(
+          ctx.homeBinPath,
+          ctx.connector.id,
+          command,
+          args,
+          ctx.scope,
+          this.id
+        );
+        command = wrapped.command;
+        args = wrapped.args;
+      }
+      const commandArray = resolveEnvRefsDeep([command, ...args]).filter(
+        (s) => s !== ""
+      );
+      const entry2 = {
+        type: "local",
+        command: commandArray
+      };
+      const environment = this.renderEnv(server.env);
+      if (environment) entry2.environment = environment;
+      if (server.enabled === false) entry2.enabled = false;
+      return entry2;
+    }
+    const entry = {
+      type: "remote",
+      url: resolveEnvRefsDeep(server.url ?? "")
+    };
+    if (server.enabled === false) entry.enabled = false;
+    return entry;
+  }
+  /**
+   * Render env values. OpenCode documents no native interpolation token, so
+   * resolve every ${env:VAR} reference to a literal at install time.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    return resolveEnvRefsDeep({ ...env });
+  }
+  // ── Hook install / uninstall (ts-plugin) ───────────────────────────────
+  installHooks(ctx) {
+    const pluginPath = this.getHookConfigPath(ctx);
+    if (ctx.connector.platforms[HOST]?.hooks === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: pluginPath,
+          detail: "hooks disabled for opencode"
+        }
+      ];
+    }
+    if (ctx.connector.hookEvents.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: pluginPath,
+          detail: "connector declares no hooks"
+        }
+      ];
+    }
+    const files = this.synthesizePlugin(ctx);
+    const changes = [];
+    for (const file of files) {
+      const before = existsSync(file.path) ? this.safeRead(file.path) : void 0;
+      let action;
+      if (before === void 0) action = "create";
+      else if (before === file.contents) action = "skip";
+      else action = "update";
+      if (action !== "skip" && !ctx.dryRun) {
+        ensureDir(dirname(file.path));
+        writeFileSync(file.path, file.contents, "utf8");
+        chmodSync(file.path, file.executable ? 493 : 420);
+      }
+      changes.push({
+        platform: this.id,
+        action,
+        path: file.path,
+        detail: `opencode plugin module (${this.hookDetail(ctx)})`
+      });
+    }
+    return changes;
+  }
+  /**
+   * Human-facing summary of which declared events the synthesized module ACTUALLY
+   * wires. Only events present in EVENT_TO_OPENCODE are mapped/wired; any declared
+   * event with no OpenCode mapping (e.g. UserPromptSubmit) is reported separately
+   * as "unsupported here" so the detail never overstates coverage.
+   */
+  hookDetail(ctx) {
+    const declared = ctx.connector.hookEvents;
+    const mapped = declared.filter((e) => EVENT_TO_OPENCODE[e] !== void 0);
+    const unsupported = declared.filter((e) => EVENT_TO_OPENCODE[e] === void 0);
+    const base = mapped.join(",");
+    return unsupported.length > 0 ? `${base}; unsupported here: ${unsupported.join(",")}` : base;
+  }
+  uninstallHooks(ctx) {
+    const pluginPath = this.getHookConfigPath(ctx);
+    if (!existsSync(pluginPath)) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: pluginPath,
+          detail: "no opencode plugin module present"
+        }
+      ];
+    }
+    if (!ctx.dryRun) rmSync(pluginPath, { force: true });
+    return [
+      {
+        platform: this.id,
+        action: "remove",
+        path: pluginPath,
+        detail: "opencode plugin module"
+      }
+    ];
+  }
+  // ── Content surfaces: commands / skills / subagents ──────────────────────
+  // CONTENT-ONLY: pure native-file writers under <ocDir>/{commands,skills,
+  // agent}. No runtime dispatch, no home-bin pointer, no telemetry wrap. Each
+  // method is idempotent (byte-identical → skip) via BaseAdapter.writeContentFile
+  // and reversible via removeContentFile. Honors platforms["opencode"]
+  // per-surface false to skip. <ocDir> is reused from getConfigDir (user
+  // ~/.config/opencode, project <projectDir>/.opencode).
+  //
+  // NOTE on dirs: commands live in commands/<name>.md and skills in
+  // skills/<name>/SKILL.md, but subagents use the SINGULAR "agent/" dir
+  // (agent/<name>.md) — the OpenCode loader/CLI historically uses singular
+  // (anomalyco/opencode#14410); singular is the safe choice.
+  commandsDir(ctx) {
+    return join(this.getConfigDir(ctx), "commands");
+  }
+  skillsDir(ctx) {
+    return join(this.getConfigDir(ctx), "skills");
+  }
+  agentDir(ctx) {
+    return join(this.getConfigDir(ctx), "agent");
+  }
+  /** Native command file path: <ocDir>/commands/<name>.md. */
+  commandPath(ctx, name) {
+    return join(this.commandsDir(ctx), `${name}.md`);
+  }
+  /** Native skill dir: <ocDir>/skills/<name>. */
+  skillDir(ctx, name) {
+    return join(this.skillsDir(ctx), name);
+  }
+  /** Native subagent file path: <ocDir>/agent/<name>.md (SINGULAR dir). */
+  subagentPath(ctx, name) {
+    return join(this.agentDir(ctx), `${name}.md`);
+  }
+  // ── Commands ──────────────────────────────────────────────────────────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for opencode" }];
+    }
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.writeContentFile(
+        this.commandPath(ctx, cmd.name),
+        this.renderCommand(cmd),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.removeContentFile(this.commandPath(ctx, cmd.name), ctx.dryRun)
+    );
+  }
+  /** Render a command to md+frontmatter (description, agent, model, subtask). */
+  renderCommand(cmd) {
+    const frontmatter = {};
+    if (cmd.description !== void 0) frontmatter.description = cmd.description;
+    if (cmd.model !== void 0) frontmatter.model = cmd.model;
+    if (cmd.subtask !== void 0) frontmatter.subtask = cmd.subtask;
+    if (cmd.extra) Object.assign(frontmatter, cmd.extra);
+    return this.renderFrontmatterMd(frontmatter, cmd.prompt);
+  }
+  // ── Skills ────────────────────────────────────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for opencode" }];
+    }
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(
+        this.writeContentFile(join(dir, "SKILL.md"), this.renderSkill(skill), ctx.dryRun)
+      );
+      for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            detail: `skill resource "${rel}" escapes the skill dir; skipped`
+          });
+          continue;
+        }
+        changes.push(this.writeContentFile(target, contents, ctx.dryRun));
+      }
+    }
+    return changes;
+  }
+  uninstallSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(this.removeContentFile(join(dir, "SKILL.md"), ctx.dryRun));
+      for (const rel of Object.keys(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) continue;
+        changes.push(this.removeContentFile(target, ctx.dryRun));
+      }
+      changes.push(this.removeDirIfEmpty(dir, ctx.dryRun));
+    }
+    return changes;
+  }
+  /**
+   * Render a skill's SKILL.md (UNIFORM across platforms): frontmatter
+   * (name, description + optional model, allowed-tools, disable-model-invocation)
+   * + markdown body. Only the parent dir differs per platform.
+   */
+  renderSkill(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.model !== void 0) frontmatter.model = skill.model;
+    const allow = skill.tools?.allow;
+    if (allow && allow.length > 0) frontmatter["allowed-tools"] = allow.join(", ");
+    if (skill.disableModelInvocation !== void 0) {
+      frontmatter["disable-model-invocation"] = skill.disableModelInvocation;
+    }
+    if (skill.extra) Object.assign(frontmatter, skill.extra);
+    return this.renderFrontmatterMd(frontmatter, skill.body);
+  }
+  // ── Subagents ───────────────────────────────────────────────────────────────
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for opencode" }];
+    }
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => this.writeContentFile(
+        this.subagentPath(ctx, agent.name),
+        this.renderSubagent(agent),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => this.removeContentFile(this.subagentPath(ctx, agent.name), ctx.dryRun)
+    );
+  }
+  /**
+   * Render a subagent to md+frontmatter. OpenCode's shape is
+   * (description, mode:"subagent", model, permission) with the system prompt as
+   * the body. `name` is NOT a frontmatter field — it comes from the filename.
+   * `permission` is derived from the coarse `readonly` knob: a readonly agent
+   * gets a per-tool deny map (edit/bash) so it cannot mutate the workspace.
+   */
+  renderSubagent(agent) {
+    const frontmatter = {
+      description: agent.description,
+      mode: "subagent"
+    };
+    if (agent.model !== void 0) frontmatter.model = agent.model;
+    if (agent.readonly === true) {
+      frontmatter.permission = { edit: "deny", bash: "deny" };
+    }
+    if (agent.extra) Object.assign(frontmatter, agent.extra);
+    return this.renderFrontmatterMd(frontmatter, agent.prompt);
+  }
+  // ── ts-plugin synthesis ────────────────────────────────────────────────
+  /**
+   * Build ONE self-contained ESM bridge module for OpenCode.
+   *
+   * The module imports nothing from agent-connector. It embeds two constants
+   * (the absolute home-bin path and the connector id) and a `bridge()` helper
+   * that shells out to the universal hook entrypoint via execFileSync, feeding
+   * the OpenCode payload on stdin and JSON.parsing the normalized HookResponse
+   * back from stdout (fail-open: any error → null). Its default export is the
+   * OpenCode plugin factory returning an object keyed only by the OpenCode event
+   * names for the events this connector actually declares.
+   */
+  synthesizePlugin(ctx) {
+    const path = this.getHookConfigPath(ctx);
+    const contents = this.buildPluginSource(ctx);
+    return [{ path, contents, executable: false }];
+  }
+  /** Compose the generated plugin source with plain string concatenation. */
+  buildPluginSource(ctx) {
+    const homeBin = JSON.stringify(ctx.homeBinPath);
+    const connectorId = JSON.stringify(ctx.connector.id);
+    const events = ctx.connector.hookEvents.filter(
+      (e) => EVENT_TO_OPENCODE[e] !== void 0
+    );
+    const has = (e) => events.includes(e);
+    const header = `/**
+ * AUTO-GENERATED by agent-connector \u2014 DO NOT EDIT.
+ *
+ * Self-contained OpenCode plugin bridge for connector ${ctx.connector.id}.
+ * It imports nothing from agent-connector: every hook invocation shells out to
+ * the stable home binary's universal entrypoint and JSON-parses the normalized
+ * response. Fail-open: any bridge error degrades to "allow".
+ */
+import { execFileSync, execSync } from "node:child_process";
+
+const HOME_BIN = ${homeBin};
+const CONNECTOR_ID = ${connectorId};
+
+/**
+ * Invoke the universal hook entrypoint for one event.
+ * @param {string} event canonical event name (PreToolUse|PostToolUse|SessionStart)
+ * @param {object} payload OpenCode-shaped payload posted on stdin
+ * @returns {object|null} normalized HookResponse, or null on any failure
+ */
+function bridge(event, payload) {
+  try {
+    // On Windows HOME_BIN is the agent-connector.cmd launcher: Node cannot
+    // execFile a batch file, and shell+args is deprecated (DEP0190), so run one
+    // quoted command line via a shell. POSIX keeps the direct execFile (no shell).
+    const args = ["hook", "opencode", event, "--connector", CONNECTOR_ID];
+    const opts = { input: JSON.stringify(payload), encoding: "utf8" };
+    const stdout =
+      process.platform === "win32"
+        ? execSync([HOME_BIN, ...args].map((a) => '"' + a + '"').join(" "), opts)
+        : execFileSync(HOME_BIN, args, opts);
+    const text = (stdout || "").trim();
+    if (text === "") return { decision: "allow" };
+    return JSON.parse(text);
+  } catch {
+    // Fail-open \u2014 never wedge a tool call on a bridge error.
+    return null;
+  }
+}
+`;
+    const handlers = [];
+    if (has("PreToolUse")) {
+      handlers.push(`    // PreToolUse \u2192 block (throw) / rewrite args (mutate output.args).
+    "tool.execute.before": async (input, output) => {
+      const payload = {
+        toolName: input.tool ?? "",
+        toolInput: (output && output.args) ?? {},
+        sessionId: input.sessionID ?? "",
+        projectDir: PROJECT_DIR,
+      };
+      const res = bridge("PreToolUse", payload);
+      if (!res) return;
+      // OpenCode has no "ask" gate \u2014 degrade "ask" to a block (safe direction).
+      if (res.decision === "deny" || res.decision === "ask") {
+        throw new Error(res.reason || "Blocked by ${ctx.connector.id}");
+      }
+      if (res.updatedInput && output && output.args) {
+        Object.assign(output.args, res.updatedInput);
+      }
+    },`);
+    }
+    if (has("PostToolUse")) {
+      handlers.push(`    // PostToolUse \u2192 observe / rewrite tool output (mutate output.output).
+    "tool.execute.after": async (input, output) => {
+      const payload = {
+        toolName: input.tool ?? "",
+        toolInput: input.args ?? {},
+        toolOutput: output ? output.output : undefined,
+        sessionId: input.sessionID ?? "",
+        projectDir: PROJECT_DIR,
+      };
+      const res = bridge("PostToolUse", payload);
+      if (!res) return;
+      if (typeof res.updatedOutput === "string" && output) {
+        output.output = res.updatedOutput;
+      }
+    },`);
+    }
+    if (has("SessionStart")) {
+      handlers.push(`    // SessionStart surrogate \u2192 inject context into the system prompt.
+    // OpenCode has no real SessionStart hook (#14808 / #5409); the
+    // experimental.chat.system.transform hook is the verified injection point.
+    "experimental.chat.system.transform": async (input, output) => {
+      const payload = {
+        sessionId: (input && input.sessionID) ?? "",
+        projectDir: PROJECT_DIR,
+      };
+      const res = bridge("SessionStart", payload);
+      if (!res) return;
+      if (res.additionalContext && output && Array.isArray(output.system)) {
+        // Insert at index 1 (after the header) to preserve OpenCode's
+        // prompt-cache fold (header must remain system[0]).
+        output.system.splice(1, 0, res.additionalContext);
+      }
+    },`);
+    }
+    const factory = `
+export default async function (ctx) {
+  // ctx.directory is the OpenCode project root; fall back to cwd.
+  const PROJECT_DIR =
+    (ctx && (ctx.directory || (ctx.worktree && ctx.worktree.path))) ||
+    process.cwd();
+
+  return {
+${handlers.join("\n")}
+  };
+}
+`;
+    return header + factory;
+  }
+  // ── Runtime: parse OUR bridge payload → normalized event ───────────────
+  /**
+   * `raw` is the payload OUR generated plugin posts (NOT a host-native shape):
+   *   { toolName, toolInput, toolOutput?, isError?, sessionId, projectDir }
+   * so this maps straight through.
+   */
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const base = {
+      hostPlatform: HOST,
+      connectorId: "",
+      sessionId: typeof input.sessionId === "string" ? input.sessionId : "",
+      raw,
+      ...typeof input.projectDir === "string" ? { projectDir: input.projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.toolName ?? "",
+          toolInput: input.toolInput ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.toolName ?? "",
+          toolInput: input.toolInput ?? {},
+          ...typeof input.toolOutput === "string" ? { toolOutput: input.toolOutput } : {},
+          ...typeof input.isError === "boolean" ? { isError: input.isError } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = { ...base, source: "startup" };
+        return ev;
+      }
+      default:
+        return { ...base, source: "startup" };
+    }
+  }
+  // ── Runtime: normalized response → reply the generated bridge parses ───
+  /**
+   * Unlike json-stdio hosts (whose reply is the host's NATIVE control payload),
+   * OUR generated bridge consumes this stdout directly. So the reply body is the
+   * NORMALIZED HookResponse itself — the bridge JSON.parses it and reads
+   * decision / updatedInput / updatedOutput / additionalContext.
+   */
+  formatReply(_event, response) {
+    return {
+      exitCode: 0,
+      stdout: JSON.stringify(response ?? { decision: "allow" })
+    };
+  }
+  // ── Diagnostics ────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    const pluginPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const hasHooks = ctx.connector.hookEvents.length > 0;
+    const checks = [
+      {
+        name: `${this.name}: opencode.json present`,
+        check: () => existsSync(serverPath) ? { status: "OK", detail: serverPath } : { status: "FAIL", detail: `not found: ${serverPath}` }
+      },
+      {
+        name: `${this.name}: mcp.${connectorId} registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          const cfg = this.readJson(
+            serverPath
+          );
+          const bucket = cfg?.[MCP_ROOT_KEY];
+          if (!cfg || !bucket) {
+            return { status: "FAIL", detail: `no ${MCP_ROOT_KEY} in ${serverPath}` };
+          }
+          return connectorId in bucket ? { status: "OK", detail: `${MCP_ROOT_KEY}.${connectorId} present` } : {
+            status: "FAIL",
+            detail: `no ${MCP_ROOT_KEY}.${connectorId} in ${serverPath}`
+          };
+        }
+      },
+      {
+        name: `${this.name}: plugin module present`,
+        check: () => {
+          if (!hasHooks) return { status: "OK", detail: "no hooks declared" };
+          return existsSync(pluginPath) ? { status: "OK", detail: pluginPath } : { status: "FAIL", detail: `not found: ${pluginPath}` };
+        }
+      }
+    ];
+    for (const cmd of ctx.connector.commands) {
+      const p = this.commandPath(ctx, cmd.name);
+      checks.push({
+        name: `${this.name}: command ${cmd.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const skill of ctx.connector.skills) {
+      const p = join(this.skillDir(ctx, skill.name), "SKILL.md");
+      checks.push({
+        name: `${this.name}: skill ${skill.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const agent of ctx.connector.subagents) {
+      const p = this.subagentPath(ctx, agent.name);
+      checks.push({
+        name: `${this.name}: subagent ${agent.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    return checks;
+  }
+  /** Read a file, returning undefined on any error (idempotency compare). */
+  safeRead(path) {
+    try {
+      return readFileSync(path, "utf8");
+    } catch {
+      return void 0;
+    }
+  }
+};
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+var adapter = new OpenCodeAdapter();
+var opencode_default = adapter;
+export {
+  OpenCodeAdapter,
+  adapter,
+  opencode_default as default
+};
+//# sourceMappingURL=opencode-FZ33JKUZ.js.map