@ken-jo/agent-connector 0.1.0

package/dist/openclaw-ETN2M63O.js

@@ -0,0 +1,751 @@
+#!/usr/bin/env node
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter,
+  parseJsonc
+} from "./chunk-TIIP3RG2.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildServeWrapperCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/openclaw/index.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+var HOST = "openclaw";
+var MCP_ROOT_KEY = "mcp";
+var MCP_SERVERS_KEY = "servers";
+var PLUGINS_KEY = "plugins";
+var PLUGINS_ENTRIES_KEY = "entries";
+var PLUGINS_LOAD_KEY = "load";
+var PLUGINS_LOAD_PATHS_KEY = "paths";
+var PLUGIN_MANIFEST_FILE = "openclaw.plugin.json";
+var EVENT_TO_OPENCLAW = {
+  PreToolUse: "before_tool_call",
+  PostToolUse: "after_tool_call",
+  SessionStart: "session_start"
+};
+var OpenClawAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "OpenClaw";
+  paradigm = "ts-plugin";
+  capabilities = {
+    preToolUse: true,
+    postToolUse: true,
+    // OpenClaw compaction is owned by a context engine, not wired through the
+    // universal bridge here.
+    preCompact: false,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: false,
+    stop: false,
+    notification: false,
+    // before_tool_call mutates event.params in place → input rewrite supported.
+    canModifyArgs: true,
+    // after_tool_call observes but cannot rewrite the tool result upstream.
+    canModifyOutput: false,
+    // injected via before_prompt_build at prompt assembly.
+    canInjectSessionContext: true,
+    // OpenClaw's MCP sidecar registration is stdio-only in practice.
+    transports: ["stdio"]
+  };
+  // ── Tolerant JSON5/JSONC read (override base strict JSON.parse) ──────────
+  /**
+   * openclaw.json is officially JSON5 (comments + trailing commas allowed). A
+   * strict JSON.parse false-fails a perfectly valid commented file, so we strip
+   * comments and trailing commas before parsing. Writes remain strict JSON
+   * (writeJson in BaseAdapter), which is itself valid JSON5 — so round-trips
+   * stay safe and idempotent.
+   */
+  readJson(path) {
+    if (!existsSync(path)) return null;
+    let raw;
+    try {
+      raw = readFileSync(path, "utf8");
+    } catch {
+      return null;
+    }
+    try {
+      return parseJsonc(raw);
+    } catch {
+      return null;
+    }
+  }
+  // ── Detection ──────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userConfig = resolveOpenClawConfigPath();
+    const userDir = join(homedir(), ".openclaw");
+    const projectConfig = join(projectDir, "openclaw.json");
+    const userInstalled = existsSync(userConfig) || existsSync(userDir);
+    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 OpenClaw config at ${projectConfig}` : `found OpenClaw config at ${configPath}` : `no OpenClaw config at ${userConfig} or ${userDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ───────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? ctx.projectDir : dirname(resolveOpenClawConfigPath());
+  }
+  getServerConfigPath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, "openclaw.json") : resolveOpenClawConfigPath();
+  }
+  /**
+   * For ts-plugin hosts the "hook config path" is the generated plugin FILE.
+   * OpenClaw additionally needs the plugins.entries reference written into
+   * openclaw.json (handled in installHooks); this is the module on disk.
+   */
+  getHookConfigPath(ctx) {
+    return join(this.pluginDir(ctx), this.pluginFileName());
+  }
+  /** Extensions directory the synthesized plugin module is written into. */
+  pluginDir(ctx) {
+    const base = ctx.scope === "project" ? join(ctx.projectDir, ".openclaw") : dirname(resolveOpenClawConfigPath());
+    return join(base, "extensions", ctx.connector.id);
+  }
+  /** Plugin module file name (ESM so the gateway loads it without a loader). */
+  pluginFileName() {
+    return "index.mjs";
+  }
+  // ── MCP server install / uninstall (mcp.servers.<id>) ───────────────────
+  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 openclaw" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const entry = this.renderServerEntry(ctx, server);
+    return [this.upsertNestedServer(serverPath, ctx.connector.id, entry, ctx.dryRun)];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [this.removeNestedServer(serverPath, 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 OpenClaw's native mcp.servers.<id> entry.
+   *
+   * stdio  → { command, args?, env? }  (NO transport key — a stdio sidecar is
+   *          inferred from `command`; OpenClaw's validator rejects
+   *          transport:"stdio" and only accepts "sse"/"streamable-http")
+   * remote → { url, transport: "sse"|"http", headers? }
+   *
+   * OpenClaw documents no native ${env:VAR} token, so refs resolve to literals.
+   */
+  renderServerEntry(ctx, server) {
+    if (server.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: resolveEnvRefsDeep(command)
+      };
+      const resolvedArgs = resolveEnvRefsDeep(args).filter((s) => s !== "");
+      if (resolvedArgs.length > 0) entry2.args = resolvedArgs;
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      if (server.enabled === false) entry2.enabled = false;
+      return entry2;
+    }
+    const transport = server.transport === "http" ? "http" : "sse";
+    const entry = {
+      url: resolveEnvRefsDeep(server.url ?? ""),
+      transport
+    };
+    if (server.headers && Object.keys(server.headers).length > 0) {
+      entry.headers = resolveEnvRefsDeep({ ...server.headers });
+    }
+    if (server.enabled === false) entry.enabled = false;
+    return entry;
+  }
+  /** Resolve every ${env:VAR} in env values to literals (no native token). */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    return resolveEnvRefsDeep({ ...env });
+  }
+  /** Upsert config.mcp.servers.<id> idempotently. */
+  upsertNestedServer(path, id, entry, dryRun) {
+    if (this.isPresentButUnparseable(path)) {
+      return {
+        platform: this.id,
+        action: "warn",
+        path,
+        detail: `existing ${path} is not parseable; left untouched (back it up / fix it, then re-run)`
+      };
+    }
+    const cfg = this.readJson(path) ?? {};
+    const servers = this.nestedServersBucket(cfg);
+    const before = JSON.stringify(servers[id]);
+    const after = JSON.stringify(entry);
+    let action;
+    if (before === void 0) action = "create";
+    else if (before === after) action = "skip";
+    else action = "update";
+    if (action !== "skip") {
+      servers[id] = entry;
+      this.writeJson(path, cfg, dryRun);
+    }
+    return {
+      platform: this.id,
+      action,
+      path,
+      detail: `${MCP_ROOT_KEY}.${MCP_SERVERS_KEY}.${id}`
+    };
+  }
+  /** Remove config.mcp.servers.<id>. */
+  removeNestedServer(path, id, dryRun) {
+    const cfg = this.readJson(path);
+    const mcp = cfg?.[MCP_ROOT_KEY];
+    const servers = mcp && typeof mcp === "object" && !Array.isArray(mcp) ? mcp[MCP_SERVERS_KEY] : void 0;
+    if (!cfg || !servers || !(id in servers)) {
+      return {
+        platform: this.id,
+        action: "skip",
+        path,
+        detail: `${MCP_ROOT_KEY}.${MCP_SERVERS_KEY}.${id} absent`
+      };
+    }
+    delete servers[id];
+    this.writeJson(path, cfg, dryRun);
+    return {
+      platform: this.id,
+      action: "remove",
+      path,
+      detail: `${MCP_ROOT_KEY}.${MCP_SERVERS_KEY}.${id}`
+    };
+  }
+  /** Get-or-create config.mcp.servers as a mutable object. */
+  nestedServersBucket(cfg) {
+    let mcp = cfg[MCP_ROOT_KEY];
+    if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) {
+      mcp = {};
+      cfg[MCP_ROOT_KEY] = mcp;
+    }
+    const mcpObj = mcp;
+    let servers = mcpObj[MCP_SERVERS_KEY];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+      servers = {};
+      mcpObj[MCP_SERVERS_KEY] = servers;
+    }
+    return servers;
+  }
+  // ── Hook install / uninstall (ts-plugin + DUAL REGISTRATION) ────────────
+  installHooks(ctx) {
+    const pluginPath = this.getHookConfigPath(ctx);
+    const configPath = this.getServerConfigPath(ctx);
+    if (ctx.connector.platforms[HOST]?.hooks === false) {
+      return [
+        { platform: this.id, action: "skip", path: pluginPath, detail: "hooks disabled for openclaw" }
+      ];
+    }
+    if (ctx.connector.hookEvents.length === 0) {
+      return [
+        { platform: this.id, action: "skip", path: pluginPath, detail: "connector declares no hooks" }
+      ];
+    }
+    const changes = [];
+    for (const file of this.synthesizePlugin(ctx)) {
+      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: `openclaw plugin module (${this.hookDetail(ctx)})`
+      });
+    }
+    changes.push(this.upsertPluginEntry(configPath, ctx, this.pluginDir(ctx)));
+    return changes;
+  }
+  /**
+   * Human-facing summary of which declared events the synthesized module ACTUALLY
+   * wires. Only events present in EVENT_TO_OPENCLAW are mapped/wired; any declared
+   * event with no OpenClaw 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_OPENCLAW[e] !== void 0);
+    const unsupported = declared.filter((e) => EVENT_TO_OPENCLAW[e] === void 0);
+    const base = mapped.join(",");
+    return unsupported.length > 0 ? `${base}; unsupported here: ${unsupported.join(",")}` : base;
+  }
+  uninstallHooks(ctx) {
+    const pluginPath = this.getHookConfigPath(ctx);
+    const configPath = this.getServerConfigPath(ctx);
+    const changes = [];
+    changes.push(
+      this.removePluginEntry(configPath, ctx.connector.id, this.pluginDir(ctx), ctx.dryRun)
+    );
+    const manifestPath = join(this.pluginDir(ctx), PLUGIN_MANIFEST_FILE);
+    for (const [path, label] of [
+      [pluginPath, "openclaw plugin module"],
+      [manifestPath, "openclaw plugin manifest"]
+    ]) {
+      if (existsSync(path)) {
+        if (!ctx.dryRun) rmSync(path, { force: true });
+        changes.push({ platform: this.id, action: "remove", path, detail: label });
+      } else {
+        changes.push({
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: `no ${label} present`
+        });
+      }
+    }
+    changes.push(this.removeDirIfEmpty(this.pluginDir(ctx), ctx.dryRun));
+    return changes;
+  }
+  /**
+   * Upsert plugins.entries.<id> = { enabled: true } AND add `pluginDir` to
+   * plugins.load.paths idempotently.
+   *
+   * `openclaw config validate` rejects a per-entry `module` field, so the entry
+   * carries ONLY `{ enabled: true }`. The gateway discovers the synthesized
+   * module by scanning the directories in plugins.load.paths (the dir holding
+   * index.mjs + openclaw.plugin.json), so the dir is added there.
+   */
+  upsertPluginEntry(configPath, ctx, pluginDir) {
+    if (this.isPresentButUnparseable(configPath)) {
+      return {
+        platform: this.id,
+        action: "warn",
+        path: configPath,
+        detail: `existing ${configPath} is not parseable; left untouched (back it up / fix it, then re-run)`
+      };
+    }
+    const cfg = this.readJson(configPath) ?? {};
+    const entries = this.pluginEntriesBucket(cfg);
+    const id = ctx.connector.id;
+    const desired = { enabled: true };
+    const entryBefore = JSON.stringify(entries[id]);
+    const entryAfter = JSON.stringify(desired);
+    const loadPaths = this.pluginLoadPathsBucket(cfg);
+    const pathPresent = loadPaths.includes(pluginDir);
+    const entryChanged = entryBefore !== entryAfter;
+    const pathChanged = !pathPresent;
+    let action;
+    if (entryBefore === void 0) action = "create";
+    else if (!entryChanged && !pathChanged) action = "skip";
+    else action = "update";
+    if (action !== "skip") {
+      entries[id] = desired;
+      if (!pathPresent) loadPaths.push(pluginDir);
+      this.writeJson(configPath, cfg, ctx.dryRun);
+    }
+    return {
+      platform: this.id,
+      action,
+      path: configPath,
+      detail: `${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY}.${id} + ${PLUGINS_KEY}.${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY}`
+    };
+  }
+  /** Remove plugins.entries.<id> AND drop `pluginDir` from plugins.load.paths. */
+  removePluginEntry(configPath, id, pluginDir, dryRun) {
+    const cfg = this.readJson(configPath);
+    const plugins = cfg?.[PLUGINS_KEY];
+    const pluginsObj = plugins && typeof plugins === "object" && !Array.isArray(plugins) ? plugins : void 0;
+    const entries = pluginsObj?.[PLUGINS_ENTRIES_KEY];
+    const load = pluginsObj?.[PLUGINS_LOAD_KEY];
+    const loadPaths = load && Array.isArray(load[PLUGINS_LOAD_PATHS_KEY]) ? load[PLUGINS_LOAD_PATHS_KEY] : void 0;
+    const entryPresent = Boolean(entries && id in entries);
+    const pathIdx = loadPaths ? loadPaths.indexOf(pluginDir) : -1;
+    if (!cfg || !entryPresent && pathIdx < 0) {
+      return {
+        platform: this.id,
+        action: "skip",
+        path: configPath,
+        detail: `${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY}.${id} absent`
+      };
+    }
+    if (entryPresent && entries) delete entries[id];
+    if (loadPaths && pathIdx >= 0) loadPaths.splice(pathIdx, 1);
+    this.writeJson(configPath, cfg, dryRun);
+    return {
+      platform: this.id,
+      action: "remove",
+      path: configPath,
+      detail: `${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY}.${id} + ${PLUGINS_KEY}.${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY}`
+    };
+  }
+  /** Get-or-create config.plugins.entries as a mutable object. */
+  pluginEntriesBucket(cfg) {
+    let plugins = cfg[PLUGINS_KEY];
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins)) {
+      plugins = {};
+      cfg[PLUGINS_KEY] = plugins;
+    }
+    const pluginsObj = plugins;
+    let entries = pluginsObj[PLUGINS_ENTRIES_KEY];
+    if (!entries || typeof entries !== "object" || Array.isArray(entries)) {
+      entries = {};
+      pluginsObj[PLUGINS_ENTRIES_KEY] = entries;
+    }
+    return entries;
+  }
+  /** Get-or-create config.plugins.load.paths as a mutable string array. */
+  pluginLoadPathsBucket(cfg) {
+    let plugins = cfg[PLUGINS_KEY];
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins)) {
+      plugins = {};
+      cfg[PLUGINS_KEY] = plugins;
+    }
+    const pluginsObj = plugins;
+    let load = pluginsObj[PLUGINS_LOAD_KEY];
+    if (!load || typeof load !== "object" || Array.isArray(load)) {
+      load = {};
+      pluginsObj[PLUGINS_LOAD_KEY] = load;
+    }
+    const loadObj = load;
+    const existing = loadObj[PLUGINS_LOAD_PATHS_KEY];
+    const paths = Array.isArray(existing) ? existing.filter((p) => typeof p === "string") : [];
+    loadObj[PLUGINS_LOAD_PATHS_KEY] = paths;
+    return paths;
+  }
+  // ── ts-plugin synthesis ────────────────────────────────────────────────
+  /**
+   * Build ONE self-contained ESM plugin module for OpenClaw.
+   *
+   * 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 OpenClaw event payload on stdin and JSON.parsing the normalized
+   * HookResponse back from stdout (fail-open: any error → null). Its default
+   * export is the OpenClaw plugin definition { id, name, configSchema,
+   * register(api) }; register wires api.on(...) handlers for the events this
+   * connector actually declares.
+   */
+  synthesizePlugin(ctx) {
+    const path = this.getHookConfigPath(ctx);
+    const contents = this.buildPluginSource(ctx);
+    const manifestPath = join(this.pluginDir(ctx), PLUGIN_MANIFEST_FILE);
+    const manifest = this.buildPluginManifest(ctx);
+    return [
+      { path, contents, executable: false },
+      { path: manifestPath, contents: manifest, executable: false }
+    ];
+  }
+  /**
+   * Build the openclaw.plugin.json manifest the gateway reads inside a
+   * plugins.load.paths directory. It names the plugin and points at the ESM
+   * module entry (index.mjs) so the loader knows what to import.
+   */
+  buildPluginManifest(ctx) {
+    const manifest = {
+      id: ctx.connector.id,
+      name: ctx.connector.displayName || ctx.connector.id,
+      main: this.pluginFileName(),
+      enabled: true
+    };
+    return `${JSON.stringify(manifest, null, 2)}
+`;
+  }
+  /** 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 connectorName = JSON.stringify(ctx.connector.displayName || ctx.connector.id);
+    const events = ctx.connector.hookEvents.filter(
+      (e) => EVENT_TO_OPENCLAW[e] !== void 0
+    );
+    const has = (e) => events.includes(e);
+    const header = "/**\n * AUTO-GENERATED by agent-connector \u2014 DO NOT EDIT.\n *\n * Self-contained OpenClaw 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 a no-op.
+ *
+ * Registered via DUAL REGISTRATION in openclaw.json: plugins.entries.<id>
+ * (loads this module) + mcp.servers.<id> (surfaces the MCP tools). The
+ * gateway hot-reloads its config on SIGUSR1.
+ */
+import { execFileSync, execSync } from "node:child_process";
+
+const HOME_BIN = ` + homeBin + ";\nconst CONNECTOR_ID = " + connectorId + `;
+
+/**
+ * Invoke the universal hook entrypoint for one canonical event.
+ * @param {string} event canonical event name (PreToolUse|PostToolUse|SessionStart)
+ * @param {object} payload OpenClaw-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.
+    const args = ["hook", "openclaw", 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;
+  }
+}
+
+// Module-scoped context the prompt-build hook injects at session start.
+// before_prompt_build is the verified injection point (session_start itself
+// returns no context payload). The flag prevents double-injection.
+let PROJECT_DIR = process.cwd();
+let SESSION_ID = "";
+let pendingContext = null;
+let contextInjected = false;
+
+`;
+    const reg = [];
+    reg.push(
+      '  register(api) {\n    PROJECT_DIR = process.cwd();\n    const on = (event, handler) => {\n      if (typeof api?.on === "function") {\n        try { api.on(event, handler); return; } catch { /* fall through */ }\n      }\n      if (typeof api?.registerHook === "function") {\n        try {\n          api.registerHook(event, handler, { name: CONNECTOR_ID + ":" + event, description: "agent-connector bridge" });\n        } catch { /* best effort */ }\n      }\n    };\n'
+    );
+    if (has("PreToolUse")) {
+      reg.push(
+        '\n    // PreToolUse \u2192 before_tool_call: block (return { block, blockReason })\n    // for deny/ask; rewrite args by mutating event.params in place for modify.\n    on("before_tool_call", async (event) => {\n      const e = event || {};\n      const toolInput = e.params || {};\n      const res = bridge("PreToolUse", {\n        toolName: e.toolName || "",\n        toolInput,\n        sessionId: SESSION_ID,\n        projectDir: PROJECT_DIR,\n      });\n      if (!res) return undefined;\n      // OpenClaw has no separate ask gate \u2014 deny and ask both block (safe).\n      if (res.decision === "deny" || res.decision === "ask") {\n        return { block: true, blockReason: res.reason || ("Blocked by " + CONNECTOR_ID) };\n      }\n      if (res.decision === "modify" && res.updatedInput && typeof toolInput === "object") {\n        Object.assign(toolInput, res.updatedInput);\n      }\n      return undefined;\n    });\n'
+      );
+    }
+    if (has("PostToolUse")) {
+      reg.push(
+        '\n    // PostToolUse \u2192 after_tool_call: observe the completed tool call.\n    // OpenClaw exposes the result (v2+) or output (older builds); it cannot\n    // rewrite the tool result, so updatedOutput is intentionally dropped.\n    on("after_tool_call", async (event) => {\n      const e = event || {};\n      const rawResult = e.result !== undefined ? e.result : e.output;\n      const toolOutput =\n        typeof rawResult === "string"\n          ? rawResult\n          : rawResult != null\n            ? JSON.stringify(rawResult)\n            : undefined;\n      bridge("PostToolUse", {\n        toolName: e.toolName || "",\n        toolInput: e.params || {},\n        toolOutput,\n        isError: Boolean(e.error || e.isError),\n        sessionId: SESSION_ID,\n        projectDir: PROJECT_DIR,\n      });\n      return undefined;\n    });\n'
+      );
+    }
+    if (has("SessionStart")) {
+      reg.push(
+        '\n    // SessionStart \u2192 session_start records the real session id and fetches\n    // the additionalContext to inject; before_prompt_build performs the\n    // injection (the verified context-injection point upstream).\n    on("session_start", async (event) => {\n      const e = event || {};\n      SESSION_ID = e.sessionId || e.sessionKey || SESSION_ID;\n      const res = bridge("SessionStart", {\n        sessionId: SESSION_ID,\n        source: e.resumedFrom ? "resume" : "startup",\n        projectDir: PROJECT_DIR,\n      });\n      contextInjected = false;\n      pendingContext =\n        res && typeof res.additionalContext === "string" && res.additionalContext\n          ? res.additionalContext\n          : null;\n      return undefined;\n    });\n\n    // Inject the session-start context once, at prompt-build time.\n    on("before_prompt_build", () => {\n      if (contextInjected || !pendingContext) return undefined;\n      contextInjected = true;\n      return { appendSystemContext: pendingContext };\n    });\n'
+      );
+    }
+    reg.push("  },\n");
+    const definition = "const plugin = {\n  id: CONNECTOR_ID,\n  name: " + connectorName + ',\n  configSchema: {\n    type: "object",\n    properties: {\n      enabled: {\n        type: "boolean",\n        default: true,\n        description: "Enable or disable the " + CONNECTOR_ID + " plugin.",\n      },\n    },\n    additionalProperties: false,\n  },\n' + reg.join("") + "};\n\nexport default plugin;\n";
+    return header + definition;
+  }
+  // ── 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, source?, 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 source = input.source === "resume" ? "resume" : input.source === "compact" ? "compact" : input.source === "clear" ? "clear" : "startup";
+        const ev = { ...base, source };
+        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 / additionalContext.
+   */
+  formatReply(_event, response) {
+    return {
+      exitCode: 0,
+      stdout: JSON.stringify(response ?? { decision: "allow" })
+    };
+  }
+  // ── Diagnostics ────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const configPath = this.getServerConfigPath(ctx);
+    const pluginPath = this.getHookConfigPath(ctx);
+    const pluginDir = this.pluginDir(ctx);
+    const id = ctx.connector.id;
+    const hasHooks = ctx.connector.hookEvents.length > 0;
+    const hasServer = Boolean(ctx.connector.server);
+    return [
+      {
+        name: `${this.name}: openclaw.json present`,
+        check: () => existsSync(configPath) ? { status: "OK", detail: configPath } : { status: "FAIL", detail: `not found: ${configPath}` }
+      },
+      {
+        // HARDEST PART — dual registration must be CONSISTENT. The plugin only
+        // delivers tools when it is LOADED (plugins.entries.<id> enabled AND its
+        // dir in plugins.load.paths) AND in mcp.servers. A config with one half
+        // but not the other is a tool-less (or never-loaded) install, so FAIL on
+        // loaded XOR mcp.servers. (We assert plugins.load.paths — NOT a per-entry
+        // `module` field, which openclaw config validate rejects.)
+        name: `${this.name}: dual registration (plugins.entries+load.paths + mcp.servers.${id})`,
+        check: () => {
+          const cfg = this.readJson(configPath);
+          if (!cfg) return { status: "FAIL", detail: `cannot read ${configPath}` };
+          const inEntries = this.hasPluginEntry(cfg, id) && this.hasLoadPath(cfg, pluginDir);
+          const inMcp = this.hasMcpServer(cfg, id);
+          if (!hasServer) {
+            return inEntries || !hasHooks ? { status: "OK", detail: "hooks-only connector (no MCP server)" } : {
+              status: "FAIL",
+              detail: `${id} not enabled in ${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY} + ${PLUGINS_KEY}.${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY} (plugin will not load)`
+            };
+          }
+          if (inEntries && inMcp) {
+            return {
+              status: "OK",
+              detail: `${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY}.${id}+${PLUGINS_KEY}.${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY} + ${MCP_ROOT_KEY}.${MCP_SERVERS_KEY}.${id}`
+            };
+          }
+          if (inEntries && !inMcp) {
+            return {
+              status: "FAIL",
+              detail: `loaded (${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY}+${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY}) but missing from ${MCP_ROOT_KEY}.${MCP_SERVERS_KEY} \u2014 plugin loads but no tools reach the agent`
+            };
+          }
+          if (!inEntries && inMcp) {
+            return {
+              status: "FAIL",
+              detail: `in ${MCP_ROOT_KEY}.${MCP_SERVERS_KEY} but not loaded (missing ${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY} or ${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY}) \u2014 tools declared but plugin never loads`
+            };
+          }
+          return {
+            status: "FAIL",
+            detail: `not loaded (${PLUGINS_KEY}.${PLUGINS_ENTRIES_KEY}+${PLUGINS_LOAD_KEY}.${PLUGINS_LOAD_PATHS_KEY}) and not in ${MCP_ROOT_KEY}.${MCP_SERVERS_KEY}`
+          };
+        }
+      },
+      {
+        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}` };
+        }
+      }
+    ];
+  }
+  /** True when config.plugins.entries.<id> exists (and is not disabled). */
+  hasPluginEntry(cfg, id) {
+    const plugins = cfg[PLUGINS_KEY];
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins)) return false;
+    const entries = plugins[PLUGINS_ENTRIES_KEY];
+    if (!entries || typeof entries !== "object" || Array.isArray(entries)) return false;
+    const entry = entries[id];
+    if (entry === void 0) return false;
+    return !(entry && typeof entry === "object" && entry.enabled === false);
+  }
+  /** True when config.plugins.load.paths includes `pluginDir`. */
+  hasLoadPath(cfg, pluginDir) {
+    const plugins = cfg[PLUGINS_KEY];
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins)) return false;
+    const load = plugins[PLUGINS_LOAD_KEY];
+    if (!load || typeof load !== "object" || Array.isArray(load)) return false;
+    const paths = load[PLUGINS_LOAD_PATHS_KEY];
+    return Array.isArray(paths) && paths.includes(pluginDir);
+  }
+  /** True when config.mcp.servers.<id> exists. */
+  hasMcpServer(cfg, id) {
+    const mcp = cfg[MCP_ROOT_KEY];
+    if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) return false;
+    const servers = mcp[MCP_SERVERS_KEY];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) return false;
+    return id in servers;
+  }
+  /** Read a file, returning undefined on any error (idempotency compare). */
+  safeRead(path) {
+    try {
+      return readFileSync(path, "utf8");
+    } catch {
+      return void 0;
+    }
+  }
+};
+function resolveOpenClawConfigPath(env = process.env) {
+  if (env.OPENCLAW_CONFIG_PATH) return resolve(env.OPENCLAW_CONFIG_PATH);
+  const stateDir = env.OPENCLAW_STATE_DIR ? resolve(env.OPENCLAW_STATE_DIR) : resolve(homedir(), ".openclaw");
+  return resolve(stateDir, "openclaw.json");
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+var adapter = new OpenClawAdapter();
+var openclaw_default = adapter;
+export {
+  OpenClawAdapter,
+  adapter,
+  openclaw_default as default
+};
+//# sourceMappingURL=openclaw-ETN2M63O.js.map