@ken-jo/agent-connector 0.4.1 → 0.4.7

package/dist/amp-JPBQJJVM.js

@@ -0,0 +1,666 @@
+#!/usr/bin/env node
+import {
+  rewriteEnvRefs
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-PFDUGDOA.js";
+import {
+  renderSkillMd
+} from "./chunk-7L6ITC4T.js";
+import {
+  buildServeWrapperCommand,
+  shouldWrapForTelemetry
+} from "./chunk-I5MLE6S7.js";
+import "./chunk-N6HH7K6P.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/amp/index.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HOST = "amp";
+var MCP_ROOT_KEY = "amp.mcpServers";
+var EVENT_TO_AMP = {
+  SessionStart: "session.start",
+  UserPromptSubmit: "agent.start",
+  PreToolUse: "tool.call",
+  PostToolUse: "tool.result",
+  Stop: "agent.end"
+};
+var AmpAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Amp";
+  paradigm = "ts-plugin";
+  capabilities = {
+    // Memory surface: AGENTS.md-first managed block via the BaseAdapter default
+    // (memoryTargets: project <projectDir>/AGENTS.md; user scope where documented).
+    supportsMemory: true,
+    // amp.on lifecycle events with a canonical analog (EVENT_TO_AMP):
+    // tool.call / tool.result / session.start / agent.start / agent.end.
+    preToolUse: true,
+    postToolUse: true,
+    // Amp has no documented compaction hook.
+    preCompact: false,
+    sessionStart: true,
+    // Amp documents NO session.end event — SessionEnd is an honest gap.
+    sessionEnd: false,
+    userPromptSubmit: true,
+    stop: true,
+    notification: false,
+    // Newer events: Amp documents no permission/approval, post-tool-failure, or
+    // subagent lifecycle hook with a canonical analog, so permissionRequest /
+    // postToolUseFailure / subagentStart / subagentStop stay unset — the
+    // generated bridge never references them and install reports them as
+    // "unsupported here".
+    // tool.call's documented decision surface is { action: "allow" |
+    // "reject-and-continue" | "modify" | "synthesize" } (ampcode.com/manual →
+    // Plugins → tool.call). We wire allow + reject-and-continue (block); the
+    // "modify" input-rewrite shape is not byte-documented, so canModifyArgs:false.
+    canModifyArgs: false,
+    // tool.result says "return a replacement status/output" but the manual never
+    // documents the replacement OBJECT SHAPE (which keys). Rather than guess it,
+    // PostToolUse is observe-only and canModifyOutput stays false until the shape
+    // is primary-source-verified (honesty bar: under-claim, never emit a guessed
+    // mutation contract).
+    canModifyOutput: false,
+    // session.start has no documented context-injection surface.
+    canInjectSessionContext: false,
+    // Amp registers stdio and Streamable HTTP MCP servers.
+    transports: ["stdio", "http"],
+    // Skills: Amp reads SKILL.md from ~/.config/agents/skills/<name>/SKILL.md
+    // (user) and <projectDir>/.agents/skills/<name>/SKILL.md (project) — a root
+    // OUTSIDE the config dir, so the skillDir() helper resolves it explicitly.
+    supportsSkills: true,
+    // Native passthrough hooks: amp.on events with no canonical HookEventName
+    // analog are reachable via platforms["amp"].nativeHooks; the generated plugin
+    // registers + bridges each declared native event verbatim and the home-bin
+    // runtime dispatches it host-generically via runNativeHook.
+    supportsNativeHooks: true
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = join(homedir(), ".config", "amp");
+    const userSettings = join(userDir, "settings.json");
+    const projectDirAmp = join(projectDir, ".amp");
+    const projectSettings = join(projectDirAmp, "settings.json");
+    const userInstalled = existsSync(userDir) || existsSync(userSettings);
+    const projectInstalled = existsSync(projectDirAmp) || existsSync(projectSettings);
+    const installed = userInstalled || projectInstalled;
+    const scope = projectInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projectSettings : userSettings;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? `found Amp config (${scope}) at ${configPath}` : `no Amp config at ${userSettings} or ${projectSettings}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".amp") : join(homedir(), ".config", "amp");
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "settings.json");
+  }
+  /**
+   * For this ts-plugin host the "hook config path" is the generated plugin
+   * MODULE. Amp loads every `.ts` file in `.amp/plugins/`, so writing this file
+   * IS the registration. The `.amp/plugins/` dir is documented at PROJECT scope
+   * (Amp documents no user-scope plugins dir — see pluginsDir); the user-scope
+   * path is returned for doctor/uninstall symmetry but installHooks warn-skips it.
+   */
+  getHookConfigPath(ctx) {
+    return join(this.pluginsDir(ctx), `${ctx.connector.id}.ts`);
+  }
+  /**
+   * Plugin directory Amp auto-loads `.ts` modules from. PROJECT scope is the
+   * documented `<projectDir>/.amp/plugins`; user scope mirrors the MCP config dir
+   * (`~/.config/amp/plugins`) for path symmetry only — installHooks never writes
+   * there because Amp documents no user-scope plugins dir.
+   */
+  pluginsDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".amp", "plugins") : join(this.getConfigDir(ctx), "plugins");
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? "server registration disabled for amp" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const server = override && typeof override === "object" ? { ...connector.server, ...override } : connector.server;
+    const serverPath = this.getServerConfigPath(ctx);
+    const entry = this.renderServerEntry(ctx, server);
+    return [
+      this.upsertServerInJson(serverPath, MCP_ROOT_KEY, connector.id, entry, ctx.dryRun)
+    ];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [
+      this.removeServerFromJson(serverPath, MCP_ROOT_KEY, ctx.connector.id, ctx.dryRun)
+    ];
+  }
+  /** Render a normalized ServerDef into Amp's native `amp.mcpServers` entry. */
+  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 entry2 = { command: this.rewrite(command) };
+      if (args.length > 0) entry2.args = args.map((a) => this.rewrite(a));
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      return entry2;
+    }
+    const entry = { url: this.rewrite(server.url ?? "") };
+    const headers = this.renderEnv(server.headers);
+    if (headers) entry.headers = headers;
+    return entry;
+  }
+  /**
+   * Render env/header values. Amp supports native `${VAR_NAME}` interpolation,
+   * so translate `${env:VAR}` refs to that native token rather than baking
+   * secrets into the file. Literals pass through unchanged.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(env)) out[k] = this.rewrite(v);
+    return out;
+  }
+  /** Translate `${env:VAR(:-default)}` to Amp's native `${VAR}` token. */
+  rewrite(value) {
+    return rewriteEnvRefs(value, ampEnvToken);
+  }
+  // ── Skills surface ───────────────────────────────────────────────────────
+  // CONTENT-ONLY: pure native-file writers under the skill root. No runtime
+  // dispatch, no home-bin pointer, no telemetry wrap. Idempotent (byte-identical
+  // → skip) via writeContentFile and reversible via removeContentFile. Honors
+  // platforms["amp"].skills === false to skip.
+  //
+  // QUIRK: the skill root is NOT under getConfigDir (~/.config/amp). Amp reads
+  // SKILL.md from the sibling cross-agent `agents` tree:
+  //   user scope    → ~/.config/agents/skills/<name>/SKILL.md
+  //   project scope → <projectDir>/.agents/skills/<name>/SKILL.md
+  // so skillDir() resolves it explicitly rather than reusing getConfigDir.
+  /** Skill root: user `~/.config/agents/skills`, project `<projectDir>/.agents/skills`. */
+  skillsDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".agents", "skills") : join(homedir(), ".config", "agents", "skills");
+  }
+  /** Native skill dir: <skillRoot>/<name>. */
+  skillDir(ctx, name) {
+    return join(this.skillsDir(ctx), name);
+  }
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for amp" }];
+    }
+    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 (delegates to the shared renderer). */
+  renderSkill(skill) {
+    return renderSkillMd(skill);
+  }
+  // ── Hook install / uninstall (ts-plugin module) ──────────────────────────
+  installHooks(ctx) {
+    const pluginPath = this.getHookConfigPath(ctx);
+    if (ctx.scope !== "project") {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: pluginPath,
+          detail: "amp plugins are project-scoped (.amp/plugins/) \u2014 no user-scope plugins dir is documented; skipped"
+        }
+      ];
+    }
+    const canonicalDisabled = ctx.connector.platforms[HOST]?.hooks === false;
+    const hasCanonical = !canonicalDisabled && ctx.connector.hookEvents.length > 0;
+    const hasNative = this.nativeHookEvents(ctx).length > 0;
+    if (!hasCanonical && !hasNative) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: pluginPath,
+          detail: canonicalDisabled ? "hooks disabled for amp" : "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: `amp plugin module (${this.hookDetail(ctx)})`
+      });
+    }
+    return changes;
+  }
+  uninstallHooks(ctx) {
+    const pluginPath = this.getHookConfigPath(ctx);
+    if (!existsSync(pluginPath)) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: pluginPath,
+          detail: "no amp plugin module present"
+        }
+      ];
+    }
+    if (!ctx.dryRun) rmSync(pluginPath, { force: true });
+    return [
+      {
+        platform: this.id,
+        action: "remove",
+        path: pluginPath,
+        detail: "amp plugin module"
+      }
+    ];
+  }
+  /**
+   * Human-facing summary of which declared events the synthesized module ACTUALLY
+   * wires. Only events present in EVENT_TO_AMP are mapped/wired; any declared
+   * event with no Amp mapping (e.g. SessionEnd) is reported separately as
+   * "unsupported here" so the detail never overstates coverage.
+   */
+  hookDetail(ctx) {
+    const canonicalOff = ctx.connector.platforms[HOST]?.hooks === false;
+    const declared = canonicalOff ? [] : ctx.connector.hookEvents;
+    const mapped = declared.filter((e) => EVENT_TO_AMP[e] !== void 0);
+    const unsupported = declared.filter((e) => EVENT_TO_AMP[e] === void 0);
+    const native = this.nativeHookEvents(ctx);
+    const parts = [];
+    if (mapped.length > 0) parts.push(mapped.join(","));
+    if (native.length > 0) parts.push(`native: ${native.join(",")}`);
+    const base = parts.join("; ") || "no canonical hooks";
+    return unsupported.length > 0 ? `${base}; unsupported here: ${unsupported.join(",")}` : base;
+  }
+  /**
+   * Amp-native passthrough events declared on platforms["amp"].nativeHooks
+   * (amp.on event names with no canonical HookEventName analog). Emitted as
+   * generic bridge registrations and dispatched host-generically by the home-bin's
+   * runNativeHook.
+   */
+  nativeHookEvents(ctx) {
+    return Object.keys(ctx.connector.platforms[HOST]?.nativeHooks ?? {});
+  }
+  // ── ts-plugin synthesis ──────────────────────────────────────────────────
+  /**
+   * Build ONE self-contained Amp plugin module (`.amp/plugins/<id>.ts`). It
+   * imports nothing from agent-connector; each `amp.on(...)` handler shells out to
+   * the universal hook entrypoint via child_process and applies the normalized
+   * HookResponse. Its default export is the Amp plugin function `(amp) => void`.
+   */
+  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 canonicalOff = ctx.connector.platforms[HOST]?.hooks === false;
+    const events = canonicalOff ? [] : ctx.connector.hookEvents.filter(
+      (e) => EVENT_TO_AMP[e] !== void 0
+    );
+    const has = (e) => events.includes(e);
+    const header = `/**
+ * AUTO-GENERATED by agent-connector \u2014 DO NOT EDIT.
+ *
+ * Self-contained Amp plugin 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 a no-op (never wedges Amp).
+ *
+ * Amp loads this module from .amp/plugins/${ctx.connector.id}.ts; the default
+ * export is the plugin function (amp) => void called once with the PluginAPI.
+ */
+import type { PluginAPI } from "@ampcode/plugin";
+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
+ * @param {object} payload amp-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", "amp", 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 an Amp tool call / lifecycle event.
+    return null;
+  }
+}
+
+// Amp documents no project-dir env var; the plugin process runs in the workspace
+// root, so resolve once at load. Session id is rebound on each session.start.
+const PROJECT_DIR = process.cwd();
+let SESSION_ID = "";
+`;
+    const handlers = [];
+    if (has("SessionStart")) {
+      handlers.push(`  // SessionStart \u2192 rebind the session id and notify the connector.
+  // Amp's session.start event carries event.thread.id (ampcode.com/manual \u2192
+  // Plugins \u2192 session.start: "Example session.start for \${event.thread.id}").
+  amp.on("session.start", async (event) => {
+    SESSION_ID =
+      (event && event.thread && event.thread.id) || "amp-session";
+    bridge("SessionStart", { sessionId: SESSION_ID, projectDir: PROJECT_DIR });
+  });`);
+    }
+    if (has("UserPromptSubmit")) {
+      handlers.push(`  // UserPromptSubmit \u2192 agent.start "fires when the user submits a prompt"
+  // (ampcode.com/manual). The manual's example takes (_event) and documents no
+  // prompt field or return surface, so this is observe-only \u2014 the raw event is
+  // forwarded for the connector to inspect; any deny/context decision is a no-op.
+  amp.on("agent.start", async (event) => {
+    bridge("UserPromptSubmit", {
+      sessionId: SESSION_ID,
+      projectDir: PROJECT_DIR,
+      raw: event,
+    });
+  });`);
+    }
+    if (has("PreToolUse")) {
+      handlers.push(`  // PreToolUse \u2192 Amp's tool.call returns a decision union (ampcode.com/manual \u2192
+  // Plugins \u2192 tool.call): { action: "allow" } to run, or { action:
+  // "reject-and-continue", message } to block and let the agent continue. The
+  // tool name is event.tool (verified); the input field is not byte-documented,
+  // so event.input is a best-effort hint for the connector's matcher (the matcher
+  // keys on the verified tool name). A deny/ask decision maps to reject-and-
+  // continue; everything else allows.
+  amp.on("tool.call", async (event) => {
+    const payload = {
+      toolName: (event && event.tool) || "",
+      toolInput: (event && event.input) || {},
+      sessionId: SESSION_ID,
+      projectDir: PROJECT_DIR,
+    };
+    const res = bridge("PreToolUse", payload);
+    if (res && (res.decision === "deny" || res.decision === "ask")) {
+      return {
+        action: "reject-and-continue",
+        message: res.reason || "Blocked by ${ctx.connector.id}",
+      };
+    }
+    return { action: "allow" };
+  });`);
+    }
+    if (has("PostToolUse")) {
+      handlers.push(`  // PostToolUse \u2192 tool.result "fires after a tool finishes and before the result
+  // is sent back to the model" (ampcode.com/manual). The tool name is event.tool
+  // and the error signal is event.status === "error" (both verified). The manual
+  // says a replacement status/output CAN be returned but never documents the
+  // replacement object shape, so this is observe-only (canModifyOutput:false) \u2014
+  // the raw event is forwarded; we never return a guessed replacement.
+  amp.on("tool.result", async (event) => {
+    bridge("PostToolUse", {
+      toolName: (event && event.tool) || "",
+      isError: !!(event && event.status === "error"),
+      sessionId: SESSION_ID,
+      projectDir: PROJECT_DIR,
+      raw: event,
+    });
+  });`);
+    }
+    if (has("Stop")) {
+      handlers.push(`  // Stop \u2192 observe turn end. Amp's agent.end exposes no decision surface, so
+  // this is observe-only (a deny decision degrades to a no-op).
+  amp.on("agent.end", async (event) => {
+    bridge("Stop", { sessionId: SESSION_ID, projectDir: PROJECT_DIR, raw: event });
+  });`);
+    }
+    for (const ev of this.nativeHookEvents(ctx)) {
+      const key = JSON.stringify(ev);
+      handlers.push(`  // nativeHooks passthrough \u2192 ${ev}
+  amp.on(${key}, async (event) => {
+    bridge(${key}, { sessionId: SESSION_ID, projectDir: PROJECT_DIR, raw: event });
+  });`);
+    }
+    const factory = `
+export default function plugin(amp: PluginAPI) {
+${handlers.join("\n\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?, prompt?, 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 "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = { ...base };
+        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, for tool.call,
+   * maps a deny/ask decision → { action: "reject-and-continue" } (else allow).
+   * Other events are observe-only, so their reply is ignored by the handler.
+   */
+  formatReply(_event, response) {
+    return {
+      exitCode: 0,
+      stdout: JSON.stringify(response ?? { decision: "allow" })
+    };
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const settingsPath = this.getServerConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    return [
+      {
+        name: `${this.name}: settings.json present`,
+        check: () => existsSync(settingsPath) ? { status: "OK", detail: settingsPath } : { status: "FAIL", detail: `not found: ${settingsPath}` }
+      },
+      {
+        name: `${this.name}: server entry registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          const cfg = this.readJson(settingsPath);
+          const bucket = cfg?.[MCP_ROOT_KEY];
+          if (!cfg || !bucket) {
+            return { status: "FAIL", detail: `no "${MCP_ROOT_KEY}" in ${settingsPath}` };
+          }
+          return connectorId in bucket ? { status: "OK", detail: `"${MCP_ROOT_KEY}".${connectorId} present` } : {
+            status: "FAIL",
+            detail: `no "${MCP_ROOT_KEY}".${connectorId} in ${settingsPath}`
+          };
+        }
+      },
+      {
+        name: `${this.name}: plugin module present`,
+        check: () => {
+          const hasHooks = ctx.connector.hookEvents.length > 0 || this.nativeHookEvents(ctx).length > 0;
+          if (!hasHooks) return { status: "OK", detail: "no hooks declared" };
+          if (ctx.scope !== "project") {
+            return {
+              status: "OK",
+              detail: "amp plugins are project-scoped (user scope skipped)"
+            };
+          }
+          const pluginPath = this.getHookConfigPath(ctx);
+          return existsSync(pluginPath) ? { status: "OK", detail: pluginPath } : { status: "FAIL", detail: `not found: ${pluginPath}` };
+        }
+      }
+    ];
+  }
+  /** 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 });
+}
+function ampEnvToken(name, def) {
+  if (def !== void 0) {
+    const v = process.env[name];
+    return v != null && v !== "" ? v : def;
+  }
+  return `\${${name}}`;
+}
+var adapter = new AmpAdapter();
+var amp_default = adapter;
+export {
+  AmpAdapter,
+  adapter,
+  amp_default as default
+};
+//# sourceMappingURL=amp-JPBQJJVM.js.map