@pragma-sh/kimi-plugin 1.0.1 → 1.1.0

package/dist/pragma-plugin.mjs

@@ -1,13 +1,423 @@
-// ../plugin/dist/shared/chunk-e222xk1w.js
-var PLUGIN_API_VERSION = "1.0.1";
+// ../plugin/dist/shared/chunk-b8hkp0vs.js
+var PLUGIN_API_VERSION = "1.2.0";
 
-// ../plugin/dist/shared/chunk-6qx2xj9p.js
+// ../plugin/dist/shared/chunk-whqa76q3.js
 function defineAgent(input) {
   return input;
 }
+function dedupeSlashCommands(commands) {
+  const seen = new Set;
+  return commands.filter((command) => {
+    if (!command.name || seen.has(command.name))
+      return false;
+    seen.add(command.name);
+    return true;
+  });
+}
+var DEFAULT_TIMEOUT_SECONDS = 30;
+var ACP_COMMANDS_TTL_MS = 5 * 60000;
+var MAX_CONCURRENT_PROBES = 2;
+var SETTLE_SECONDS = "1.5";
+var UPDATE_MARKER = "available_commands_update";
+var STATE_KEY = Symbol.for("pragma.acpDiscovery");
+var state = globalThis[STATE_KEY] ??= { cache: new Map, inflight: new Map, running: 0, waiting: [] };
+var { cache, inflight } = state;
+async function discoverAcpSlashCommands(ctx, source) {
+  const cwd = ctx.project?.path ?? "/tmp";
+  const key = `${cwd}\x00${source.command.join("\x00")}`;
+  const cached = cache.get(key);
+  if (cached && Date.now() - cached.at < ACP_COMMANDS_TTL_MS)
+    return cached.commands;
+  const probe = inflight.get(key) ?? startProbe(ctx, source, cwd, key);
+  return cached ? cached.commands : probe;
+}
+function startProbe(ctx, source, cwd, key) {
+  const probe = withProbeSlot(async () => {
+    const [result] = await ctx.sdk.exec.run({ cwd, commands: [acpCommandsScript(source)] });
+    return result?.status === 0 ? parseAcpCommands(result.stdout) : [];
+  }).catch(() => []).then((commands) => {
+    if (commands.length > 0)
+      cache.set(key, { commands, at: Date.now() });
+    return commands;
+  }).finally(() => inflight.delete(key));
+  inflight.set(key, probe);
+  return probe;
+}
+async function withProbeSlot(work) {
+  if (state.running >= MAX_CONCURRENT_PROBES) {
+    await new Promise((resolve) => state.waiting.push(resolve));
+  }
+  state.running += 1;
+  try {
+    return await work();
+  } finally {
+    state.running -= 1;
+    state.waiting.shift()?.();
+  }
+}
+function acpCommandsScript(source) {
+  const ticks = Math.round((source.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 10);
+  const [binary] = source.command;
+  const initialize = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: { protocolVersion: 1, clientCapabilities: {} }
+  });
+  return [
+    `command -v ${shellQuote(binary ?? "")} >/dev/null 2>&1 || exit 0`,
+    "work=$(mktemp -d) || exit 0",
+    `trap 'rm -rf "$work"' 0`,
+    'mkfifo "$work/in" || exit 0',
+    ': >"$work/out"',
+    "{",
+    `  printf '%s\\n' ${shellQuote(initialize)}`,
+    "  n=0",
+    `  while ! grep -q '"id":1' "$work/out" && [ ! -e "$work/done" ] && [ "$n" -lt ${ticks} ]; do sleep 0.1; n=$((n + 1)); done`,
+    `  printf '{"jsonrpc":"2.0","id":2,"method":"session/new","params":{"cwd":"%s","mcpServers":[]}}\\n' "$PWD"`,
+    `  while [ ! -e "$work/done" ] && [ "$n" -lt ${ticks * 2} ]; do sleep 0.1; n=$((n + 1)); done`,
+    '} >"$work/in" &',
+    "writer=$!",
+    `${source.command.map(shellArg).join(" ")} <"$work/in" >"$work/out" 2>/dev/null &`,
+    "agent=$!",
+    "n=0",
+    `while [ "$n" -lt ${ticks} ]; do`,
+    `  if grep -q ${UPDATE_MARKER} "$work/out"; then sleep ${SETTLE_SECONDS}; break; fi`,
+    "  sleep 0.1; n=$((n + 1))",
+    "done",
+    ': >"$work/done"',
+    'kill "$agent" 2>/dev/null',
+    'wait "$writer" 2>/dev/null',
+    `grep ${UPDATE_MARKER} "$work/out" | tail -n 1`,
+    "exit 0"
+  ].join(`
+`);
+}
+function parseAcpCommands(stdout) {
+  let commands = [];
+  for (const line of stdout.split(`
+`)) {
+    if (!line.includes(UPDATE_MARKER))
+      continue;
+    const parsed = updateCommands(line);
+    if (parsed)
+      commands = parsed;
+  }
+  return commands;
+}
+function updateCommands(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const update = record(record(record(message)?.params)?.update);
+  if (update?.sessionUpdate !== UPDATE_MARKER || !Array.isArray(update.availableCommands)) {
+    return null;
+  }
+  return update.availableCommands.flatMap((entry) => {
+    const command = acpCommand(entry);
+    return command ? [command] : [];
+  });
+}
+function acpCommand(entry) {
+  const command = record(entry);
+  const name = text(command?.name).replace(/^\//, "");
+  if (!name)
+    return null;
+  const description = text(command?.description);
+  const argumentHint = text(record(command?.input)?.hint);
+  return {
+    name,
+    ...description ? { description } : {},
+    ...argumentHint ? { argumentHint } : {}
+  };
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function shellArg(value) {
+  return value.split("{tmp}").map((part) => part ? shellQuote(part) : "").join('"$work/tmp"');
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+var RECORD_SEPARATOR = "\x1E";
+var HEAD_LINES = 40;
+var MAX_DEPTH = 8;
+async function discoverMarkdownEntries(ctx, sources) {
+  if (sources.length === 0)
+    return [];
+  const [result] = await ctx.sdk.exec.run({
+    cwd: ctx.project?.path ?? "/tmp",
+    commands: [markdownScanScript(sources)]
+  });
+  if (!result || result.status !== 0)
+    return [];
+  return parseMarkdownScan(result.stdout, sources);
+}
+async function discoverSlashCommands(ctx, sources) {
+  return markdownSlashCommands(await discoverMarkdownEntries(ctx, sources));
+}
+function markdownSlashCommands(entries) {
+  const seen = new Set;
+  const commands = [];
+  for (const entry of entries) {
+    if (entry.frontmatter["user-invocable"] === "false" || seen.has(entry.name))
+      continue;
+    seen.add(entry.name);
+    const description = entry.frontmatter.description;
+    const argumentHint = entry.frontmatter["argument-hint"];
+    commands.push({
+      name: entry.name,
+      ...description ? { description } : {},
+      ...argumentHint ? { argumentHint } : {}
+    });
+  }
+  return commands;
+}
+function markdownModes(entries) {
+  const seen = new Set;
+  const modes = [];
+  for (const entry of entries) {
+    if (seen.has(entry.name))
+      continue;
+    seen.add(entry.name);
+    const description = entry.frontmatter.description;
+    modes.push({
+      id: entry.name,
+      name: titleCase(entry.name),
+      ...description ? { description } : {}
+    });
+  }
+  return modes;
+}
+var noCommands = () => [];
+function slashCommandProvider(builtins, sources, discovery = {}) {
+  return async (ctx) => {
+    const [acp, loaded, files] = await Promise.all([
+      discovery.acp ? discoverAcpSlashCommands(ctx, discovery.acp).catch(noCommands) : [],
+      discovery.load ? discovery.load(ctx).catch(noCommands) : [],
+      discoverSlashCommands(ctx, sources).catch(noCommands)
+    ]);
+    return dedupeSlashCommands([...builtins, ...acp, ...loaded, ...files]);
+  };
+}
+function modeProvider(builtins, sources, keep = () => true) {
+  return async (ctx) => {
+    const entries = await discoverMarkdownEntries(ctx, sources).catch(() => []);
+    const discovered = markdownModes(entries.filter(keep));
+    const ids = new Set(builtins.map((mode) => mode.id));
+    return [...builtins, ...discovered.filter((mode) => !ids.has(mode.id))];
+  };
+}
+function markdownScanScript(sources) {
+  const lines = [
+    "pragma_scan() {",
+    '  [ -d "$2" ] || return 0',
+    '  find -L "$2" -maxdepth "$3" -type f -name "$4" 2>/dev/null | sort | while IFS= read -r f; do',
+    `    printf '\\036%s\\t%s\\n' "$1" "\${f#"$2"/}"; head -n ${HEAD_LINES} "$f" 2>/dev/null; printf '\\n'`,
+    "  done",
+    "}"
+  ];
+  sources.forEach((source, index) => {
+    const skills = source.layout === "skills";
+    const depth = skills ? 2 : source.recursive === false ? 1 : MAX_DEPTH;
+    const pattern = skills ? "SKILL.md" : `*${source.suffix ?? ".md"}`;
+    lines.push(`pragma_scan ${index} ${shellDir(source.dir)} ${depth} ${shellQuote2(pattern)}`);
+  });
+  lines.push("exit 0");
+  return lines.join(`
+`);
+}
+function parseMarkdownScan(stdout, sources) {
+  const entries = [];
+  for (const record2 of stdout.split(RECORD_SEPARATOR).slice(1)) {
+    const newline = record2.indexOf(`
+`);
+    const header = newline === -1 ? record2 : record2.slice(0, newline);
+    const [indexText, relativePath] = header.split("\t");
+    const source = sources[Number(indexText)];
+    if (!source || !relativePath)
+      continue;
+    const frontmatter = parseFrontmatter(newline === -1 ? "" : record2.slice(newline + 1));
+    const name = entryName(source, relativePath, frontmatter);
+    if (name)
+      entries.push({ name: `${source.prefix ?? ""}${name}`, frontmatter, source });
+  }
+  return entries;
+}
+function parseFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---")
+    return {};
+  const result = {};
+  let blockKey = null;
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "---")
+      break;
+    if (blockKey && /^\s+\S/.test(line)) {
+      const previous = result[blockKey];
+      result[blockKey] = previous ? `${previous} ${line.trim()}` : line.trim();
+      continue;
+    }
+    blockKey = null;
+    const match = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+    if (!match)
+      continue;
+    const value = unquote(match[2].trim());
+    if (/^[|>][+-]?$/.test(value)) {
+      blockKey = match[1];
+    } else if (value) {
+      result[match[1]] = value;
+    }
+  }
+  return result;
+}
+function entryName(source, relativePath, frontmatter) {
+  if (source.layout === "skills") {
+    const directory = relativePath.split("/").slice(0, -1).join("/");
+    return frontmatter.name ?? (directory || null);
+  }
+  if (source.nameFromFrontmatter && frontmatter.name)
+    return frontmatter.name;
+  const suffix = source.suffix ?? ".md";
+  if (!relativePath.endsWith(suffix))
+    return null;
+  return relativePath.slice(0, -suffix.length).split("/").join(":") || null;
+}
+function unquote(value) {
+  const quoted = /^(["'])(.*)\1$/.exec(value);
+  return quoted ? quoted[2] : value;
+}
+function titleCase(value) {
+  return value.split(/[-_\s]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
+}
+function shellDir(dir) {
+  if (dir === "~")
+    return '"$HOME"';
+  if (dir.startsWith("~/"))
+    return `"$HOME"/${shellQuote2(dir.slice(2))}`;
+  return shellQuote2(dir);
+}
+function shellQuote2(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
 function definePlugin(input) {
   return { ...input, __apiVersion: PLUGIN_API_VERSION };
 }
+var ACCOUNT_PROVIDERS = {
+  anthropic: { title: "Anthropic", modelsDevIds: ["anthropic"] },
+  openai: { title: "OpenAI", modelsDevIds: ["openai"] },
+  cursor: { title: "Cursor" },
+  "github-copilot": { title: "GitHub Copilot" },
+  xai: { title: "xAI", dashboardUrl: "https://console.x.ai", modelsDevIds: ["xai"] },
+  jetbrains: { title: "JetBrains" },
+  "opencode-go": { title: "OpenCode Go", modelsDevIds: ["opencode-go"] },
+  "opencode-zen": {
+    title: "OpenCode Zen",
+    dashboardUrl: "https://opencode.ai/auth",
+    modelsDevIds: ["opencode"]
+  },
+  moonshot: { title: "Moonshot", modelsDevIds: ["kimi-code-plan-global", "kimi-code-plan-cn"] },
+  "moonshot-platform": {
+    title: "Moonshot AI Platform",
+    dashboardUrl: "https://platform.moonshot.ai/console/api-keys",
+    modelsDevIds: ["moonshotai", "moonshotai-cn"]
+  },
+  google: {
+    title: "Google Gemini API",
+    dashboardUrl: "https://aistudio.google.com/apikey",
+    modelsDevIds: ["google"]
+  },
+  openrouter: {
+    title: "OpenRouter",
+    dashboardUrl: "https://openrouter.ai/settings/keys",
+    modelsDevIds: ["openrouter"]
+  },
+  deepseek: {
+    title: "DeepSeek",
+    dashboardUrl: "https://platform.deepseek.com/api_keys",
+    modelsDevIds: ["deepseek"]
+  },
+  groq: { title: "Groq", dashboardUrl: "https://console.groq.com/keys", modelsDevIds: ["groq"] },
+  mistral: {
+    title: "Mistral",
+    dashboardUrl: "https://console.mistral.ai/api-keys",
+    modelsDevIds: ["mistral"]
+  },
+  cerebras: {
+    title: "Cerebras",
+    dashboardUrl: "https://cloud.cerebras.ai",
+    modelsDevIds: ["cerebras"]
+  },
+  fireworks: {
+    title: "Fireworks AI",
+    dashboardUrl: "https://fireworks.ai/account/api-keys",
+    modelsDevIds: ["fireworks-ai"]
+  },
+  together: {
+    title: "Together AI",
+    dashboardUrl: "https://api.together.ai/settings/api-keys",
+    modelsDevIds: ["togetherai"]
+  },
+  huggingface: {
+    title: "Hugging Face",
+    dashboardUrl: "https://huggingface.co/settings/tokens",
+    modelsDevIds: ["huggingface"]
+  },
+  nvidia: { title: "NVIDIA", dashboardUrl: "https://build.nvidia.com", modelsDevIds: ["nvidia"] },
+  "vercel-ai-gateway": {
+    title: "Vercel AI Gateway",
+    dashboardUrl: "https://vercel.com/dashboard/ai-gateway",
+    modelsDevIds: ["vercel"]
+  },
+  zai: {
+    title: "Z.ai",
+    dashboardUrl: "https://z.ai/manage-apikey/apikey-list",
+    modelsDevIds: ["zai-coding-plan", "zai", "zhipuai"]
+  },
+  minimax: {
+    title: "MiniMax",
+    dashboardUrl: "https://platform.minimax.io",
+    modelsDevIds: ["minimax-coding-plan", "minimax", "minimax-cn-coding-plan", "minimax-cn"]
+  },
+  xiaomi: {
+    title: "Xiaomi MiMo",
+    dashboardUrl: "https://platform.xiaomimimo.com",
+    modelsDevIds: [
+      "xiaomi",
+      "xiaomi-token-plan-ams",
+      "xiaomi-token-plan-sgp",
+      "xiaomi-token-plan-cn"
+    ]
+  }
+};
+function modelsDevAccountProviders(except = []) {
+  return Object.keys(ACCOUNT_PROVIDERS).flatMap((provider) => {
+    const { modelsDevIds } = ACCOUNT_PROVIDERS[provider];
+    return modelsDevIds && !except.includes(provider) ? [{ provider, modelsDevIds }] : [];
+  });
+}
+function apiKeyTokenKind(provider) {
+  return `key:${provider}`;
+}
+function defineAccounts(providers) {
+  return providers;
+}
+var API_KEY_DIGEST_LENGTH = 16;
+async function apiKeyIdentity(key) {
+  const trimmed = key.trim();
+  if (!trimmed)
+    return null;
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(trimmed));
+  const hex = [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, API_KEY_DIGEST_LENGTH);
+  return { id: `key:${hex}`, name: `API key …${trimmed.slice(-4)}` };
+}
 
 // ../watcher-kit/src/index.ts
 var DEFAULT_APPROVE_KEYS = "\r";
@@ -207,8 +617,8 @@ async function finalizeQuestionAnswers(ctx, runtime) {
   if (!ctx.signal.aborted)
     await writeKeys(ctx, runtime.questionFinalizeKeys);
 }
-async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text) {
-  const input = mode === "plain" ? text : `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text2) {
+  const input = mode === "plain" ? text2 : `${BRACKETED_PASTE_START}${text2}${BRACKETED_PASTE_END}`;
   await writeKeys(ctx, input);
   if (!submitKeys) {
     return;
@@ -226,15 +636,15 @@ function rememberCommandAttention(runtime, event) {
     runtime.outstandingCommandRequestId = null;
   }
 }
-function rememberQuestion(cache, event) {
+function rememberQuestion(cache2, event) {
   if (event.status === "attention" && event.attentionKind === "question" && typeof event.requestId === "string" && event.requestId.length > 0) {
     const entries = (event.questions ?? []).flatMap(questionEntry);
     if (entries.length > 0) {
-      cache.set(event.requestId, { questions: entries });
+      cache2.set(event.requestId, { questions: entries });
       return;
     }
     const options = (event.options ?? []).map((option) => option.label).filter((option) => option.trim() !== "");
-    cache.set(event.requestId, {
+    cache2.set(event.requestId, {
       questions: [{ question: event.question ?? "", options }]
     });
   }
@@ -243,12 +653,12 @@ function questionEntry(value) {
   if (typeof value !== "object" || value === null || !("question" in value)) {
     return [];
   }
-  const record = value;
-  if (typeof record.question !== "string" || !record.question.trim()) {
+  const record2 = value;
+  if (typeof record2.question !== "string" || !record2.question.trim()) {
     return [];
   }
-  const options = Array.isArray(record.options) ? record.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
-  return [{ question: record.question, options }];
+  const options = Array.isArray(record2.options) ? record2.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
+  return [{ question: record2.question, options }];
 }
 function questionAnswerKeys(input) {
   if (input.dismissed || input.reply === null) {
@@ -363,9 +773,142 @@ function recordValue(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
 
+// src/accounts.ts
+var PROVIDER_LIST_TTL_MS = 5000;
+var CATALOG_TTL_MS = 10 * 60000;
+var CATALOG_TIMEOUT_MS = 1e4;
+var KIMI_CATALOG_COMMAND = `kimi provider catalog list --json || "${KIMI_BIN_DIR}/kimi" provider catalog list --json`;
+var KIMI_API_KEY_PROVIDERS = modelsDevAccountProviders([
+  "moonshot"
+]);
+var providerLists = new Map;
+var catalog;
+function kimiApiKeyProviders() {
+  return KIMI_API_KEY_PROVIDERS.map(({ provider, modelsDevIds }) => ({
+    provider,
+    agent: "kimi",
+    credentialPath: () => "$KIMI_CODE_HOME or ~/.kimi-code/config.toml",
+    available: (ctx) => kimiOffers(ctx, modelsDevIds),
+    identify: (ctx) => identifyKimiProvider(ctx, modelsDevIds),
+    sharedToken: {
+      kind: apiKeyTokenKind(provider),
+      read: async (ctx) => {
+        const key = await kimiProviderKey(ctx, modelsDevIds);
+        return key ? { type: "api", key } : null;
+      }
+    }
+  }));
+}
+async function kimiOffers(ctx, modelsDevIds) {
+  const ids = await catalogIds(ctx);
+  return ids === null || modelsDevIds.some((id) => ids.has(id));
+}
+function catalogIds(ctx) {
+  if (catalog && Date.now() - catalog.at < CATALOG_TTL_MS)
+    return catalog.ids;
+  const ids = listCatalogIds(ctx);
+  const entry = { at: Date.now(), ids };
+  catalog = entry;
+  ids.then((result) => {
+    if (result === null && catalog === entry)
+      catalog = undefined;
+    return;
+  });
+  return ids;
+}
+async function listCatalogIds(ctx) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(null), CATALOG_TIMEOUT_MS);
+  });
+  const listing = ctx.sdk.exec.run({ cwd: ctx.project?.path ?? "/tmp", commands: [KIMI_CATALOG_COMMAND] }).then(([result]) => parseKimiCatalogIds(result?.stdout ?? "")).catch(() => null);
+  try {
+    return await Promise.race([listing, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseKimiCatalogIds(output) {
+  try {
+    const providers = recordValue(JSON.parse(output));
+    return providers && Object.keys(providers).length > 0 ? new Set(Object.keys(providers)) : null;
+  } catch {
+    return null;
+  }
+}
+async function identifyKimiProvider(ctx, modelsDevIds) {
+  const key = await kimiProviderKey(ctx, modelsDevIds);
+  return key ? apiKeyIdentity(key) : null;
+}
+async function kimiProviderKey(ctx, modelsDevIds) {
+  const keys = await providerKeys(ctx);
+  for (const id of modelsDevIds) {
+    const key = keys.get(id);
+    if (key)
+      return key;
+  }
+  return null;
+}
+function providerKeys(ctx) {
+  const cacheKey = JSON.stringify([ctx.project?.path ?? null, ctx.account.env]);
+  const cached = providerLists.get(cacheKey);
+  if (cached && Date.now() - cached.at < PROVIDER_LIST_TTL_MS)
+    return cached.keys;
+  const keys = listProviderKeys(ctx);
+  providerLists.set(cacheKey, { at: Date.now(), keys });
+  return keys;
+}
+async function listProviderKeys(ctx) {
+  try {
+    const [result] = await ctx.sdk.exec.run({
+      cwd: ctx.project?.path ?? "/tmp",
+      commands: [KIMI_MODELS_COMMAND]
+    });
+    return parseKimiProviderKeys(result?.stdout ?? "");
+  } catch {
+    return new Map;
+  }
+}
+function parseKimiProviderKeys(output) {
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    return new Map;
+  }
+  const keys = new Map;
+  for (const [id, candidate] of Object.entries(recordValue(recordValue(value)?.providers) ?? {})) {
+    const apiKey = recordValue(candidate)?.apiKey;
+    if (typeof apiKey === "string" && apiKey.trim())
+      keys.set(id, apiKey.trim());
+  }
+  return keys;
+}
+
 // src/pragma-plugin.ts
 var INTERJECT_SUBMIT_DELAY_MS = 200;
 var PREFILL_DELAY_MS = 2500;
+var BUILTIN_SLASH_COMMANDS = [
+  { name: "init", description: "Analyze the project and write AGENTS.md" },
+  { name: "compact", description: "Compact the conversation context" }
+];
+var SLASH_COMMAND_SOURCES = [
+  { dir: ".kimi-code/skills", layout: "skills", prefix: "skill:" },
+  { dir: ".agents/skills", layout: "skills", prefix: "skill:" },
+  { dir: ".claude/skills", layout: "skills", prefix: "skill:" },
+  { dir: ".claude/commands", layout: "files" },
+  { dir: "~/.kimi-code/skills", layout: "skills", prefix: "skill:" },
+  { dir: "~/.agents/skills", layout: "skills", prefix: "skill:" },
+  { dir: "~/.claude/skills", layout: "skills", prefix: "skill:" },
+  { dir: "~/.claude/commands", layout: "files" }
+];
+var AGENT_SOURCES = [
+  { dir: ".kimi-code/agents", layout: "files", nameFromFrontmatter: true },
+  { dir: ".agents/agents", layout: "files", nameFromFrontmatter: true },
+  { dir: "~/.kimi-code/agents", layout: "files", nameFromFrontmatter: true },
+  { dir: "~/.agents/agents", layout: "files", nameFromFrontmatter: true }
+];
+var DEFAULT_MODE = "default";
 var baseWatcher = createTuiWatcher({
   agent: "kimi",
   handleDecisions: false,
@@ -376,6 +919,20 @@ var baseWatcher = createTuiWatcher({
 var kimiAgentPlugin = definePlugin({
   name: "Kimi Code",
   description: "Launch Kimi Code from Pragma.",
+  accounts: defineAccounts([
+    {
+      provider: "moonshot",
+      agent: "kimi",
+      iconPath: "assets/kimi.png",
+      login: {
+        command: ["kimi", "login"],
+        instructions: "Open the link, sign in to Kimi, and enter the code shown here."
+      },
+      env: (home) => ({ KIMI_CODE_HOME: home }),
+      credentialPath: (home) => home ?? "~/.kimi-code"
+    },
+    ...kimiApiKeyProviders()
+  ]),
   watchers: [
     {
       agent: "kimi",
@@ -402,7 +959,7 @@ var kimiAgentPlugin = definePlugin({
       name: "Kimi Code",
       icon: () => null,
       iconPath: "assets/kimi.png",
-      launch: { command: ["kimi", "-y"] },
+      launch: { command: ["kimi"] },
       prefillDelayMs: PREFILL_DELAY_MS,
       prefillMode: "plain",
       prefillSubmit: "\r",
@@ -413,13 +970,18 @@ var kimiAgentPlugin = definePlugin({
         { id: "auto", name: "Fully autonomous" },
         { id: "plan", name: "Plan mode" }
       ],
+      modes: modeProvider([{ id: DEFAULT_MODE, name: "Default" }], AGENT_SOURCES),
+      slashCommands: slashCommandProvider(BUILTIN_SLASH_COMMANDS, SLASH_COMMAND_SOURCES, {
+        acp: { command: ["kimi", "acp"] }
+      }),
       excludeFeatures: ["commandApproval"],
       args: {
         model: (modelId) => ["-m", modelId],
         reasoning: () => [],
+        mode: (modeId) => modeId === DEFAULT_MODE ? [] : ["--agent", modeId],
         permissionMode: (permissionModeId) => {
           if (permissionModeId === "yolo") {
-            return [];
+            return ["-y"];
           }
           if (permissionModeId === "auto") {
             return ["--auto"];

package/kimi.plugin.json

@@ -1,12 +1,15 @@
 {
   "name": "pragma-kimi",
-  "version": "0.0.0",
+  "version": "1.1.0",
   "description": "Report Kimi Code agent status into Pragma via pragma-cli.",
   "author": {
     "name": "Pragma"
   },
   "license": "MIT",
-  "keywords": ["pragma", "agent"],
+  "keywords": [
+    "pragma",
+    "agent"
+  ],
   "hooks": [
     {
       "event": "SessionStart",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pragma-sh/kimi-plugin",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Kimi Code CLI plugin that reports agent status to Pragma via native hooks.",
   "license": "AGPL-3.0-only",
   "repository": {

package/src/accounts.ts

@@ -0,0 +1,186 @@
+import {
+  apiKeyIdentity,
+  apiKeyTokenKind,
+  modelsDevAccountProviders,
+  type AccountContext,
+  type AccountIdentity,
+  type AccountProviderDefinition,
+  type ModelsDevAccountProvider,
+  type PluginContext,
+} from "@pragma-sh/plugin/catalog";
+
+import { KIMI_BIN_DIR, KIMI_MODELS_COMMAND, recordValue } from "./models";
+
+/** How long one `kimi provider list` answers every provider's `identify`. */
+const PROVIDER_LIST_TTL_MS = 5_000;
+/** The catalog is models.dev, fetched over the network: ask rarely. */
+const CATALOG_TTL_MS = 10 * 60_000;
+/** Past this, an offline or slow catalog fetch stops holding up the account list. */
+const CATALOG_TIMEOUT_MS = 10_000;
+/** Every provider `kimi provider catalog add` can import, as JSON keyed by models.dev id. */
+const KIMI_CATALOG_COMMAND = `kimi provider catalog list --json || "${KIMI_BIN_DIR}/kimi" provider catalog list --json`;
+
+/**
+ * API-key providers Kimi Code can hold, besides its own Kimi sign-in
+ * (`moonshot`, declared with `kimi login`). `kimi provider catalog add <id>`
+ * imports them from models.dev under that id, so they are matched the same
+ * way OpenCode's are.
+ */
+export const KIMI_API_KEY_PROVIDERS: ModelsDevAccountProvider[] = modelsDevAccountProviders([
+  "moonshot",
+]);
+
+/** Kimi Code's configured providers: id → API key. Never logged or returned. */
+type ProviderKeys = ReadonlyMap<string, string>;
+
+const providerLists = new Map<string, { at: number; keys: Promise<ProviderKeys> }>();
+let catalog: { at: number; ids: Promise<ReadonlySet<string> | null> } | undefined;
+
+/**
+ * One account provider per API-key provider in Kimi Code's `config.toml`.
+ *
+ * Each follows Kimi's own config (no `env`): only `moonshot` may relocate
+ * `KIMI_CODE_HOME`, and two providers setting it would fight at launch. Keys
+ * are added with `kimi provider catalog add <id> --api-key …`, so there is no
+ * login command. `identify` digests the key — never the key itself. A
+ * provider is listed only while Kimi's own catalog still offers one of its ids.
+ */
+export function kimiApiKeyProviders(): AccountProviderDefinition[] {
+  return KIMI_API_KEY_PROVIDERS.map(({ provider, modelsDevIds }) => ({
+    provider,
+    agent: "kimi",
+    credentialPath: () => "$KIMI_CODE_HOME or ~/.kimi-code/config.toml",
+    available: (ctx) => kimiOffers(ctx, modelsDevIds),
+    identify: (ctx) => identifyKimiProvider(ctx, modelsDevIds),
+    // Kimi lends its keys to other harnesses but takes none: its config is
+    // written through `kimi provider catalog add`, which would put the key on
+    // a command line, and it has no per-account slot to put a copy in.
+    sharedToken: {
+      kind: apiKeyTokenKind(provider),
+      read: async (ctx) => {
+        const key = await kimiProviderKey(ctx, modelsDevIds);
+        return key ? { type: "api", key } : null;
+      },
+    },
+  }));
+}
+
+/**
+ * Whether `kimi provider catalog add` can import any of these ids. Kimi's
+ * answer when it gives one; when it cannot (offline, not installed), the
+ * declaration stands.
+ */
+async function kimiOffers(ctx: PluginContext, modelsDevIds: readonly string[]): Promise<boolean> {
+  const ids = await catalogIds(ctx);
+  return ids === null || modelsDevIds.some((id) => ids.has(id));
+}
+
+/**
+ * Kimi's catalog ids, one listing shared by every provider for a while. A
+ * failed listing is not kept, so the next account refresh asks again.
+ */
+function catalogIds(ctx: PluginContext): Promise<ReadonlySet<string> | null> {
+  if (catalog && Date.now() - catalog.at < CATALOG_TTL_MS) return catalog.ids;
+  const ids = listCatalogIds(ctx);
+  const entry = { at: Date.now(), ids };
+  catalog = entry;
+  void ids.then((result) => {
+    if (result === null && catalog === entry) catalog = undefined;
+    return undefined;
+  });
+  return ids;
+}
+
+/** Forgets the cached catalog; for tests. */
+export function resetKimiCatalogCache(): void {
+  catalog = undefined;
+}
+
+async function listCatalogIds(ctx: PluginContext): Promise<ReadonlySet<string> | null> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<null>((resolve) => {
+    timer = setTimeout(() => resolve(null), CATALOG_TIMEOUT_MS);
+  });
+  const listing = ctx.sdk.exec
+    .run({ cwd: ctx.project?.path ?? "/tmp", commands: [KIMI_CATALOG_COMMAND] })
+    .then(([result]) => parseKimiCatalogIds(result?.stdout ?? ""))
+    .catch(() => null);
+  try {
+    return await Promise.race([listing, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** The provider ids in `kimi provider catalog list --json`, or null when unreadable. */
+export function parseKimiCatalogIds(output: string): ReadonlySet<string> | null {
+  try {
+    const providers = recordValue(JSON.parse(output));
+    return providers && Object.keys(providers).length > 0 ? new Set(Object.keys(providers)) : null;
+  } catch {
+    return null;
+  }
+}
+
+async function identifyKimiProvider(
+  ctx: AccountContext,
+  modelsDevIds: readonly string[],
+): Promise<AccountIdentity | null> {
+  const key = await kimiProviderKey(ctx, modelsDevIds);
+  return key ? apiKeyIdentity(key) : null;
+}
+
+/** The first of a provider's models.dev ids Kimi holds a key for. Never logged. */
+async function kimiProviderKey(
+  ctx: AccountContext,
+  modelsDevIds: readonly string[],
+): Promise<string | null> {
+  const keys = await providerKeys(ctx);
+  for (const id of modelsDevIds) {
+    const key = keys.get(id);
+    if (key) return key;
+  }
+  return null;
+}
+
+/**
+ * Kimi's providers through its supported CLI, which applies `KIMI_CODE_HOME`
+ * and its own config rules. Every provider identifies at once, so one listing
+ * per login env is shared for a few seconds instead of running Kimi per row.
+ */
+function providerKeys(ctx: AccountContext): Promise<ProviderKeys> {
+  const cacheKey = JSON.stringify([ctx.project?.path ?? null, ctx.account.env]);
+  const cached = providerLists.get(cacheKey);
+  if (cached && Date.now() - cached.at < PROVIDER_LIST_TTL_MS) return cached.keys;
+  const keys = listProviderKeys(ctx);
+  providerLists.set(cacheKey, { at: Date.now(), keys });
+  return keys;
+}
+
+async function listProviderKeys(ctx: AccountContext): Promise<ProviderKeys> {
+  try {
+    const [result] = await ctx.sdk.exec.run({
+      cwd: ctx.project?.path ?? "/tmp",
+      commands: [KIMI_MODELS_COMMAND],
+    });
+    return parseKimiProviderKeys(result?.stdout ?? "");
+  } catch {
+    return new Map();
+  }
+}
+
+/** Reads each provider's API key from `kimi provider list --json`. */
+export function parseKimiProviderKeys(output: string): ProviderKeys {
+  let value: unknown;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    return new Map();
+  }
+  const keys = new Map<string, string>();
+  for (const [id, candidate] of Object.entries(recordValue(recordValue(value)?.providers) ?? {})) {
+    const apiKey = recordValue(candidate)?.apiKey;
+    if (typeof apiKey === "string" && apiKey.trim()) keys.set(id, apiKey.trim());
+  }
+  return keys;
+}

package/src/launch-options.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  agentLaunchArgs,
+  resolveAgentOptions,
+  type PluginContext,
+} from "@pragma-sh/plugin/catalog";
+
+import { kimiAgentPlugin } from "./pragma-plugin";
+
+/** A context whose host shell finds no command or agent files. */
+const emptyHost = {
+  project: { id: "p", name: "p", path: "/repo" },
+  sdk: { exec: { run: async () => [{ status: 0, stdout: "", stderr: "" }] } },
+} as unknown as PluginContext;
+
+const agent = kimiAgentPlugin.agents![0]!;
+
+describe("Kimi launch options", () => {
+  it("exposes built-in slash commands", async () => {
+    const { slashCommands } = await resolveAgentOptions(agent, emptyHost);
+    expect(slashCommands.map((command) => command.name)).toEqual(["init", "compact"]);
+  });
+
+  it("launches in yolo mode by default", () => {
+    expect(agent.launch.command).toEqual(["kimi"]);
+    expect(agentLaunchArgs(agent, null)).toEqual(["-y"]);
+    expect(agentLaunchArgs(agent, { modeId: "okabe", permissionModeId: "plan" })).toEqual([
+      "--agent",
+      "okabe",
+      "--plan",
+    ]);
+  });
+});

package/src/models.ts

@@ -4,8 +4,10 @@ import type { AgentModelEntry, PluginContext } from "@pragma-sh/plugin/catalog";
 // GUI-launched Pragma hosts do not put on the subprocess PATH (see
 // `process_env` in pragma-core). The `||` fallback keeps the loader working on
 // such a host while still preferring a `kimi` the user installed on PATH.
-const KIMI_BIN_DIR = "$HOME/.kimi-code/bin";
-const KIMI_MODELS_COMMAND = `kimi provider list --json || "${KIMI_BIN_DIR}/kimi" provider list --json`;
+/** Where the official Kimi Code installer puts the CLI. */
+export const KIMI_BIN_DIR = "$HOME/.kimi-code/bin";
+/** Kimi Code's configured providers and model aliases, as JSON. */
+export const KIMI_MODELS_COMMAND = `kimi provider list --json || "${KIMI_BIN_DIR}/kimi" provider list --json`;
 const KIMI_DEFAULT_MODEL_COMMAND = `kimi provider list || "${KIMI_BIN_DIR}/kimi" provider list`;
 
 interface KimiConfigModel {
@@ -87,7 +89,8 @@ export function parseKimiDefaultModel(output: string): string | undefined {
   return match?.[1]?.trim() || undefined;
 }
 
-function recordValue(value: unknown): Record<string, unknown> | undefined {
+/** `value` as a plain object, or undefined. */
+export function recordValue(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value !== null && !Array.isArray(value)
     ? (value as Record<string, unknown>)
     : undefined;

package/src/pragma-plugin.ts

@@ -1,6 +1,14 @@
-import { defineAgent, definePlugin, type PluginDefinition } from "@pragma-sh/plugin/catalog";
+import {
+  defineAccounts,
+  defineAgent,
+  definePlugin,
+  modeProvider,
+  slashCommandProvider,
+  type PluginDefinition,
+} from "@pragma-sh/plugin/catalog";
 import { createTuiWatcher } from "@pragma-sh/watcher-kit";
 
+import { kimiApiKeyProviders } from "./accounts";
 import { loadKimiModels } from "./models";
 
 /** Lets Kimi's paste-aware composer commit interjected text before Enter. */
@@ -8,6 +16,31 @@ const INTERJECT_SUBMIT_DELAY_MS = 200;
 /** Kimi paints its TUI within a couple of seconds of launch; type after it. */
 const PREFILL_DELAY_MS = 2500;
 
+/** Kimi built-ins worth starting a session with; skills and commands are discovered. */
+const BUILTIN_SLASH_COMMANDS = [
+  { name: "init", description: "Analyze the project and write AGENTS.md" },
+  { name: "compact", description: "Compact the conversation context" },
+];
+/** Kimi invokes skills as `/skill:<name>`; Claude Code commands keep their name. */
+const SLASH_COMMAND_SOURCES = [
+  { dir: ".kimi-code/skills", layout: "skills" as const, prefix: "skill:" },
+  { dir: ".agents/skills", layout: "skills" as const, prefix: "skill:" },
+  { dir: ".claude/skills", layout: "skills" as const, prefix: "skill:" },
+  { dir: ".claude/commands", layout: "files" as const },
+  { dir: "~/.kimi-code/skills", layout: "skills" as const, prefix: "skill:" },
+  { dir: "~/.agents/skills", layout: "skills" as const, prefix: "skill:" },
+  { dir: "~/.claude/skills", layout: "skills" as const, prefix: "skill:" },
+  { dir: "~/.claude/commands", layout: "files" as const },
+];
+/** Agent profiles selected with `--agent <name>`. */
+const AGENT_SOURCES = [
+  { dir: ".kimi-code/agents", layout: "files" as const, nameFromFrontmatter: true },
+  { dir: ".agents/agents", layout: "files" as const, nameFromFrontmatter: true },
+  { dir: "~/.kimi-code/agents", layout: "files" as const, nameFromFrontmatter: true },
+  { dir: "~/.agents/agents", layout: "files" as const, nameFromFrontmatter: true },
+];
+const DEFAULT_MODE = "default";
+
 const baseWatcher = createTuiWatcher({
   agent: "kimi",
   // Kimi command approvals cannot be brokered, but AskUserQuestion is reported
@@ -30,6 +63,22 @@ const baseWatcher = createTuiWatcher({
 export const kimiAgentPlugin: PluginDefinition = definePlugin({
   name: "Kimi Code",
   description: "Launch Kimi Code from Pragma.",
+  accounts: defineAccounts([
+    {
+      provider: "moonshot",
+      agent: "kimi",
+      iconPath: "assets/kimi.png",
+      login: {
+        command: ["kimi", "login"],
+        instructions: "Open the link, sign in to Kimi, and enter the code shown here.",
+      },
+      // `KIMI_CODE_HOME` is Kimi Code's whole data root: config, sessions,
+      // and OAuth tokens.
+      env: (home) => ({ KIMI_CODE_HOME: home }),
+      credentialPath: (home) => home ?? "~/.kimi-code",
+    },
+    ...kimiApiKeyProviders(),
+  ]),
   watchers: [
     {
       agent: "kimi",
@@ -60,35 +109,36 @@ export const kimiAgentPlugin: PluginDefinition = definePlugin({
       name: "Kimi Code",
       icon: () => null,
       iconPath: "assets/kimi.png",
-      // `-y` (yolo) is the default launch: Kimi's manual mode gates Bash behind
-      // a TUI approval prompt, so a plain `kimi` never completes a safe shell
-      // command headlessly (`pragma-cli agent verify` `command-no-permission`).
-      // Baking `-y` into the base command mirrors Claude Code's
-      // `--permission-mode auto`; the mode selector below is declared for when
-      // the host wires it up (then this base and the per-mode args must be
-      // reconciled).
-      launch: { command: ["kimi", "-y"] },
+      launch: { command: ["kimi"] },
       prefillDelayMs: PREFILL_DELAY_MS,
       prefillMode: "plain",
       prefillSubmit: "\r",
       models: loadKimiModels,
-      // First entry is the default; it matches the `-y` baked into `launch`.
-      // These are the real launch flags that change how much Kimi asks for.
+      // First entry is the default: `-y` (yolo), because Kimi's manual mode
+      // gates Bash behind a TUI approval prompt, so a plain `kimi` never
+      // completes a safe shell command headlessly (`pragma-cli agent verify`
+      // `command-no-permission`). These are the real launch flags that change
+      // how much Kimi asks for.
       permissionModes: [
         { id: "yolo", name: "Auto-approve tools" },
         { id: "default", name: "Ask for approval" },
         { id: "auto", name: "Fully autonomous" },
         { id: "plan", name: "Plan mode" },
       ],
+      modes: modeProvider([{ id: DEFAULT_MODE, name: "Default" }], AGENT_SOURCES),
+      slashCommands: slashCommandProvider(BUILTIN_SLASH_COMMANDS, SLASH_COMMAND_SOURCES, {
+        acp: { command: ["kimi", "acp"] },
+      }),
       // `commandApproval`: Kimi's permission-request hook is fire-and-forget,
       // so Pragma cannot approve on the agent's behalf.
       excludeFeatures: ["commandApproval"],
       args: {
         model: (modelId: string) => ["-m", modelId],
         reasoning: () => [],
+        mode: (modeId: string) => (modeId === DEFAULT_MODE ? [] : ["--agent", modeId]),
         permissionMode: (permissionModeId: string) => {
           if (permissionModeId === "yolo") {
-            return [];
+            return ["-y"];
           }
           if (permissionModeId === "auto") {
             return ["--auto"];