kojee-mcp 0.2.1 → 0.4.0

package/dist/cli.js

@@ -1,41 +1,211 @@
 #!/usr/bin/env node
 import {
+  AuthModule,
   startProxy
-} from "./chunk-RNKJONY3.js";
+} from "./chunk-ZGVUM4AG.js";
+import {
+  loadPairedConfig,
+  pairedConfigPath,
+  savePairedConfig
+} from "./chunk-E7TE4QZD.js";
+import "./chunk-36DMIXH7.js";
 
 // src/cli.ts
 import { Command } from "commander";
+import crypto from "crypto";
 import path from "path";
-var DEFAULT_KEYSTORE_PATH = path.join(
-  process.env["HOME"] ?? "~",
-  ".kojee",
-  "keypair.json"
-);
+
+// src/tandem/pair.ts
+import fs from "fs";
+async function runPair(opts) {
+  if (loadPairedConfig(opts.configPath) !== null) {
+    throw new Error(
+      `Already paired (config exists at ${opts.configPath}). To re-pair this slot, delete the config file first. For a second account, use --keystore-path /custom/keypair.json.`
+    );
+  }
+  try {
+    fs.unlinkSync(opts.keystorePath);
+  } catch {
+  }
+  const auth = new AuthModule(opts.code, opts.url, opts.keystorePath);
+  await auth.ensureEnrolled();
+  let principal_id;
+  let agent_id;
+  try {
+    const me = await fetch(`${opts.url}/api/v1/users/me/`, {
+      headers: { Authorization: `DPoP ${opts.code}` }
+    });
+    if (me.ok) {
+      const body = await me.json();
+      principal_id = body.principal_id;
+      agent_id = body.agent_id;
+    }
+  } catch {
+  }
+  const config = {
+    token: opts.code,
+    broker_url: opts.url,
+    paired_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...principal_id ? { principal_id } : {},
+    ...agent_id ? { agent_id } : {}
+  };
+  savePairedConfig(opts.configPath, config);
+  const who = principal_id && agent_id ? `${principal_id} (${agent_id})` : "(use kojee-mcp without args to start the proxy)";
+  return { message: `Paired as ${who}. Keypair: ${opts.keystorePath}. Config: ${opts.configPath}.` };
+}
+
+// src/cli.ts
+var KOJEE_DIR = path.join(process.env["HOME"] ?? "~", ".kojee");
+function deriveKeystorePath(token) {
+  const hash = crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
+  return path.join(KOJEE_DIR, `keypair-${hash}.json`);
+}
+function defaultPairedKeystorePath() {
+  return path.join(KOJEE_DIR, "keypair.json");
+}
 var program = new Command().name("kojee-mcp").description(
   "Local MCP proxy for Kojee \u2014 handles DPoP auth, tool discovery, and governance transparently"
-).version("0.1.0").requiredOption(
-  "--token <token>",
-  "Gateway token (gw_...)"
-).requiredOption(
-  "--url <url>",
-  "Broker base URL (e.g. https://kojee.ai)"
-).option(
-  "--keystore-path <path>",
-  "Path to persisted keypair file",
-  DEFAULT_KEYSTORE_PATH
-).action(async (opts) => {
-  if (!opts.token.startsWith("gw_")) {
+).version("0.3.0").enablePositionalOptions();
+program.command("pair <code>").description("Pair this machine against Kojee using a pair code from the dashboard").requiredOption("--url <url>", "Broker base URL (e.g. https://rosie-server.kojee.net)").option("--keystore-path <path>", "Path to keypair.json (default ~/.kojee/keypair.json)").action(async (code, opts) => {
+  const url = opts.url.replace(/\/+$/, "");
+  const keystorePath = opts.keystorePath ?? defaultPairedKeystorePath();
+  const configPath = opts.keystorePath ? path.join(path.dirname(opts.keystorePath), "config.json") : pairedConfigPath();
+  try {
+    const result = await runPair({ code, url, keystorePath, configPath });
+    console.error(result.message);
+  } catch (err) {
+    console.error("[kojee-mcp pair] Failed:", err.message);
+    process.exit(1);
+  }
+});
+program.command("hook").description("Run a kojee MCP hook script (called by Claude Code via ~/.claude/settings.json)").requiredOption("--type <type>", "Hook type: stop or user-prompt-submit").action(async (opts) => {
+  if (opts.type === "stop") {
+    const { runStopHook } = await import("./stop-hook-5XU3EQAE.js");
+    await runStopHook();
+    process.exit(0);
+  } else if (opts.type === "user-prompt-submit") {
+    const { runUserPromptSubmitHook } = await import("./user-prompt-submit-hook-WSRIJVF4.js");
+    await runUserPromptSubmitHook();
+    process.exit(0);
+  } else {
+    console.error(`Unknown hook type: ${opts.type}. Expected 'stop' or 'user-prompt-submit'.`);
+    process.exit(1);
+  }
+});
+program.command("install-hooks").description("Install kojee Stop + UserPromptSubmit hooks in ~/.claude/settings.json (idempotent)").option("--hooks-path <path>", "Override default ~/.claude/settings.json").option("--uninstall", "Remove kojee hook entries instead of installing them").action(async (opts) => {
+  const { installHooks, uninstallHooks } = await import("./install-WV25CRU2.js");
+  if (opts.uninstall) {
+    const removed = uninstallHooks({ hooksPath: opts.hooksPath });
+    console.error(removed ? "Removed kojee hook entries." : "No kojee hook entries found.");
+  } else {
+    const { stop, ups } = installHooks({ hooksPath: opts.hooksPath });
     console.error(
-      "Warning: Gateway token does not start with 'gw_'. Ensure you are using a valid gateway token."
+      "Installed kojee hooks in " + (opts.hooksPath ?? "~/.claude/settings.json") + `:
+  - Stop:              ${stop === "added" ? "\u2713 added" : "\u21BB already installed"}
+  - UserPromptSubmit:  ${ups === "added" ? "\u2713 added" : "\u21BB already installed"}
+Restart Claude Code for hooks to take effect.`
     );
   }
-  const url = opts.url.replace(/\/+$/, "");
+});
+program.command("init").description("Install kojee into Claude Code (MCP server entry + hooks). Run after `kojee-mcp pair`.").option("--config-path <path>", "Override default ~/.claude.json").option("--uninstall", "Remove the kojee MCP server entry and hooks").action(async (opts) => {
+  const { loadPairedConfig: loadPairedConfig2 } = await import("./paired-config-OAR3O3XY.js");
+  if (loadPairedConfig2() === null && !opts.uninstall) {
+    console.error("Not paired. Run `kojee-mcp pair <code> --url <broker>` first, then re-run `init`.");
+    process.exit(1);
+  }
+  const { runInit, runUninstall } = await import("./install-WV25CRU2.js");
+  if (opts.uninstall) {
+    const report = runUninstall({ configPath: opts.configPath });
+    console.error(formatUninstall(report));
+  } else {
+    const report = runInit({ configPath: opts.configPath });
+    console.error(formatInit(report));
+  }
+});
+function formatInit(report) {
+  const tick = (s) => {
+    if (s === "added") return "\u2713 added";
+    if (s === "already-installed") return "\u21BB already installed";
+    if (s === "preserved-different") return "\u26A0 preserved (existing entry differs \u2014 left untouched)";
+    if (s === "not-found") return "\u2014 not found";
+    return s ?? "\u2014";
+  };
+  const lines = ["Installing kojee for Claude:"];
+  for (const t of report.targets) {
+    const label = t.kind === "cli" ? "CLI" : "Claude.app";
+    lines.push("");
+    lines.push(`  ${t.path} (${label})`);
+    lines.push(`    mcpServers.kojee           ${tick(t.mcpServer)}`);
+    if (t.kind === "cli") {
+      if (t.hooksPath) {
+        lines.push(`  ${t.hooksPath} (hooks)`);
+      }
+      lines.push(`    hooks.Stop                 ${tick(t.stopHook)}`);
+      lines.push(`    hooks.UserPromptSubmit     ${tick(t.userPromptSubmitHook)}`);
+    } else {
+      lines.push(`    (hooks not applicable for Claude.app agent mode)`);
+    }
+  }
+  lines.push("");
+  const desktopWritten = report.targets.some((t) => t.kind === "desktop" && t.mcpServer === "added");
+  if (desktopWritten) {
+    lines.push(
+      "Existing Claude.app agent-mode sessions snapshotted the previous config",
+      "and won't pick up this change automatically. Start a NEW agent-mode",
+      "session (not a resumed one) to use the updated kojee config.",
+      ""
+    );
+  }
+  lines.push("To verify: in any new CC session, run /mcp and confirm `kojee` is listed.");
+  lines.push("                          run /hooks and confirm both Stop and UserPromptSubmit show the kojee entries.");
+  lines.push("To remove: `kojee-mcp init --uninstall`");
+  return lines.join("\n");
+}
+function formatUninstall(report) {
+  const lines = ["Removing kojee from Claude:"];
+  for (const t of report.targets) {
+    const label = t.kind === "cli" ? "CLI" : "Claude.app";
+    lines.push("");
+    lines.push(`  ${t.path} (${label})`);
+    lines.push(`    mcpServers.kojee   ${t.mcpServer ? "\u2713 removed" : "\u2014 not found"}`);
+    if (t.kind === "cli") {
+      if (t.hooksPath) {
+        lines.push(`  ${t.hooksPath} (hooks)`);
+      }
+      lines.push(`    hook entries       ${t.hooks ? "\u2713 removed" : "\u2014 not found"}`);
+    }
+  }
+  return lines.join("\n");
+}
+program.option("--token <token>", "Gateway token (for token-mode)").option("--url <url>", "Broker base URL (for token-mode; required if --token is passed)").option(
+  "--keystore-path <path>",
+  "Path to keypair file (defaults to per-token path under ~/.kojee/)"
+).action(async (opts) => {
+  let token = opts.token;
+  let url = opts.url;
+  let keystorePath = opts.keystorePath;
+  if (token) {
+    if (!url) {
+      console.error("--url is required when --token is provided");
+      process.exit(1);
+    }
+    url = url.replace(/\/+$/, "");
+    keystorePath ??= deriveKeystorePath(token);
+  } else {
+    const { loadPairedConfig: loadPairedConfig2 } = await import("./paired-config-OAR3O3XY.js");
+    const cfg = loadPairedConfig2();
+    if (!cfg) {
+      console.error(
+        "No --token provided and no ~/.kojee/config.json found. Run `kojee-mcp pair <code> --url <broker>` first."
+      );
+      process.exit(1);
+    }
+    token = cfg.token;
+    url = (opts.url ?? cfg.broker_url).replace(/\/+$/, "");
+    keystorePath ??= defaultPairedKeystorePath();
+  }
   try {
-    await startProxy({
-      token: opts.token,
-      url,
-      keystorePath: opts.keystorePath
-    });
+    await startProxy({ token, url, keystorePath });
   } catch (err) {
     console.error("[kojee-mcp] Fatal error:", err);
     process.exit(1);

package/dist/event-log-ETWR6PPY.js

@@ -0,0 +1,112 @@
+import {
+  sessionDiscoveryDir
+} from "./chunk-VZVGTHGF.js";
+
+// src/tandem/event-log.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_DIR = "/tmp";
+var MAX_BODY_CHARS = 200;
+var DEFAULT_MIN_AGE_MS = 6e4;
+function startEventLog(opts) {
+  const dir = opts.dir ?? DEFAULT_DIR;
+  const filePath = path.join(dir, `kojee-events-${opts.key}.log`);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, "", { mode: 384 });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+  return {
+    path: filePath,
+    async append(event) {
+      const line = formatLine(event);
+      try {
+        await fs.promises.appendFile(filePath, line + "\n", { encoding: "utf8" });
+      } catch (err) {
+        console.error("[event-log] append failed:", err.message);
+      }
+    },
+    cleanup() {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  };
+}
+function formatLine(event) {
+  const body = (event.content?.body ?? "").replace(/[\r\n]+/g, " ").slice(0, MAX_BODY_CHARS + 1);
+  const truncated = body.length > MAX_BODY_CHARS;
+  const safeBody = truncated ? body.slice(0, MAX_BODY_CHARS) + "\u2026" : body;
+  return `[${event.time}] tandem=${event.tandem_id} from=${event.from.displayname} (${event.from.principal}) kind=${event.kind} cursor=${event.cursor}: ${safeBody}`;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+function listActiveSessionIds() {
+  const dir = sessionDiscoveryDir();
+  const active = /* @__PURE__ */ new Set();
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return active;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    const rawId = name.slice(0, -".json".length);
+    const sessionId = rawId.startsWith("cc-") ? rawId.slice("cc-".length) : rawId;
+    const filePath = path.join(dir, name);
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+      if (typeof data.pid === "number" && isProcessAlive(data.pid)) {
+        active.add(sessionId);
+      } else {
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return active;
+}
+function sweepStaleEventLogs(dir = DEFAULT_DIR, minAgeMs = DEFAULT_MIN_AGE_MS) {
+  try {
+    fs.unlinkSync(path.join(dir, "kojee-events-no-session.log"));
+  } catch {
+  }
+  const active = listActiveSessionIds();
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const name of entries) {
+    if (!name.startsWith("kojee-events-") || !name.endsWith(".log")) continue;
+    const sessionId = name.slice("kojee-events-".length, -".log".length);
+    if (active.has(sessionId)) continue;
+    const filePath = path.join(dir, name);
+    try {
+      const stat = fs.statSync(filePath);
+      const ageMs = Math.max(0, now - stat.mtimeMs);
+      if (ageMs < minAgeMs) continue;
+      fs.unlinkSync(filePath);
+    } catch {
+    }
+  }
+}
+export {
+  startEventLog,
+  sweepStaleEventLogs
+};

package/dist/event-queue-5YVJFR3E.js

@@ -0,0 +1,43 @@
+// src/tandem/event-queue.ts
+var EventQueue = class {
+  entries = [];
+  capacity;
+  maxAgeMs;
+  constructor(opts = {}) {
+    this.capacity = opts.capacity ?? 200;
+    this.maxAgeMs = opts.maxAgeMs ?? 10 * 6e4;
+  }
+  push(event) {
+    const now = Date.now();
+    this.entries = this.entries.filter((e) => now - e.receivedAt <= this.maxAgeMs);
+    this.entries.push({
+      event,
+      receivedAt: now,
+      deliveredViaChannel: false,
+      deliveredViaMonitor: false,
+      deliveredViaHook: false
+    });
+    while (this.entries.length > this.capacity) this.entries.shift();
+  }
+  markChannelDelivered(eventId) {
+    const entry = this.entries.find((e) => e.event.id === eventId);
+    if (entry) entry.deliveredViaChannel = true;
+  }
+  markMonitorDelivered(eventId) {
+    const entry = this.entries.find((e) => e.event.id === eventId);
+    if (entry) entry.deliveredViaMonitor = true;
+  }
+  takeForHook() {
+    const eligible = this.entries.filter(
+      (e) => !e.deliveredViaChannel && !e.deliveredViaMonitor && !e.deliveredViaHook
+    );
+    for (const e of eligible) e.deliveredViaHook = true;
+    return eligible;
+  }
+  snapshot() {
+    return [...this.entries];
+  }
+};
+export {
+  EventQueue
+};

package/dist/hook-server-43QS7L7P.js

@@ -0,0 +1,71 @@
+// src/tandem/hook-server.ts
+import { createServer } from "http";
+async function startHookServer(opts) {
+  const server = createServer((req, res) => {
+    handleRequest(req, res, opts).catch((err) => {
+      console.error("[hook-server] error:", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "internal_error" }));
+      }
+    });
+  });
+  await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+  const addr = server.address();
+  return {
+    port: addr.port,
+    stop: () => new Promise((resolve, reject) => {
+      server.close((err) => err ? reject(err) : resolve());
+    })
+  };
+}
+async function handleRequest(req, res, opts) {
+  const url = new URL(req.url ?? "/", "http://x");
+  if (req.method === "GET" && url.pathname === "/health") {
+    return json(res, 200, { ok: true });
+  }
+  if (req.method === "GET" && url.pathname === "/poll") {
+    const type = url.searchParams.get("type") ?? "";
+    const timeoutMs = Number.parseInt(url.searchParams.get("timeout_ms") ?? "0", 10);
+    if (type === "user-prompt-submit") {
+      return respondWithEvents(res, opts);
+    }
+    if (type === "stop") {
+      return longPollAndRespond(res, opts, Math.max(0, timeoutMs));
+    }
+    return json(res, 400, { error: "unknown type", detail: "type must be 'stop' or 'user-prompt-submit'" });
+  }
+  return json(res, 404, { error: "not_found", detail: `${req.method} ${url.pathname}` });
+}
+function respondWithEvents(res, opts) {
+  const entries = opts.queue.takeForHook();
+  const events = entries.map((entry) => opts.adapter.formatTandemEvent(entry.event));
+  json(res, 200, { events, count: events.length });
+}
+async function longPollAndRespond(res, opts, timeoutMs) {
+  const immediate = opts.queue.takeForHook();
+  if (immediate.length > 0) {
+    const events = immediate.map((e) => opts.adapter.formatTandemEvent(e.event));
+    return json(res, 200, { events, count: events.length });
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await sleep(100);
+    const batch = opts.queue.takeForHook();
+    if (batch.length > 0) {
+      const events = batch.map((e) => opts.adapter.formatTandemEvent(e.event));
+      return json(res, 200, { events, count: events.length });
+    }
+  }
+  json(res, 200, { events: [], count: 0 });
+}
+function json(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export {
+  startHookServer
+};

package/dist/index.d.ts

@@ -4,16 +4,6 @@ interface ProxyConfig {
     keystorePath: string;
 }
 
-/**
- * Bootstrap and start the Kojee MCP proxy.
- *
- * Startup sequence:
- * 1. Enroll keypair (or load existing)
- * 2. Derive session ID
- * 3. Create gateway client
- * 4. Discover tools from gateway
- * 5. Start MCP stdio server
- */
 declare function startProxy(config: ProxyConfig): Promise<void>;
 
 export { type ProxyConfig, startProxy };

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
   startProxy
-} from "./chunk-RNKJONY3.js";
+} from "./chunk-ZGVUM4AG.js";
+import "./chunk-36DMIXH7.js";
 export {
   startProxy
 };

package/dist/install-WV25CRU2.js

@@ -0,0 +1,182 @@
+// src/hooks/install.ts
+import fs from "fs";
+import path from "path";
+function discoverInstallTargets() {
+  const home = process.env["HOME"] ?? "~";
+  const targets = [];
+  const cliPath = path.join(home, ".claude.json");
+  const cliHooksPath = path.join(home, ".claude", "settings.json");
+  targets.push({ kind: "cli", path: cliPath, exists: fs.existsSync(cliPath), hooksPath: cliHooksPath });
+  let desktopPath = null;
+  if (process.platform === "darwin") {
+    desktopPath = path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "win32") {
+    const appData = process.env["APPDATA"] ?? path.join(home, "AppData", "Roaming");
+    desktopPath = path.join(appData, "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "linux") {
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? path.join(home, ".config");
+    desktopPath = path.join(xdgConfig, "Claude", "claude_desktop_config.json");
+  }
+  if (desktopPath) {
+    targets.push({ kind: "desktop", path: desktopPath, exists: fs.existsSync(desktopPath) });
+  }
+  return targets;
+}
+var STOP_COMMAND = "npx -y kojee-mcp hook --type=stop";
+var UPS_COMMAND = "npx -y kojee-mcp hook --type=user-prompt-submit";
+var MCP_SERVER_CMD = "npx";
+var MCP_SERVER_ARGS = ["kojee-mcp"];
+var MCP_SERVER_ENV = { KOJEE_RUNTIME: "claude-code" };
+function defaultConfigPath() {
+  return path.join(process.env["HOME"] ?? "~", ".claude.json");
+}
+function defaultHooksPath() {
+  return path.join(process.env["HOME"] ?? "~", ".claude", "settings.json");
+}
+function deriveHooksPath(configPath) {
+  return path.join(path.dirname(configPath), ".claude", "settings.json");
+}
+function readConfig(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(p, cfg) {
+  const dir = path.dirname(p);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(cfg, null, 2), { mode: 384 });
+  try {
+    fs.chmodSync(p, 384);
+  } catch {
+  }
+}
+function hasKojeeEntry(arr, command) {
+  if (!arr) return false;
+  return arr.some((e) => e.hooks.some((h) => h.command === command));
+}
+function installHookEntry(cfg, event, command) {
+  cfg.hooks ??= {};
+  cfg.hooks[event] ??= [];
+  if (hasKojeeEntry(cfg.hooks[event], command)) return "already-installed";
+  cfg.hooks[event].push({ hooks: [{ type: "command", command }] });
+  return "added";
+}
+function uninstallHookEntries(cfg) {
+  let removed = false;
+  if (!cfg.hooks) return false;
+  for (const event of ["Stop", "UserPromptSubmit"]) {
+    const arr = cfg.hooks[event];
+    if (!arr) continue;
+    const before = arr.length;
+    cfg.hooks[event] = arr.filter(
+      (entry) => !entry.hooks.some((h) => h.command.startsWith("npx -y kojee-mcp hook"))
+    );
+    if (cfg.hooks[event].length !== before) removed = true;
+  }
+  return removed;
+}
+function installHooks(opts = {}) {
+  const p = opts.hooksPath ?? (opts.configPath ? deriveHooksPath(opts.configPath) : defaultHooksPath());
+  const cfg = readConfig(p);
+  const stop = installHookEntry(cfg, "Stop", STOP_COMMAND);
+  const ups = installHookEntry(cfg, "UserPromptSubmit", UPS_COMMAND);
+  writeConfig(p, cfg);
+  return { stop, ups };
+}
+function uninstallHooks(opts = {}) {
+  const p = opts.hooksPath ?? (opts.configPath ? deriveHooksPath(opts.configPath) : defaultHooksPath());
+  const cfg = readConfig(p);
+  const removed = uninstallHookEntries(cfg);
+  writeConfig(p, cfg);
+  return removed;
+}
+function installMcpServer(opts = {}) {
+  const p = opts.configPath ?? defaultConfigPath();
+  const cfg = readConfig(p);
+  cfg.mcpServers ??= {};
+  const existing = cfg.mcpServers["kojee"];
+  if (existing) {
+    const sameCommand = existing.command === MCP_SERVER_CMD;
+    const sameArgs = JSON.stringify(existing.args ?? []) === JSON.stringify(MCP_SERVER_ARGS);
+    const sameEnv = JSON.stringify(existing.env ?? {}) === JSON.stringify(MCP_SERVER_ENV);
+    if (sameCommand && sameArgs && sameEnv) return "already-installed";
+    return "preserved-different";
+  }
+  cfg.mcpServers["kojee"] = {
+    command: MCP_SERVER_CMD,
+    args: [...MCP_SERVER_ARGS],
+    env: { ...MCP_SERVER_ENV }
+  };
+  writeConfig(p, cfg);
+  return "added";
+}
+function uninstallMcpServer(opts = {}) {
+  const p = opts.configPath ?? defaultConfigPath();
+  const cfg = readConfig(p);
+  if (!cfg.mcpServers || !cfg.mcpServers["kojee"]) return false;
+  delete cfg.mcpServers["kojee"];
+  writeConfig(p, cfg);
+  return true;
+}
+function runInit(opts = {}) {
+  const targets = opts.configPath ? [{
+    kind: "cli",
+    path: opts.configPath,
+    exists: true,
+    hooksPath: opts.hooksPath ?? deriveHooksPath(opts.configPath)
+  }] : discoverInstallTargets();
+  const reports = [];
+  for (const t of targets) {
+    if (!t.exists) {
+      reports.push({ kind: t.kind, path: t.path, ...t.hooksPath ? { hooksPath: t.hooksPath } : {}, mcpServer: "not-found" });
+      continue;
+    }
+    const mcpServer = installMcpServer({ configPath: t.path });
+    let stopHook;
+    let upsHook;
+    if (t.kind === "cli") {
+      const hookReport = installHooks({ hooksPath: t.hooksPath ?? deriveHooksPath(t.path) });
+      stopHook = hookReport.stop;
+      upsHook = hookReport.ups;
+    }
+    reports.push({
+      kind: t.kind,
+      path: t.path,
+      ...t.hooksPath ? { hooksPath: t.hooksPath } : {},
+      mcpServer,
+      ...stopHook ? { stopHook } : {},
+      ...upsHook ? { userPromptSubmitHook: upsHook } : {}
+    });
+  }
+  return { targets: reports, configPath: targets[0]?.path };
+}
+function runUninstall(opts = {}) {
+  const targets = opts.configPath ? [{
+    kind: "cli",
+    path: opts.configPath,
+    exists: true,
+    hooksPath: opts.hooksPath ?? deriveHooksPath(opts.configPath)
+  }] : discoverInstallTargets();
+  const reports = [];
+  for (const t of targets) {
+    if (!t.exists) {
+      reports.push({ kind: t.kind, path: t.path, ...t.hooksPath ? { hooksPath: t.hooksPath } : {}, mcpServer: false, hooks: false });
+      continue;
+    }
+    const mcpServer = uninstallMcpServer({ configPath: t.path });
+    const hooks = t.kind === "cli" ? uninstallHooks({ hooksPath: t.hooksPath ?? deriveHooksPath(t.path) }) : false;
+    reports.push({ kind: t.kind, path: t.path, ...t.hooksPath ? { hooksPath: t.hooksPath } : {}, mcpServer, hooks });
+  }
+  return { targets: reports, configPath: targets[0]?.path };
+}
+export {
+  discoverInstallTargets,
+  installHooks,
+  installMcpServer,
+  runInit,
+  runUninstall,
+  uninstallHooks,
+  uninstallMcpServer
+};

package/dist/paired-config-OAR3O3XY.js

@@ -0,0 +1,10 @@
+import {
+  loadPairedConfig,
+  pairedConfigPath,
+  savePairedConfig
+} from "./chunk-E7TE4QZD.js";
+export {
+  loadPairedConfig,
+  pairedConfigPath,
+  savePairedConfig
+};