kojee-mcp 0.5.13 → 0.5.15

package/dist/wizard-3FDEWEYO.js

@@ -0,0 +1,904 @@
+import {
+  clearRuntimeRecord,
+  readRecordedRuntime,
+  recordRuntime
+} from "./chunk-EW72ZNQL.js";
+import {
+  buildCodexMcpServerTable,
+  buildCodexStopHookBlock,
+  removeCodexConfig,
+  writeCodexConfig
+} from "./chunk-65KRRDHP.js";
+import {
+  kojeeHomeDir
+} from "./chunk-SQL56SEB.js";
+import {
+  WIZARD_RUNTIMES,
+  isWizardRuntime
+} from "./chunk-77HWBSRH.js";
+import {
+  resolveSignatureEmission,
+  resolveWebhookConfig
+} from "./chunk-V5VZPYMZ.js";
+import {
+  secureFile
+} from "./chunk-BLEGIR35.js";
+import {
+  CODEX_LISTEN_CAP_MS,
+  buildWebhookReceiverNote
+} from "./chunk-X672ZN7V.js";
+
+// src/wizard/wizard.ts
+import crypto2 from "crypto";
+import fs5 from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+
+// src/wizard/registry.ts
+var installers = /* @__PURE__ */ new Map();
+function register(installer) {
+  installers.set(installer.id, installer);
+}
+function getInstaller(id) {
+  return installers.get(id);
+}
+function runtimeUsesWebhook(id) {
+  return getInstaller(id)?.capabilities.includes("webhook") ?? false;
+}
+
+// src/wizard/capabilities/webhook-secret.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+function generateSecret() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function readSecretFromEnv(envPath) {
+  let body;
+  try {
+    body = fs.readFileSync(envPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const m = body.match(/^(?:export\s+)?KOJEE_WEBHOOK_SECRET=(.*)$/m);
+  if (!m) return void 0;
+  const raw = m[1].trim().replace(/^['"]|['"]$/g, "");
+  return raw.length > 0 ? raw : void 0;
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function upsertEnvFile(filePath, vars, opts = {}) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  let lines = [];
+  try {
+    lines = fs.readFileSync(filePath, "utf8").split("\n");
+  } catch {
+  }
+  if (opts.header && !lines.some((l) => l === opts.header)) lines.unshift(opts.header);
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const pre = opts.exportPrefix ? "export " : "";
+  for (const [k, v] of vars) {
+    const line = `${pre}${k}=${shellSingleQuote(v)}`;
+    const idx = lines.findIndex((l) => l.startsWith(`${k}=`) || l.startsWith(`export ${k}=`));
+    if (idx >= 0) lines[idx] = line;
+    else lines.push(line);
+  }
+  fs.writeFileSync(filePath, lines.join("\n") + "\n", { mode: 384 });
+}
+function writeWebhookSecretBothSides(opts) {
+  const existing = opts.existingSecret ?? readSecretFromEnv(opts.daemonEnvPath) ?? readSecretFromEnv(opts.adapterEnvPath);
+  const secret = existing ?? generateSecret();
+  const reused = existing !== void 0;
+  const daemonVars = [
+    ["KOJEE_RUNTIME", opts.runtime],
+    ["KOJEE_WEBHOOK_URL", opts.webhookUrl],
+    ["KOJEE_WEBHOOK_SECRET", secret],
+    ...opts.signatureEnv ?? []
+  ];
+  upsertEnvFile(opts.daemonEnvPath, daemonVars, {
+    exportPrefix: true,
+    header: `# kojee daemon env for runtime=${opts.runtime} (source this before starting the daemon)`
+  });
+  secureFile(opts.daemonEnvPath);
+  const adapterVars = [
+    ["KOJEE_WEBHOOK_SECRET", secret],
+    ...opts.mcpDir ? [["KOJEE_MCP_DIR", opts.mcpDir]] : [],
+    ...opts.allowAllUsers ? [["KOJEE_TANDEM_ALLOW_ALL_USERS", "true"]] : []
+  ];
+  upsertEnvFile(opts.adapterEnvPath, adapterVars);
+  secureFile(opts.adapterEnvPath);
+  return { secret, reused, daemonEnvPath: opts.daemonEnvPath, adapterEnvPath: opts.adapterEnvPath };
+}
+
+// src/wizard/installers/hermes.ts
+import path4 from "path";
+
+// src/wizard/plugin-payload.ts
+import fs2 from "fs";
+import path2 from "path";
+var HERMES_PAYLOAD_FILES = [
+  "__init__.py",
+  "adapter.py",
+  "kojee_tandem_core.py",
+  "plugin.yaml"
+];
+function stagePluginPayload(opts) {
+  fs2.mkdirSync(opts.destDir, { recursive: true });
+  const written = [];
+  for (const file of opts.files) {
+    const src = path2.join(opts.srcDir, file);
+    if (!fs2.existsSync(src)) {
+      throw new Error(
+        `stagePluginPayload: missing payload file '${file}' in ${opts.srcDir}`
+      );
+    }
+    const dest = path2.join(opts.destDir, file);
+    fs2.copyFileSync(src, dest);
+    written.push(dest);
+  }
+  return written;
+}
+function resolveBundledPayloadDir(runtime, baseDir) {
+  const dir = path2.join(baseDir, "plugins", runtime);
+  if (!fs2.existsSync(dir) || !fs2.statSync(dir).isDirectory()) {
+    throw new Error(
+      `resolveBundledPayloadDir: no bundled payload for '${runtime}' at ${dir} \u2014 run the build (npm run build) so dist/plugins is staged.`
+    );
+  }
+  return dir;
+}
+function missingPayloadFiles(runtime, baseDir, files) {
+  const dir = path2.join(baseDir, "plugins", runtime);
+  const dirOk = fs2.existsSync(dir) && fs2.statSync(dir).isDirectory();
+  if (!dirOk) return [...files];
+  return files.filter((f) => !fs2.existsSync(path2.join(dir, f)));
+}
+function installBundledPayload(opts) {
+  const srcDir = resolveBundledPayloadDir(opts.runtime, opts.baseDir);
+  return stagePluginPayload({ srcDir, destDir: opts.destDir, files: opts.files });
+}
+
+// src/wizard/service.ts
+import fs3 from "fs";
+import path3 from "path";
+function systemdUnit(spec) {
+  return [
+    "[Unit]",
+    `Description=kojee-mcp daemon (${spec.runtime} runtime) \u2014 Tandem wake sidecar`,
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `EnvironmentFile=${spec.envFile}`,
+    `Environment=KOJEE_RUNTIME=${spec.runtime}`,
+    `ExecStart=${spec.binPath}`,
+    "Restart=always",
+    "RestartSec=5",
+    "StandardOutput=journal",
+    "StandardError=journal",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function darwinLabel(serviceName) {
+  return `net.kojee.${serviceName}`;
+}
+function launchdPlist(spec, label) {
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>Label</key>",
+    `  <string>${label}</string>`,
+    "  <key>ProgramArguments</key>",
+    `  <array><string>${spec.binPath}</string></array>`,
+    "  <key>EnvironmentVariables</key>",
+    `  <dict><key>KOJEE_RUNTIME</key><string>${spec.runtime}</string></dict>`,
+    "  <key>RunAtLoad</key><true/>",
+    "  <key>KeepAlive</key><true/>",
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+function planService(platform, spec) {
+  if (platform === "linux") {
+    const unitPath = path3.join(
+      spec.homeDir,
+      ".config",
+      "systemd",
+      "user",
+      `${spec.serviceName}.service`
+    );
+    return {
+      supported: true,
+      unitPath,
+      unitContent: systemdUnit(spec),
+      activateCmd: `systemctl --user daemon-reload && systemctl --user enable --now ${spec.serviceName}`,
+      deactivateCmd: `systemctl --user disable --now ${spec.serviceName}`
+    };
+  }
+  if (platform === "darwin") {
+    const label = darwinLabel(spec.serviceName);
+    const unitPath = path3.join(spec.homeDir, "Library", "LaunchAgents", `${label}.plist`);
+    return {
+      supported: true,
+      unitPath,
+      unitContent: launchdPlist(spec, label),
+      activateCmd: `launchctl load -w ${unitPath}`,
+      deactivateCmd: `launchctl unload -w ${unitPath}`
+    };
+  }
+  const manual = `schtasks /create /tn ${spec.serviceName} /sc onlogon /tr "${spec.binPath}" /f (wrap it to set KOJEE_RUNTIME=${spec.runtime} and load ${spec.envFile}), or run directly: KOJEE_RUNTIME=${spec.runtime} ${spec.binPath}`;
+  return {
+    supported: false,
+    activateCmd: manual,
+    deactivateCmd: `schtasks /delete /tn ${spec.serviceName} /f`,
+    note: "Auto-service install isn't supported on this platform yet; run the command above to keep the daemon up."
+  };
+}
+function writeService(platform, spec) {
+  const plan = planService(platform, spec);
+  if (plan.supported && plan.unitPath && plan.unitContent !== void 0) {
+    fs3.mkdirSync(path3.dirname(plan.unitPath), { recursive: true });
+    fs3.writeFileSync(plan.unitPath, plan.unitContent, { mode: 420 });
+  }
+  return plan;
+}
+
+// src/wizard/installers/hermes.ts
+function installHermes(inp) {
+  const daemonEnv = path4.join(inp.homeDir, ".kojee", "hermes.env");
+  const adapterEnv = path4.join(inp.homeDir, ".hermes", ".env");
+  const pluginDir = path4.join(inp.homeDir, ".hermes", "plugins", "kojee-tandem");
+  if (!inp.skipPayload) {
+    const missing = missingPayloadFiles("hermes", inp.payloadBaseDir, HERMES_PAYLOAD_FILES);
+    if (missing.length > 0) {
+      return {
+        runtime: "hermes",
+        output: `hermes install ERROR: the bundled plugin payload is incomplete \u2014 missing ${missing.join(", ")} under ${path4.join(inp.payloadBaseDir, "plugins", "hermes")}. No changes were written. Run \`npm run build\` to stage dist/plugins/hermes, then retry.`,
+        exitCode: 2,
+        secret: "",
+        secretReused: false
+      };
+    }
+  }
+  const sec = writeWebhookSecretBothSides({
+    daemonEnvPath: daemonEnv,
+    adapterEnvPath: adapterEnv,
+    webhookUrl: inp.webhookUrl,
+    runtime: "hermes",
+    ...inp.mcpDir ? { mcpDir: inp.mcpDir } : {},
+    ...inp.allowAllUsers ? { allowAllUsers: true } : {},
+    ...inp.signatureEnv && inp.signatureEnv.length > 0 ? { signatureEnv: inp.signatureEnv } : {},
+    ...inp.webhookSecret ? { existingSecret: inp.webhookSecret } : {}
+  });
+  const staged = inp.skipPayload ? [] : installBundledPayload({
+    runtime: "hermes",
+    baseDir: inp.payloadBaseDir,
+    destDir: pluginDir,
+    files: [...HERMES_PAYLOAD_FILES]
+  });
+  const svc = writeService(inp.platform, {
+    serviceName: "kojee-hermes",
+    binPath: inp.binPath,
+    envFile: daemonEnv,
+    runtime: "hermes",
+    homeDir: inp.homeDir
+  });
+  const lines = [
+    "Configured runtime: hermes (complete install)",
+    `  secret:      ${sec.reused ? "reused existing" : "generated"} (matched on daemon + adapter env)`,
+    `  daemon env:  ${daemonEnv}`,
+    `  adapter env: ${adapterEnv}`,
+    inp.skipPayload ? `  plugin:      SKIPPED \u2014 no bundled payload (run \`npm run build\` to stage dist/plugins/hermes)` : `  plugin:      ${pluginDir} (${staged.length} files)`,
+    svc.supported ? `  service:     ${svc.unitPath}` : `  service:     manual \u2014 ${svc.note ?? "unsupported platform"}`,
+    // NB: the "Receiver contract" section is intentionally NOT printed here.
+    // configureHermes prints buildDaemonEnvBlock (the single contract owner for
+    // every daemon runtime) on the same URL-present path before this output, so
+    // emitting it here too would print the contract twice.
+    "",
+    "Next:",
+    `  - start the daemon service:  ${svc.activateCmd}`,
+    "  - reload the Hermes gateway to load the plugin:  systemctl --user restart hermes-gateway (or: hermes gateway restart)",
+    "  - join a tandem once:  tandem_join <tandem_id>",
+    "  - verify:  kojee-mcp doctor"
+  ];
+  return {
+    runtime: "hermes",
+    output: lines.join("\n"),
+    exitCode: 0,
+    secret: sec.secret,
+    secretReused: sec.reused
+  };
+}
+
+// src/wizard/capabilities/openclaw-channel-config.ts
+import fs4 from "fs";
+import path5 from "path";
+var CHANNEL_ID = "kojee-tandem";
+function mergeOpenclawChannelConfig(existing, block) {
+  const prevChannels = existing.channels && typeof existing.channels === "object" ? existing.channels : {};
+  return {
+    ...existing,
+    channels: {
+      ...prevChannels,
+      [CHANNEL_ID]: { ...block }
+    }
+  };
+}
+function readOpenclawConfigState(configPath) {
+  let raw;
+  try {
+    raw = fs4.readFileSync(configPath, "utf8");
+  } catch {
+    return { cfg: {}, unparseable: false };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      cfg: parsed && typeof parsed === "object" ? parsed : {},
+      unparseable: false
+    };
+  } catch {
+    return { cfg: {}, unparseable: true };
+  }
+}
+function atomicWrite(filePath, content, secret) {
+  fs4.mkdirSync(path5.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  fs4.writeFileSync(tmp, content, { ...secret ? { mode: 384 } : {} });
+  if (secret) secureFile(tmp);
+  fs4.renameSync(tmp, filePath);
+  if (secret) secureFile(filePath);
+}
+function writeOpenclawChannelConfig(configPath, block, opts = {}) {
+  const { cfg, unparseable } = readOpenclawConfigState(configPath);
+  let backedUp;
+  if (unparseable) {
+    const stamp = opts.timestamp ?? corruptStamp();
+    backedUp = `${configPath}.corrupt-${stamp}`;
+    fs4.copyFileSync(configPath, backedUp);
+  }
+  const merged = mergeOpenclawChannelConfig(cfg, block);
+  atomicWrite(configPath, JSON.stringify(merged, null, 2) + "\n", Boolean(block.credential));
+  return backedUp ? { backedUp } : {};
+}
+function corruptStamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
+function removeOpenclawChannel(configPath) {
+  let raw;
+  try {
+    raw = fs4.readFileSync(configPath, "utf8");
+  } catch {
+    return false;
+  }
+  let cfg;
+  try {
+    cfg = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  const channels = cfg.channels && typeof cfg.channels === "object" ? cfg.channels : void 0;
+  if (!channels || !(CHANNEL_ID in channels)) return false;
+  const { [CHANNEL_ID]: _removed, ...rest } = channels;
+  const next = { ...cfg, channels: rest };
+  atomicWrite(configPath, JSON.stringify(next, null, 2) + "\n", false);
+  return true;
+}
+
+// src/wizard/installers/openclaw.ts
+function installOpenclaw(inp) {
+  const gatewayUrl = inp.url ? inp.url.replace(/\/+$/, "") : void 0;
+  const block = {
+    enabled: true,
+    ...gatewayUrl ? { gatewayUrl } : {},
+    // Token-mode → credential lands here (config-first). Paired-mode → omitted.
+    ...inp.token ? { credential: inp.token } : {},
+    tandems: [],
+    selfPrincipals: [],
+    wake: { severities: [], mentionsOnly: false }
+  };
+  const stamp = (inp.now ? inp.now() : /* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const { backedUp } = writeOpenclawChannelConfig(inp.openclawConfigPath, block, { timestamp: stamp });
+  const installCmd = inp.pluginSourceDir ? `openclaw plugins install -l ${inp.pluginSourceDir}` : `openclaw plugins install npm:openclaw-channel-kojee-tandem  (available once published)`;
+  const lines = [];
+  if (backedUp) {
+    lines.push(
+      `WARNING: ${inp.openclawConfigPath} was present but could not be parsed as JSON.`,
+      `         The original was backed up to ${backedUp} before writing the kojee-tandem block.`,
+      `         If it held other channels, recover them from that backup and re-merge by hand.`,
+      ""
+    );
+  }
+  lines.push(
+    "Configured runtime: openclaw (in-process channel plugin)",
+    "Wake mode: native OpenClaw channel \u2014 the plugin streams Tandem events while the gateway is up.",
+    `  channel config:  ${inp.openclawConfigPath} (channels.${CHANNEL_ID})`,
+    inp.token ? `  credential:      written into the channel block (owner-only perms; the plugin's config-first path)` : `  credential:      shared ~/.kojee/config.json (paired) \u2014 not duplicated into the channel block`,
+    "",
+    "Next steps (openclaw):",
+    `  - Install the plugin via OpenClaw's own plugin manager:  ${installCmd}`,
+    "  - Reload the gateway to load the plugin:  openclaw gateway restart",
+    "  - Verify:  openclaw plugins inspect kojee-tandem  /  openclaw channels status"
+  );
+  return {
+    runtime: "openclaw",
+    output: lines.join("\n"),
+    exitCode: 0,
+    configPath: inp.openclawConfigPath
+  };
+}
+function uninstallOpenclaw(inp) {
+  const removed = removeOpenclawChannel(inp.openclawConfigPath);
+  const lines = ["Uninstalling runtime: openclaw (in-process channel plugin)"];
+  lines.push(
+    removed ? `  removed channels.${CHANNEL_ID} from ${inp.openclawConfigPath} (sibling channels preserved)` : `  no channels.${CHANNEL_ID} block found in ${inp.openclawConfigPath} \u2014 nothing to remove`
+  );
+  lines.push("");
+  lines.push("Next steps (openclaw):");
+  lines.push("  - Remove the plugin via OpenClaw's own plugin manager:  openclaw plugins uninstall kojee-tandem");
+  lines.push("  - Reload the gateway:  openclaw gateway restart");
+  return {
+    runtime: "openclaw",
+    output: lines.join("\n"),
+    exitCode: 0,
+    configPath: inp.openclawConfigPath
+  };
+}
+
+// src/wizard/wizard.ts
+var DEFAULT_BROKER_URL = "https://rosie-staging.kojee.net";
+function generateWebhookSecret() {
+  return crypto2.randomBytes(32).toString("hex");
+}
+async function resolveRuntime(opts) {
+  if (opts.runtime !== void 0) {
+    if (!isWizardRuntime(opts.runtime) && getInstaller(opts.runtime) === void 0) {
+      return {
+        error: `Unknown --runtime "${opts.runtime}". Expected one of: ${WIZARD_RUNTIMES.join(", ")}.`
+      };
+    }
+    return { runtime: opts.runtime };
+  }
+  if (opts.interactive && opts.promptRuntime) {
+    const picked = await opts.promptRuntime();
+    if (!isWizardRuntime(picked) && getInstaller(picked) === void 0) {
+      return { error: `Unknown runtime "${picked}". Expected one of: ${WIZARD_RUNTIMES.join(", ")}.` };
+    }
+    return { runtime: picked };
+  }
+  return { runtime: "claude-code" };
+}
+function resolveWizardWebhook(opts) {
+  const env = opts.env ?? process.env;
+  const url = (opts.webhookUrl ?? env["KOJEE_WEBHOOK_URL"] ?? "").trim();
+  let secret = (opts.webhookSecret ?? env["KOJEE_WEBHOOK_SECRET"] ?? "").trim();
+  if (url && !secret) secret = generateWebhookSecret();
+  const sigFormat = (opts.webhookSignatureFormat ?? env["KOJEE_WEBHOOK_SIGNATURE_FORMAT"] ?? "").trim();
+  const sigHeader = (opts.webhookSignatureHeader ?? env["KOJEE_WEBHOOK_SIGNATURE_HEADER"] ?? "").trim();
+  const sigPrefix = opts.webhookSignaturePrefix ?? env["KOJEE_WEBHOOK_SIGNATURE_PREFIX"];
+  const signatureEnv = [];
+  if (sigFormat) signatureEnv.push(["KOJEE_WEBHOOK_SIGNATURE_FORMAT", sigFormat]);
+  if (sigHeader) signatureEnv.push(["KOJEE_WEBHOOK_SIGNATURE_HEADER", sigHeader]);
+  if (sigPrefix !== void 0) signatureEnv.push(["KOJEE_WEBHOOK_SIGNATURE_PREFIX", sigPrefix]);
+  const emission = resolveSignatureEmission(Object.fromEntries(signatureEnv));
+  const resolution = resolveWebhookConfig({
+    KOJEE_WEBHOOK_URL: url,
+    KOJEE_WEBHOOK_SECRET: secret,
+    ...env["KOJEE_WEBHOOK_TIMEOUT_MS"] !== void 0 ? { KOJEE_WEBHOOK_TIMEOUT_MS: env["KOJEE_WEBHOOK_TIMEOUT_MS"] } : {},
+    ...env["KOJEE_WEBHOOK_MAX_RETRIES"] !== void 0 ? { KOJEE_WEBHOOK_MAX_RETRIES: env["KOJEE_WEBHOOK_MAX_RETRIES"] } : {},
+    ...Object.fromEntries(signatureEnv)
+  });
+  const warning = resolution.warning ?? (emission.warnings.length > 0 ? emission.warnings.join("; ") : void 0);
+  if (resolution.error) {
+    return {
+      url,
+      secret,
+      redactedSummary: "",
+      signatureEnv,
+      signatureHeader: emission.header,
+      signaturePrefix: emission.prefix,
+      error: resolution.error
+    };
+  }
+  return {
+    url,
+    secret,
+    redactedSummary: resolution.config?.redactedSummary ?? `url=${url} secret=<redacted>`,
+    signatureEnv,
+    signatureHeader: emission.header,
+    signaturePrefix: emission.prefix,
+    ...warning !== void 0 ? { warning } : {}
+  };
+}
+var CODEX_UNVERIFIED_NOTE = "NOTE: live Codex verification (hook fires, MCP server connects, bounded listen works) has not been run on this build \u2014 confirm in a real Codex session. This is the owner morning step.";
+async function gatherGuidedInputs(runtime, opts) {
+  const preamble = [];
+  const next = { ...opts };
+  if (opts.promptUrl) {
+    const answered = (await opts.promptUrl(opts.url ?? DEFAULT_BROKER_URL)).trim();
+    next.url = (answered.length > 0 ? answered : opts.url ?? DEFAULT_BROKER_URL).replace(/\/+$/, "");
+  }
+  const brokerUrl = (next.url ?? DEFAULT_BROKER_URL).replace(/\/+$/, "");
+  if (opts.promptAuth) {
+    const mode = await opts.promptAuth();
+    if (mode === "token") {
+      const token = opts.promptToken ? (await opts.promptToken()).trim() : "";
+      if (!token) return { error: "No token entered. Re-run `kojee-mcp init` and paste a token, or choose pair mode." };
+      next.token = token;
+      next.url = brokerUrl;
+      preamble.push("Auth: token mode \u2014 the written MCP config will launch the proxy with --token/--url");
+      preamble.push("      (it enrolls its own per-token keystore on first boot).");
+    } else {
+      const code = opts.promptPairCode ? (await opts.promptPairCode()).trim() : "";
+      if (!code) return { error: "No pair code entered. Re-run `kojee-mcp init` and enter a pair code, or choose token mode." };
+      const pair = opts.runPair ?? (async (a) => {
+        const { runPair } = await import("./pair-P4ILCMT7.js");
+        const { pairedConfigPath } = await import("./paired-config-JTFLHMZ2.js");
+        const { defaultPairedKeystorePath } = await import("./keystore-XLEV3FL5.js");
+        return runPair({ code: a.code, url: a.url, keystorePath: defaultPairedKeystorePath(), configPath: pairedConfigPath() });
+      });
+      try {
+        const { message } = await pair({ code, url: brokerUrl });
+        preamble.push(`Auth: pair mode \u2014 ${message}`);
+      } catch (err) {
+        return { error: `Pairing failed: ${err.message}` };
+      }
+    }
+  }
+  if (runtimeUsesWebhook(runtime) && opts.promptWebhookUrl && opts.webhookUrl === void 0) {
+    const wh = (await opts.promptWebhookUrl()).trim();
+    if (wh.length > 0) next.webhookUrl = wh;
+  }
+  return { opts: next, preamble };
+}
+async function runWizard(opts) {
+  const resolved = await resolveRuntime(opts);
+  if ("error" in resolved) {
+    return { runtime: "claude-code", output: resolved.error, exitCode: 2 };
+  }
+  const runtime = resolved.runtime;
+  if (opts.uninstall) {
+    return runWizardUninstall(runtime, opts);
+  }
+  let effective = opts;
+  let preamble = [];
+  if (opts.interactive && (opts.promptUrl || opts.promptAuth || opts.promptWebhookUrl)) {
+    const gathered = await gatherGuidedInputs(runtime, opts);
+    if ("error" in gathered) {
+      return { runtime, output: gathered.error, exitCode: 2 };
+    }
+    effective = gathered.opts;
+    preamble = gathered.preamble;
+  }
+  const installer = getInstaller(runtime);
+  const result = installer ? await installer.install({ opts: effective }) : { runtime, output: `No installer registered for runtime '${runtime}'`, exitCode: 2 };
+  if (preamble.length > 0 && result.exitCode === 0) {
+    return {
+      runtime,
+      output: [...preamble, "", result.output, "", whatHappensNext(runtime, effective)].join("\n"),
+      exitCode: result.exitCode
+    };
+  }
+  return { runtime, output: result.output, exitCode: result.exitCode };
+}
+function whatHappensNext(runtime, opts) {
+  const lines = ["What happens next:"];
+  lines.push("  - Restart your runtime so it picks up the new kojee config.");
+  if (opts.token) {
+    lines.push("  - First boot enrolls this token's own keystore (~/.kojee/keypair-<hash>.json).");
+  } else {
+    lines.push("  - The proxy uses your paired credentials (~/.kojee/config.json + keypair.json).");
+  }
+  lines.push("  - Verify with: kojee-mcp doctor");
+  return lines.join("\n");
+}
+async function configureClaudeCode(opts) {
+  const { runInit } = await import("./install-LJY2CHKG.js");
+  const report = runInit({
+    ...opts.configPath ? { configPath: opts.configPath } : {},
+    ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
+    // Token mode threads --token/--url into the written args (per-token
+    // keystore). Paired mode leaves both unset ⇒ args stay `["kojee-mcp"]`.
+    ...opts.token && opts.url ? { token: opts.token, url: opts.url } : {}
+  });
+  recordRuntime("claude-code");
+  return { runtime: "claude-code", output: formatClaudeInit(report), exitCode: 0 };
+}
+function formatClaudeInit(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 = ["Configured runtime: claude-code", "", "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("");
+  if (report.targets.some((t) => t.kind === "desktop" && t.mcpServer === "added")) {
+    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 configureCodex(opts) {
+  const wh = resolveWizardWebhook(opts);
+  if (wh.error) {
+    return { runtime: "codex", output: `webhook env ERROR: ${wh.error}`, exitCode: 2 };
+  }
+  const url = wh.url || "https://YOUR-CODEX-WEBHOOK-RECEIVER.local/kojee";
+  const secret = wh.secret || generateWebhookSecret();
+  const tokenArgs = opts.token && opts.url ? { token: opts.token, url: opts.url } : {};
+  writeCodexConfig({
+    ...opts.configPath ? { configPath: opts.configPath } : {},
+    ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {},
+    webhookUrl: url,
+    webhookSecret: secret,
+    ...wh.signatureEnv.length > 0 ? { signatureEnv: wh.signatureEnv } : {},
+    ...tokenArgs
+  });
+  recordRuntime("codex");
+  const lines = [];
+  lines.push("Configured runtime: codex");
+  lines.push("Wake mode: webhook-sink + stop-hook peek (Codex has no channel injection).");
+  lines.push("");
+  lines.push("Wrote [mcp_servers.kojee] to ~/.codex/config.toml:");
+  lines.push(indent(buildCodexMcpServerTable({
+    webhookUrl: url,
+    webhookSecret: "<redacted>",
+    ...wh.signatureEnv.length > 0 ? { signatureEnv: wh.signatureEnv } : {},
+    // Redact the gateway token in the human-readable printed copy (it ends up
+    // in result.output → cli.ts console.error). The WRITTEN config above keeps
+    // the real token; only this printed report is redacted, like webhookSecret.
+    ...tokenArgs.token ? { token: "<redacted>", url: tokenArgs.url } : {}
+  })));
+  if (wh.warning) lines.push(`webhook WARNING: ${wh.warning}`);
+  lines.push("");
+  lines.push("Wrote the Codex Stop hook (~/.codex/hooks.json; inline TOML form):");
+  lines.push(indent(buildCodexStopHookBlock()));
+  lines.push("");
+  lines.push(`webhook: ${wh.url ? wh.redactedSummary : "(receiver URL not set \u2014 fill KOJEE_WEBHOOK_URL above)"}`);
+  lines.push(`bounded-listen cap: ${CODEX_LISTEN_CAP_MS}ms (the model picks listen vs drain vs ignore).`);
+  lines.push("");
+  lines.push("Next steps (codex):");
+  lines.push("  Restart Codex (or start a new `codex` / `codex exec` session) to load the MCP server and hook.");
+  lines.push("  Stand up your webhook receiver at KOJEE_WEBHOOK_URL \u2014 contract:");
+  lines.push(indent(buildWebhookReceiverNote({ header: wh.signatureHeader, prefix: wh.signaturePrefix })));
+  lines.push("  Verify: kojee-mcp doctor");
+  lines.push("");
+  lines.push(CODEX_UNVERIFIED_NOTE);
+  return { runtime: "codex", output: lines.join("\n"), exitCode: 0 };
+}
+function buildDaemonEnvBlock(runtime, wh, envFile) {
+  const lines = [];
+  if (wh.url && envFile) {
+    lines.push("Export these before starting the daemon (also written to a source-able file):");
+    lines.push(`  export KOJEE_RUNTIME=${shellSingleQuote(runtime)}`);
+    lines.push(`  export KOJEE_WEBHOOK_URL=${shellSingleQuote(wh.url)}`);
+    lines.push(`  export KOJEE_WEBHOOK_SECRET=<generated; in ${envFile}>`);
+    for (const [k, v] of wh.signatureEnv) lines.push(`  export ${k}=${shellSingleQuote(v)}`);
+    lines.push(`  (validated: ${wh.redactedSummary})`);
+    lines.push(`  source ${envFile}`);
+  } else {
+    lines.push("Set the daemon env (no receiver URL supplied yet):");
+    lines.push(`  export KOJEE_RUNTIME=${shellSingleQuote(runtime)}`);
+    lines.push(`  export KOJEE_WEBHOOK_URL="https://YOUR-RECEIVER.local/kojee"`);
+    lines.push(`  export KOJEE_WEBHOOK_SECRET=<generate a hex secret>`);
+    for (const [k, v] of wh.signatureEnv) lines.push(`  export ${k}=${shellSingleQuote(v)}`);
+  }
+  lines.push("");
+  lines.push("Receiver contract:");
+  lines.push(indent(buildWebhookReceiverNote({ header: wh.signatureHeader, prefix: wh.signaturePrefix })));
+  return lines;
+}
+function distDir() {
+  return path6.dirname(fileURLToPath(import.meta.url));
+}
+function resolveBinPath() {
+  const entry = process.argv[1];
+  return entry && entry.length > 0 ? entry : "kojee-mcp";
+}
+function configureHermes(opts) {
+  const runtime = "hermes";
+  const wh = resolveWizardWebhook(opts);
+  if (wh.error) {
+    return { runtime, output: `webhook env ERROR: ${wh.error}`, exitCode: 2 };
+  }
+  const lines = [];
+  lines.push(`Configured runtime: ${runtime}`);
+  lines.push("Wake mode: webhook sink (daemon-consumed). NO MCP-config file, NO hooks written.");
+  lines.push("");
+  if (wh.warning) lines.push(`webhook WARNING: ${wh.warning}`);
+  if (wh.url) {
+    const home = kojeeHomeDir();
+    let skipPayload = false;
+    const base = distDir();
+    try {
+      resolveBundledPayloadDir("hermes", base);
+    } catch {
+      skipPayload = true;
+    }
+    const env = opts.env ?? process.env;
+    const suppliedSecret = (opts.webhookSecret ?? env["KOJEE_WEBHOOK_SECRET"] ?? "").trim();
+    const install = installHermes({
+      homeDir: home,
+      payloadBaseDir: base,
+      platform: process.platform,
+      binPath: resolveBinPath(),
+      webhookUrl: wh.url,
+      ...suppliedSecret ? { webhookSecret: suppliedSecret } : {},
+      ...wh.signatureEnv.length > 0 ? { signatureEnv: wh.signatureEnv } : {},
+      signatureHeader: wh.signatureHeader,
+      signaturePrefix: wh.signaturePrefix,
+      skipPayload
+    });
+    if (install.exitCode !== 0) {
+      lines.push(install.output);
+      return { runtime, output: lines.join("\n"), exitCode: install.exitCode };
+    }
+    recordRuntime(runtime);
+    const envFile = path6.join(home, ".kojee", "hermes.env");
+    lines.push(...buildDaemonEnvBlock(runtime, wh, envFile));
+    lines.push("");
+    lines.push(install.output);
+    return { runtime, output: lines.join("\n"), exitCode: install.exitCode };
+  }
+  recordRuntime(runtime);
+  lines.push(...buildDaemonEnvBlock(runtime, wh, void 0));
+  lines.push("");
+  lines.push(`Next steps (${runtime}):`);
+  lines.push("  Re-run with --webhook-url once your receiver is up to complete the install");
+  lines.push("  (writes both env files, copies the plugin, installs the daemon service).");
+  lines.push("  Verify: kojee-mcp doctor (after the daemon is up).");
+  return { runtime, output: lines.join("\n"), exitCode: 0 };
+}
+function openclawConfigPath(opts) {
+  return opts.openclawConfigPath ?? path6.join(kojeeHomeDir(), ".openclaw", "config.json");
+}
+function resolveOpenclawPluginSourceDir() {
+  const candidates = [
+    path6.resolve(distDir(), "..", "..", "integrations", "openclaw-plugin"),
+    path6.resolve(distDir(), "..", "..", "..", "integrations", "openclaw-plugin")
+  ];
+  for (const dir of candidates) {
+    if (fs5.existsSync(path6.join(dir, "openclaw.plugin.json"))) return dir;
+  }
+  return void 0;
+}
+function configureOpenclaw(opts) {
+  const runtime = "openclaw";
+  const env = opts.env ?? process.env;
+  const token = (opts.token ?? "").trim();
+  const url = (opts.url ?? env["KOJEE_GATEWAY_URL"] ?? "").trim();
+  const pluginSourceDir = resolveOpenclawPluginSourceDir();
+  const install = installOpenclaw({
+    homeDir: kojeeHomeDir(),
+    openclawConfigPath: openclawConfigPath(opts),
+    ...url ? { url } : {},
+    ...token ? { token } : {},
+    ...pluginSourceDir ? { pluginSourceDir } : {}
+  });
+  recordRuntime(runtime);
+  return { runtime, output: install.output, exitCode: install.exitCode };
+}
+async function runWizardUninstall(runtime, opts) {
+  const effective = opts.runtime !== void 0 ? runtime : readRecordedRuntime() ?? runtime;
+  const lines = [`Uninstalling runtime: ${effective}`];
+  if (effective === "claude-code") {
+    const { runUninstall } = await import("./install-LJY2CHKG.js");
+    const report = runUninstall({
+      ...opts.configPath ? { configPath: opts.configPath } : {},
+      ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
+    });
+    lines.push("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"}`);
+      }
+    }
+  } else if (effective === "codex") {
+    const removed = removeCodexConfig({
+      ...opts.configPath ? { configPath: opts.configPath } : {},
+      ...opts.hooksPath ? { hooksPath: opts.hooksPath } : {}
+    });
+    lines.push(`  config.toml [mcp_servers.kojee]: ${removed.mcpServer ? "removed" : "not found"}`);
+    lines.push(`  hooks.json Stop: ${removed.stopHook ? "removed" : "not found"}`);
+  } else if (effective === "openclaw") {
+    const un = uninstallOpenclaw({ openclawConfigPath: openclawConfigPath(opts) });
+    lines.push(un.output);
+  } else {
+    lines.push("  (hermes writes no MCP-config or hooks \u2014 nothing to tear down.");
+    lines.push("   Stop the daemon and unset KOJEE_WEBHOOK_URL/SECRET to disable the sink.)");
+    const envPath = path6.join(kojeeHomeDir(), ".kojee", `${effective}.env`);
+    try {
+      fs5.unlinkSync(envPath);
+      lines.push(`  removed ${envPath}`);
+    } catch {
+    }
+  }
+  clearRuntimeRecord();
+  return { runtime: effective, output: lines.join("\n"), exitCode: 0 };
+}
+function indent(s) {
+  return s.split("\n").map((l) => "    " + l).join("\n");
+}
+function registerBuiltinInstaller(id, menuLabel, capabilities, doInstall) {
+  register({
+    id,
+    menuLabel,
+    capabilities,
+    install: async (ctx) => doInstall(ctx.opts),
+    uninstall: async (ctx) => runWizardUninstall(id, ctx.opts),
+    verify: async () => ({ runtime: id, ok: true, checks: [] })
+  });
+}
+registerBuiltinInstaller(
+  "claude-code",
+  "Claude Code",
+  ["pair-credential", "mcp-config-write", "hooks-write"],
+  (o) => configureClaudeCode(o)
+);
+registerBuiltinInstaller(
+  "codex",
+  "Codex",
+  ["pair-credential", "mcp-config-write", "hooks-write", "webhook"],
+  (o) => configureCodex(o)
+);
+registerBuiltinInstaller(
+  "hermes",
+  "Hermes",
+  [
+    "pair-credential",
+    "webhook",
+    "webhook-secret-both-sides",
+    "plugin-payload-copy",
+    "service-install"
+  ],
+  (o) => configureHermes(o)
+);
+registerBuiltinInstaller(
+  "openclaw",
+  "OpenClaw",
+  ["pair-credential", "in-process-plugin"],
+  (o) => configureOpenclaw(o)
+);
+export {
+  CODEX_UNVERIFIED_NOTE,
+  DEFAULT_BROKER_URL,
+  generateWebhookSecret,
+  resolveRuntime,
+  resolveWizardWebhook,
+  runWizard
+};