@ken-jo/agent-connector 0.1.0

package/dist/kilo-cli-EAQTHXUW.js

@@ -0,0 +1,587 @@
+#!/usr/bin/env node
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-TIIP3RG2.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildServeWrapperCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import "./chunk-TRQKHP7D.js";
+
+// src/adapters/kilo-cli/index.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HOST = "kilo-cli";
+var MCP_ROOT_KEY = "mcp";
+var PLUGIN_ARRAY_KEY = "plugin";
+var CONFIG_FILE = "kilo.jsonc";
+var CLI_DB_RELPATH = [".local", "share", "kilo", "kilo.db"];
+var EVENT_TO_KILO = {
+  PreToolUse: "tool.execute.before",
+  PostToolUse: "tool.execute.after",
+  SessionStart: "experimental.chat.system.transform"
+};
+var KiloCliAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Kilo CLI";
+  paradigm = "ts-plugin";
+  capabilities = {
+    // Matches the OpenCode capability surface — the fork inherits its plugin
+    // event model.
+    preToolUse: true,
+    postToolUse: true,
+    // The fork's compaction hook is experimental and not wired here.
+    preCompact: false,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: false,
+    stop: false,
+    notification: false,
+    // tool.execute.before mutates output.args → input rewrite supported.
+    canModifyArgs: true,
+    // tool.execute.after mutates output.output → output rewrite supported.
+    canModifyOutput: true,
+    // injected via the system-prompt transform at session start.
+    canInjectSessionContext: true,
+    // The Kilo CLI registers stdio (local), SSE, and Streamable HTTP MCP servers.
+    transports: ["stdio", "sse", "http"],
+    // No confirmed CLI content surface — these inherit the BaseAdapter warn/skip.
+    supportsCommands: false,
+    supportsSkills: false,
+    supportsSubagents: false
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = join(homedir(), ".config", "kilo");
+    const userConfig = join(userDir, CONFIG_FILE);
+    const projectConfig = join(projectDir, ".kilo", CONFIG_FILE);
+    const cliDb = join(homedir(), ...CLI_DB_RELPATH);
+    const userInstalled = existsSync(userDir) || existsSync(cliDb);
+    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 Kilo CLI config at ${projectConfig}` : existsSync(cliDb) ? `found Kilo CLI session store at ${cliDb}` : `found Kilo CLI config under ${userDir}` : `no Kilo CLI config at ${userDir} or session store at ${cliDb}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".kilo") : join(homedir(), ".config", "kilo");
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), CONFIG_FILE);
+  }
+  /**
+   * For ts-plugin hosts the "hook config path" is the generated plugin FILE.
+   * Unlike OpenCode, writing the file is NOT sufficient: the fork loads only the
+   * module paths listed in kilo.jsonc's `plugin` array, so installHooks also
+   * registers this path there.
+   */
+  getHookConfigPath(ctx) {
+    return join(this.pluginDir(ctx), this.pluginFileName(ctx));
+  }
+  /** Plugin directory the synthesized module is written into, per scope. */
+  pluginDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".kilo", "plugin") : join(homedir(), ".config", "kilo", "plugin");
+  }
+  /** Plugin module file name (one per connector, kebab-case id). */
+  pluginFileName(ctx) {
+    return `${ctx.connector.id}.js`;
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { 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 kilo-cli" : "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 the Kilo CLI's new-gen `mcp` 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 = {
+        type: "local",
+        command: resolveEnvRefsDeep([command, ...args])
+      };
+      const env = this.renderEnv(server.env);
+      if (env) entry2.environment = env;
+      return entry2;
+    }
+    const entry = {
+      type: "remote",
+      url: resolveEnvRefsDeep(server.url ?? "")
+    };
+    return entry;
+  }
+  /**
+   * Render env values. The Kilo CLI documents no 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;
+    return resolveEnvRefsDeep({ ...env });
+  }
+  // ── Hook install / uninstall (ts-plugin + explicit `plugin` array) ────────
+  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 kilo-cli" }
+      ];
+    }
+    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: `kilo plugin module (${this.hookDetail(ctx)})`
+      });
+    }
+    changes.push(this.upsertPluginInArray(configPath, pluginPath, ctx.dryRun));
+    return changes;
+  }
+  /**
+   * Human-facing summary of which declared events the synthesized module ACTUALLY
+   * wires. Only events present in EVENT_TO_KILO are mapped/wired; any declared
+   * event with no Kilo mapping 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_KILO[e] !== void 0);
+    const unsupported = declared.filter((e) => EVENT_TO_KILO[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.removePluginFromArray(configPath, pluginPath, ctx.dryRun));
+    if (existsSync(pluginPath)) {
+      if (!ctx.dryRun) rmSync(pluginPath, { force: true });
+      changes.push({
+        platform: this.id,
+        action: "remove",
+        path: pluginPath,
+        detail: "kilo plugin module"
+      });
+    } else {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: pluginPath,
+        detail: "no kilo plugin module present"
+      });
+    }
+    changes.push(this.removeDirIfEmpty(this.pluginDir(ctx), ctx.dryRun));
+    return changes;
+  }
+  /** Upsert the module path into kilo.jsonc's top-level `plugin` array (idempotent). */
+  upsertPluginInArray(configPath, modulePath, dryRun) {
+    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 plugins = this.pluginArrayBucket(cfg);
+    if (plugins.includes(modulePath)) {
+      return {
+        platform: this.id,
+        action: "skip",
+        path: configPath,
+        detail: `${PLUGIN_ARRAY_KEY}[] already includes module`
+      };
+    }
+    plugins.push(modulePath);
+    this.writeJson(configPath, cfg, dryRun);
+    return {
+      platform: this.id,
+      action: "create",
+      path: configPath,
+      detail: `${PLUGIN_ARRAY_KEY}[] += module`
+    };
+  }
+  /** Remove the module path from kilo.jsonc's `plugin` array. */
+  removePluginFromArray(configPath, modulePath, dryRun) {
+    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 raw = cfg?.[PLUGIN_ARRAY_KEY];
+    const plugins = Array.isArray(raw) ? raw : void 0;
+    const idx = plugins ? plugins.indexOf(modulePath) : -1;
+    if (!cfg || !plugins || idx < 0) {
+      return {
+        platform: this.id,
+        action: "skip",
+        path: configPath,
+        detail: `${PLUGIN_ARRAY_KEY}[] does not include module`
+      };
+    }
+    plugins.splice(idx, 1);
+    this.writeJson(configPath, cfg, dryRun);
+    return {
+      platform: this.id,
+      action: "remove",
+      path: configPath,
+      detail: `${PLUGIN_ARRAY_KEY}[] -= module`
+    };
+  }
+  /** Get-or-create the top-level `plugin` array as a mutable string array. */
+  pluginArrayBucket(cfg) {
+    const existing = cfg[PLUGIN_ARRAY_KEY];
+    const plugins = Array.isArray(existing) ? existing.filter((p) => typeof p === "string") : [];
+    cfg[PLUGIN_ARRAY_KEY] = plugins;
+    return plugins;
+  }
+  // ── ts-plugin synthesis ────────────────────────────────────────────────
+  /**
+   * Build ONE self-contained ESM plugin module for the Kilo CLI fork.
+   *
+   * 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 Kilo payload on stdin and JSON.parsing the normalized HookResponse back
+   * from stdout (fail-open: any error → null). Its default export is the
+   * `@kilocode/plugin` PluginModule shape — { id, server: async (input) =>
+   * ({ "tool.execute.before": …, "tool.execute.after": …, … }) } — keyed only by
+   * the fork event names for the events this connector actually declares.
+   */
+  synthesizePlugin(ctx) {
+    const path = this.getHookConfigPath(ctx);
+    const contents = this.buildPluginSource(ctx);
+    return [{ path, contents, executable: false }];
+  }
+  /** Compose the generated plugin source with plain string concatenation. */
+  buildPluginSource(ctx) {
+    const homeBin = JSON.stringify(ctx.homeBinPath);
+    const connectorId = JSON.stringify(ctx.connector.id);
+    const events = ctx.connector.hookEvents.filter(
+      (e) => EVENT_TO_KILO[e] !== void 0
+    );
+    const has = (e) => events.includes(e);
+    const header = `/**
+ * AUTO-GENERATED by agent-connector \u2014 DO NOT EDIT.
+ *
+ * Self-contained Kilo CLI plugin bridge for connector ${ctx.connector.id}.
+ * It imports nothing from agent-connector: every hook invocation shells out to
+ * the stable home binary's universal entrypoint and JSON-parses the normalized
+ * response. Fail-open: any bridge error degrades to "allow".
+ *
+ * Default export is the @kilocode/plugin PluginModule shape
+ * ({ id, server: async (input) => Hooks }); the fork loads it because its path
+ * is registered in kilo.jsonc's "plugin" array.
+ */
+import { execFileSync, execSync } from "node:child_process";
+
+const HOME_BIN = ${homeBin};
+const CONNECTOR_ID = ${connectorId};
+
+/**
+ * Invoke the universal hook entrypoint for one event.
+ * @param {string} event canonical event name (PreToolUse|PostToolUse|SessionStart)
+ * @param {object} payload Kilo-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", "kilo-cli", event, "--connector", CONNECTOR_ID];
+    const opts = { input: JSON.stringify(payload), encoding: "utf8" };
+    const stdout =
+      process.platform === "win32"
+        ? execSync([HOME_BIN, ...args].map((a) => '"' + a + '"').join(" "), opts)
+        : execFileSync(HOME_BIN, args, opts);
+    const text = (stdout || "").trim();
+    if (text === "") return { decision: "allow" };
+    return JSON.parse(text);
+  } catch {
+    // Fail-open \u2014 never wedge a tool call on a bridge error.
+    return null;
+  }
+}
+`;
+    const handlers = [];
+    if (has("PreToolUse")) {
+      handlers.push(`    // PreToolUse \u2192 block (throw) / rewrite args (mutate output.args).
+    "tool.execute.before": async (input, output) => {
+      const payload = {
+        toolName: input.tool ?? "",
+        toolInput: (output && output.args) ?? {},
+        sessionId: input.sessionID ?? "",
+        projectDir: PROJECT_DIR,
+      };
+      const res = bridge("PreToolUse", payload);
+      if (!res) return;
+      // Kilo has no "ask" gate \u2014 degrade "ask" to a block (safe direction).
+      if (res.decision === "deny" || res.decision === "ask") {
+        throw new Error(res.reason || "Blocked by ${ctx.connector.id}");
+      }
+      if (res.updatedInput && output && output.args) {
+        Object.assign(output.args, res.updatedInput);
+      }
+    },`);
+    }
+    if (has("PostToolUse")) {
+      handlers.push(`    // PostToolUse \u2192 observe / rewrite tool output (mutate output.output).
+    "tool.execute.after": async (input, output) => {
+      const payload = {
+        toolName: input.tool ?? "",
+        toolInput: input.args ?? {},
+        toolOutput: output ? output.output : undefined,
+        sessionId: input.sessionID ?? "",
+        projectDir: PROJECT_DIR,
+      };
+      const res = bridge("PostToolUse", payload);
+      if (!res) return;
+      if (typeof res.updatedOutput === "string" && output) {
+        output.output = res.updatedOutput;
+      }
+    },`);
+    }
+    if (has("SessionStart")) {
+      handlers.push(`    // SessionStart surrogate \u2192 inject context into the system prompt.
+    // The fork has no real SessionStart hook; the system-prompt transform is the
+    // verified injection point (mirrors OpenCode).
+    "experimental.chat.system.transform": async (input, output) => {
+      const payload = {
+        sessionId: (input && input.sessionID) ?? "",
+        projectDir: PROJECT_DIR,
+      };
+      const res = bridge("SessionStart", payload);
+      if (!res) return;
+      if (res.additionalContext && output && Array.isArray(output.system)) {
+        // Insert at index 1 (after the header) to preserve the prompt-cache fold
+        // (header must remain system[0]).
+        output.system.splice(1, 0, res.additionalContext);
+      }
+    },`);
+    }
+    const definition = `
+const plugin = {
+  id: CONNECTOR_ID,
+  // @kilocode/plugin PluginModule: server(input) returns the Hooks object keyed
+  // by the fork's event names. ctx.directory is the project root; fall back to cwd.
+  server: async (input) => {
+    const PROJECT_DIR =
+      (input && (input.directory || (input.worktree && input.worktree.path))) ||
+      process.cwd();
+
+    return {
+${handlers.join("\n")}
+    };
+  },
+};
+
+export default plugin;
+`;
+    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, projectDir }
+   * so this maps straight through.
+   */
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const base = {
+      hostPlatform: HOST,
+      connectorId: "",
+      sessionId: typeof input.sessionId === "string" ? input.sessionId : "",
+      raw,
+      ...typeof input.projectDir === "string" ? { projectDir: input.projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.toolName ?? "",
+          toolInput: input.toolInput ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.toolName ?? "",
+          toolInput: input.toolInput ?? {},
+          ...typeof input.toolOutput === "string" ? { toolOutput: input.toolOutput } : {},
+          ...typeof input.isError === "boolean" ? { isError: input.isError } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = { ...base, source: "startup" };
+        return ev;
+      }
+      default:
+        return { ...base, source: "startup" };
+    }
+  }
+  // ── Runtime: normalized response → reply the generated bridge parses ───
+  /**
+   * Unlike json-stdio hosts (whose reply is the host's NATIVE control payload),
+   * OUR generated bridge consumes this stdout directly. So the reply body is the
+   * NORMALIZED HookResponse itself — the bridge JSON.parses it and reads
+   * decision / updatedInput / updatedOutput / additionalContext.
+   */
+  formatReply(_event, response) {
+    return {
+      exitCode: 0,
+      stdout: JSON.stringify(response ?? { decision: "allow" })
+    };
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const configPath = this.getServerConfigPath(ctx);
+    const pluginPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const hasHooks = ctx.connector.hookEvents.length > 0;
+    return [
+      {
+        name: `${this.name}: ${CONFIG_FILE} present`,
+        check: () => existsSync(configPath) ? { status: "OK", detail: configPath } : { status: "FAIL", detail: `not found: ${configPath}` }
+      },
+      {
+        name: `${this.name}: server entry registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          const cfg = this.readJson(configPath);
+          const bucket = cfg?.[MCP_ROOT_KEY];
+          if (!cfg || !bucket) {
+            return { status: "FAIL", detail: `no ${MCP_ROOT_KEY} in ${configPath}` };
+          }
+          return connectorId in bucket ? { status: "OK", detail: `${MCP_ROOT_KEY}.${connectorId} present` } : {
+            status: "FAIL",
+            detail: `no ${MCP_ROOT_KEY}.${connectorId} in ${configPath}`
+          };
+        }
+      },
+      {
+        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}` };
+        }
+      },
+      {
+        name: `${this.name}: plugin registered in ${PLUGIN_ARRAY_KEY}[]`,
+        check: () => {
+          if (!hasHooks) return { status: "OK", detail: "no hooks declared" };
+          const cfg = this.readJson(configPath);
+          const raw = cfg?.[PLUGIN_ARRAY_KEY];
+          const plugins = Array.isArray(raw) ? raw : void 0;
+          return plugins && plugins.includes(pluginPath) ? { status: "OK", detail: `${PLUGIN_ARRAY_KEY}[] includes module` } : {
+            status: "FAIL",
+            detail: `module not in ${PLUGIN_ARRAY_KEY}[] of ${configPath} (fork will not load it)`
+          };
+        }
+      }
+    ];
+  }
+  /** Read a file, returning undefined on any error (idempotency compare). */
+  safeRead(path) {
+    try {
+      return readFileSync(path, "utf8");
+    } catch {
+      return void 0;
+    }
+  }
+};
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+var adapter = new KiloCliAdapter();
+var kilo_cli_default = adapter;
+export {
+  KiloCliAdapter,
+  adapter,
+  kilo_cli_default as default
+};
+//# sourceMappingURL=kilo-cli-EAQTHXUW.js.map