kimi-plugin-cc 2.4.5 → 2.5.1

package/plugins/kimi-dsh/dist/commands/worker.js

@@ -0,0 +1,25 @@
+import { RuntimeError } from "../errors.js";
+import { executeRescueJob } from "./rescue.js";
+import { executeAskJob } from "./ask.js";
+export async function runWorker(argv, context) {
+    const [kind, jobId] = argv;
+    if (!jobId || (kind !== "rescue" && kind !== "ask")) {
+        throw new RuntimeError("INVALID_COMMAND", "worker expects the form: worker rescue <job-id> or worker ask <job-id>.", "worker");
+    }
+    if (kind === "rescue") {
+        const encodedPrompt = context.env.KIMI_PLUGIN_CC_RESCUE_PROMPT_B64;
+        if (!encodedPrompt) {
+            throw new RuntimeError("MISSING_RESCUE_PROMPT", "Background rescue prompt is missing.", "worker");
+        }
+        const prompt = Buffer.from(encodedPrompt, "base64").toString("utf8");
+        const reusedSession = context.env.KIMI_PLUGIN_CC_RESCUE_REUSED_SESSION === "1";
+        await executeRescueJob(jobId, prompt, context, { workerPid: process.pid, reusedSession });
+        return;
+    }
+    const encodedPrompt = context.env.KIMI_PLUGIN_CC_ASK_PROMPT_B64;
+    if (!encodedPrompt) {
+        throw new RuntimeError("MISSING_ASK_PROMPT", "Background ask prompt is missing.", "worker");
+    }
+    const prompt = Buffer.from(encodedPrompt, "base64").toString("utf8");
+    await executeAskJob(jobId, prompt, context, { workerPid: process.pid });
+}

package/plugins/kimi-dsh/dist/companion.js

