kimi-plugin-cc 2.0.7

package/plugins/kimi-codex/dist/kimi-errors.js

@@ -0,0 +1,220 @@
+import { RuntimeError, formatError } from "./errors.js";
+export function classifyManagedCommandFailure(error, commandType, jobId, options) {
+    const classification = classifyKimiAvailability(error);
+    if (!classification) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const label = formatCommandLabel(commandType);
+    const stage = options?.preserveStage && error instanceof RuntimeError
+        ? error.stage
+        : `${commandType}.runtime`;
+    // Thread the cause's code and message into `details` so the underlying
+    // failure survives the wrap on every channel (formatError renders details
+    // as a JSON line; normalizeJobError persists them in the job row). Without
+    // this, a CLI_NONZERO_EXIT whose message embeds kimi's stderr tail (e.g.
+    // `auth.login_required` on 2026-08-08) was reduced to the generic
+    // "run /kimi:setup" advice with the real cause reachable only as `cause`,
+    // which no output channel serializes — an LLM caller could not diagnose it.
+    const details = { availability: classification.kind };
+    if (error instanceof RuntimeError) {
+        details.cause_code = error.code;
+    }
+    if (error instanceof Error && error.message.length > 0) {
+        details.cause_message = truncateCauseMessageForDetails(error.message);
+    }
+    return new RuntimeError(mapAvailabilityCode(classification.kind, commandType), `${label} could not run because ${classification.summary} ${classification.nextStep} Job ${jobId} was persisted as failed.`, stage, error instanceof Error ? { cause: error, details } : { details });
+}
+/**
+ * Cap the cause message carried in `details` so a large stderr tail cannot
+ * bloat the SQLite job row or the rendered details JSON line. Keep the TAIL
+ * end: for a crashed subprocess the informative lines (kimi's own `error:`
+ * output) are the trailing bytes of stderr, which cli-helpers appends last.
+ */
+const CAUSE_MESSAGE_DETAILS_MAX = 2000;
+function truncateCauseMessageForDetails(message) {
+    if (message.length <= CAUSE_MESSAGE_DETAILS_MAX) {
+        return message;
+    }
+    return `…${message.slice(-CAUSE_MESSAGE_DETAILS_MAX)}`;
+}
+export function summarizeKimiAvailabilityWarning(error, commandType) {
+    const classification = classifyKimiAvailability(error);
+    if (!classification) {
+        return null;
+    }
+    if (classification.kind === "auth_unavailable") {
+        return `Kimi ${formatCommandLabel(commandType).toLowerCase()} is not configured for model access; allowing stop.`;
+    }
+    if (classification.kind === "binary_unavailable") {
+        return `Kimi ${formatCommandLabel(commandType).toLowerCase()} could not find the Kimi CLI; allowing stop.`;
+    }
+    if (classification.kind === "startup_failed") {
+        return `Kimi ${formatCommandLabel(commandType).toLowerCase()} could not start a usable Kimi subprocess; allowing stop.`;
+    }
+    switch (classification.kind) {
+        case "startup_timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} did not respond during startup; allowing stop.`;
+        case "initialize_timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} did not complete session initialization; allowing stop.`;
+        case "response_timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} did not return a final response; allowing stop.`;
+        case "max_steps_reached":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} exhausted its step budget; allowing stop.`;
+        case "timeout":
+            return `Kimi ${formatCommandLabel(commandType).toLowerCase()} timed out; allowing stop.`;
+    }
+}
+export function classifySetupFailure(error) {
+    return classifyKimiAvailability(error);
+}
+function classifyKimiAvailability(error) {
+    const message = formatError(error);
+    // kimi-code's managed OAuth store emits `auth.login_required: OAuth
+    // provider "managed:kimi-code" requires login…` on stderr when the token
+    // is missing or expired (observed on 0.34.0 after an out-of-band binary
+    // upgrade invalidated the token). The line reaches us inside the
+    // CLI_NONZERO_EXIT message because cli-helpers embeds the stderr tail.
+    // This MUST precede the code-based CLI_NONZERO_EXIT branch below, which
+    // would otherwise misclassify a logged-out CLI as startup_failed and
+    // point the user at /kimi:setup — which cannot fix auth.
+    if (message.includes("auth.login_required")) {
+        return {
+            kind: "auth_unavailable",
+            summary: "the local Kimi CLI is logged out (its OAuth login is missing or expired).",
+            nextStep: "Run `kimi login` to re-authenticate, then retry. `/kimi:setup` does not repair auth.",
+            runtimeProbe: "ok",
+            authProbe: "failed",
+        };
+    }
+    if (message.includes("LLM is not set") || message.includes("LLM service error")) {
+        return {
+            kind: "auth_unavailable",
+            summary: "local Kimi authentication or model configuration is not usable.",
+            nextStep: "Run `/kimi:setup`, then `kimi login` or fix the local Kimi model configuration and retry.",
+            runtimeProbe: "ok",
+            authProbe: "failed",
+        };
+    }
+    if (error instanceof RuntimeError && error.code === "CLI_SPAWN_FAILED") {
+        return {
+            kind: "binary_unavailable",
+            summary: "the Kimi CLI is missing from PATH or not executable in this environment.",
+            nextStep: "Run `/kimi:setup` to verify the install, then expose `kimi` on PATH and retry.",
+            runtimeProbe: "failed",
+            authProbe: "failed",
+        };
+    }
+    // v1.0 cli-client surfaces async ENOENT (Bun) as CLI_PROCESS_ERROR with
+    // "spawn ... ENOENT" in the message. Map that to binary_unavailable so
+    // the failure message points users at /kimi:setup.
+    if (error instanceof RuntimeError &&
+        error.code === "CLI_PROCESS_ERROR" &&
+        /\bENOENT\b/.test(message)) {
+        return {
+            kind: "binary_unavailable",
+            summary: "the Kimi CLI is missing from PATH or not executable in this environment.",
+            nextStep: "Run `/kimi:setup` to verify the install, then expose `kimi` on PATH and retry.",
+            runtimeProbe: "failed",
+            authProbe: "failed",
+        };
+    }
+    // v1.0 cli-client surfaces non-ENOENT process errors and non-zero
+    // exits as CLI_PROCESS_ERROR / CLI_NONZERO_EXIT. Treat both as
+    // startup-failed for classifier purposes — the next step is the same
+    // (run /kimi:setup) and the distinction between "kimi crashed during
+    // init" vs "kimi exited with status 1" is post-hoc.
+    if (error instanceof RuntimeError &&
+        (error.code === "CLI_PROCESS_ERROR" || error.code === "CLI_NONZERO_EXIT")) {
+        return {
+            kind: "startup_failed",
+            summary: "the Kimi CLI exited before completing the requested operation.",
+            nextStep: "Run `/kimi:setup` to verify local Kimi health, then retry.",
+            runtimeProbe: "failed",
+            authProbe: "failed",
+        };
+    }
+    if (error instanceof RuntimeError && error.code === "MAX_STEPS_REACHED") {
+        return {
+            kind: "max_steps_reached",
+            summary: "Kimi exhausted its step budget before finalizing the turn.",
+            nextStep: "Retry with a more focused prompt or a higher step budget.",
+            runtimeProbe: "ok",
+            authProbe: "ok",
+        };
+    }
+    if (error instanceof RuntimeError) {
+        // STARTUP_TIMEOUT and INITIALIZE_TIMEOUT predate the v1.0 subprocess
+        // transport (the v0.4 Wire client had a three-phase startup). The
+        // v1.0 cli-client only emits RESPONSE_TIMEOUT, so these branches are
+        // defensive — callers that synthesize the old codes (or load v0.4
+        // job rows from SQLite) still get a useful classification.
+        if (error.code === "STARTUP_TIMEOUT") {
+            return {
+                kind: "startup_timeout",
+                summary: "the Kimi CLI did not respond during startup.",
+                nextStep: "Run `/kimi:setup` to verify local Kimi health, then retry.",
+                runtimeProbe: "failed",
+                authProbe: "failed",
+            };
+        }
+        if (error.code === "INITIALIZE_TIMEOUT") {
+            return {
+                kind: "initialize_timeout",
+                summary: "the Kimi session started but did not finish initializing in time.",
+                nextStep: "Run `/kimi:setup` to verify local Kimi configuration and retry.",
+                runtimeProbe: "failed",
+                authProbe: "failed",
+            };
+        }
+        if (error.code === "RESPONSE_TIMEOUT") {
+            return {
+                kind: "response_timeout",
+                summary: "Kimi started and accepted the prompt but never returned a final response.",
+                nextStep: "Reduce the prompt scope (or for /kimi:ask and /kimi:rescue, retry with --background to detach). If the response still hangs after a fresh run, check local Kimi version and report upstream.",
+                runtimeProbe: "ok",
+                authProbe: "ok",
+            };
+        }
+    }
+    if (message.includes("timed out")) {
+        return {
+            kind: "timeout",
+            summary: "the Kimi runtime did not become ready within the expected time budget.",
+            nextStep: "Run `/kimi:setup` to check local Kimi auth and network health, then retry.",
+            runtimeProbe: "failed",
+            authProbe: "failed",
+        };
+    }
+    return null;
+}
+function mapAvailabilityCode(kind, commandType) {
+    const prefix = commandType.toUpperCase();
+    switch (kind) {
+        case "auth_unavailable":
+            return `${prefix}_KIMI_AUTH_UNAVAILABLE`;
+        case "binary_unavailable":
+            return `${prefix}_KIMI_BINARY_UNAVAILABLE`;
+        case "startup_failed":
+            return `${prefix}_KIMI_STARTUP_FAILED`;
+        case "startup_timeout":
+            return `${prefix}_KIMI_STARTUP_TIMEOUT`;
+        case "initialize_timeout":
+            return `${prefix}_KIMI_INITIALIZE_TIMEOUT`;
+        case "response_timeout":
+            return `${prefix}_KIMI_RESPONSE_TIMEOUT`;
+        case "timeout":
+            return `${prefix}_KIMI_TIMEOUT`;
+        case "max_steps_reached":
+            return `${prefix}_KIMI_MAX_STEPS_REACHED`;
+    }
+}
+function formatCommandLabel(commandType) {
+    switch (commandType) {
+        case "challenge":
+            return "challenge";
+        case "review_gate":
+            return "review gate";
+        default:
+            return commandType.replaceAll("_", " ");
+    }
+}

