caik-cli 0.1.1 → 0.6.0

package/dist/chunk-TFKT7V7H.js

@@ -0,0 +1,1545 @@
+#!/usr/bin/env node
+import {
+  ClaudeCodeAdapter
+} from "./chunk-US4CYDNS.js";
+import {
+  CLI_NPX_PACKAGE,
+  CursorAdapter
+} from "./chunk-T73Z5UMA.js";
+
+// src/platform/detect.ts
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/platform/platform-configs.ts
+var platformConfigs = {
+  windsurf: {
+    label: "Windsurf",
+    tier: "cli-mcp",
+    homeDirs: [".windsurf"],
+    cwdDirs: [".windsurf"],
+    binaries: [],
+    mcpConfigPath: "~/.windsurf/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: ".agents/skills/caik",
+    capabilities: { hooks: false, mcp: true, skills: true }
+  },
+  copilot: {
+    label: "GitHub Copilot",
+    tier: "cli-mcp",
+    homeDirs: [],
+    cwdDirs: [".github/copilot"],
+    binaries: [],
+    mcpConfigPath: ".github/copilot/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: ".github/copilot/skills/caik",
+    capabilities: { hooks: false, mcp: true, skills: true }
+  },
+  "gemini-cli": {
+    label: "Gemini CLI",
+    tier: "cli-mcp",
+    homeDirs: [".gemini"],
+    cwdDirs: [".gemini"],
+    binaries: ["gemini"],
+    mcpConfigPath: "~/.gemini/settings.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: "~/.gemini/skills/caik",
+    localSkillsDir: ".gemini/skills/caik",
+    capabilities: { hooks: false, mcp: true, skills: true }
+  },
+  aider: {
+    label: "Aider",
+    tier: "cli-mcp",
+    homeDirs: [".aider"],
+    cwdDirs: [],
+    binaries: ["aider"],
+    mcpConfigPath: "~/.aider.conf.yml",
+    mcpConfigKey: "manual",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  cline: {
+    label: "Cline",
+    tier: "cli-mcp",
+    homeDirs: [".cline"],
+    cwdDirs: [".cline"],
+    binaries: [],
+    mcpConfigPath: "~/cline_mcp_settings.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: "~/.cline/skills/caik",
+    localSkillsDir: ".cline/skills/caik",
+    capabilities: { hooks: false, mcp: true, skills: true }
+  },
+  "roo-code": {
+    label: "Roo Code",
+    tier: "cli-mcp",
+    homeDirs: [".roo"],
+    cwdDirs: [".roo"],
+    binaries: [],
+    mcpConfigPath: "~/.roo/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: "~/.roo/skills/caik",
+    localSkillsDir: ".roo/skills/caik",
+    capabilities: { hooks: false, mcp: true, skills: true }
+  },
+  "amazon-q": {
+    label: "Amazon Q",
+    tier: "cli-mcp",
+    homeDirs: [".aws/amazonq"],
+    cwdDirs: [],
+    binaries: ["q"],
+    mcpConfigPath: "~/.aws/amazonq/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  devin: {
+    label: "Devin",
+    tier: "cli-mcp",
+    homeDirs: [],
+    cwdDirs: [],
+    binaries: ["devin"],
+    mcpConfigPath: "~/devin.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  goose: {
+    label: "Goose",
+    tier: "cli-mcp",
+    homeDirs: [".goose"],
+    cwdDirs: [".goose"],
+    binaries: ["goose"],
+    mcpConfigPath: "~/.goose/config.yaml",
+    mcpConfigKey: "manual",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  warp: {
+    label: "Warp",
+    tier: "cli-mcp",
+    homeDirs: [".warp"],
+    cwdDirs: [".warp"],
+    binaries: ["warp"],
+    mcpConfigPath: "~/.warp/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  zed: {
+    label: "Zed",
+    tier: "cli-mcp",
+    homeDirs: [".config/zed"],
+    cwdDirs: [".zed"],
+    binaries: ["zed"],
+    mcpConfigPath: "~/.config/zed/settings.json",
+    mcpConfigKey: "manual",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  augment: {
+    label: "Augment",
+    tier: "cli-mcp",
+    homeDirs: [".augment"],
+    cwdDirs: [".augment"],
+    binaries: [],
+    mcpConfigPath: "~/.augment/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  replit: {
+    label: "Replit",
+    tier: "cli-mcp",
+    homeDirs: [".replit"],
+    cwdDirs: [".replit"],
+    binaries: [],
+    mcpConfigPath: "~/.replit/mcp.json",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  // Generic fallbacks — no auto-detection, manual config only
+  "generic-mcp": {
+    label: "Generic MCP",
+    tier: "cli-mcp",
+    homeDirs: [],
+    cwdDirs: [],
+    binaries: [],
+    mcpConfigPath: "",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  "generic-agent": {
+    label: "Generic Agent",
+    tier: "cli-mcp",
+    homeDirs: [],
+    cwdDirs: [],
+    binaries: [],
+    mcpConfigPath: "",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  "generic-ide": {
+    label: "Generic IDE",
+    tier: "cli-mcp",
+    homeDirs: [],
+    cwdDirs: [],
+    binaries: [],
+    mcpConfigPath: "",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  },
+  generic: {
+    label: "Generic",
+    tier: "cli-mcp",
+    homeDirs: [],
+    cwdDirs: [],
+    binaries: [],
+    mcpConfigPath: "",
+    mcpConfigKey: "mcpServers",
+    skillsDir: null,
+    localSkillsDir: null,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  }
+};
+
+// src/platform/detect.ts
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectClaudeCode() {
+  const home = homedir();
+  const claudeDir = join(home, ".claude");
+  if (!existsSync(claudeDir)) return null;
+  const hasSettings = existsSync(join(claudeDir, "settings.json"));
+  const hasMcpConfig = existsSync(join(claudeDir, "mcp.json"));
+  const hasAnyMarker = hasSettings || hasMcpConfig || existsSync(join(claudeDir, "statsig"));
+  if (!hasAnyMarker) return null;
+  const configPaths = [];
+  if (hasSettings) configPaths.push(join(claudeDir, "settings.json"));
+  if (hasMcpConfig) configPaths.push(join(claudeDir, "mcp.json"));
+  return {
+    name: "claude-code",
+    tier: "full-plugin",
+    configPaths,
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function detectOpenClaw() {
+  const home = homedir();
+  const openclawDir = join(home, ".openclaw");
+  const cwdConfig = join(process.cwd(), "openclaw.json");
+  const inPath = commandExists("openclaw");
+  if (!existsSync(openclawDir) && !existsSync(cwdConfig) && !inPath) return null;
+  const configPaths = [];
+  if (existsSync(cwdConfig)) configPaths.push(cwdConfig);
+  if (existsSync(join(openclawDir, "openclaw.json"))) {
+    configPaths.push(join(openclawDir, "openclaw.json"));
+  }
+  return {
+    name: "openclaw",
+    tier: "hook-enabled",
+    configPaths,
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function detectCursor() {
+  const home = homedir();
+  const cursorDir = join(home, ".cursor");
+  const cwdCursor = join(process.cwd(), ".cursor");
+  if (!existsSync(cursorDir) && !existsSync(cwdCursor)) return null;
+  const configPaths = [];
+  if (existsSync(join(cwdCursor, "mcp.json"))) {
+    configPaths.push(join(cwdCursor, "mcp.json"));
+  }
+  if (existsSync(join(cursorDir, "mcp.json"))) {
+    configPaths.push(join(cursorDir, "mcp.json"));
+  }
+  return {
+    name: "cursor",
+    tier: "hook-enabled",
+    configPaths,
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function detectCodex() {
+  const home = homedir();
+  const codexDir = join(home, ".codex");
+  if (!existsSync(codexDir) && !commandExists("codex")) return null;
+  if (existsSync(codexDir)) {
+    const hasConfig = existsSync(join(codexDir, "config.toml"));
+    const hasHooks = existsSync(join(codexDir, "hooks.json"));
+    const hasMcp = existsSync(join(codexDir, "mcp.json"));
+    if (!hasConfig && !hasHooks && !hasMcp) {
+      if (!commandExists("codex")) return null;
+    }
+    const configPaths = [];
+    if (hasHooks) configPaths.push(join(codexDir, "hooks.json"));
+    if (hasMcp) configPaths.push(join(codexDir, "mcp.json"));
+    if (hasConfig) configPaths.push(join(codexDir, "config.toml"));
+    return {
+      name: "codex",
+      tier: "full-plugin",
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  return {
+    name: "codex",
+    tier: "full-plugin",
+    configPaths: [],
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function expandHome(p) {
+  if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+  if (p === "~") return homedir();
+  return p;
+}
+function createConfigDetector(name, config) {
+  return () => {
+    const home = homedir();
+    const cwd = process.cwd();
+    let found = false;
+    for (const dir of config.homeDirs) {
+      if (existsSync(join(home, dir))) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      for (const dir of config.cwdDirs) {
+        if (existsSync(join(cwd, dir))) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      for (const bin of config.binaries) {
+        if (commandExists(bin)) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) return null;
+    const configPaths = [];
+    if (config.mcpConfigPath) {
+      const resolved = config.mcpConfigPath.startsWith("~/") ? expandHome(config.mcpConfigPath) : join(cwd, config.mcpConfigPath);
+      if (existsSync(resolved)) {
+        configPaths.push(resolved);
+      }
+    }
+    return {
+      name,
+      tier: config.tier,
+      configPaths,
+      capabilities: config.capabilities
+    };
+  };
+}
+var customDetectors = [
+  detectClaudeCode,
+  detectOpenClaw,
+  detectCursor,
+  detectCodex
+];
+var genericFallbacks = /* @__PURE__ */ new Set(["generic-mcp", "generic-agent", "generic-ide", "generic"]);
+var configDetectors = [];
+var configDetectorMap = {};
+for (const [name, config] of Object.entries(platformConfigs)) {
+  if (genericFallbacks.has(name)) continue;
+  const detector = createConfigDetector(name, config);
+  configDetectors.push(detector);
+  configDetectorMap[name] = detector;
+}
+var allDetectors = [
+  ...customDetectors,
+  ...configDetectors
+];
+function detectPlatforms() {
+  const detected = [];
+  for (const detect of allDetectors) {
+    try {
+      const result = detect();
+      if (result) detected.push(result);
+    } catch {
+    }
+  }
+  return detected;
+}
+function detectPlatform(name) {
+  const customMap = {
+    "claude-code": detectClaudeCode,
+    "openclaw": detectOpenClaw,
+    "cursor": detectCursor,
+    "codex": detectCodex
+  };
+  const customDetector = customMap[name];
+  if (customDetector) {
+    try {
+      return customDetector();
+    } catch {
+      return null;
+    }
+  }
+  const configDetector = configDetectorMap[name];
+  if (configDetector) {
+    try {
+      return configDetector();
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/platform/openclaw.ts
+import {
+  existsSync as existsSync2,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmSync
+} from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+var MCP_KEY = "caik";
+var OpenClawAdapter = class {
+  name = "openclaw";
+  tier = "hook-enabled";
+  // --- Path helpers --------------------------------------------------------
+  get openclawDir() {
+    return join2(homedir2(), ".openclaw");
+  }
+  get managedHooksDir() {
+    return join2(this.openclawDir, "hooks");
+  }
+  get caikHookDir() {
+    return join2(this.managedHooksDir, "caik-contributions");
+  }
+  /** OpenClaw's own config — NOT where MCP servers go. */
+  get openclawConfigPath() {
+    return join2(this.openclawDir, "openclaw.json");
+  }
+  /** Project-level `.mcp.json` — where MCP servers are registered. */
+  get mcpConfigPath() {
+    return join2(process.cwd(), ".mcp.json");
+  }
+  /** Skills directory following OpenClaw convention. */
+  get skillsBaseDir() {
+    return join2(homedir2(), ".agents", "skills");
+  }
+  get skillDir() {
+    return join2(this.skillsBaseDir, "caik");
+  }
+  get skillLockPath() {
+    return join2(homedir2(), ".agents", ".skill-lock.json");
+  }
+  // --- JSON helpers --------------------------------------------------------
+  readJson(path) {
+    if (!existsSync2(path)) return {};
+    try {
+      const raw = readFileSync(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  writeJson(path, data) {
+    const dir = dirname(path);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+  readSkillLock() {
+    if (!existsSync2(this.skillLockPath)) {
+      return { version: 3, skills: {} };
+    }
+    try {
+      const raw = readFileSync(this.skillLockPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        version: parsed.version ?? 3,
+        skills: parsed.skills ?? {}
+      };
+    } catch {
+      return { version: 3, skills: {} };
+    }
+  }
+  writeSkillLock(lock) {
+    const dir = dirname(this.skillLockPath);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(
+      this.skillLockPath,
+      JSON.stringify(lock, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+  /** Check if `openclaw` binary is in PATH. */
+  isInPath() {
+    try {
+      execSync2("which openclaw", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- PlatformAdapter implementation --------------------------------------
+  async detect() {
+    const hasDir = existsSync2(this.openclawDir);
+    const inPath = this.isInPath();
+    const hasCwdConfig = existsSync2(join2(process.cwd(), "openclaw.json"));
+    if (!hasDir && !inPath && !hasCwdConfig) return null;
+    const configPaths = [];
+    if (hasCwdConfig) {
+      configPaths.push(join2(process.cwd(), "openclaw.json"));
+    }
+    if (existsSync2(this.openclawConfigPath)) {
+      configPaths.push(this.openclawConfigPath);
+    }
+    if (existsSync2(this.mcpConfigPath)) {
+      configPaths.push(this.mcpConfigPath);
+    }
+    return {
+      name: this.name,
+      tier: this.tier,
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  async registerMcp(serverConfig) {
+    const config = this.readJson(this.mcpConfigPath);
+    const servers = config.mcpServers ?? {};
+    servers[MCP_KEY] = {
+      type: "stdio",
+      command: serverConfig.command,
+      args: serverConfig.args,
+      ...serverConfig.env && Object.keys(serverConfig.env).length > 0 ? { env: serverConfig.env } : {}
+    };
+    config.mcpServers = servers;
+    this.writeJson(this.mcpConfigPath, config);
+  }
+  async unregisterMcp() {
+    if (!existsSync2(this.mcpConfigPath)) return;
+    const config = this.readJson(this.mcpConfigPath);
+    const servers = config.mcpServers;
+    if (!servers || !(MCP_KEY in servers)) return;
+    delete servers[MCP_KEY];
+    config.mcpServers = servers;
+    this.writeJson(this.mcpConfigPath, config);
+  }
+  get pluginDir() {
+    return join2(homedir2(), ".openclaw", "plugins", "caik");
+  }
+  async registerHooks(_hookConfig) {
+    if (!existsSync2(this.caikHookDir)) {
+      mkdirSync(this.caikHookDir, { recursive: true });
+    }
+    writeFileSync(
+      join2(this.caikHookDir, "HOOK.md"),
+      HOOK_MD_CONTENT,
+      "utf-8"
+    );
+    writeFileSync(
+      join2(this.caikHookDir, "handler.js"),
+      HANDLER_JS_CONTENT,
+      "utf-8"
+    );
+    await this.installPlugin();
+  }
+  async installPlugin() {
+    try {
+      if (!existsSync2(this.pluginDir)) {
+        mkdirSync(this.pluginDir, { recursive: true });
+      }
+      const thisDir = dirname(new URL(import.meta.url).pathname);
+      const pluginSources = [
+        join2(thisDir, "..", "..", "openclaw-plugin", "dist"),
+        // monorepo sibling
+        join2(thisDir, "..", "..", "..", "openclaw-plugin", "dist")
+        // npm installed
+      ];
+      let pluginDistDir = null;
+      for (const src of pluginSources) {
+        if (existsSync2(join2(src, "index.js"))) {
+          pluginDistDir = src;
+          break;
+        }
+      }
+      const manifestSources = [
+        join2(thisDir, "..", "..", "openclaw-plugin", "openclaw.plugin.json"),
+        join2(thisDir, "..", "..", "..", "openclaw-plugin", "openclaw.plugin.json")
+      ];
+      for (const src of manifestSources) {
+        if (existsSync2(src)) {
+          const manifest = readFileSync(src, "utf-8");
+          writeFileSync(join2(this.pluginDir, "openclaw.plugin.json"), manifest, "utf-8");
+          break;
+        }
+      }
+      if (pluginDistDir) {
+        const indexJs = readFileSync(join2(pluginDistDir, "index.js"), "utf-8");
+        writeFileSync(join2(this.pluginDir, "index.js"), indexJs, "utf-8");
+      }
+      const config = this.readJson(this.openclawConfigPath);
+      if (!config.plugins) config.plugins = {};
+      if (!config.plugins.entries) config.plugins.entries = {};
+      config.plugins.entries.caik = { enabled: true };
+      if (!config.plugins.load) config.plugins.load = {};
+      if (!config.plugins.load.paths) config.plugins.load.paths = [];
+      const paths = config.plugins.load.paths;
+      if (!paths.includes(this.pluginDir)) {
+        paths.push(this.pluginDir);
+      }
+      this.writeJson(this.openclawConfigPath, config);
+    } catch {
+    }
+  }
+  async unregisterHooks() {
+    if (existsSync2(this.caikHookDir)) {
+      try {
+        rmSync(this.caikHookDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  async installSkill(_slug, content, files) {
+    if (!existsSync2(this.skillDir)) {
+      mkdirSync(this.skillDir, { recursive: true });
+    }
+    writeFileSync(join2(this.skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join2(this.skillDir, file.path);
+        const fileDir = dirname(filePath);
+        if (!existsSync2(fileDir)) {
+          mkdirSync(fileDir, { recursive: true });
+        }
+        writeFileSync(filePath, file.content, "utf-8");
+      }
+    }
+    const lock = this.readSkillLock();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.skills["caik"];
+    lock.skills["caik"] = {
+      source: CLI_NPX_PACKAGE,
+      sourceType: "local",
+      sourceUrl: "",
+      skillPath: "skills/caik/SKILL.md",
+      skillFolderHash: "",
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now
+    };
+    this.writeSkillLock(lock);
+  }
+  async uninstallSkill(_slug) {
+    if (existsSync2(this.skillDir)) {
+      try {
+        rmSync(this.skillDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    const lock = this.readSkillLock();
+    if ("caik" in lock.skills) {
+      delete lock.skills["caik"];
+      this.writeSkillLock(lock);
+    }
+  }
+  getConfigPath() {
+    return this.openclawConfigPath;
+  }
+  async readConfig() {
+    return this.readJson(this.openclawConfigPath);
+  }
+  async isRegistered() {
+    if (!existsSync2(this.mcpConfigPath)) return false;
+    const config = this.readJson(this.mcpConfigPath);
+    const servers = config.mcpServers;
+    return !!servers && MCP_KEY in servers;
+  }
+};
+var HOOK_MD_CONTENT = `---
+name: caik-contributions
+description: "Track artifact usage to build your CAIK contribution level and community karma"
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "\u{1F4E6}",
+        "events": ["session_start", "session_end", "after_tool_call", "agent_end", "gateway_start"],
+        "install": [{ "id": "local", "kind": "local", "label": "CAIK CLI hook pack" }],
+      },
+  }
+---
+
+# CAIK Contribution Tracking
+
+Reports session lifecycle and tool usage events to the CAIK API to build your contribution level and community karma.
+
+## What It Does
+
+- **Session start** (\`session_start\`): Computes stack fingerprint, starts daemon, records session
+- **Tool use** (\`after_tool_call\`): Buffers tool execution events with success/failure signals
+- **Session end** (\`session_end\`, \`agent_end\`): Computes session shape, flushes events, records session end
+- **Gateway start** (\`gateway_start\`): Clears session state on gateway restart
+
+## Privacy
+
+- Only sends: event type, platform name, tool name, success/failure, timestamp
+- At Collective level: adds stack fingerprint, session shape, agent model
+- No code, file contents, or conversation data is transmitted
+- Contribution tracking can be disabled: \`caik config set contributionLevel none\`
+
+## Configuration
+
+Set \`CAIK_API_URL\` and \`CAIK_API_KEY\` environment variables, or configure via \`caik init --auth\`.
+`;
+var HANDLER_JS_CONTENT = `/**
+ * CAIK contribution tracking hook for OpenClaw.
+ *
+ * Uses OpenClaw lifecycle hooks (session_start, after_tool_call, session_end, agent_end,
+ * gateway_start) for rich event data. Delegates to the CLI for session-start/end
+ * (full processing: fingerprint, daemon, metrics) and buffers tool events in-process
+ * for speed.
+ *
+ * Fire-and-forget \u2014 never blocks the agent, never throws.
+ */
+import { spawn } from "node:child_process";
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CAIK_DIR = join(homedir(), ".caik");
+const PENDING_PATH = join(CAIK_DIR, "pending-events.json");
+const CONFIG_PATH = join(CAIK_DIR, "config.json");
+const DAEMON_PORT = process.env.CAIK_DAEMON_PORT ?? "37778";
+
+// \u2500\u2500\u2500 Discovery logging \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+// Logs first event of each type to learn OpenClaw's event field names.
+// Remove once field names are confirmed.
+const seenEventTypes = new Set();
+function logEventShape(event, ctx) {
+  const name = event?.hookName ?? event?.type ?? "unknown";
+  if (seenEventTypes.has(name)) return;
+  seenEventTypes.add(name);
+  try {
+    if (!existsSync(CAIK_DIR)) mkdirSync(CAIK_DIR, { recursive: true });
+    const summary = {};
+    if (ctx) {
+      for (const [k, v] of Object.entries(ctx)) {
+        if (typeof v === "string" && v.length > 200) summary[k] = v.slice(0, 200) + "...";
+        else if (typeof v === "object" && v !== null) summary[k] = "[" + typeof v + ": " + Object.keys(v).join(",") + "]";
+        else summary[k] = v;
+      }
+    }
+    appendFileSync(
+      join(CAIK_DIR, "openclaw-events-captured.jsonl"),
+      JSON.stringify({
+        hookName: name,
+        eventKeys: Object.keys(event ?? {}),
+        ctxKeys: Object.keys(ctx ?? {}),
+        event,
+        ctxSummary: summary,
+      }) + "\\n",
+    );
+  } catch { /* ignore */ }
+}
+
+// \u2500\u2500\u2500 Disk-backed session tracking \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+// Persisted to disk because OpenClaw runs each hook invocation as a separate
+// process, so in-memory state is lost between events.
+const SESSION_STATE_PATH = join(CAIK_DIR, "openclaw-sessions.json");
+
+function loadSessionState() {
+  try { return existsSync(SESSION_STATE_PATH) ? JSON.parse(readFileSync(SESSION_STATE_PATH, "utf-8")) : {}; }
+  catch { return {}; }
+}
+
+function saveSessionState(state) {
+  try {
+    if (!existsSync(CAIK_DIR)) mkdirSync(CAIK_DIR, { recursive: true });
+    writeFileSync(SESSION_STATE_PATH, JSON.stringify(state), "utf-8");
+  } catch { /* ignore */ }
+}
+
+function getOrCreateSessionId(event) {
+  const key = event?.agentId ?? event?.runId ?? event?.sessionId ?? "default";
+  const state = loadSessionState();
+  if (!state[key]) {
+    state[key] = "caik-oc-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+    saveSessionState(state);
+  }
+  return state[key];
+}
+
+function removeSessionId(sessionId) {
+  const state = loadSessionState();
+  for (const k of Object.keys(state)) {
+    if (state[k] === sessionId) delete state[k];
+  }
+  saveSessionState(state);
+}
+
+function clearAllSessions() {
+  try { writeFileSync(SESSION_STATE_PATH, "{}", "utf-8"); }
+  catch { /* ignore */ }
+}
+
+// \u2500\u2500\u2500 Config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function loadConfig() {
+  try { return JSON.parse(readFileSync(CONFIG_PATH, "utf-8")); }
+  catch { return {}; }
+}
+
+function shouldSend() {
+  const cfg = loadConfig();
+  if (cfg.contributions === false || cfg.contribution === false) return false;
+  return cfg.contributionLevel !== "none";
+}
+
+// \u2500\u2500\u2500 CLI delegation (session-start/end only) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function findCli() {
+  try {
+    const local = join(__dirname, "..", "..", "..", "cli", "dist", "index.js");
+    if (existsSync(local)) return [process.execPath, local];
+  } catch { /* ignore */ }
+  return ["npx", "-y", "${CLI_NPX_PACKAGE}"];
+}
+
+function runCliHook(subcommand, stdinData) {
+  return new Promise((resolve) => {
+    const [cmd, ...args] = findCli();
+    const proc = spawn(cmd, [...args, "hook", subcommand], {
+      stdio: ["pipe", "inherit", "inherit"],
+      timeout: 8000,
+      env: { ...process.env, CAIK_OPENCLAW: "1" },
+    });
+    if (stdinData) {
+      proc.stdin.write(JSON.stringify(stdinData));
+      proc.stdin.end();
+    }
+    proc.on("close", resolve);
+    proc.on("error", () => resolve(1));
+  });
+}
+
+// \u2500\u2500\u2500 Fast in-process event buffering \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function bufferEvent(event) {
+  try {
+    if (!existsSync(CAIK_DIR)) mkdirSync(CAIK_DIR, { recursive: true });
+    let events = [];
+    try { events = JSON.parse(readFileSync(PENDING_PATH, "utf-8")); } catch { /* empty */ }
+    if (!Array.isArray(events)) events = [];
+    events.push(event);
+    writeFileSync(PENDING_PATH, JSON.stringify(events), "utf-8");
+  } catch { /* ignore */ }
+}
+
+// \u2500\u2500\u2500 Daemon observation posting \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+function postToDaemon(obs) {
+  try {
+    fetch("http://127.0.0.1:" + DAEMON_PORT + "/observations", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(obs),
+      signal: AbortSignal.timeout(1000),
+    }).catch(() => {});
+  } catch { /* ignore */ }
+}
+
+// \u2500\u2500\u2500 Main handler \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+const handler = async (event, ctx) => {
+  try {
+    logEventShape(event, ctx);
+    if (!shouldSend()) return;
+    // If the native plugin is active, skip hook pack to avoid double-counting
+    if (process.env.CAIK_PLUGIN_ACTIVE === "1") return;
+
+    const hookName = event?.hookName ?? event?.type ?? "";
+    const timestamp = new Date().toISOString();
+
+    switch (hookName) {
+      case "session_start": {
+        const sessionId = getOrCreateSessionId(event);
+        await runCliHook("session-start", {
+          hook_event_name: "session-start",
+          session_id: sessionId,
+          model: event?.model ?? ctx?.model ?? undefined,
+          cwd: event?.cwd ?? ctx?.cwd ?? ctx?.workspace ?? process.cwd(),
+        });
+        break;
+      }
+
+      case "after_tool_call": {
+        const sessionId = getOrCreateSessionId(event);
+        const toolName = event?.toolName ?? event?.tool ?? event?.name ?? event?.action ?? "unknown";
+        const success = event?.error == null && event?.success !== false;
+
+        bufferEvent({
+          type: "tool_use",
+          platform: "openclaw",
+          sessionId,
+          tool: toolName,
+          success,
+          timestamp,
+        });
+
+        postToDaemon({
+          sessionId,
+          slug: toolName,
+          tool: toolName,
+          success,
+          platform: "openclaw",
+          timestamp,
+        });
+        break;
+      }
+
+      case "session_end":
+      case "agent_end": {
+        const key = event?.agentId ?? event?.runId ?? event?.sessionId ?? "default";
+        const state = loadSessionState();
+        const sessionId = state[key] ?? "unknown";
+        await runCliHook("session-end", {
+          hook_event_name: "session-end",
+          session_id: sessionId,
+          reason: hookName,
+          cwd: event?.cwd ?? ctx?.cwd ?? ctx?.workspace ?? process.cwd(),
+        });
+        removeSessionId(sessionId);
+        break;
+      }
+
+      case "gateway_start": {
+        clearAllSessions();
+        break;
+      }
+    }
+  } catch { /* never fail */ }
+};
+
+export default handler;
+`;
+
+// src/platform/codex.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  rmSync as rmSync2
+} from "fs";
+import { execSync as execSync3 } from "child_process";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var MCP_KEY2 = "caik";
+var PLUGIN_MANAGED_SKILLS = [
+  "caik",
+  "caik-discover",
+  "caik-observe",
+  "caik-improve",
+  "caik-status"
+];
+var CodexAdapter = class {
+  name = "codex";
+  tier = "full-plugin";
+  get codexDir() {
+    return join3(homedir3(), ".codex");
+  }
+  get configTomlPath() {
+    return join3(this.codexDir, "config.toml");
+  }
+  get hooksPath() {
+    return join3(this.codexDir, "hooks.json");
+  }
+  get skillsDir() {
+    return join3(this.codexDir, "skills");
+  }
+  get localSkillsDir() {
+    return join3(process.cwd(), ".agents", "skills");
+  }
+  get pluginsCacheDir() {
+    return join3(this.codexDir, "plugins", "cache");
+  }
+  // ---------------------------------------------------------------------------
+  // JSON helpers (for hooks.json)
+  // ---------------------------------------------------------------------------
+  readJson(path) {
+    if (!existsSync3(path)) return {};
+    try {
+      const raw = readFileSync2(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  writeJson(path, data) {
+    const dir = join3(path, "..");
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+  // ---------------------------------------------------------------------------
+  // TOML helpers (for config.toml — read-only, writes go through codex CLI)
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if a key exists in config.toml (simple regex, no TOML parser needed).
+   */
+  configTomlHasKey(key) {
+    if (!existsSync3(this.configTomlPath)) return false;
+    try {
+      const content = readFileSync2(this.configTomlPath, "utf-8");
+      return content.includes(`[mcp_servers.${key}]`);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if `codex` CLI is available in PATH.
+   */
+  codexCliAvailable() {
+    try {
+      execSync3("which codex", { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Ensure `codex_hooks = true` is set in config.toml [features] section.
+   * Codex requires this feature flag for hooks to fire.
+   */
+  ensureHooksEnabled() {
+    if (!existsSync3(this.configTomlPath)) return;
+    try {
+      const content = readFileSync2(this.configTomlPath, "utf-8");
+      if (content.includes("codex_hooks")) return;
+      if (content.includes("[features]")) {
+        const updated = content.replace(
+          /(\[features\]\n)/,
+          "$1codex_hooks = true\n"
+        );
+        writeFileSync2(this.configTomlPath, updated, "utf-8");
+      } else {
+        writeFileSync2(
+          this.configTomlPath,
+          content.trimEnd() + "\n\n[features]\ncodex_hooks = true\n",
+          "utf-8"
+        );
+      }
+    } catch {
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Plugin detection
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if CAIK is installed as a Codex plugin.
+   * Checks plugins cache directory and config.toml [plugins] section.
+   */
+  isPluginInstalled() {
+    if (existsSync3(this.pluginsCacheDir)) {
+      try {
+        const publishers = readdirSync(this.pluginsCacheDir);
+        for (const publisher of publishers) {
+          const caikDir = join3(this.pluginsCacheDir, publisher, "caik");
+          if (existsSync3(caikDir)) {
+            return true;
+          }
+        }
+      } catch {
+      }
+    }
+    if (existsSync3(this.configTomlPath)) {
+      try {
+        const content = readFileSync2(this.configTomlPath, "utf-8");
+        if (/\[plugins\.[^\]]*caik/i.test(content)) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  // ---------------------------------------------------------------------------
+  // PlatformAdapter implementation
+  // ---------------------------------------------------------------------------
+  async detect() {
+    if (!existsSync3(this.codexDir)) return null;
+    const hasHooks = existsSync3(this.hooksPath);
+    const hasConfig = existsSync3(this.configTomlPath);
+    if (!hasHooks && !hasConfig) return null;
+    const configPaths = [];
+    if (hasConfig) configPaths.push(this.configTomlPath);
+    if (hasHooks) configPaths.push(this.hooksPath);
+    return {
+      name: this.name,
+      tier: this.tier,
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  async registerMcp(serverConfig) {
+    if (this.isPluginInstalled()) return;
+    const serverKey = serverConfig.key ?? MCP_KEY2;
+    if (this.configTomlHasKey(serverKey)) return;
+    if (this.codexCliAvailable()) {
+      try {
+        const args = [serverConfig.command, ...serverConfig.args];
+        const envFlags = serverConfig.env ? Object.entries(serverConfig.env).map(([k, v]) => `--env ${k}=${v}`).join(" ") : "";
+        const cmd = `codex mcp add ${serverKey} ${envFlags} -- ${args.join(" ")}`;
+        execSync3(cmd, { stdio: "pipe", timeout: 1e4 });
+        return;
+      } catch {
+      }
+    }
+    const envSection = serverConfig.env ? Object.entries(serverConfig.env).map(([k, v]) => `${k} = "${v}"`).join("\n") : "";
+    const tomlSnippet = [
+      `[mcp_servers.${serverKey}]`,
+      `command = "${serverConfig.command}"`,
+      `args = ${JSON.stringify(serverConfig.args)}`,
+      ...envSection ? [`
+[mcp_servers.${serverKey}.env]`, envSection] : []
+    ].join("\n");
+    process.stdout.write(
+      `
+Add this to ~/.codex/config.toml:
+
+${tomlSnippet}
+
+Or run: codex mcp add ${serverKey} -- ${serverConfig.command} ${serverConfig.args.join(" ")}
+
+`
+    );
+  }
+  async unregisterMcp() {
+    if (!this.configTomlHasKey(MCP_KEY2)) return;
+    if (this.codexCliAvailable()) {
+      try {
+        execSync3(`codex mcp remove ${MCP_KEY2}`, { stdio: "pipe", timeout: 1e4 });
+        return;
+      } catch {
+      }
+    }
+    process.stdout.write(
+      `
+Remove [mcp_servers.${MCP_KEY2}] from ~/.codex/config.toml
+Or run: codex mcp remove ${MCP_KEY2}
+
+`
+    );
+  }
+  async registerHooks(hookConfig) {
+    if (this.isPluginInstalled()) return;
+    this.ensureHooksEnabled();
+    const hooksFile = this.readJson(this.hooksPath);
+    const existingHooks = hooksFile.hooks ?? {};
+    for (const [event, entries] of Object.entries(hookConfig.hooks)) {
+      const newEntries = Array.isArray(entries) ? entries : [entries];
+      const existing = Array.isArray(existingHooks[event]) ? existingHooks[event] : [];
+      const filtered = existing.filter((group) => {
+        if (typeof group === "object" && group !== null) {
+          const g = group;
+          if (Array.isArray(g.hooks)) {
+            const hasCAIK = g.hooks.some(
+              (h) => typeof h.command === "string" && h.command.toLowerCase().includes("caik")
+            );
+            if (hasCAIK) return false;
+          }
+          if ("command" in g) {
+            return !g.command.toLowerCase().includes("caik");
+          }
+        }
+        return true;
+      });
+      const wrappedEntries = newEntries.map((entry) => {
+        if (typeof entry === "object" && entry !== null) {
+          const e = entry;
+          const hookEntry = {
+            type: "command",
+            timeout: 10,
+            ...e
+          };
+          return { hooks: [hookEntry] };
+        }
+        return entry;
+      });
+      existingHooks[event] = [...filtered, ...wrappedEntries];
+    }
+    hooksFile.hooks = existingHooks;
+    this.writeJson(this.hooksPath, hooksFile);
+  }
+  async unregisterHooks() {
+    if (!existsSync3(this.hooksPath)) return;
+    const hooksFile = this.readJson(this.hooksPath);
+    const hooks = hooksFile.hooks;
+    if (!hooks) return;
+    for (const event of Object.keys(hooks)) {
+      const entries = hooks[event];
+      if (!Array.isArray(entries)) continue;
+      hooks[event] = entries.filter((group) => {
+        if (typeof group === "object" && group !== null) {
+          const g = group;
+          if (Array.isArray(g.hooks)) {
+            const hasCAIK = g.hooks.some(
+              (h) => typeof h.command === "string" && h.command.includes("caik")
+            );
+            if (hasCAIK) return false;
+          }
+          if ("command" in g) {
+            return !g.command.includes("caik");
+          }
+        }
+        return true;
+      });
+      if (hooks[event].length === 0) {
+        delete hooks[event];
+      }
+    }
+    if (Object.keys(hooks).length === 0) {
+      delete hooksFile.hooks;
+    } else {
+      hooksFile.hooks = hooks;
+    }
+    this.writeJson(this.hooksPath, hooksFile);
+  }
+  async installSkill(slug, content, files, local) {
+    if (!local && this.isPluginInstalled() && PLUGIN_MANAGED_SKILLS.includes(slug)) {
+      return;
+    }
+    const baseDir = local ? this.localSkillsDir : this.skillsDir;
+    const skillDir = join3(baseDir, slug);
+    if (!existsSync3(skillDir)) {
+      mkdirSync2(skillDir, { recursive: true });
+    }
+    writeFileSync2(join3(skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join3(skillDir, file.path);
+        const fileDir = join3(filePath, "..");
+        if (!existsSync3(fileDir)) {
+          mkdirSync2(fileDir, { recursive: true });
+        }
+        writeFileSync2(filePath, file.content, "utf-8");
+      }
+    }
+  }
+  async uninstallSkill(slug, local) {
+    const baseDir = local ? this.localSkillsDir : this.skillsDir;
+    const skillDir = join3(baseDir, slug);
+    if (!existsSync3(skillDir)) return;
+    try {
+      rmSync2(skillDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  getConfigPath() {
+    return this.configTomlPath;
+  }
+  async readConfig() {
+    if (!existsSync3(this.configTomlPath)) return {};
+    try {
+      const content = readFileSync2(this.configTomlPath, "utf-8");
+      return { _raw: content, _format: "toml" };
+    } catch {
+      return {};
+    }
+  }
+  async isRegistered() {
+    if (this.isPluginInstalled()) return true;
+    return this.configTomlHasKey(MCP_KEY2);
+  }
+};
+
+// src/platform/generic.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, rmSync as rmSync3 } from "fs";
+import { execSync as execSync4 } from "child_process";
+import { join as join4, dirname as dirname2 } from "path";
+import { homedir as homedir4 } from "os";
+var MCP_KEY3 = "caik";
+function expandHome2(p) {
+  if (p.startsWith("~/")) return join4(homedir4(), p.slice(2));
+  if (p === "~") return homedir4();
+  return p;
+}
+function commandExists2(cmd) {
+  try {
+    execSync4(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJsonFile(path) {
+  try {
+    if (!existsSync4(path)) return null;
+    const raw = readFileSync3(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, data) {
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+var GenericAdapter = class {
+  name;
+  tier;
+  config;
+  constructor(name, config) {
+    this.name = name;
+    this.config = config ?? null;
+    this.tier = config?.tier ?? "cli-mcp";
+  }
+  // ── Detection ─────────────────────────────────────────────
+  async detect() {
+    if (!this.config) return null;
+    const home = homedir4();
+    const cwd = process.cwd();
+    let found = false;
+    for (const dir of this.config.homeDirs) {
+      if (existsSync4(join4(home, dir))) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      for (const dir of this.config.cwdDirs) {
+        if (existsSync4(join4(cwd, dir))) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      for (const bin of this.config.binaries) {
+        if (commandExists2(bin)) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) return null;
+    const configPaths = [];
+    if (this.config.mcpConfigPath) {
+      const resolved = this.resolveConfigPath();
+      if (resolved && existsSync4(resolved)) {
+        configPaths.push(resolved);
+      }
+    }
+    return {
+      name: this.name,
+      tier: this.tier,
+      configPaths,
+      capabilities: this.config.capabilities
+    };
+  }
+  // ── MCP Registration ──────────────────────────────────────
+  async registerMcp(serverConfig) {
+    const configPath = this.resolveConfigPath();
+    if (!configPath || this.config?.mcpConfigKey === "manual") {
+      this.printManualInstructions(serverConfig);
+      return;
+    }
+    const config = readJsonFile(configPath) ?? {};
+    const key = this.config?.mcpConfigKey ?? "mcpServers";
+    const servers = config[key] ?? {};
+    const serverKey = serverConfig.key ?? MCP_KEY3;
+    const { key: _key, ...mcpEntry } = serverConfig;
+    servers[serverKey] = mcpEntry;
+    config[key] = servers;
+    writeJsonFile(configPath, config);
+  }
+  async unregisterMcp() {
+    const configPath = this.resolveConfigPath();
+    if (!configPath || this.config?.mcpConfigKey === "manual") {
+      process.stdout.write(
+        `
+To unregister CAIK from ${this.name}, remove the "caik" entry
+from the MCP section in your configuration file.
+
+`
+      );
+      return;
+    }
+    const config = readJsonFile(configPath);
+    if (!config) return;
+    const key = this.config?.mcpConfigKey ?? "mcpServers";
+    const servers = config[key];
+    if (!servers?.[MCP_KEY3]) return;
+    delete servers[MCP_KEY3];
+    if (Object.keys(servers).length === 0) {
+      delete config[key];
+    }
+    writeJsonFile(configPath, config);
+  }
+  // ── Skills ────────────────────────────────────────────────
+  async installSkill(slug, content, files, local) {
+    const baseDir = this.resolveSkillsDir(local);
+    if (!baseDir) return;
+    const skillDir = join4(baseDir, slug);
+    mkdirSync3(skillDir, { recursive: true });
+    writeFileSync3(join4(skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join4(skillDir, file.path);
+        mkdirSync3(dirname2(filePath), { recursive: true });
+        writeFileSync3(filePath, file.content, "utf-8");
+      }
+    }
+  }
+  async uninstallSkill(slug, local) {
+    const baseDir = this.resolveSkillsDir(local);
+    if (!baseDir) return;
+    const skillDir = join4(baseDir, slug);
+    try {
+      if (existsSync4(skillDir)) {
+        rmSync3(skillDir, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+  // ── Config Accessors ──────────────────────────────────────
+  getConfigPath() {
+    return this.resolveConfigPath() ?? "";
+  }
+  async readConfig() {
+    const configPath = this.resolveConfigPath();
+    if (!configPath) return {};
+    return readJsonFile(configPath) ?? {};
+  }
+  async isRegistered() {
+    const configPath = this.resolveConfigPath();
+    if (!configPath || this.config?.mcpConfigKey === "manual") return false;
+    const config = readJsonFile(configPath);
+    if (!config) return false;
+    const key = this.config?.mcpConfigKey ?? "mcpServers";
+    const servers = config[key];
+    return Boolean(servers?.[MCP_KEY3]);
+  }
+  // ── Private Helpers ───────────────────────────────────────
+  /** Resolve the MCP config path, expanding ~ and handling cwd-relative paths */
+  resolveConfigPath() {
+    if (!this.config?.mcpConfigPath) return null;
+    const raw = this.config.mcpConfigPath;
+    if (raw.startsWith("~/") || raw.startsWith("~")) {
+      return expandHome2(raw);
+    }
+    return join4(process.cwd(), raw);
+  }
+  /** Resolve the skills directory for global or local scope */
+  resolveSkillsDir(local) {
+    if (!this.config) return null;
+    if (local && this.config.localSkillsDir) {
+      return join4(process.cwd(), this.config.localSkillsDir);
+    }
+    if (!local && this.config.skillsDir) {
+      return expandHome2(this.config.skillsDir);
+    }
+    if (local && this.config.skillsDir) {
+      return expandHome2(this.config.skillsDir);
+    }
+    if (!local && this.config.localSkillsDir) {
+      return join4(process.cwd(), this.config.localSkillsDir);
+    }
+    return null;
+  }
+  /** Print manual MCP setup instructions for platforms with non-JSON configs */
+  printManualInstructions(serverConfig) {
+    const snippet = {
+      mcpServers: {
+        caik: {
+          command: serverConfig.command,
+          args: serverConfig.args,
+          ...serverConfig.env && Object.keys(serverConfig.env).length > 0 ? { env: serverConfig.env } : {}
+        }
+      }
+    };
+    const json = JSON.stringify(snippet, null, 2);
+    const configFile = this.config?.mcpConfigPath ? `Config file: ${this.config.mcpConfigPath}` : `Refer to your platform's documentation for the correct config file location.`;
+    process.stdout.write(
+      `
+CAIK MCP server configuration for ${this.config?.label ?? this.name}:
+
+Add the following to your MCP configuration:
+
+${json}
+
+${configFile}
+
+`
+    );
+  }
+};
+
+// src/platform/index.ts
+var customAdapters = {
+  "claude-code": () => new ClaudeCodeAdapter(),
+  "openclaw": () => new OpenClawAdapter(),
+  "cursor": () => new CursorAdapter(),
+  "codex": () => new CodexAdapter()
+};
+function getPlatformAdapter(name) {
+  const custom = customAdapters[name];
+  if (custom) return custom();
+  const config = platformConfigs[name];
+  return new GenericAdapter(name, config);
+}
+function getDefaultMcpConfig() {
+  return {
+    command: "npx",
+    args: ["-y", "@caik.dev/mcp"]
+  };
+}
+
+export {
+  detectPlatforms,
+  detectPlatform,
+  getPlatformAdapter,
+  getDefaultMcpConfig
+};