khala-cli 0.3.0

package/dist/chunk-6GOETMWV.mjs

@@ -0,0 +1,91 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  fail,
+  reserved
+} from "./chunk-GO5DD2TR.mjs";
+
+// src/client.ts
+var KhalaClientError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message ?? code);
+    this.name = "KhalaClientError";
+    this.code = code;
+  }
+};
+
+// ../contracts/src/m1/colors.ts
+var HUMAN_COLOR_IDS = ["red", "orange", "amber", "lime", "green", "teal", "blue", "indigo", "purple", "pink"];
+function isHumanColorId(value) {
+  return typeof value === "string" && HUMAN_COLOR_IDS.includes(value);
+}
+function fnv1a(value) {
+  let hash = 2166136261;
+  for (const byte of new TextEncoder().encode(value)) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash >>> 0;
+}
+function defaultHumanColor(ownerId) {
+  return HUMAN_COLOR_IDS[fnv1a(ownerId) % HUMAN_COLOR_IDS.length];
+}
+function readHumanColorId(input, path) {
+  if (!isHumanColorId(input)) return fail(path, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/m1/initials.ts
+function normalizeInitials(input) {
+  if (typeof input !== "string") return null;
+  const nfc = input.normalize("NFC");
+  if ([...nfc].length !== 2) return null;
+  const up = nfc.toLocaleUpperCase("en-US");
+  return /^[\p{L}\p{Nd}]{2}$/u.test(up) ? up : null;
+}
+function isCanonicalInitials(value) {
+  return typeof value === "string" && normalizeInitials(value) === value;
+}
+function readHumanInitials(input, path) {
+  if (!isCanonicalInitials(input)) return fail(path, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/m1/names.ts
+var USERNAME_MIN = 2;
+var USERNAME_MAX = 24;
+var AGENT_NAME_MIN = 2;
+var AGENT_NAME_MAX = 40;
+var mentionName = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/u;
+var adjacentSeparators = /[._-]{2}/u;
+var agentSuffix = /-(?:claude|codex)(?:-\d+)?$/iu;
+function checkName(input, kind) {
+  if (typeof input !== "string") return { ok: false, error: "invalid_characters" };
+  const name = input.trim();
+  if (name.length < (kind === "username" ? USERNAME_MIN : AGENT_NAME_MIN)) return { ok: false, error: "too_short" };
+  if (name.length > (kind === "username" ? USERNAME_MAX : AGENT_NAME_MAX)) return { ok: false, error: "too_long" };
+  if (!mentionName.test(name) || adjacentSeparators.test(name)) return { ok: false, error: "invalid_characters" };
+  if (reserved.test(name) || kind === "username" && agentSuffix.test(name)) return { ok: false, error: "reserved" };
+  return { ok: true, name };
+}
+var MODEL_NAMES = { claude: "Claude", codex: "Codex" };
+function defaultAgentName(username, harness, n = 1) {
+  return `${username}-${MODEL_NAMES[harness]}${n === 1 ? "" : `-${n}`}`;
+}
+function isDefaultAgentName(name, username, harness) {
+  const escaped = `${username}-${MODEL_NAMES[harness]}`.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`^${escaped}(?:-\\d+)?$`, "iu").test(name);
+}
+
+export {
+  KhalaClientError,
+  isHumanColorId,
+  defaultHumanColor,
+  readHumanColorId,
+  normalizeInitials,
+  readHumanInitials,
+  checkName,
+  MODEL_NAMES,
+  defaultAgentName,
+  isDefaultAgentName
+};

package/dist/chunk-CTXFYQIX.mjs

@@ -0,0 +1,352 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  LOCAL_LONG_POLL_MAX_S,
+  LOCAL_OWNER_USER_ID,
+  decodeLocalErrorBody,
+  decodeLocalEventsPage,
+  decodeLocalHistoryPage,
+  decodeLocalJoined,
+  decodeLocalMe,
+  decodeLocalMemberContent,
+  decodeLocalMembersResponse,
+  decodeLocalNameContent,
+  decodeLocalSendResult,
+  ensureHelper,
+  localRoomPath
+} from "./chunk-ZRUF3P53.mjs";
+import {
+  KhalaClientError
+} from "./chunk-6GOETMWV.mjs";
+import "./chunk-S6XASSNU.mjs";
+import {
+  CHANNEL_EVENT_TYPE,
+  LISTENING_MODE_COMMAND_TYPE
+} from "./chunk-GO5DD2TR.mjs";
+import "./chunk-HMGN52QY.mjs";
+import "./chunk-6FNXMYOM.mjs";
+
+// src/local/session.ts
+import { randomUUID } from "node:crypto";
+var LocalCallError = class extends Error {
+  constructor(status, code) {
+    super(code);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+var LocalNetworkError = class extends Error {
+  constructor(refused2) {
+    super("local_network_error");
+    this.refused = refused2;
+  }
+  refused;
+};
+function decoded(value, decoder) {
+  const result = decoder(value);
+  if (!result.ok) throw new LocalCallError(0, "protocol");
+  return result.value;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("session_stopped"));
+      return;
+    }
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      reject(new Error("session_stopped"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function refused(error) {
+  const cause = error?.cause;
+  return cause?.code === "ECONNREFUSED" || cause?.errors?.some((e) => e.code === "ECONNREFUSED") === true;
+}
+function message(event) {
+  return {
+    eventId: event.eventId,
+    roomId: event.roomId,
+    sender: event.sender,
+    ts: event.ts,
+    type: event.type,
+    body: typeof event.content["body"] === "string" ? event.content["body"] : "",
+    content: event.content
+  };
+}
+async function createLocalSession(creds, opts = {}) {
+  let origin;
+  try {
+    if (!/^http:\/\/(?:127\.0\.0\.1|localhost|\[::1\]):[0-9]+\/?$/iu.test(creds.homeserver)) throw new Error();
+    origin = new URL(creds.homeserver).origin;
+  } catch {
+    throw new KhalaClientError("internal_error", "invalid_local_origin");
+  }
+  const fetchImpl = opts.fetch ?? globalThis.fetch;
+  const pause = opts.sleep ?? sleep;
+  const log = opts.log ?? (() => {
+  });
+  const ensure = async () => {
+    try {
+      await (opts.ensureHelper ?? (async () => {
+        await ensureHelper(process.env);
+      }))();
+    } catch (error) {
+      const code = error?.code;
+      throw new KhalaClientError("internal_error", code === "unsafe_state_dir" || code === "storage_failed" ? code : "helper_unavailable");
+    }
+  };
+  const controller = new AbortController();
+  const names = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Set();
+  const modes = /* @__PURE__ */ new Set();
+  const ended = /* @__PURE__ */ new Set();
+  let stopped = false;
+  let terminal;
+  let joined = false;
+  let joining;
+  let loop;
+  let name;
+  let invitedBy;
+  let after = 0;
+  function check(roomId) {
+    if (stopped) throw new Error("session_stopped");
+    if (roomId !== creds.roomId) throw new Error("unknown_room");
+    if (terminal) throw terminal;
+  }
+  async function request(method, tail, body, signal, timeout = 1e4) {
+    check(creds.roomId);
+    const combined = AbortSignal.any([controller.signal, AbortSignal.timeout(timeout), ...signal ? [signal] : []]);
+    let response;
+    try {
+      response = await fetchImpl(origin + localRoomPath(creds.roomId, tail), {
+        method,
+        headers: { authorization: `Bearer ${creds.accessToken}`, ...body !== void 0 ? { "content-type": "application/json" } : {} },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+        signal: combined
+      });
+    } catch (error) {
+      if (stopped) throw new Error("session_stopped");
+      if (signal?.aborted) throw new Error("request_aborted");
+      throw new LocalNetworkError(refused(error));
+    }
+    if (stopped) throw new Error("session_stopped");
+    if (signal?.aborted) throw new Error("request_aborted");
+    if (response.status === 204) return void 0;
+    let value;
+    try {
+      value = await response.json();
+    } catch {
+      if (stopped) throw new Error("session_stopped");
+      if (signal?.aborted) throw new Error("request_aborted");
+      throw new LocalCallError(response.ok ? 0 : response.status, response.ok ? "protocol" : `http_${response.status}`);
+    }
+    check(creds.roomId);
+    if (signal?.aborted) throw new Error("request_aborted");
+    if (!response.ok) {
+      const error = decodeLocalErrorBody(value);
+      throw new LocalCallError(response.status, error.ok && !error.value.error.includes(creds.accessToken) ? error.value.error : `http_${response.status}`);
+    }
+    return value;
+  }
+  async function withHelper(call) {
+    try {
+      return await call();
+    } catch (error) {
+      if (!(error instanceof LocalNetworkError && error.refused) || stopped) throw error;
+      log("local_helper_restart");
+      await ensure();
+      return call();
+    }
+  }
+  function cache(me2) {
+    if (me2.userId !== creds.userId || me2.roomId !== creds.roomId) throw new LocalCallError(0, "protocol");
+    names.set(me2.userId, me2.displayName);
+    name = me2.roomName;
+    if (me2.invitedBy !== void 0) invitedBy = me2.invitedBy;
+  }
+  async function me() {
+    const value = decoded(await withHelper(() => request("GET", "me")), decodeLocalMe);
+    cache(value);
+    return value;
+  }
+  function dispatch(event) {
+    if (stopped || event.roomId !== creds.roomId) return;
+    if (event.type === "m.room.member") {
+      const content = decoded(event.content, decodeLocalMemberContent);
+      names.set(content.user, content.displayname);
+      return;
+    }
+    if (event.type === "m.room.name") {
+      name = decoded(event.content, decodeLocalNameContent).name;
+      return;
+    }
+    if (event.type === "m.room.create" || event.sender === creds.userId) return;
+    if (event.type === LISTENING_MODE_COMMAND_TYPE) {
+      for (const handler of modes) {
+        if (stopped) break;
+        try {
+          handler({ eventId: event.eventId, roomId: event.roomId, sender: event.sender, ts: event.ts, content: event.content });
+        } catch {
+          log("mode_handler_error");
+        }
+      }
+    } else if (event.type === "m.room.message" || event.type === CHANNEL_EVENT_TYPE) {
+      for (const handler of messages) {
+        if (stopped) break;
+        try {
+          handler(message(event));
+        } catch {
+          log("message_handler_error");
+        }
+      }
+    }
+  }
+  async function run() {
+    let backoff = 500;
+    let streak = 0;
+    let lastEnsureAt = 0;
+    while (!stopped) {
+      try {
+        const page = decoded(await request(
+          "GET",
+          `events?after=${after}&wait=${LOCAL_LONG_POLL_MAX_S}`,
+          void 0,
+          controller.signal,
+          (LOCAL_LONG_POLL_MAX_S + 10) * 1e3
+        ), decodeLocalEventsPage);
+        if (stopped) return;
+        for (const event of page.events) {
+          if (event.seq <= after) continue;
+          after = event.seq;
+          dispatch(event);
+        }
+        backoff = 500;
+        streak = 0;
+        lastEnsureAt = 0;
+      } catch (error) {
+        if (stopped) return;
+        if (error instanceof LocalCallError && [401, 403, 404].includes(error.status)) {
+          terminal = error;
+          log(error.status === 404 ? "local_channel_gone" : "local_session_revoked");
+          const reason = error.status === 404 ? "channel_deleted" : error.status === 403 ? "removed" : "unauthorized";
+          for (const handler of ended) {
+            try {
+              handler(reason);
+            } catch {
+              log("ended_handler_error");
+            }
+          }
+          ended.clear();
+          return;
+        }
+        streak++;
+        if (error instanceof LocalNetworkError && error.refused && (lastEnsureAt === 0 || streak - lastEnsureAt >= 5)) {
+          lastEnsureAt = streak;
+          log("local_helper_restart");
+          try {
+            await ensure();
+          } catch {
+            log("local_helper_unavailable");
+          }
+        }
+        if (stopped) return;
+        try {
+          await pause(backoff, controller.signal);
+        } catch {
+          return;
+        }
+        backoff = Math.min(backoff * 2, 8e3);
+      }
+    }
+  }
+  await me();
+  async function send(roomId, type, content, txnId = `kls-${randomUUID()}`) {
+    check(roomId);
+    return decoded(await withHelper(() => request("POST", "send", { txnId, type, content })), decodeLocalSendResult);
+  }
+  return {
+    userId: creds.userId,
+    onEnded(handler) {
+      if (!stopped) ended.add(handler);
+      return () => {
+        ended.delete(handler);
+      };
+    },
+    inviter: (roomId) => roomId === creds.roomId ? invitedBy ?? LOCAL_OWNER_USER_ID : void 0,
+    roomName: (roomId) => roomId === creds.roomId ? name : void 0,
+    displayName: (userId) => names.get(userId),
+    onMessage(handler) {
+      if (!stopped) messages.add(handler);
+      return () => {
+        messages.delete(handler);
+      };
+    },
+    onListeningModeCommand(handler) {
+      if (!stopped) modes.add(handler);
+      return () => {
+        modes.delete(handler);
+      };
+    },
+    async waitForInvite(roomId, timeoutMs) {
+      check(roomId);
+      for (let i = 0; i < Math.max(1, Math.ceil(timeoutMs / 250)); i++) {
+        const value = await me();
+        if (value.membership === "invite" || value.membership === "join") return;
+        await pause(250, controller.signal);
+        check(roomId);
+      }
+      throw new Error("invite_timeout");
+    },
+    async join(roomId) {
+      check(roomId);
+      if (joined) return;
+      joining ??= (async () => {
+        const result = decoded(await withHelper(() => request("POST", "join", {})), decodeLocalJoined);
+        after = result.seq;
+        await me();
+        const members = decoded(await withHelper(() => request("GET", "members")), decodeLocalMembersResponse);
+        check(roomId);
+        for (const member of members.members) names.set(member.userId, member.displayName);
+        joined = true;
+        loop = run();
+      })();
+      try {
+        await joining;
+      } finally {
+        joining = void 0;
+      }
+    },
+    async history(roomId, limit, before) {
+      check(roomId);
+      const page = decoded(await withHelper(() => request("GET", `messages?limit=${limit}${before !== void 0 ? `&before=${encodeURIComponent(before)}` : ""}`)), decodeLocalHistoryPage);
+      const result = page.events.filter((e) => e.roomId === creds.roomId).map(message);
+      return { messages: result, ...page.nextBefore !== void 0 ? { nextBefore: page.nextBefore } : {} };
+    },
+    send: (roomId, text) => send(roomId, "m.room.message", { msgtype: "m.text", body: text }),
+    sendChannelEvent: (roomId, content, txnId) => send(roomId, CHANNEL_EVENT_TYPE, content, txnId),
+    async publishListeningMode(roomId, mode, signal) {
+      check(roomId);
+      const result = await withHelper(() => request("PUT", `members/${encodeURIComponent(creds.userId)}`, { listeningMode: mode }, signal));
+      if (result !== void 0) throw new LocalCallError(0, "protocol");
+    },
+    async stop() {
+      stopped = true;
+      controller.abort();
+      messages.clear();
+      modes.clear();
+      ended.clear();
+      await loop;
+    }
+  };
+}
+export {
+  createLocalSession
+};

package/dist/chunk-FGIU3YO2.mjs

@@ -0,0 +1,214 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  bundle
+} from "./chunk-HMGN52QY.mjs";
+import "./chunk-6FNXMYOM.mjs";
+
+// src/install/main.ts
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// hooks/hooks.codex.json
+var hooks_codex_default = {
+  hooks: {
+    PostToolUse: [
+      { hooks: [{ type: "command", command: "khala hook deliver --harness codex", timeout: 10 }] }
+    ],
+    UserPromptSubmit: [{ hooks: [{ type: "command", command: "khala hook deliver --harness codex", timeout: 10 }] }],
+    Stop: [{ hooks: [{ type: "command", command: "khala hook deliver --harness codex", timeout: 10 }] }]
+  }
+};
+
+// codex/hooks-config.mjs
+function codexHooksFragment(command = "khala hook deliver --harness codex") {
+  const hooks = {};
+  for (const [event, groups] of Object.entries(hooks_codex_default.hooks)) {
+    hooks[event] = groups.map((group) => ({ ...group, hooks: group.hooks.map((hook) => ({ ...hook, command })) }));
+  }
+  return { hooks };
+}
+function mergeCodexHooks(config, action, hooksFragment = codexHooksFragment()) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("invalid_hooks_config");
+  config.hooks ??= {};
+  if (typeof config.hooks !== "object" || Array.isArray(config.hooks)) throw new Error("invalid_hooks_config");
+  for (const groups of Object.values(config.hooks)) {
+    if (!Array.isArray(groups) || groups.some((group) => !group || !Array.isArray(group.hooks))) {
+      throw new Error("invalid_hooks_config");
+    }
+  }
+  const commands = new Set(Object.values(hooksFragment.hooks).flatMap((groups) => groups.flatMap((group) => group.hooks.map((hook) => hook.command))));
+  const warnings = [];
+  if (action === "install") {
+    for (const [event, groups] of Object.entries(hooksFragment.hooks)) {
+      const existing = config.hooks[event] ??= [];
+      for (const group of groups) {
+        if (!existing.some((item) => item.hooks.some((hook) => hook.command === group.hooks[0].command))) existing.push(group);
+      }
+    }
+    for (const groups of Object.values(config.hooks)) {
+      for (const group of groups) {
+        for (const hook of group.hooks) {
+          if (typeof hook.command === "string" && hook.command.endsWith(" codex-hook")) {
+            warnings.push("warning: remove old Khala handler: " + hook.command);
+          }
+        }
+      }
+    }
+  } else {
+    for (const [event, groups] of Object.entries(config.hooks)) {
+      const remaining = groups.flatMap((group) => {
+        const hooks = group.hooks.filter((hook) => !commands.has(hook.command));
+        if (hooks.length === group.hooks.length) return [group];
+        return hooks.length ? [{ ...group, hooks }] : [];
+      });
+      if (remaining.length === groups.length && remaining.every((group, index) => group === groups[index])) continue;
+      if (remaining.length) config.hooks[event] = remaining;
+      else delete config.hooks[event];
+    }
+  }
+  return { config, warnings };
+}
+
+// src/install/main.ts
+var MCP_MARKER = "# Khala MCP server, managed by `khala install codex`";
+var USAGE = "usage: khala install codex [--codex-home <dir>] [--uninstall]";
+function shellQuote(value) {
+  return /^[A-Za-z0-9_./-]+$/u.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function defaultNpmInstall(prefix, spec) {
+  const result = spawnSync("npm", ["install", "--global", "--prefix", prefix, "--no-audit", "--no-fund", "--loglevel=error", spec], {
+    stdio: ["ignore", "ignore", "inherit"],
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
+}
+function updateCodexToml(text, block) {
+  const lines = text.split("\n");
+  const start = lines.indexOf(MCP_MARKER);
+  if (start >= 0) {
+    let end = start + 2;
+    while (end < lines.length && !/^\s*\[/u.test(lines[end] ?? "")) end++;
+    while (end > start + 2 && (lines[end - 1] ?? "").trim() === "") end--;
+    const from = start > 0 && (lines[start - 1] ?? "").trim() === "" ? start - 1 : start;
+    lines.splice(from, end - from);
+  } else if (lines.some((line) => /^\s*\[\s*mcp_servers\s*\.\s*"?khala"?\s*\]/u.test(line))) {
+    return { error: "codex_mcp_exists" };
+  }
+  let out = lines.join("\n").replace(/\n*$/u, "");
+  if (block) out = (out ? out + "\n\n" : "") + block;
+  return { text: out ? out + "\n" : "" };
+}
+function codexMcpBlock(bin, env) {
+  const home = env.HOME && path.isAbsolute(env.HOME) ? env.HOME : os.homedir();
+  const state = env.XDG_STATE_HOME && path.isAbsolute(env.XDG_STATE_HOME) ? env.XDG_STATE_HOME : path.join(home, ".local/state");
+  return [
+    MCP_MARKER,
+    "[mcp_servers.khala]",
+    `command = ${JSON.stringify(bin)}`,
+    'args = ["mcp", "--harness", "codex"]',
+    `env = { HOME = ${JSON.stringify(home)}, XDG_STATE_HOME = ${JSON.stringify(state)} }`
+  ].join("\n");
+}
+async function readOr(file, fallback) {
+  try {
+    return { text: await fs.readFile(file, "utf8"), mode: (await fs.stat(file)).mode & 511 };
+  } catch (error) {
+    if (error.code === "ENOENT") return { text: fallback, mode: 384 };
+    throw error;
+  }
+}
+async function runInstall(argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => {
+    process.stdout.write(line + "\n");
+  });
+  const stderr = deps.stderr ?? ((line) => {
+    process.stderr.write(line + "\n");
+  });
+  const [target, ...flags] = argv;
+  let codexHome = env.CODEX_HOME && path.isAbsolute(env.CODEX_HOME) ? env.CODEX_HOME : path.join(env.HOME ?? os.homedir(), ".codex");
+  let uninstall = false;
+  for (let i = 0; i < flags.length; i++) {
+    if (flags[i] === "--uninstall") uninstall = true;
+    else if (flags[i] === "--codex-home" && flags[i + 1]) codexHome = path.resolve(flags[++i]);
+    else {
+      stderr(USAGE);
+      return 1;
+    }
+  }
+  if (target !== "codex") {
+    stderr(USAGE);
+    return 1;
+  }
+  const pkg = "package" in deps ? deps.package : bundle;
+  if (!pkg && !uninstall) {
+    stderr("khala: install runs from the published package (npx -y <package> install codex); from a checkout follow packages/agent/docs/install-codex.md");
+    return 1;
+  }
+  const dataHome = env.XDG_DATA_HOME && path.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path.join(env.HOME ?? os.homedir(), ".local/share");
+  const prefix = path.join(dataHome, "khala", "npm");
+  const bin = path.join(prefix, "bin", "khala");
+  const command = `${shellQuote(bin)} hook deliver --harness codex`;
+  const hooksFile = path.join(codexHome, "hooks.json");
+  const tomlFile = path.join(codexHome, "config.toml");
+  const hooks = await readOr(hooksFile, '{"hooks":{}}\n');
+  const toml = await readOr(tomlFile, "");
+  let parsed;
+  try {
+    parsed = JSON.parse(hooks.text);
+  } catch {
+    stderr("khala: invalid hooks.json in " + codexHome);
+    return 1;
+  }
+  let merged;
+  try {
+    merged = mergeCodexHooks(parsed, uninstall ? "uninstall" : "install", codexHooksFragment(command));
+  } catch {
+    stderr("khala: invalid hooks.json in " + codexHome);
+    return 1;
+  }
+  const nextToml = updateCodexToml(toml.text, uninstall ? null : codexMcpBlock(bin, env));
+  if ("error" in nextToml) {
+    stderr(`khala: ${tomlFile} already has an unmanaged [mcp_servers.khala] table; remove it and run this again`);
+    return 1;
+  }
+  if (!uninstall && pkg) {
+    const spec = env.KHALA_INSTALL_SPEC || `${pkg.name}@${pkg.version}`;
+    stdout(`installing ${spec} into ${prefix}`);
+    if (!(deps.npmInstall ?? defaultNpmInstall)(prefix, spec)) {
+      stderr("khala: npm install failed for " + spec);
+      return 1;
+    }
+  }
+  await fs.mkdir(codexHome, { recursive: true });
+  if (!uninstall) {
+    try {
+      await fs.writeFile(hooksFile + ".khala-bak", hooks.text, { flag: "wx", mode: hooks.mode });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+  for (const warning of merged.warnings) stderr(warning);
+  await fs.writeFile(hooksFile, JSON.stringify(merged.config, null, 2) + "\n", { mode: hooks.mode });
+  await fs.writeFile(tomlFile, nextToml.text, { mode: toml.mode });
+  if (uninstall) {
+    stdout(`removed the Khala MCP server and hooks from ${codexHome}; delete ${prefix} to remove the CLI`);
+  } else {
+    stdout(`configured ${tomlFile} and ${hooksFile}`);
+    stdout('restart or resume Codex, then trust the three Khala hooks in "Hooks need review"');
+  }
+  return 0;
+}
+async function main(argv) {
+  return runInstall(argv);
+}
+export {
+  MCP_MARKER,
+  codexMcpBlock,
+  main as default,
+  runInstall,
+  shellQuote,
+  updateCodexToml
+};