@ken-jo/agent-connector 0.1.0

package/dist/codex-JFQTS6LU.js

@@ -0,0 +1,593 @@
+#!/usr/bin/env node
+import {
+  writeTomlString
+} from "./chunk-OPXAP3AC.js";
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-TIIP3RG2.js";
+import "./chunk-7L6ITC4T.js";
+import {
+  buildHomeBinHookCommand,
+  buildServeWrapperCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import {
+  ensureDir
+} from "./chunk-TRQKHP7D.js";
+
+// src/adapters/codex/index.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import TOML from "@iarna/toml";
+var CODEX_HOOK_EVENTS = [
+  "SessionStart",
+  "PreToolUse",
+  "PostToolUse",
+  "PreCompact",
+  "UserPromptSubmit",
+  "Stop"
+];
+var PRE_TOOL_USE_MATCHER = "local_shell|shell|shell_command|exec_command|Bash|Shell|apply_patch|Edit|Write|grep_files|mcp__";
+var CodexAdapter = class extends BaseAdapter {
+  id = "codex";
+  name = "Codex CLI";
+  paradigm = "json-stdio";
+  capabilities = {
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: true,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: true,
+    stop: true,
+    notification: false,
+    canModifyArgs: false,
+    canModifyOutput: false,
+    canInjectSessionContext: true,
+    transports: ["stdio", "http"],
+    // Content surfaces: Codex implements all three.
+    //   command  → ~/.codex/prompts/<name>.md   (md+frontmatter, USER SCOPE ONLY)
+    //   skill    → <codexDir>/skills/<name>/SKILL.md (+ resources)
+    //   subagent → <codexDir>/agents/<name>.toml (TOML)
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: true
+  };
+  // ── Detection ──────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = this.userConfigDir();
+    const projDir = join(projectDir, ".codex");
+    const userCfg = join(userDir, "config.toml");
+    const projCfg = join(projDir, "config.toml");
+    const userInstalled = existsSync(userDir) || existsSync(userCfg);
+    const projInstalled = existsSync(projDir) || existsSync(projCfg);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projCfg : userCfg;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? `Found Codex config dir (${scope})` : `No .codex config dir at ${userDir} or ${projDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ───────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    if (ctx.scope === "project") return join(ctx.projectDir, ".codex");
+    return this.userConfigDir();
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "config.toml");
+  }
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "hooks.json");
+  }
+  /** `$CODEX_HOME` || `~/.codex` for user scope. */
+  userConfigDir() {
+    const env = process.env.CODEX_HOME;
+    if (env && env.trim() !== "") {
+      if (env.startsWith("~")) {
+        return join(homedir(), env.replace(/^~[/\\]?/, ""));
+      }
+      return env;
+    }
+    return join(homedir(), ".codex");
+  }
+  // ── TOML config IO (override JSON helpers — config.toml is TOML) ─────────
+  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");
+  }
+  // ── 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" }];
+    }
+    if (server.transport !== "stdio" || !server.command) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: `transport "${server.transport}" not registrable in config.toml (stdio only)`
+        }
+      ];
+    }
+    const entry = this.renderMcpEntry(ctx, server);
+    const cfg = this.readToml(path);
+    const bucket = this.tomlBucket(cfg, "mcp_servers");
+    const before = JSON.stringify(bucket[connector.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") {
+      bucket[connector.id] = entry;
+      this.writeToml(path, cfg, dryRun);
+    }
+    return [{ platform: this.id, action, path, detail: `mcp_servers.${connector.id}` }];
+  }
+  uninstallServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getServerConfigPath(ctx);
+    const cfg = this.readToml(path);
+    const bucket = cfg["mcp_servers"];
+    if (!existsSync(path) || typeof bucket !== "object" || bucket === null || !(connector.id in bucket)) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: `mcp_servers.${connector.id} absent`
+        }
+      ];
+    }
+    delete bucket[connector.id];
+    this.writeToml(path, cfg, dryRun);
+    return [{ platform: this.id, action: "remove", path, detail: `mcp_servers.${connector.id}` }];
+  }
+  // ── Install hooks (hooks.json) ──────────────────────────────────────────
+  installHooks(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getHookConfigPath(ctx);
+    const events = this.effectiveHookEvents(ctx);
+    if (events.length === 0) {
+      return [{ platform: this.id, action: "skip", path, detail: "no hooks declared" }];
+    }
+    const file = this.readHooksFile(path);
+    const hooks = file.hooks ??= {};
+    const changes = [];
+    for (const event of events) {
+      const desired = this.renderHookEntry(ctx, event);
+      const list = Array.isArray(hooks[event]) ? hooks[event] : hooks[event] = [];
+      const idx = list.findIndex((e) => this.isOurEntry(ctx, event, e));
+      if (idx < 0) {
+        list.push(desired);
+        changes.push({ platform: this.id, action: "create", path, detail: `hooks.${event}` });
+      } else if (JSON.stringify(list[idx]) !== JSON.stringify(desired)) {
+        list[idx] = desired;
+        changes.push({ platform: this.id, action: "update", path, detail: `hooks.${event}` });
+      } else {
+        changes.push({ platform: this.id, action: "skip", path, detail: `hooks.${event}` });
+      }
+    }
+    if (changes.some((c) => c.action !== "skip")) {
+      this.writeJson(path, file, dryRun);
+    }
+    return changes;
+  }
+  uninstallHooks(ctx) {
+    const path = this.getHookConfigPath(ctx);
+    const file = this.readJson(path);
+    const hooks = file?.hooks;
+    if (!file || !hooks) {
+      return [{ platform: this.id, action: "skip", path, detail: "no hooks.json" }];
+    }
+    const changes = [];
+    let mutated = false;
+    for (const event of CODEX_HOOK_EVENTS) {
+      const list = hooks[event];
+      if (!Array.isArray(list)) continue;
+      const kept = list.filter((e) => !this.isOurEntry(ctx, event, e));
+      if (kept.length === list.length) continue;
+      mutated = true;
+      if (kept.length > 0) hooks[event] = kept;
+      else delete hooks[event];
+      changes.push({ platform: this.id, action: "remove", path, detail: `hooks.${event}` });
+    }
+    if (mutated) this.writeJson(path, file, ctx.dryRun);
+    if (changes.length === 0) {
+      return [{ platform: this.id, action: "skip", path, detail: "no agent-connector hooks present" }];
+    }
+    return changes;
+  }
+  // ── Health checks (default doctor renders these) ────────────────────────
+  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: () => {
+          const cfg = this.readToml(path);
+          const bucket = cfg["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}` };
+        }
+      }
+    ];
+    if (ctx.scope !== "project") {
+      for (const cmd of ctx.connector.commands) {
+        const p = this.commandPath(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 ──────────────────────
+  // CONTENT-ONLY: pure native-file writers. No runtime dispatch, no home-bin
+  // pointer, no telemetry wrap. Each method is idempotent (byte-identical →
+  // skip) via writeContentFile and reversible via removeContentFile. Honors
+  // platforms["codex"] per-surface false to skip.
+  //
+  // Native locations:
+  //   command  → ~/.codex/prompts/<name>.md   md+frontmatter(description,argument-hint)
+  //              USER SCOPE ONLY — project scope yields a single "warn".
+  //   skill    → <codexDir>/skills/<name>/SKILL.md (+ resources)
+  //   subagent → <codexDir>/agents/<name>.toml  TOML via writeTomlString
+  /** Command files always live under the USER codex dir: ~/.codex/prompts. */
+  commandPath(name) {
+    return join(this.userConfigDir(), "prompts", `${name}.md`);
+  }
+  skillDir(ctx, name) {
+    return join(this.getConfigDir(ctx), "skills", name);
+  }
+  subagentPath(ctx, name) {
+    return join(this.getConfigDir(ctx), "agents", `${name}.toml`);
+  }
+  // ── Commands (USER SCOPE ONLY) ───────────────────────────────────────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for codex" }];
+    }
+    if (ctx.scope === "project") {
+      return [{ platform: this.id, action: "warn", detail: "codex commands are user-scope only" }];
+    }
+    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(cmd.name), this.renderCommand(cmd), ctx.dryRun)
+    );
+  }
+  uninstallCommands(ctx) {
+    const { connector } = ctx;
+    if (ctx.scope === "project") {
+      return [{ platform: this.id, action: "warn", detail: "codex commands are user-scope only" }];
+    }
+    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(cmd.name), ctx.dryRun)
+    );
+  }
+  /** Render a command to md+frontmatter (description, argument-hint). */
+  renderCommand(cmd) {
+    const frontmatter = {};
+    if (cmd.description !== void 0) frontmatter.description = cmd.description;
+    if (cmd.argumentHint !== void 0) frontmatter["argument-hint"] = cmd.argumentHint;
+    if (cmd.extra) Object.assign(frontmatter, cmd.extra);
+    return this.renderFrontmatterMd(frontmatter, cmd.prompt);
+  }
+  // ── Skills ───────────────────────────────────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for codex" }];
+    }
+    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: frontmatter (name, description + optional model,
+   * allowed-tools, disable-model-invocation) + body. UNIFORM with every other
+   * skill-supporting platform — only the parent dir differs.
+   */
+  renderSkill(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.model !== void 0) frontmatter.model = skill.model;
+    const allow = skill.tools?.allow;
+    if (allow && allow.length > 0) frontmatter["allowed-tools"] = allow.join(", ");
+    if (skill.disableModelInvocation !== void 0) {
+      frontmatter["disable-model-invocation"] = skill.disableModelInvocation;
+    }
+    if (skill.extra) Object.assign(frontmatter, skill.extra);
+    return this.renderFrontmatterMd(frontmatter, skill.body);
+  }
+  // ── Subagents (TOML) ─────────────────────────────────────────────────────
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for codex" }];
+    }
+    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)
+    );
+  }
+  /**
+   * Render a subagent to a Codex agent TOML file:
+   *   { name, description, developer_instructions: prompt, model }.
+   * model is omitted when undefined so Codex applies its default.
+   */
+  renderSubagent(agent) {
+    const table = {
+      name: agent.name,
+      description: agent.description,
+      developer_instructions: agent.prompt
+    };
+    if (agent.model !== void 0) table.model = agent.model;
+    if (agent.extra) Object.assign(table, agent.extra);
+    return writeTomlString(table);
+  }
+  // ── Runtime dispatch ────────────────────────────────────────────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const base = {
+      hostPlatform: this.id,
+      connectorId: "",
+      sessionId: input.session_id ?? `pid-${process.ppid}`,
+      projectDir: input.cwd ?? process.env.CODEX_PROJECT_DIR ?? process.cwd(),
+      raw
+    };
+    switch (event) {
+      case "PreToolUse":
+        return {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+      case "PostToolUse":
+        return {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          toolOutput: input.tool_response,
+          isError: input.is_error ?? false
+        };
+      case "SessionStart":
+        return { ...base, source: this.normalizeSource(input.source) };
+      case "SessionEnd":
+        return { ...base, reason: input.message };
+      case "UserPromptSubmit":
+        return { ...base, prompt: input.prompt ?? "" };
+      case "PreCompact":
+        return { ...base, trigger: input.trigger === "manual" ? "manual" : "auto" };
+      case "Stop":
+        return { ...base, stopHookActive: input.stop_hook_active ?? false };
+      case "Notification":
+        return { ...base, message: input.message ?? "" };
+    }
+  }
+  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"
+            }
+          })
+        };
+      }
+      return { exitCode: 0 };
+    }
+    if (response.additionalContext && (event === "SessionStart" || event === "PostToolUse")) {
+      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;
+  }
+  /** Which canonical hook events to register for Codex, honoring overrides. */
+  effectiveHookEvents(ctx) {
+    const override = ctx.connector.platforms[this.id]?.hooks;
+    if (override === false) return [];
+    return CODEX_HOOK_EVENTS.filter((e) => ctx.connector.hookEvents.includes(e));
+  }
+  /**
+   * Render the `[mcp_servers.<id>]` table. TOML has NO interpolation, so every
+   * `${env:VAR}` is resolved to a literal at install time. The env table is a
+   * plain string→string map. Honors the telemetry serve-wrapper.
+   */
+  renderMcpEntry(ctx, server) {
+    let command = server.command;
+    let args = [...server.args ?? []];
+    if (shouldWrapForTelemetry(server, ctx.connector.telemetry)) {
+      const wrapped = buildServeWrapperCommand(ctx.homeBinPath, ctx.connector.id, command, args, ctx.scope, this.id);
+      command = wrapped.command;
+      args = wrapped.args;
+    }
+    command = resolveEnvRefsDeep(command);
+    args = resolveEnvRefsDeep(args);
+    const entry = { 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;
+    }
+    return entry;
+  }
+  /** Render one hooks.json entry pointing at the stable home binary. */
+  renderHookEntry(ctx, event) {
+    const command = buildHomeBinHookCommand(
+      ctx.homeBinPath,
+      "codex",
+      event,
+      ctx.connector.id
+    );
+    const entry = { hooks: [{ type: "command", command }] };
+    if (event === "PreToolUse") entry.matcher = PRE_TOOL_USE_MATCHER;
+    else entry.matcher = "";
+    return entry;
+  }
+  /** Does this hooks.json entry belong to this connector (by home-bin command)? */
+  isOurEntry(ctx, event, entry) {
+    if (!entry || typeof entry !== "object" || !Array.isArray(entry.hooks)) return false;
+    const ours = buildHomeBinHookCommand(ctx.homeBinPath, "codex", event, ctx.connector.id);
+    const needle = ours.replace(/\\/g, "/");
+    return entry.hooks.some((h) => (h.command ?? "").replace(/\\/g, "/") === needle);
+  }
+  readHooksFile(path) {
+    return this.readJson(path) ?? {};
+  }
+  /** Get-or-create a nested table inside a parsed TOML object. */
+  tomlBucket(cfg, key) {
+    const existing = cfg[key];
+    if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+      return existing;
+    }
+    const fresh = {};
+    cfg[key] = fresh;
+    return fresh;
+  }
+  normalizeSource(raw) {
+    switch (raw) {
+      case "compact":
+        return "compact";
+      case "resume":
+        return "resume";
+      case "clear":
+        return "clear";
+      default:
+        return "startup";
+    }
+  }
+};
+var adapter = new CodexAdapter();
+var codex_default = adapter;
+export {
+  CodexAdapter,
+  adapter,
+  codex_default as default
+};
+//# sourceMappingURL=codex-JFQTS6LU.js.map