@@ -0,0 +1,97 @@
+import { runRecoverSwarm } from "./commands/recover-swarm.js";
+import { companionHelp } from "./help.js";
+import { runModelInventory } from "./commands/models.js";
+import { runCancel } from "./commands/cancel.js";
+import { runReplay } from "./commands/replay.js";
+import { runRepairSessions } from "./commands/repair-sessions.js";
+import { runResult } from "./commands/result.js";
+import { renderSetupResult, runSetup } from "./commands/setup.js";
+import { runStatus } from "./commands/status.js";
+import { runWorker } from "./commands/worker.js";
+import { formatError, RuntimeError } from "./errors.js";
+import { resolveKimiHome } from "./kimi-home.js";
+import { runModelCommand } from "./model-command.js";
+import { runMcpChild } from "./mcp/supervised-child.js";
+import { runMcpServer } from "./mcp/server.js";
+async function main(argv) {
+    const help = companionHelp(argv);
+    if (help !== undefined) {
+        process.stdout.write(`${help}\n`);
+        return;
+    }
+    const [command, ...rest] = argv;
+    const cwd = process.env.KIMI_PLUGIN_CC_WORKSPACE_CWD || process.cwd();
+    const context = {
+        cwd,
+        env: {
+            ...process.env,
+            KIMI_CODE_HOME: command === "mcp" ? process.env.KIMI_CODE_HOME : resolveKimiHome(process.env, cwd),
+        },
+        stdout: process.stdout,
+        stderr: process.stderr,
+    };
+    const modelResult = await runModelCommand(argv, context);
+    if (modelResult !== undefined) {
+        context.stdout.write(modelResult);
+        return;
+    }
+    switch (command) {
+        case "setup": {
+            if (rest.includes("--models")) {
+                const args = [...rest];
+                args.splice(args.indexOf("--models"), 1);
+                context.stdout.write(`${await runModelInventory(args, context)}\n`);
+                return;
+            }
+            const result = await runSetup(rest, context);
+            context.stdout.write(`${renderSetupResult(result)}\n`);
+            // A failed probe means the hook did not actually deny when exercised —
+            // enforcement is NOT in place, whichever action produced it. This must be
+            // nonzero for `install` too, not just `check`: since v1.9.0 an agent may
+            // run setup and then RETRY the refused command, and it keys that decision
+            // on the exit code. Exiting 0 after a failed probe would walk it straight
+            // past a proven-dead hook (a byte-exact command + a readable-but-broken
+            // script passes `verifyHookInstalled`, since only the probe can tell that
+            // the script cannot deny — e.g. a truncated `approval-hook.js`, which has
+            // happened here via iCloud sync, or a half-extracted plugin cache).
+            // `probe: "skipped"` (uninstall) is deliberately untouched.
+            if (result.probe === "failed") {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        case "mcp":
+            await runMcpServer(context);
+            return;
+        case "mcp-child":
+            context.stdout.write(await runMcpChild(rest, context));
+            return;
+        case "status":
+            context.stdout.write(await runStatus(rest, context));
+            return;
+        case "result":
+            context.stdout.write(await runResult(rest, context));
+            return;
+        case "cancel":
+            context.stdout.write(await runCancel(rest, context));
+            return;
+        case "replay":
+            context.stdout.write(await runReplay(rest, context));
+            return;
+        case "recover-swarm":
+            context.stdout.write(await runRecoverSwarm(rest, context));
+            return;
+        case "repair-sessions":
+            context.stdout.write(await runRepairSessions(rest, context));
+            return;
+        case "worker":
+            await runWorker(rest, context);
+            return;
+        default:
+            throw new RuntimeError("INVALID_COMMAND", `Unknown or missing companion subcommand: ${command ?? "<none>"}. Expected one of setup, review, task, ask, status, result, cancel, replay, repair-sessions, recover-swarm.`, "companion");
+    }
+}
+main(process.argv.slice(2)).catch((error) => {
+    process.stderr.write(`${formatError(error)}\n`);
+    process.exitCode = 1;
+});

package/plugins/kimi-dsh/dist/config.js

@@ -0,0 +1,22 @@
+import { readFile, writeFile } from "node:fs/promises";
+const DEFAULT_CONFIG = {
+    reviewGateEnabled: false,
+};
+export async function readPluginConfig(paths) {
+    try {
+        const contents = await readFile(paths.configPath, "utf8");
+        const parsed = JSON.parse(contents);
+        return {
+            reviewGateEnabled: parsed.reviewGateEnabled ?? DEFAULT_CONFIG.reviewGateEnabled,
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return DEFAULT_CONFIG;
+        }
+        throw error;
+    }
+}
+export async function writePluginConfig(paths, config) {
+    await writeFile(paths.configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}

package/plugins/kimi-dsh/dist/dsh/companion.js

@@ -0,0 +1,174 @@
+import { randomUUID } from "node:crypto";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { assertUsableCwd, settleRunResult, subprocessRunHandle, } from "@deepseek-ai/dsh-subagent";
+export const DSH_COMPANION_OPERATIONS = [
+    "ask",
+    "review",
+    "challenge",
+    "rescue",
+    "pursue",
+    "swarm",
+    "swarm-write",
+];
+export function companionTextTask(prompt) {
+    if (prompt.length === 0 || prompt.some((block) => block.type !== "text")) {
+        throw new Error("kimi-plugin-cc: a delegation must contain only text blocks");
+    }
+    const text = prompt.map((block) => block.type === "text" ? block.text : "").join("\n\n");
+    if (text.trim().length === 0) {
+        throw new Error("kimi-plugin-cc: a delegation must not be empty");
+    }
+    return text;
+}
+export function companionArgv(operation, prompt, companionPath, nodeBin = process.execPath, options = {}) {
+    const command = operation === "ask" || operation === "review"
+        ? [operation]
+        : operation === "swarm-write"
+            ? ["task", "swarm", "--write"]
+            : ["task", operation];
+    return [
+        nodeBin,
+        companionPath,
+        ...command,
+        ...(operation === "ask" || operation === "rescue" ? ["--fresh"] : []),
+        ...(options.model === undefined ? [] : ["-m", options.model]),
+        ...(options.thinkingEffort === undefined ? [] : ["--thinking", options.thinkingEffort]),
+        ...(options.budget === undefined ? [] : ["--budget", options.budget]),
+        ...((operation === "review" || operation === "challenge") && options.reviewBase !== undefined
+            ? ["--base", options.reviewBase]
+            : []),
+        "--",
+        prompt,
+    ];
+}
+export function companionEnvironment(dataRoot, cwd, env, nodeBin = process.execPath) {
+    return {
+        ...env,
+        KIMI_PLUGIN_CC_DATA: dataRoot,
+        KIMI_PLUGIN_CC_HOST_ID: "dsh",
+        KIMI_PLUGIN_CC_NODE_BIN: nodeBin,
+        KIMI_PLUGIN_CC_WORKSPACE_CWD: cwd,
+        CLAUDE_PLUGIN_DATA: undefined,
+        PLUGIN_DATA: undefined,
+        CLAUDE_PLUGIN_ROOT: undefined,
+        PLUGIN_ROOT: undefined,
+        KIMI_PLUGIN_CC_SHELL_LAUNCH: undefined,
+        KIMI_PLUGIN_CC_MCP_WORKSPACE: undefined,
+        KIMI_PLUGIN_CC_WORKSPACE_ROOT: undefined,
+        KIMI_PLUGIN_CC_HOOK_SCRIPT: undefined,
+        KIMI_PLUGIN_CC_SKIP_HOOK_CHECK: undefined,
+        KIMI_PLUGIN_CC_SKIP_VERSION_PROBE: undefined,
+        KIMI_CODE_TRUST_WORKSPACE: undefined,
+    };
+}
+export async function startCompanionRun(request, operation, spec) {
+    const prompt = companionTextTask(request.prompt);
+    if (request.signal.aborted) {
+        throw new Error("kimi-plugin-cc: delegation was aborted before companion startup");
+    }
+    const cwd = assertUsableCwd("kimi-plugin-cc", "child cwd", request.cwd ?? process.cwd());
+    const termination = new AbortController();
+    let cancelled = false;
+    const requestCancel = () => {
+        cancelled = true;
+        if (!termination.signal.aborted) {
+            termination.abort(new Error("kimi-plugin-cc: delegation cancelled"));
+        }
+    };
+    const onAbort = () => requestCancel();
+    request.signal.addEventListener("abort", onAbort, { once: true });
+    let child;
+    try {
+        child = spec.spawn({
+            argv: companionArgv(operation, prompt, spec.companionPath, process.execPath, spec),
+            cwd,
+            stdio: {
+                stdin: "ignore",
+                stdout: { maxBytes: spec.maxOutputBytes },
+                stderr: "inherit",
+            },
+            graceMs: spec.disposeGraceMs,
+            signal: termination.signal,
+            env: companionEnvironment(spec.dataRoot, cwd, spec.env),
+        });
+    }
+    catch (error) {
+        request.signal.removeEventListener("abort", onAbort);
+        throw error;
+    }
+    let diagnostic;
+    const result = settleRunResult({
+        attempt: async () => {
+            let outcome;
+            try {
+                outcome = await child.done;
+            }
+            catch (error) {
+                diagnostic = `Kimi ${operation} companion failed before producing a terminal exit`;
+                throw error;
+            }
+            const collected = child.collected.stdout?.readFrom(0);
+            const text = collected?.text.trimEnd() ?? "";
+            if (!cancelled && outcome.exitCode === 0 && collected && !collected.lossy && text.trim().length > 0) {
+                return { output: [{ type: "text", text }], stopReason: "completed" };
+            }
+            const facts = [
+                `exit code: ${outcome.exitCode ?? "none"}`,
+                `signal: ${outcome.signal ?? "none"}`,
+                ...(collected?.lossy ? ["stdout truncated"] : []),
+                ...(text.trim().length === 0 ? ["stdout empty"] : []),
+            ];
+            diagnostic = `Kimi ${operation} companion failed (${facts.join("; ")})`;
+            return { output: [], diagnostic, stopReason: cancelled ? "aborted" : "error" };
+        },
+        collectOutput: () => [],
+        collectDiagnostic: () => diagnostic,
+        cancelled: () => cancelled,
+        signal: request.signal,
+        onAbort,
+    });
+    return subprocessRunHandle({
+        id: brandString(randomUUID()),
+        result,
+        signal: request.signal,
+        onAbort,
+        requestCancel,
+        teardown: async () => {
+            child.terminate();
+            await child.waitForExit();
+            await child.done.catch(() => { });
+        },
+    });
+}
+export async function runCompanionCommand(argv, cwd, spec, signal) {
+    const child = spec.spawn({
+        argv: [process.execPath, spec.companionPath, ...argv],
+        cwd,
+        stdio: {
+            stdin: "ignore",
+            stdout: { maxBytes: spec.maxOutputBytes },
+            stderr: { maxBytes: spec.maxOutputBytes },
+        },
+        graceMs: spec.disposeGraceMs,
+        signal,
+        env: companionEnvironment(spec.dataRoot, cwd, spec.env),
+    });
+    try {
+        const outcome = await child.done;
+        await child.waitForExit();
+        const stdout = child.collected.stdout?.readFrom(0);
+        const stderr = child.collected.stderr?.readFrom(0);
+        return {
+            exitCode: outcome.exitCode,
+            signal: outcome.signal,
+            stdout: stdout?.text ?? "",
+            stderr: stderr?.text ?? "",
+            truncated: Boolean(stdout?.lossy || stderr?.lossy),
+        };
+    }
+    catch (error) {
+        child.terminate();
+        await child.waitForExit().catch(() => false);
+        throw error;
+    }
+}

package/plugins/kimi-dsh/dist/dsh/index.js

@@ -0,0 +1,156 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CommandDefinitionId } from "@deepseek-ai/dsh-commands/brand";
+import z from "@deepseek-ai/schemastery";
+import { NO_START_CAPABILITIES, } from "@deepseek-ai/dsh-subagent";
+import { DSH_COMPANION_OPERATIONS, runCompanionCommand, startCompanionRun, } from "./companion.js";
+import { parseDurationMs } from "../parsing.js";
+export const name = "kimi-plugin-cc";
+export const inject = ["subagents", "subprocess"];
+const DEFAULT_DISPOSE_GRACE_MS = 6_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const COMPANION_PATH = fileURLToPath(new URL("../../dist/companion.js", import.meta.url));
+export const Config = z.object({
+    dataRoot: z.string().min(1),
+    env: z.dict(z.string()).default({}),
+    disposeGraceMs: z.number().default(DEFAULT_DISPOSE_GRACE_MS),
+    maxOutputBytes: z.number().default(DEFAULT_MAX_OUTPUT_BYTES),
+    model: z.string().min(1),
+    thinkingEffort: z.string().min(1),
+    budget: z.string().min(1),
+    reviewBase: z.string().min(1),
+});
+export function defaultDshDataRoot(env = process.env) {
+    const explicit = env.KIMI_PLUGIN_CC_DATA;
+    if (explicit !== undefined) {
+        if (!path.isAbsolute(explicit)) {
+            throw new Error("kimi-plugin-cc: KIMI_PLUGIN_CC_DATA must be absolute");
+        }
+        return path.normalize(explicit);
+    }
+    const dshHome = env.DSH_HOME ?? path.join(env.HOME || homedir(), ".dsh");
+    if (!path.isAbsolute(dshHome)) {
+        throw new Error("kimi-plugin-cc: DSH_HOME must be absolute");
+    }
+    return path.join(dshHome, "plugin-data", "kimi-plugin-cc");
+}
+function resolveConfig(config) {
+    const resolved = {
+        dataRoot: config.dataRoot ?? defaultDshDataRoot(),
+        env: config.env ?? {},
+        disposeGraceMs: config.disposeGraceMs ?? DEFAULT_DISPOSE_GRACE_MS,
+        maxOutputBytes: config.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+        model: config.model,
+        thinkingEffort: config.thinkingEffort,
+        budget: config.budget,
+        reviewBase: config.reviewBase,
+    };
+    if (!path.isAbsolute(resolved.dataRoot)) {
+        throw new Error("kimi-plugin-cc: dataRoot must be absolute");
+    }
+    if (!Number.isFinite(resolved.disposeGraceMs) || resolved.disposeGraceMs <= 0 || resolved.disposeGraceMs > MAX_TIMER_DELAY_MS) {
+        throw new Error(`kimi-plugin-cc: disposeGraceMs must be positive, finite, and no greater than ${MAX_TIMER_DELAY_MS}`);
+    }
+    if (!Number.isSafeInteger(resolved.maxOutputBytes) || resolved.maxOutputBytes <= 0) {
+        throw new Error("kimi-plugin-cc: maxOutputBytes must be a positive safe integer");
+    }
+    for (const [field, value] of [["model", resolved.model], ["thinkingEffort", resolved.thinkingEffort], ["reviewBase", resolved.reviewBase]]) {
+        if (value?.startsWith("-"))
+            throw new Error(`kimi-plugin-cc: ${field} must not start with '-'`);
+    }
+    if (resolved.budget !== undefined)
+        parseDurationMs(resolved.budget, "--budget", "dsh.config", "safety");
+    return resolved;
+}
+class KimiCompanionProvider {
+    name;
+    operation;
+    spec;
+    capabilities = NO_START_CAPABILITIES;
+    inheritsParentContext = false;
+    constructor(name, operation, spec) {
+        this.name = name;
+        this.operation = operation;
+        this.spec = spec;
+    }
+    start(request) {
+        return startCompanionRun(request, this.operation, this.spec);
+    }
+}
+function commandArguments(rawInput) {
+    const trimmed = rawInput.trim();
+    return trimmed.length === 0 ? [] : trimmed.split(/\s+/);
+}
+function commandText(result) {
+    return [result.stdout.trimEnd(), result.stderr.trimEnd()]
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+export function apply(ctx, config) {
+    const resolved = resolveConfig(config);
+    const spec = {
+        companionPath: COMPANION_PATH,
+        dataRoot: resolved.dataRoot,
+        env: resolved.env,
+        disposeGraceMs: resolved.disposeGraceMs,
+        maxOutputBytes: resolved.maxOutputBytes,
+        model: resolved.model,
+        thinkingEffort: resolved.thinkingEffort,
+        budget: resolved.budget,
+        reviewBase: resolved.reviewBase,
+        spawn: (spawnSpec) => ctx.subprocess.spawn(spawnSpec),
+    };
+    for (const operation of DSH_COMPANION_OPERATIONS) {
+        ctx.subagents.registerProvider(new KimiCompanionProvider(`kimi-${operation}`, operation, spec));
+    }
+    ctx.inject(["commands"], (commandCtx) => {
+        const execute = async (invocation, argv) => {
+            const directories = commandCtx.get("workingDirectory");
+            if (directories === undefined) {
+                return { kind: "error", text: "Kimi commands require the DSH working-directory service." };
+            }
+            const cwd = await directories.ensure(invocation.agent, invocation.signal);
+            const result = await runCompanionCommand(argv, cwd, spec, invocation.signal);
+            const text = commandText(result);
+            if (result.truncated) {
+                return { kind: "error", text: `${text}\nKimi command output exceeded the configured byte limit.`.trim() };
+            }
+            if (result.exitCode !== 0) {
+                return {
+                    kind: "error",
+                    text: `${text}\nKimi command failed (exit code: ${result.exitCode ?? "none"}; signal: ${result.signal ?? "none"}).`.trim(),
+                };
+            }
+            return { kind: "success", text: text.length > 0 ? text : "Kimi command completed." };
+        };
+        commandCtx.commands.register({
+            definitionId: CommandDefinitionId("kimi-plugin-cc/dsh/setup"),
+            name: "kimi-setup",
+            description: "Install, check, or remove the DSH-owned Kimi PreToolUse hook; list configured models",
+            input: { hint: "[--check|--uninstall|--models [--json]]" },
+            recordInput: false,
+            handler: (invocation) => {
+                const args = commandArguments(invocation.rawInput);
+                const valid = args.length === 0
+                    || (args.length === 1 && ["--check", "--uninstall", "--models"].includes(args[0]))
+                    || (args.length === 2 && args[0] === "--models" && args[1] === "--json");
+                if (!valid) {
+                    return { kind: "error", text: "Usage: /kimi-setup [--check|--uninstall|--models [--json]]" };
+                }
+                return execute(invocation, ["setup", ...args]);
+            },
+        });
+        for (const command of ["status", "result", "cancel"]) {
+            commandCtx.commands.register({
+                definitionId: CommandDefinitionId(`kimi-plugin-cc/dsh/${command}`),
+                name: `kimi-${command}`,
+                description: `${command === "cancel" ? "Cancel" : command === "status" ? "Inspect" : "Return"} a companion Kimi job`,
+                input: { hint: "[job-id]" },
+                recordInput: false,
+                handler: (invocation) => execute(invocation, [command, ...commandArguments(invocation.rawInput)]),
+            });
+        }
+    });
+}

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

@@ -0,0 +1,40 @@
+export class RuntimeError extends Error {
+    code;
+    stage;
+    details;
+    constructor(code, message, stage, options) {
+        super(message, options);
+        this.name = "RuntimeError";
+        this.code = code;
+        this.stage = stage;
+        this.details = options?.details ?? {};
+    }
+}
+export function formatError(error) {
+    if (error instanceof RuntimeError) {
+        const base = `[${error.code}] [${error.stage}] ${error.message}`;
+        // Serialize structured context so an LLM caller can act on it. Without
+        // this, `details` existed only in the SQLite job row — reachable via
+        // `result <jobId> --json` for BACKGROUND jobs, but simply lost for
+        // foreground ones (review/challenge/ask), whose only output is this
+        // string. v1.9.0 needs `drift_axis` to reach the caller on every path, so
+        // it is rendered here as one deterministic JSON line. (Kimi's pre-release
+        // review caught that the agents were told to branch on a field no channel
+        // actually carried.)
+        const details = error.details;
+        if (details !== undefined && Object.keys(details).length > 0) {
+            try {
+                return `${base}\ndetails: ${JSON.stringify(details)}`;
+            }
+            catch {
+                // A non-serializable value must never suppress the error itself.
+                return base;
+            }
+        }
+        return base;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}