package/plugins/kimi-codex/dist/kimi-home.js

@@ -0,0 +1,9 @@
+import os from "node:os";
+import path from "node:path";
+export function resolveKimiHome(env, baseCwd = process.cwd()) {
+    const override = env.KIMI_CODE_HOME?.trim();
+    if (override) {
+        return path.resolve(baseCwd, override);
+    }
+    return path.join(os.homedir(), ".kimi-code");
+}

package/plugins/kimi-codex/dist/kimi-timeouts.js

@@ -0,0 +1,68 @@
+// Per-command response-budget constants for the v1.0 cli-client path.
+//
+// v0.4 also exposed startup / initialize timeouts plus a generic
+// `withTimeout` helper. Those existed because the Wire transport had a
+// three-phase lifecycle (spawn → initialize → prompt). The v1.0
+// subprocess transport collapses spawn + prompt into a single
+// `runCliPromptWithBudget` call (see `runtime/cli-client.ts`), and
+// startup failures surface as CLI_SPAWN_FAILED / CLI_PROCESS_ERROR —
+// not as separate timeouts. So only the per-command response budgets
+// remain.
+// Budgets are sized for thinking-on workflow (the default since v1.0).
+// kimi-code spends real wallclock on extended reasoning before emitting
+// the first assistant record; pre-alpha.4 budgets (300s/600s) were sized
+// against the non-thinking path and timed out in production smoke
+// testing under default flags. Raised to 900/1800/1800 so a real
+// thinking-on review/rescue session has headroom; review-gate stays at
+// 8s because it fires inside Claude Code's Stop hook and is forced to
+// thinking-off in its own caller.
+/** Ask budget. Conversational; thinking-on free-form reasoning. */
+export const KIMI_ASK_PROMPT_TIMEOUT_MS = 900_000;
+/** Review/challenge budget. Thinking-on single-turn analysis over the workspace. */
+export const KIMI_REVIEW_PROMPT_TIMEOUT_MS = 1_800_000;
+/** Rescue budget. Thinking-on multi-step apply/test/verify loops. */
+export const KIMI_RESCUE_PROMPT_TIMEOUT_MS = 1_800_000;
+/**
+ * Pursue (autonomous goal mode) DEFAULT wall-clock ceiling when the user
+ * passes no `--budget`. This is the ONLY hard bound on an autonomous goal —
+ * headless goal create sets no token/turn budget (only the model, via
+ * SetGoalBudget, or this AbortController stops the loop). Larger than the
+ * single-turn rescue budget (a goal spans multiple continuation turns) but
+ * deliberately finite. Overridable per-job via `--budget` (parsed to ms in
+ * parsePursueArgs). See runtime/commands/pursue.ts and docs/safety.md.
+ */
+export const KIMI_PURSUE_DEFAULT_BUDGET_MS = 2_700_000; // 45 minutes
+/**
+ * Swarm (read-only parallel fan-out) DEFAULT wall-clock ceiling when the user
+ * passes no `--budget`. Read-only swarm opens no write surface, so the only new
+ * risk is COST/runaway from N parallel model runs (plus possible nested
+ * AgentSwarm). This AbortController is the hard bound on that; the `--cap`
+ * subagent count is a soft prompt-injected hint (not hook-enforceable —
+ * the hook is stateless and can't count subagents). Sized like the single-turn
+ * review budget — a swarm fans review work out in parallel within one process,
+ * so 30m of wall-clock is generous headroom. Overridable per-job via `--budget`
+ * (parsed to ms in parseSwarmArgs). See runtime/commands/swarm.ts and
+ * docs/safety.md.
+ */
+export const KIMI_SWARM_DEFAULT_BUDGET_MS = 1_800_000; // 30 minutes
+/**
+ * Review-gate budget. Fires inside Claude Code's Stop hook so any value
+ * above the user's perceptible wait makes the gate feel broken.
+ *
+ * kimi-code 0.1.1 has no per-spawn CLI flag for thinking control
+ * (Round 2 multi-agent review caught this — emitting `--no-thinking`
+ * triggers an unknown-option crash). The 8s budget assumes the user
+ * has either `default_thinking = false` or `[thinking].mode = "off"`
+ * in `~/.kimi-code/config.toml`, OR a non-thinking-capable model
+ * selected for review-gate (via KIMI_PLUGIN_CC_REVIEW_GATE_MODEL).
+ * Under thinking-on the gate will time out — the gate is fail-open on
+ * timeout by design, so the worst case is the gate becomes
+ * always-allow. See docs/safety.md.
+ */
+export const KIMI_REVIEW_GATE_TIMEOUT_MS = 8_000;
+export function isTimeoutCode(code) {
+    return (code === "TIMEOUT" ||
+        code === "STARTUP_TIMEOUT" ||
+        code === "INITIALIZE_TIMEOUT" ||
+        code === "RESPONSE_TIMEOUT");
+}