@ken-jo/agent-connector 0.4.0 → 0.4.6

package/dist/continue-K43SUHLQ.js

@@ -0,0 +1,790 @@
+#!/usr/bin/env node
+import {
+  readYaml,
+  writeYaml
+} from "./chunk-EXLS7BSI.js";
+import {
+  extractSessionId,
+  toolResponseToString
+} from "./chunk-WZA4CSGJ.js";
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-CPLK7GTE.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildHomeBinHookCommand,
+  buildServeWrapperCommand,
+  isHomeBinHookCommand,
+  shouldWrapForTelemetry
+} from "./chunk-I5MLE6S7.js";
+import "./chunk-N6HH7K6P.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/continue/index.ts
+import { existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join } from "path";
+var HOST = "continue";
+var MCP_ROOT_KEY = "mcpServers";
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set([
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "UserPromptSubmit",
+  "SessionStart",
+  "SessionEnd",
+  "Stop",
+  "Notification",
+  "SubagentStart",
+  "SubagentStop",
+  "PermissionRequest",
+  "PreCompact"
+]);
+var ContinueAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Continue";
+  paradigm = "json-stdio";
+  capabilities = {
+    // Memory surface: WIRED. Continue reads `.continue/rules/*.md` (NOT
+    // AGENTS.md), so the AGENTS.md-first BaseAdapter default does not apply — the
+    // installMemory/uninstallMemory overrides below write a DEDICATED
+    // agent-connector-owned file (<projectDir>/.continue/rules/agent-connector.md)
+    // that LEADS with `alwaysApply: true` frontmatter (always-included). Project
+    // scope only; user scope skip-warns (no verified user/global rules dir).
+    supportsMemory: true,
+    //
+    // json-stdio: the `cn` CLI ships a Claude-Code-COMPATIBLE hooks system (PR
+    // #11029). Every event in HOOK_EVENT_NAMES ∩ canonical fires natively; the
+    // names are PascalCase 1:1 with Claude. PreCompact IS in continue's set
+    // (PreCompactInput); only PostCompact is absent → that stays false (install
+    // warn-skips it).
+    preToolUse: true,
+    postToolUse: true,
+    postToolUseFailure: true,
+    preCompact: true,
+    sessionStart: true,
+    sessionEnd: true,
+    userPromptSubmit: true,
+    stop: true,
+    notification: true,
+    subagentStart: true,
+    subagentStop: true,
+    permissionRequest: true,
+    // Continue's PreToolUse output carries updatedInput (HookOutput
+    // PreToolUseHookOutput.updatedInput) → it CAN rewrite tool input. It cannot
+    // rewrite already-emitted tool output (PostToolUse exposes updatedMCPToolOutput,
+    // but — matching the claude-code adapter's conservative stance — we do not
+    // wire output rewrite). It honors hookSpecificOutput.additionalContext.
+    canModifyArgs: true,
+    canModifyOutput: false,
+    canInjectSessionContext: true,
+    // Continue registers stdio + remote (SSE / Streamable HTTP) MCP servers
+    // (primary-verified: type ∈ stdio|sse|streamable-http). Mapped to the
+    // framework's transport enum: stdio + sse + http (http = streamable-http).
+    transports: ["stdio", "sse", "http"],
+    // Native (passthrough) hooks: continue's HOOK_EVENT_NAMES carries five
+    // host-specific events with NO canonical analog — ConfigChange, TeammateIdle,
+    // TaskCompleted, WorktreeCreate, WorktreeRemove (each a real HookInput
+    // member, types.ts:214-241). They sit below the ≥3-host promotion bar, so a
+    // connector reaches them via platforms.continue.nativeHooks; installHooks
+    // files the event-name key VERBATIM and the generic uninstallHooks reverses
+    // it by connector-id ownership (same proven pattern as copilot-cli/hermes/
+    // jetbrains-copilot).
+    supportsNativeHooks: true
+    // Content surfaces: Continue's Rules/prompts are NOT wired here. Leave the
+    // supports* flags UNSET (base skip-warns).
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = this.userConfigDir();
+    const userCfg = join(userDir, "config.yaml");
+    const projCfg = join(projectDir, ".continue", "config.yaml");
+    const userInstalled = existsSync(userDir) || existsSync(userCfg);
+    const projInstalled = existsSync(projCfg);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projCfg : userCfg;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? `found Continue config (${scope}) at ${configPath}` : `no Continue config at ${userCfg} or ${projCfg}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  /** ~/.continue (user) or <projectDir>/.continue (project). */
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".continue") : this.userConfigDir();
+  }
+  /** MCP config: config.yaml under the per-scope .continue dir. */
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "config.yaml");
+  }
+  /**
+   * Hooks live in a SEPARATE settings.json (NOT the YAML config.yaml that holds
+   * MCP servers): user-global → <CONTINUE_GLOBAL_DIR|~/.continue>/settings.json;
+   * project → <projectDir>/.continue/settings.json (hookConfig.ts
+   * getSettingsFilePaths). The user-scope dir honors CONTINUE_GLOBAL_DIR exactly
+   * as the `cn` CLI's hook loader does — this is INTENTIONALLY independent of
+   * getConfigDir/userConfigDir (the MCP path), which the hook env must not perturb.
+   */
+  getHookConfigPath(ctx) {
+    const dir = ctx.scope === "project" ? join(ctx.projectDir, ".continue") : process.env.CONTINUE_GLOBAL_DIR || join(homedir(), ".continue");
+    return join(dir, "settings.json");
+  }
+  /** ~/.continue — homedir() covers %USERPROFILE% on Windows. */
+  userConfigDir() {
+    return join(homedir(), ".continue");
+  }
+  // ── Memory surface: the `.continue/rules` content tree ────────────────────
+  // A DEDICATED agent-connector-owned file that MUST LEAD with `alwaysApply:
+  // true` frontmatter (always-included). Because of that leading frontmatter we
+  // do NOT use the base managed-block engine (it appends a block at EOF and
+  // cannot guarantee a leading frontmatter, nor delete a file that retains
+  // frontmatter on uninstall) — instead we own the whole file via the
+  // content-file writers: install writes/updates it idempotently, uninstall
+  // deletes it. PROJECT SCOPE ONLY (the user/global rules dir is unverified).
+  /** <projectDir>/.continue/rules/agent-connector.md — the dedicated owned file. */
+  memoryFilePath(ctx) {
+    return join(ctx.projectDir, ".continue", "rules", "agent-connector.md");
+  }
+  /** True when `<projectDir>/.continue/rules` exists and is a regular FILE. */
+  rulesDirIsFile(ctx) {
+    const p = join(ctx.projectDir, ".continue", "rules");
+    if (!existsSync(p)) return false;
+    try {
+      return statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Compose the dedicated rule file: `alwaysApply: true` frontmatter (the
+   * always-on activation directive) + every declared memory entry's content,
+   * joined with a blank line. The connector's content is host-agnostic markdown
+   * (MemoryDef forbids its own frontmatter), so the directive is ours to add.
+   */
+  renderMemoryFile(ctx) {
+    const body = (ctx.connector.memory ?? []).map((m) => m.content.trim()).filter((c) => c.length > 0).join("\n\n");
+    return this.renderFrontmatterMd({ alwaysApply: true }, body);
+  }
+  installMemory(ctx) {
+    const { connector } = ctx;
+    const entries = connector.memory ?? [];
+    if (connector.platforms[this.id]?.memory === false) {
+      return [{ platform: this.id, action: "skip", detail: `memory disabled for ${this.id}` }];
+    }
+    if (entries.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no memory" }];
+    }
+    if (ctx.scope !== "project") {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          detail: `no ${ctx.scope}-scope rules dir verified for continue (.continue/rules is project-scope); ${entries.length} skipped`
+        }
+      ];
+    }
+    if (this.rulesDirIsFile(ctx)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: join(ctx.projectDir, ".continue", "rules"),
+          detail: "existing .continue/rules is a file, not a directory; left untouched \u2014 convert it to a .continue/rules/ directory to receive agent-connector memory"
+        }
+      ];
+    }
+    return [this.writeContentFile(this.memoryFilePath(ctx), this.renderMemoryFile(ctx), ctx.dryRun)];
+  }
+  uninstallMemory(ctx) {
+    if (ctx.scope !== "project" || this.rulesDirIsFile(ctx)) {
+      const path = this.memoryFilePath(ctx);
+      return [
+        { platform: this.id, action: "skip", path, detail: `${basename(path)} absent` }
+      ];
+    }
+    return [this.removeContentFile(this.memoryFilePath(ctx), ctx.dryRun)];
+  }
+  // ── MCP server install / uninstall (YAML — ARRAY merge) ───────────────────
+  installServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getServerConfigPath(ctx);
+    const server = this.effectiveServer(ctx);
+    if (!server) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: connector.server ? "server registration disabled for continue" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const entry = this.renderServerEntry(ctx, server);
+    const cfg = readYaml(path) ?? {};
+    const existingRoot = cfg[MCP_ROOT_KEY];
+    if (existingRoot !== void 0 && !Array.isArray(existingRoot)) {
+      return [{ platform: this.id, action: "skip", path, detail: `${MCP_ROOT_KEY} is not a YAML array \u2014 left untouched (manual fix needed)` }];
+    }
+    const list = this.serverArray(cfg);
+    const idx = list.findIndex((e) => this.entryName(e) === connector.id);
+    let action;
+    if (idx < 0) {
+      list.push(entry);
+      action = "create";
+    } else if (JSON.stringify(list[idx]) === JSON.stringify(entry)) {
+      action = "skip";
+    } else {
+      list[idx] = entry;
+      action = "update";
+    }
+    if (action !== "skip") {
+      cfg[MCP_ROOT_KEY] = list;
+      writeYaml(path, cfg, dryRun);
+    }
+    return [{ platform: this.id, action, path, detail: `${MCP_ROOT_KEY}[name=${connector.id}]` }];
+  }
+  uninstallServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getServerConfigPath(ctx);
+    const cfg = readYaml(path);
+    const rawList = cfg?.[MCP_ROOT_KEY];
+    if (!cfg || !Array.isArray(rawList)) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: `${MCP_ROOT_KEY}[name=${connector.id}] absent`
+        }
+      ];
+    }
+    const list = rawList;
+    const kept = list.filter((e) => this.entryName(e) !== connector.id);
+    if (kept.length === list.length) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: `${MCP_ROOT_KEY}[name=${connector.id}] absent`
+        }
+      ];
+    }
+    cfg[MCP_ROOT_KEY] = kept;
+    writeYaml(path, cfg, dryRun);
+    return [
+      { platform: this.id, action: "remove", path, detail: `${MCP_ROOT_KEY}[name=${connector.id}]` }
+    ];
+  }
+  /**
+   * Render a normalized ServerDef into Continue's native mcpServers entry.
+   * Continue has no documented native ${env:VAR} token — resolve every reference
+   * to a literal at install time (the safe path, matching amazon-q/goose/hermes).
+   * Honors the telemetry serve-wrapper for stdio.
+   */
+  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;
+      }
+      command = resolveEnvRefsDeep(command);
+      args = resolveEnvRefsDeep(args);
+      const entry = {
+        name: ctx.connector.id,
+        command
+      };
+      if (args.length > 0) entry.args = args;
+      const env = this.renderEnv(server.env);
+      if (env) entry.env = env;
+      if (typeof server.cwd === "string" && server.cwd.length > 0) {
+        entry.cwd = resolveEnvRefsDeep(server.cwd);
+      }
+      return entry;
+    }
+    const type = transport === "sse" ? "sse" : "streamable-http";
+    return {
+      name: ctx.connector.id,
+      type,
+      url: resolveEnvRefsDeep(server.url ?? "")
+    };
+  }
+  /**
+   * Render stdio env values. Continue has no documented native interpolation
+   * token, so resolve `${env:VAR}` references to literals at install time.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(resolveEnvRefsDeep({ ...env }))) {
+      out[k] = String(v);
+    }
+    return out;
+  }
+  // ── Hook install / uninstall (separate settings.json, Claude-shaped) ──────
+  // Continue's hooks live in settings.json (NOT the YAML config.yaml that holds
+  // MCP servers), under `hooks` keyed by PascalCase event, each value an array
+  // of { matcher?, hooks:[{ type:"command", command }] } — BYTE-IDENTICAL to
+  // Claude Code. Events outside SUPPORTED_EVENTS (PostCompact) warn-skip; the
+  // five host-specific events with no canonical analog (ConfigChange,
+  // TeammateIdle, TaskCompleted, WorktreeCreate, WorktreeRemove) ride the
+  // nativeHooks passthrough below. Merge-preserving: the user's own hooks + any
+  // sibling connector's hooks survive; uninstall strips ONLY this connector's
+  // home-bin command (anchored).
+  installHooks(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST];
+    const hooksDisabled = override?.hooks === false;
+    const normalizedEvents = hooksDisabled ? [] : connector.hookEvents;
+    const nativeHooks = override?.nativeHooks ?? {};
+    const nativeEvents = Object.keys(nativeHooks);
+    if (normalizedEvents.length === 0 && nativeEvents.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: hooksDisabled ? "hooks disabled for continue" : "connector declares no hooks"
+        }
+      ];
+    }
+    const hookPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hookPath) ?? {};
+    const hooks = file.hooks ??= {};
+    const changes = [];
+    let mutated = false;
+    for (const event of normalizedEvents) {
+      if (!SUPPORTED_EVENTS.has(event)) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: hookPath,
+          detail: `${event} has no Continue hook equivalent \u2014 skipped`
+        });
+        continue;
+      }
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, event, connector.id);
+      const matcher = connector.hooks[event]?.matcher ?? "";
+      const entry = {
+        matcher,
+        hooks: [{ type: "command", command }]
+      };
+      const bucket = hooks[event] ??= [];
+      const existingIdx = bucket.findIndex((e) => this.entryHasOurCommand(e, ctx));
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: hookPath,
+            detail: `hooks.${event} already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({
+          platform: this.id,
+          action: "update",
+          path: hookPath,
+          detail: `hooks.${event}`
+        });
+      } else {
+        bucket.push(entry);
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: hookPath,
+          detail: `hooks.${event}`
+        });
+      }
+      mutated = true;
+    }
+    for (const nativeEvent of nativeEvents) {
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, nativeEvent, connector.id);
+      const entry = {
+        matcher: nativeHooks[nativeEvent]?.matcher ?? "",
+        hooks: [{ type: "command", command }]
+      };
+      const bucket = hooks[nativeEvent] ??= [];
+      const existingIdx = bucket.findIndex((e) => e.hooks?.[0]?.command === command);
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: hookPath,
+            detail: `hooks.${nativeEvent} (native) already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({
+          platform: this.id,
+          action: "update",
+          path: hookPath,
+          detail: `hooks.${nativeEvent} (native)`
+        });
+      } else {
+        bucket.push(entry);
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: hookPath,
+          detail: `hooks.${nativeEvent} (native)`
+        });
+      }
+      mutated = true;
+    }
+    if (mutated) this.writeJson(hookPath, file, ctx.dryRun);
+    return changes;
+  }
+  uninstallHooks(ctx) {
+    const hookPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hookPath);
+    const hooks = file?.hooks;
+    if (!file || !hooks) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: hookPath,
+          detail: "no hooks section present"
+        }
+      ];
+    }
+    const changes = [];
+    let mutated = false;
+    for (const event of Object.keys(hooks)) {
+      const bucket = hooks[event];
+      if (!Array.isArray(bucket)) continue;
+      const next = [];
+      let removed = 0;
+      for (const e of bucket) {
+        const innerBefore = e.hooks?.length ?? 0;
+        const inner = (e.hooks ?? []).filter((h) => !this.isOurCommand(h.command, ctx));
+        removed += innerBefore - inner.length;
+        if (inner.length > 0) next.push({ matcher: e.matcher ?? "", hooks: inner });
+      }
+      if (removed > 0) {
+        if (next.length > 0) hooks[event] = next;
+        else delete hooks[event];
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: hookPath,
+          detail: `hooks.${event} (${removed})`
+        });
+        mutated = true;
+      }
+    }
+    if (mutated) this.writeJson(hookPath, file, ctx.dryRun);
+    if (changes.length === 0) {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: hookPath,
+        detail: "no matching hook entries"
+      });
+    }
+    return changes;
+  }
+  entryHasOurCommand(entry, ctx) {
+    return (entry.hooks ?? []).some((h) => this.isOurCommand(h.command, ctx));
+  }
+  /** True when a hook command references our home binary AND this connector id
+   *  (anchored so a shared-prefix id can't collide — see isHomeBinHookCommand). */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Runtime: parse Continue stdin JSON → normalized event ────────────────
+  // Continue's stdin wire is Claude-identical snake_case (PR #11029 types.ts
+  // HookInput), so the claude-code wire helpers (ClaudeWireInput / extractSessionId
+  // / toolResponseToString) apply verbatim.
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = extractSessionId(input);
+    const projectDir = typeof input.cwd === "string" ? input.cwd : void 0;
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...toolResponseToString(input.tool_response) !== void 0 ? { toolOutput: toolResponseToString(input.tool_response) } : {}
+        };
+        return ev;
+      }
+      case "PostToolUseFailure": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          error: typeof input.error === "string" ? input.error : "",
+          ...typeof input.tool_use_id === "string" ? { toolUseId: input.tool_use_id } : {},
+          ...typeof input.is_interrupt === "boolean" ? { isInterrupt: input.is_interrupt } : {},
+          ...typeof input.duration_ms === "number" ? { durationMs: input.duration_ms } : {}
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source)
+        };
+        return ev;
+      }
+      case "SessionEnd": {
+        const ev = {
+          ...base,
+          ...typeof input.reason === "string" ? { reason: input.reason } : {}
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "Notification": {
+        const ev = {
+          ...base,
+          message: typeof input.message === "string" ? input.message : ""
+        };
+        return ev;
+      }
+      case "PermissionRequest": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...Array.isArray(input.permission_suggestions) ? { permissionSuggestions: input.permission_suggestions } : {}
+        };
+        return ev;
+      }
+      case "SubagentStart": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_id === "string" ? { agentId: input.agent_id } : {},
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {}
+        };
+        return ev;
+      }
+      case "SubagentStop": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_id === "string" ? { agentId: input.agent_id } : {},
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {},
+          ...typeof input.agent_transcript_path === "string" ? { agentTranscriptPath: input.agent_transcript_path } : {},
+          ...typeof input.last_assistant_message === "string" ? { lastAssistantMessage: input.last_assistant_message } : {},
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "PreCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      default: {
+        throw new Error(`unsupported continue hook event: ${String(event)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → Continue native (Claude-shaped) reply ──
+  // Continue's HookOutput is Claude-identical, so this mirrors the claude-code
+  // adapter's formatReply byte-for-byte:
+  //   PermissionRequest → nested decision{ behavior:"allow"|"deny" } envelope;
+  //   PostToolUseFailure / SubagentStart → context-only (deny degrades to
+  //     additionalContext carrying the reason);
+  //   Stop / SubagentStop / UserPromptSubmit / PostToolUse deny → TOP-LEVEL
+  //     { decision:"block", reason };
+  //   other deny → hookSpecificOutput.permissionDecision:"deny"; ask → "ask";
+  //   modify (PreToolUse) → updatedInput; context → additionalContext.
+  formatReply(event, response) {
+    const hookEventName = event;
+    const decision = response.decision ?? "allow";
+    if (event === "PermissionRequest") {
+      if (response.decision === "deny") {
+        return this.stdout({
+          hookSpecificOutput: {
+            hookEventName,
+            decision: { behavior: "deny", message: response.reason ?? "Blocked by hook" }
+          }
+        });
+      }
+      if (response.decision === "allow" || response.decision === "modify" && response.updatedInput) {
+        return this.stdout({
+          hookSpecificOutput: {
+            hookEventName,
+            decision: {
+              behavior: "allow",
+              ...response.updatedInput ? { updatedInput: response.updatedInput } : {}
+            }
+          }
+        });
+      }
+      return { exitCode: 0 };
+    }
+    if (event === "PostToolUseFailure" || event === "SubagentStart") {
+      const context = decision === "context" ? response.additionalContext : decision === "deny" ? response.reason ?? response.additionalContext : void 0;
+      if (context) {
+        return this.stdout({
+          hookSpecificOutput: { hookEventName, additionalContext: context }
+        });
+      }
+      return { exitCode: 0 };
+    }
+    if (decision === "deny") {
+      if (event === "Stop" || event === "SubagentStop" || event === "UserPromptSubmit" || event === "PostToolUse") {
+        return this.stdout({
+          decision: "block",
+          reason: response.reason ?? "Blocked by hook"
+        });
+      }
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "deny",
+          permissionDecisionReason: response.reason ?? "Blocked by hook"
+        }
+      });
+    }
+    if (decision === "ask") {
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "ask",
+          permissionDecisionReason: response.reason ?? "Confirmation required by hook"
+        }
+      });
+    }
+    if (decision === "modify") {
+      if (event === "PreToolUse" && response.updatedInput) {
+        return this.stdout({
+          hookSpecificOutput: { hookEventName, updatedInput: response.updatedInput }
+        });
+      }
+    }
+    if (decision === "context" && response.additionalContext) {
+      return this.stdout({
+        hookSpecificOutput: { hookEventName, additionalContext: response.additionalContext }
+      });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const path = this.getServerConfigPath(ctx);
+    const id = ctx.connector.id;
+    return [
+      {
+        name: `${this.name}: config.yaml present`,
+        check: () => existsSync(path) ? { status: "OK", detail: path } : { status: "FAIL", detail: `not found: ${path}` }
+      },
+      {
+        name: `${this.name}: ${MCP_ROOT_KEY}[name=${id}] registered`,
+        check: () => {
+          if (!ctx.connector.server) return { status: "OK", detail: "no MCP server declared" };
+          const cfg = readYaml(path);
+          const list = cfg?.[MCP_ROOT_KEY];
+          const present = Array.isArray(list) && list.some((e) => this.entryName(e) === id);
+          return present ? { status: "OK", detail: `${MCP_ROOT_KEY}[name=${id}]` } : { status: "FAIL", detail: `${MCP_ROOT_KEY}[name=${id}] not found in ${path}` };
+        }
+      }
+    ];
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────────
+  /** Get-or-create the mcpServers ARRAY at `cfg.mcpServers` (tolerate non-array). */
+  serverArray(cfg) {
+    const existing = cfg[MCP_ROOT_KEY];
+    if (Array.isArray(existing)) return existing;
+    const fresh = [];
+    cfg[MCP_ROOT_KEY] = fresh;
+    return fresh;
+  }
+  /** The `name` of an array entry, or undefined when it is not a named object. */
+  entryName(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return void 0;
+    const name = entry.name;
+    return typeof name === "string" ? name : void 0;
+  }
+  /** Resolve the per-platform server override into an effective ServerDef. */
+  effectiveServer(ctx) {
+    const override = ctx.connector.platforms[this.id]?.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;
+  }
+};
+function normalizeSessionSource(source) {
+  switch (source) {
+    case "compact":
+      return "compact";
+    case "resume":
+      return "resume";
+    case "clear":
+      return "clear";
+    default:
+      return "startup";
+  }
+}
+var adapter = new ContinueAdapter();
+var continue_default = adapter;
+export {
+  ContinueAdapter,
+  adapter,
+  continue_default as default
+};
+//# sourceMappingURL=continue-K43SUHLQ.js.map