@ken-jo/agent-connector 0.5.0 → 0.6.1

package/dist/grok-build-FSN4TNLQ.js

@@ -0,0 +1,682 @@
+#!/usr/bin/env node
+import {
+  grokBuildConfigHome
+} from "./chunk-KOFCNA5T.js";
+import {
+  normalizeSessionSource
+} from "./chunk-H53QZQJI.js";
+import {
+  resolveEnvRefsDeep
+} from "./chunk-BEFVJ2OE.js";
+import {
+  BaseAdapter,
+  removeFromObjectMap,
+  renderCommandMd,
+  renderSkillMd,
+  renderSubagentMd,
+  upsertInObjectMap
+} from "./chunk-PMOFA5BT.js";
+import {
+  buildHomeBinHookCommand,
+  buildWrappedStdio
+} from "./chunk-QSY74NAP.js";
+import "./chunk-UMQ6NBQR.js";
+import {
+  ensureDir
+} from "./chunk-GZGLCCEE.js";
+
+// src/adapters/grok-build/index.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import TOML from "@iarna/toml";
+var GROK_BUILD_HOOK_EVENTS = [
+  "SessionStart",
+  "SessionEnd",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "Stop",
+  "Notification",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact"
+];
+var PRE_TOOL_USE_MATCHER = "run_terminal_command|Bash|search_replace|Edit|Write|MultiEdit|apply_patch|spawn_subagent|Task";
+var WARN_SKIP_EVENTS = /* @__PURE__ */ new Set(["PermissionRequest"]);
+var HOOKS_FILENAME = "agent-connector.json";
+function coerceToolResult(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var GrokBuildAdapter = class extends BaseAdapter {
+  id = "grok-build";
+  name = "Grok Build";
+  paradigm = "json-stdio";
+  capabilities = {
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: true,
+    sessionStart: true,
+    sessionEnd: true,
+    userPromptSubmit: true,
+    stop: true,
+    notification: true,
+    // PostToolUseFailure is a first-class Grok event (a dispatch failure or an
+    // MCP error result fires it INSTEAD of PostToolUse); SubagentStart/Stop and
+    // PostCompact are all native. permissionRequest stays UNSET — see the header.
+    postToolUseFailure: true,
+    subagentStart: true,
+    subagentStop: true,
+    postCompact: true,
+    // PreToolUse `updatedInput` rewrites the call before it runs, and every
+    // downstream consumer (plan-mode gate, permission prompt, the tool, the later
+    // PostToolUse payload) sees the rewritten input.
+    canModifyArgs: true,
+    // PostToolUse `updatedToolOutput` replaces the model's copy of the result —
+    // "Universal key; works for every tool".
+    canModifyOutput: true,
+    // FALSE: Grok ignores stdout on SessionStart ("For events like SessionStart
+    // or Notification, stdout is ignored. Just exit 0.") and on an allowing
+    // UserPromptSubmit ("stdout of an allowing hook is discarded (no
+    // additionalContext)"). Context injection exists only on the tool events,
+    // which this flag does not describe.
+    canInjectSessionContext: false,
+    // `grok mcp add` documents stdio (default), --transport http and
+    // --transport sse; the TOML carries `url` for both remote forms.
+    transports: ["stdio", "http", "sse"],
+    // Content surfaces, all under <scope>/.grok:
+    //   command  → commands/<name>.md        (flat md, stem = slash name)
+    //   skill    → skills/<name>/SKILL.md    (Anthropic frontmatter)
+    //   subagent → agents/<name>.md          (name/description/tools/model)
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: true,
+    // Memory: AGENTS.md (project) / $GROK_HOME/rules (user).
+    supportsMemory: true
+  };
+  // ── Detection ──────────────────────────────────────────────────────────
+  /**
+   * Grok Build is installed when its OWN marker file exists, or when a config
+   * dir exists that is not merely the community Grok CLI's `~/.grok`. The
+   * sibling bow-out is what keeps the two products' shared default directory
+   * from cross-reporting (see the header).
+   */
+  detectInstalled(projectDir) {
+    const userDir = this.userConfigDir();
+    const projDir = join(projectDir, ".grok");
+    const userCfg = join(userDir, "config.toml");
+    const projCfg = join(projDir, "config.toml");
+    const siblingOnly = existsSync(join(userDir, "user-settings.json")) && !existsSync(userCfg);
+    const userInstalled = existsSync(userCfg) || existsSync(userDir) && !siblingOnly;
+    const projInstalled = existsSync(projCfg) || existsSync(projDir);
+    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 Grok Build config dir (${scope})` : siblingOnly ? `${userDir} holds only the community Grok CLI's user-settings.json` : `no .grok config dir at ${userDir} or ${projDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ───────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    if (ctx.scope === "project") return join(ctx.projectDir, ".grok");
+    return this.userConfigDir();
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "config.toml");
+  }
+  /**
+   * Hooks live in their OWN directory, one JSON file per author —
+   * `$GROK_HOME/hooks/*.json` (user) or `<project>/.grok/hooks/*.json`. We own
+   * exactly one file there, so an install never rewrites a hand-authored config.
+   */
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "hooks", HOOKS_FILENAME);
+  }
+  /** `$GROK_HOME` (tilde-expanded, then resolved) || `~/.grok`. */
+  userConfigDir() {
+    return grokBuildConfigHome();
+  }
+  // ── Memory surface: AGENTS.md (project) / $GROK_HOME/rules (user) ────────
+  // 12-project-rules.md is titled "Project Rules (AGENTS.md)" and documents
+  // AGENTS.md discovery from the repo root down to the cwd. The USER tier has no
+  // AGENTS.md equivalent: home-level guidance is `*.md` under
+  // `$GROK_HOME/rules/` ("Always scanned; applies to all projects").
+  memoryTargets(ctx) {
+    if (this.memoryOverride(ctx)?.path) return super.memoryTargets(ctx);
+    if (ctx.scope === "project") {
+      return [
+        {
+          path: join(ctx.projectDir, "AGENTS.md"),
+          reason: "AGENTS.md standard (project root; Grok Build loads it root \u2192 cwd)"
+        }
+      ];
+    }
+    if (ctx.scope === "user") {
+      return [
+        {
+          path: join(this.userConfigDir(), "rules", "agent-connector.md"),
+          reason: "$GROK_HOME/rules/*.md global rules (always scanned, all projects)"
+        }
+      ];
+    }
+    return [];
+  }
+  // ── TOML config IO (config.toml is TOML, not JSON) ───────────────────────
+  readToml(path) {
+    if (!existsSync(path)) return {};
+    try {
+      return TOML.parse(readFileSync(path, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  writeToml(path, data, dryRun) {
+    if (dryRun) return;
+    ensureDir(dirname(path));
+    writeFileSync(path, TOML.stringify(data), "utf8");
+  }
+  /** ObjectMapCodec over config.toml, mirroring codex: readToml fail-softs to
+   *  {} so a corrupt file coerces rather than warn-skipping. */
+  tomlObjectMapCodec() {
+    return {
+      parse: (path) => this.readToml(path),
+      serialize: (path, data, dryRun) => this.writeToml(path, data, dryRun),
+      isPresentButUnparseable: () => false
+    };
+  }
+  // ── Install server (config.toml → [mcp_servers.<id>]) ────────────────────
+  installServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const server = this.effectiveServer(ctx);
+    const path = this.getServerConfigPath(ctx);
+    if (!server) {
+      return [{ platform: this.id, action: "skip", path, detail: "no server declared" }];
+    }
+    const isStdio = server.transport === "stdio" && !!server.command;
+    const isRemote = (server.transport === "http" || server.transport === "sse") && !!server.url;
+    if (!isStdio && !isRemote) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: `transport "${server.transport}" not registrable in config.toml (stdio + http/sse url only)`
+        }
+      ];
+    }
+    const symlink = this.symlinkPathWarning(path);
+    if (symlink) return [symlink];
+    return [
+      upsertInObjectMap({
+        codec: this.tomlObjectMapCodec(),
+        rootKey: "mcp_servers",
+        policy: "coerce",
+        platform: this.id,
+        configPath: path,
+        entryId: connector.id,
+        entry: this.renderMcpEntry(ctx, server),
+        dryRun
+      })
+    ];
+  }
+  uninstallServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getServerConfigPath(ctx);
+    const symlink = this.symlinkPathWarning(path);
+    if (symlink) return [symlink];
+    return [
+      removeFromObjectMap({
+        codec: this.tomlObjectMapCodec(),
+        rootKey: "mcp_servers",
+        policy: "coerce",
+        platform: this.id,
+        configPath: path,
+        entryId: connector.id,
+        dryRun
+      })
+    ];
+  }
+  // ── Install hooks (hooks/agent-connector.json) ───────────────────────────
+  installHooks(ctx) {
+    const path = this.getHookConfigPath(ctx);
+    const hooksOff = ctx.connector.platforms[this.id]?.hooks === false;
+    const declared = hooksOff ? [] : ctx.connector.hookEvents;
+    if (declared.length === 0) {
+      return [{ platform: this.id, action: "skip", path, detail: "no hooks declared" }];
+    }
+    const supported = (e) => GROK_BUILD_HOOK_EVENTS.includes(e);
+    const pending = [
+      ...declared.filter((e) => !supported(e)).map((event) => ({ event, matcher: "" })),
+      ...declared.filter(supported).map((event) => ({ event, matcher: "" }))
+    ];
+    return this.upsertHookEntries(ctx, path, pending, this.hookDescriptor(ctx));
+  }
+  uninstallHooks(ctx) {
+    return this.removeHookEntries(ctx, this.getHookConfigPath(ctx), this.hookDescriptor(ctx));
+  }
+  /** Hook-merge policy for the shared object-map engine (Claude-compatible file). */
+  hookDescriptor(_ctx) {
+    return {
+      malformedPolicy: "coerce",
+      mapEvent: (e) => GROK_BUILD_HOOK_EVENTS.includes(e) ? e : void 0,
+      unmappedWarnDetail: (e) => `${e} has no Grok Build hook equivalent \u2014 skipped`,
+      unmappedAction: (e) => WARN_SKIP_EVENTS.has(e) ? "warn" : "skip",
+      renderEntry: (event, _matcher, command) => {
+        const entry = { hooks: [{ type: "command", command }] };
+        entry.matcher = event === "PreToolUse" ? PRE_TOOL_USE_MATCHER : "";
+        return entry;
+      },
+      entryOwnsCommand: (entry, command) => Array.isArray(entry.hooks) && entry.hooks.some(
+        (h) => (h.command ?? "").replace(/\\/g, "/") === command.replace(/\\/g, "/")
+      ),
+      ownsEntryForRemove: (c, event) => (entry) => this.isOurEntry(c, event, entry),
+      skipDetail: (e) => `hooks.${e}`,
+      removeDetail: (e, _n) => `hooks.${e}`,
+      absentDetail: `no ${HOOKS_FILENAME}`,
+      noMatchDetail: "no agent-connector hooks present",
+      removeEventKeys: GROK_BUILD_HOOK_EVENTS
+    };
+  }
+  // ── Health checks ────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const path = this.getServerConfigPath(ctx);
+    const id = ctx.connector.id;
+    const checks = [
+      {
+        name: `${this.name}: config.toml exists`,
+        check: () => existsSync(path) ? { status: "OK", detail: path } : { status: "FAIL", detail: `not found: ${path}` }
+      },
+      {
+        name: `${this.name}: mcp_servers.${id} registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          const bucket = this.readToml(path)["mcp_servers"];
+          const present = typeof bucket === "object" && bucket !== null && id in bucket;
+          return present ? { status: "OK", detail: `mcp_servers.${id}` } : { status: "FAIL", detail: `mcp_servers.${id} not found in ${path}` };
+        }
+      }
+    ];
+    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;
+  }
+  // ── Content surfaces: commands / skills / subagents ──────────────────────
+  // Pure native-file writers under <scope>/.grok — idempotent via
+  // writeContentFile, reversible via removeContentFile. All three roots are
+  // scope-symmetric (Grok scans the same layout at user, repo and cwd tiers).
+  commandPath(ctx, name) {
+    return join(this.getConfigDir(ctx), "commands", `${name}.md`);
+  }
+  skillDir(ctx, name) {
+    return join(this.getConfigDir(ctx), "skills", name);
+  }
+  subagentPath(ctx, name) {
+    return join(this.getConfigDir(ctx), "agents", `${name}.md`);
+  }
+  // ── Commands (flat markdown; filename stem = slash-command name) ──────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for grok-build" }];
+    }
+    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),
+        // Grok's command markdown is the Claude legacy layout: description +
+        // argument-hint frontmatter. It has no allowed-tools/model keys on a
+        // COMMAND (those are skill/agent frontmatter fields), so both are dropped.
+        renderCommandMd(cmd, { includeToolsAndModel: false }),
+        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)
+    );
+  }
+  // ── Skills (Anthropic-format SKILL.md) ───────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for grok-build" }];
+    }
+    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"), renderSkillMd(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;
+  }
+  // ── Subagents (md + frontmatter: name, description, tools, model) ─────────
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for grok-build" }];
+    }
+    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)
+    );
+  }
+  /**
+   * Grok agent definitions are md + YAML frontmatter whose documented keys —
+   * name, description, tools, model — are exactly the shared renderer's shape
+   * (16-subagents.md shows `name`, `description`, `tools` in its frontmatter
+   * example). `extra` remains the escape hatch for Grok-only keys such as
+   * `mcpInheritance`.
+   */
+  renderSubagent(agent) {
+    return renderSubagentMd(agent);
+  }
+  // ── Runtime dispatch ─────────────────────────────────────────────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const toolName = input.toolName ?? input.tool_name ?? "";
+    const toolInput = input.toolInput ?? input.tool_input ?? {};
+    const base = {
+      hostPlatform: this.id,
+      connectorId: "",
+      sessionId: input.sessionId ?? input.session_id ?? `pid-${process.ppid}`,
+      // `cwd` is the session's working directory; `workspaceRoot` is the repo
+      // root. Prefer cwd (matches every other adapter's projectDir semantics).
+      projectDir: input.cwd ?? input.workspaceRoot ?? process.cwd(),
+      raw
+    };
+    switch (event) {
+      case "PreToolUse":
+        return { ...base, toolName, toolInput };
+      case "PostToolUse":
+        return {
+          ...base,
+          toolName,
+          toolInput,
+          // Upstream field is `toolResult` (aliased to `tool_response`).
+          toolOutput: coerceToolResult(input.toolResult ?? input.tool_response),
+          // Grok's PostToolUse payload has NO error flag: a dispatch failure or
+          // an MCP error result fires PostToolUseFailure instead. Never invent one.
+          isError: false
+        };
+      case "SessionStart":
+        return { ...base, source: normalizeSessionSource(input.source) };
+      case "SessionEnd":
+        return { ...base, reason: input.reason };
+      case "UserPromptSubmit":
+        return { ...base, prompt: input.prompt ?? "" };
+      case "PreCompact":
+      case "PostCompact":
+        return { ...base, trigger: input.source === "manual" ? "manual" : "auto" };
+      case "Stop":
+        return { ...base, stopHookActive: input.stopHookActive ?? false };
+      case "Notification":
+        return { ...base, message: input.message ?? input.notificationType ?? "" };
+      case "PostToolUseFailure":
+        return {
+          ...base,
+          toolName,
+          toolInput,
+          error: input.error ?? "",
+          ...typeof (input.toolUseId ?? input.tool_use_id) === "string" ? { toolUseId: input.toolUseId ?? input.tool_use_id } : {},
+          ...typeof (input.isInterrupt ?? input.is_interrupt) === "boolean" ? { isInterrupt: input.isInterrupt ?? input.is_interrupt } : {},
+          ...typeof (input.durationMs ?? input.duration_ms) === "number" ? { durationMs: input.durationMs ?? input.duration_ms } : {}
+        };
+      case "SubagentStart":
+        return {
+          ...base,
+          ...typeof input.subagentId === "string" ? { agentId: input.subagentId } : {},
+          ...typeof input.subagentType === "string" ? { agentType: input.subagentType } : {}
+        };
+      case "SubagentStop":
+        return {
+          ...base,
+          ...typeof input.subagentId === "string" ? { agentId: input.subagentId } : {},
+          ...typeof input.subagentType === "string" ? { agentType: input.subagentType } : {},
+          ...typeof input.lastAssistantMessage === "string" ? { lastAssistantMessage: input.lastAssistantMessage } : {},
+          ...typeof input.stopHookActive === "boolean" ? { stopHookActive: input.stopHookActive } : {}
+        };
+      case "PermissionRequest":
+        return { ...base, toolName, toolInput };
+    }
+  }
+  formatReply(event, response) {
+    if (response.decision === "deny") {
+      if (event === "PreToolUse") {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "deny",
+              permissionDecisionReason: response.reason ?? "Blocked by hook"
+            }
+          })
+        };
+      }
+      if (event === "UserPromptSubmit" || event === "Stop" || event === "SubagentStop" || event === "PostToolUse") {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({
+            decision: "block",
+            reason: response.reason ?? "Blocked by hook"
+          })
+        };
+      }
+      if (event === "PostToolUseFailure") {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PostToolUseFailure",
+              additionalContext: response.reason ?? "Blocked by hook"
+            }
+          })
+        };
+      }
+      return { exitCode: 0 };
+    }
+    if (response.decision === "ask" && event === "PreToolUse") {
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "ask",
+            permissionDecisionReason: response.reason ?? "Confirmation required by hook"
+          }
+        })
+      };
+    }
+    if (response.decision === "modify") {
+      if (event === "PreToolUse" && response.updatedInput) {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              updatedInput: response.updatedInput
+            }
+          })
+        };
+      }
+      if (event === "PostToolUse" && response.updatedOutput !== void 0) {
+        return {
+          exitCode: 0,
+          stdout: JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PostToolUse",
+              updatedToolOutput: response.updatedOutput
+            }
+          })
+        };
+      }
+      return { exitCode: 0 };
+    }
+    if (response.additionalContext && (event === "PreToolUse" || event === "PostToolUse" || event === "PostToolUseFailure" || event === "Stop" || event === "SubagentStop")) {
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: event,
+            additionalContext: response.additionalContext
+          }
+        })
+      };
+    }
+    return { exitCode: 0 };
+  }
+  // ── Internal helpers ─────────────────────────────────────────────────────
+  /** 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 ? { ...base, ...override } : base;
+  }
+  /**
+   * Render the `[mcp_servers.<id>]` table. TOML has NO interpolation, so every
+   * `${env:VAR}` resolves to a literal at install time. Honors the telemetry
+   * serve-wrapper (stdio only — a remote server cannot be intercepted).
+   */
+  renderMcpEntry(ctx, server) {
+    if (server.transport === "http" || server.transport === "sse") {
+      const remote = { url: resolveEnvRefsDeep(server.url ?? "") };
+      const headers = {};
+      if (server.auth?.type === "bearerEnv" && server.auth.bearerEnvVar) {
+        headers["Authorization"] = `Bearer \${${server.auth.bearerEnvVar}}`;
+      }
+      for (const [k, v] of Object.entries(resolveEnvRefsDeep(server.headers ?? {}))) {
+        headers[k] = String(v);
+      }
+      if (Object.keys(headers).length > 0) remote.headers = headers;
+      if (server.enabled === false) remote.enabled = false;
+      return remote;
+    }
+    let command = server.command;
+    let args = [...server.args ?? []];
+    ({ command, args } = buildWrappedStdio(ctx, server, this.id, command, args));
+    command = resolveEnvRefsDeep(command);
+    args = resolveEnvRefsDeep(args);
+    const entry = { command };
+    if (args.length > 0) entry.args = args;
+    if (server.env && Object.keys(server.env).length > 0) {
+      const env = {};
+      for (const [k, v] of Object.entries(resolveEnvRefsDeep(server.env))) {
+        env[k] = String(v);
+      }
+      entry.env = env;
+    }
+    if (server.enabled === false) entry.enabled = false;
+    return entry;
+  }
+  /**
+   * Does this hooks-file entry belong to this connector for `event`? EVENT-
+   * SPECIFIC + path-normalized exact-command match, so an entry under one event
+   * key is never matched while iterating another.
+   */
+  isOurEntry(ctx, event, entry) {
+    if (!entry || typeof entry !== "object" || !Array.isArray(entry.hooks)) return false;
+    const ours = buildHomeBinHookCommand(ctx.homeBinPath, "grok-build", event, ctx.connector.id);
+    const needle = ours.replace(/\\/g, "/");
+    return entry.hooks.some((h) => (h.command ?? "").replace(/\\/g, "/") === needle);
+  }
+};
+var adapter = new GrokBuildAdapter();
+var grok_build_default = adapter;
+export {
+  GrokBuildAdapter,
+  adapter,
+  grok_build_default as default
+};
+//# sourceMappingURL=grok-build-FSN4TNLQ.js.map