kimi-plugin-cc 2.5.2 → 2.5.3

package/plugins/kimi-codex/dist/swarm-activation.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { open } from "node:fs/promises";
 import path from "node:path";
@@ -9,7 +10,7 @@ import { assertExecutionPlanMatchesSpawn, assertNoUnsafeExperimentalSelector, }
 import { resolveKimiHome } from "./kimi-home.js";
 import { assertNativeV2Preflight } from "./native-v2-preflight.js";
 import { collectDescendantIdentities, collectProcessGroupsIdentities, probeProcessIdentity, revalidateProcessIdentities, waitForProcessTreeExit, } from "./process-tree.js";
-const PREACTIVATION_VERSIONS = ["2.3.2", "2.3.3", "2.4.0", "2.4.1"];
+const PREACTIVATION_VERSIONS = ["2.3.2", "2.3.3", "2.4.0", "2.4.1", "2.5.0", "2.5.1"];
 const READY_TIMEOUT_MS = 10_000;
 const REST_TIMEOUT_MS = 5_000;
 // Exact 2.4.0 can take longer than 5s to drain session/workspace lifecycle work.
@@ -18,6 +19,8 @@ const JOURNAL_TIMEOUT_MS = 2_000;
 const JOURNAL_POLL_MS = 50;
 const READY_LINE_MAX_CHARS = 65_536;
 const REST_RESPONSE_MAX_BYTES = 1024 * 1024;
+const WEBSOCKET_MAX_FRAMES = 64;
+const WEBSOCKET_RESPONSE_MAX_CHARS = 1024 * 1024;
 const JOURNAL_MAX_BYTES = 64 * 1024 * 1024;
 const DESCENDANT_SNAPSHOT_TIMEOUT_MS = 2_000;
 const DESCENDANT_TRACK_INTERVAL_MS = 50;
@@ -39,11 +42,12 @@ export async function preactivateSwarmSession(options) {
         web = await startWebChild(options, prepared.env, failureCode);
         await verifyMeta(web, prepared.expectedVersion, options.signal, failureCode);
         const model = await resolveProfileModel(web, options, failureCode);
-        identity = await createSession(web, options, failureCode);
+        identity = await createSession(web, options, prepared.expectedVersion, failureCode);
+        await verifyLocalEnvironment(web, identity, options.cwd, prepared.expectedVersion, options.signal, failureCode);
         options.onRecoveryEvent?.({ kind: "session", ...identity });
         profileMutationAttempted = true;
         await postSwarmProfile(web, identity, true, model, options.signal, failureCode);
-        await verifySwarmStatus(web, identity, true, model, options.signal, failureCode);
+        await verifySwarmStatus(web, identity, true, model, prepared.expectedVersion, options.signal, failureCode);
         await shutdownWeb(web, options.signal, failureCode);
         await requireSwarmJournal(prepared.kimiHome, identity, "enter", options.signal, failureCode);
         throwIfAborted(options.signal, failureCode, "swarm-activation.complete");
@@ -86,8 +90,9 @@ export async function deactivateSwarmSession(options) {
         throwIfAborted(options.signal, failureCode, "swarm-deactivation.pre-spawn");
         web = await startWebChild(options, prepared.env, failureCode);
         await verifyMeta(web, prepared.expectedVersion, options.signal, failureCode);
+        await verifyLocalEnvironment(web, options, options.cwd, prepared.expectedVersion, options.signal, failureCode);
         await postSwarmProfile(web, options, false, undefined, options.signal, failureCode);
-        await verifySwarmStatus(web, options, false, undefined, options.signal, failureCode);
+        await verifySwarmStatus(web, options, false, undefined, prepared.expectedVersion, options.signal, failureCode);
         await shutdownWeb(web, options.signal, failureCode);
         await requireSwarmJournal(prepared.kimiHome, options, "exit", options.signal, failureCode);
         options.onRecoveryEvent?.({ kind: "disabled" });
@@ -124,6 +129,7 @@ async function prepareWebSpawn(options, failureCode) {
         await assertNativeV2Preflight({
             kimiHome,
             env: options.env,
+            expectedExecutionRoot: options.cwd,
             stage: "swarm-activation.pre-spawn",
         });
     }
@@ -329,13 +335,29 @@ async function resolveProfileModel(web, options, failureCode) {
     }
     return data.default_model;
 }
-async function createSession(web, options, failureCode) {
-    const data = await restData(web, "POST", "/api/v1/sessions", { metadata: { cwd: options.cwd } }, options.signal, failureCode);
+async function createSession(web, options, expectedVersion, failureCode) {
+    const request = { metadata: { cwd: options.cwd } };
+    if (["2.5.0", "2.5.1"].includes(expectedVersion)) {
+        request.environment_id = "local";
+        request.environment_cwd = options.cwd;
+    }
+    const data = await restData(web, "POST", "/api/v1/sessions", request, options.signal, failureCode);
     if (!isRecord(data) || !validPathId(data.id) || !validPathId(data.workspace_id)) {
         throw failure(failureCode, "swarm-activation.create-session", "Kimi web returned an invalid session identity.");
     }
     return { sessionId: data.id, workspaceId: data.workspace_id };
 }
+async function verifyLocalEnvironment(web, identity, expectedCwd, expectedVersion, signal, failureCode) {
+    if (!["2.5.0", "2.5.1"].includes(expectedVersion))
+        return;
+    const data = await restData(web, "GET", `/api/v1/sessions/${encodeURIComponent(identity.sessionId)}/environment`, undefined, signal, failureCode);
+    if (!isRecord(data)) {
+        throw failure(failureCode, "swarm-activation.environment", "Kimi web /environment returned an invalid payload.");
+    }
+    if (data.workspace_id !== identity.workspaceId || data.environment_id !== "local" || data.cwd !== expectedCwd) {
+        throw failure(failureCode, "swarm-activation.environment", "Kimi web /environment did not confirm the expected local workspace binding.");
+    }
+}
 async function postSwarmProfile(web, identity, active, model, signal, failureCode) {
     const agentConfig = {
         swarm_mode: active,
@@ -345,24 +367,264 @@ async function postSwarmProfile(web, identity, active, model, signal, failureCod
         agentConfig.model = model;
     await restData(web, "POST", `/api/v1/sessions/${encodeURIComponent(identity.sessionId)}/profile`, { agent_config: agentConfig }, signal, failureCode);
 }
-async function verifySwarmStatus(web, identity, active, model, signal, failureCode) {
-    const data = await restData(web, "GET", `/api/v1/sessions/${encodeURIComponent(identity.sessionId)}/status`, undefined, signal, failureCode);
+async function verifySwarmStatus(web, identity, active, model, expectedVersion, signal, failureCode) {
+    const data = ["2.5.0", "2.5.1"].includes(expectedVersion)
+        ? await readWebSocketAgentState(web, identity.sessionId, signal, failureCode)
+        : await restData(web, "GET", `/api/v1/sessions/${encodeURIComponent(identity.sessionId)}/status`, undefined, signal, failureCode);
+    const source = ["2.5.0", "2.5.1"].includes(expectedVersion) ? "agent state" : "/status";
     if (!isRecord(data)) {
-        throw failure(failureCode, "swarm-activation.status", "Kimi web /status returned an invalid payload.");
+        throw failure(failureCode, "swarm-activation.status", `Kimi web ${source} returned an invalid payload.`);
     }
     if (data.swarm_mode !== active) {
-        throw failure(failureCode, "swarm-activation.status", `Kimi web /status did not confirm swarm_mode=${active}.`, { expected_swarm_mode: active });
+        throw failure(failureCode, "swarm-activation.status", `Kimi web ${source} did not confirm swarm_mode=${active}.`, { expected_swarm_mode: active });
     }
     if (data.plan_mode !== false) {
-        throw failure(failureCode, "swarm-activation.status", "Kimi web /status did not confirm plan mode is off.");
+        throw failure(failureCode, "swarm-activation.status", `Kimi web ${source} did not confirm plan mode is off.`);
     }
-    if (data.permission !== "auto") {
-        throw failure(failureCode, "swarm-activation.status", "Kimi web /status did not confirm auto permission mode.");
+    if (["2.5.0", "2.5.1"].includes(expectedVersion) && data.tower_mode !== false) {
+        throw failure(failureCode, "swarm-activation.status", "Kimi web agent state did not confirm tower mode is off.");
+    }
+    const permission = ["2.5.0", "2.5.1"].includes(expectedVersion) ? data.permission_mode : data.permission;
+    if (permission !== "auto") {
+        throw failure(failureCode, "swarm-activation.status", `Kimi web ${source} did not confirm auto permission mode.`);
     }
     if (active && data.model !== model) {
-        throw failure(failureCode, "swarm-activation.status", "Kimi web /status did not confirm the selected model alias.");
+        throw failure(failureCode, "swarm-activation.status", `Kimi web ${source} did not confirm the selected model alias.`);
     }
 }
+async function readWebSocketAgentState(web, sessionId, signal, failureCode) {
+    throwIfAborted(signal, failureCode, "swarm-activation.status");
+    await refreshOwnedDescendants(web);
+    throwIfAborted(signal, failureCode, "swarm-activation.status");
+    try {
+        return await new Promise((resolve, reject) => {
+            let socket;
+            const bearerProtocol = `kimi-code.bearer.${web.token}`;
+            const helloId = `swarm-activation-hello-${randomUUID()}`;
+            const subscribeId = `swarm-activation-subscribe-${randomUUID()}`;
+            try {
+                const url = new URL(web.origin);
+                url.protocol = "ws:";
+                url.pathname = "/api/v1/ws";
+                socket = new WebSocket(url, bearerProtocol);
+            }
+            catch {
+                reject(failure(failureCode, "swarm-activation.status", "Could not open the authenticated Kimi web agent-state channel."));
+                return;
+            }
+            let settled = false;
+            let serverHello = false;
+            let clientHelloAcknowledged = false;
+            let subscribeSent = false;
+            let subscriptionAcknowledged = false;
+            let closeRequested = false;
+            let latestState;
+            let frames = 0;
+            let receivedChars = 0;
+            const timer = setTimeout(() => {
+                settle(failure(failureCode, "swarm-activation.status", "Kimi web agent-state verification timed out.", { timeout_ms: REST_TIMEOUT_MS }));
+            }, REST_TIMEOUT_MS);
+            const cleanup = () => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                socket.removeEventListener("open", onOpen);
+                socket.removeEventListener("message", onMessage);
+                socket.removeEventListener("error", onError);
+                socket.removeEventListener("close", onClose);
+                try {
+                    socket.close();
+                }
+                catch {
+                }
+            };
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (result instanceof RuntimeError)
+                    reject(result);
+                else
+                    resolve(result);
+            };
+            const rejectState = (message) => {
+                settle(failure(failureCode, "swarm-activation.status", message));
+            };
+            const send = (frame) => {
+                try {
+                    socket.send(JSON.stringify(frame));
+                    return true;
+                }
+                catch {
+                    rejectState("Could not send a Kimi web agent-state control frame.");
+                    return false;
+                }
+            };
+            const completeIfReady = () => {
+                if (serverHello &&
+                    clientHelloAcknowledged &&
+                    subscriptionAcknowledged &&
+                    latestState !== undefined &&
+                    !closeRequested) {
+                    closeRequested = true;
+                    try {
+                        socket.close();
+                    }
+                    catch {
+                        rejectState("Could not close the Kimi web agent-state channel for final validation.");
+                    }
+                }
+            };
+            const onOpen = () => {
+                if (socket.protocol !== bearerProtocol) {
+                    rejectState("Kimi web did not authenticate the agent-state channel with the expected subprotocol.");
+                    return;
+                }
+                send({
+                    type: "client_hello",
+                    id: helloId,
+                    payload: { client_id: "kimi-plugin-cc-swarm-activation" },
+                });
+            };
+            const onMessage = (event) => {
+                if (settled)
+                    return;
+                if (typeof event.data !== "string") {
+                    rejectState("Kimi web agent-state channel returned a non-text frame.");
+                    return;
+                }
+                frames += 1;
+                receivedChars += event.data.length;
+                if (frames > WEBSOCKET_MAX_FRAMES || receivedChars > WEBSOCKET_RESPONSE_MAX_CHARS) {
+                    rejectState("Kimi web agent-state channel exceeded the bounded response limit.");
+                    return;
+                }
+                let frame;
+                try {
+                    frame = JSON.parse(event.data);
+                }
+                catch {
+                    rejectState("Kimi web agent-state channel returned malformed JSON.");
+                    return;
+                }
+                if (!isRecord(frame) || typeof frame.type !== "string") {
+                    rejectState("Kimi web agent-state channel returned an invalid frame.");
+                    return;
+                }
+                if (frame.type === "server_hello") {
+                    if (serverHello || !isRecord(frame.payload) ||
+                        frame.payload.protocol_version !== 2 ||
+                        typeof frame.payload.ws_connection_id !== "string" ||
+                        !isRecord(frame.payload.capabilities) ||
+                        frame.payload.capabilities.event_batching !== false ||
+                        frame.payload.capabilities.compression !== false) {
+                        rejectState("Kimi web agent-state channel did not provide the expected protocol-v2 hello.");
+                        return;
+                    }
+                    serverHello = true;
+                    return;
+                }
+                if (!serverHello) {
+                    rejectState("Kimi web agent-state channel sent data before its protocol hello.");
+                    return;
+                }
+                if (frame.type === "ack") {
+                    if (typeof frame.id !== "string" || typeof frame.code !== "number" || !isRecord(frame.payload)) {
+                        rejectState("Kimi web agent-state channel returned an invalid acknowledgement.");
+                        return;
+                    }
+                    if (frame.id === helloId) {
+                        if (clientHelloAcknowledged || frame.code !== 0) {
+                            rejectState("Kimi web agent-state channel rejected the client hello.");
+                            return;
+                        }
+                        clientHelloAcknowledged = true;
+                        subscribeSent = send({
+                            type: "subscribe_v2",
+                            id: subscribeId,
+                            payload: { session_id: sessionId, transcript: { main: "block" } },
+                        });
+                        return;
+                    }
+                    if (frame.id === subscribeId) {
+                        if (subscriptionAcknowledged || !subscribeSent || frame.code !== 0 ||
+                            !Array.isArray(frame.payload.accepted) ||
+                            frame.payload.accepted.length !== 1 ||
+                            frame.payload.accepted[0] !== sessionId ||
+                            !Array.isArray(frame.payload.not_found) ||
+                            frame.payload.not_found.length !== 0) {
+                            rejectState("Kimi web agent-state channel did not accept the exact main-session subscription.");
+                            return;
+                        }
+                        subscriptionAcknowledged = true;
+                        completeIfReady();
+                        return;
+                    }
+                    rejectState("Kimi web agent-state channel returned an unexpected acknowledgement.");
+                    return;
+                }
+                if (frame.type === "agent") {
+                    if (!subscribeSent || !isAgentStateFrame(frame, sessionId)) {
+                        rejectState("Kimi web agent-state channel returned invalid or misbound main-agent state.");
+                        return;
+                    }
+                    latestState = frame;
+                    completeIfReady();
+                    return;
+                }
+                if (frame.type === "ping") {
+                    if (isRecord(frame.payload) && typeof frame.payload.nonce === "string") {
+                        send({ type: "pong", payload: { nonce: frame.payload.nonce } });
+                    }
+                }
+            };
+            const onAbort = () => {
+                settle(cancelledFailure(failureCode, "swarm-activation.status"));
+            };
+            const onError = () => {
+                rejectState("Kimi web agent-state channel failed before valid state was received.");
+            };
+            const onClose = (event) => {
+                if (event.wasClean &&
+                    closeRequested &&
+                    serverHello &&
+                    clientHelloAcknowledged &&
+                    subscriptionAcknowledged &&
+                    latestState !== undefined) {
+                    settle(latestState);
+                    return;
+                }
+                rejectState("Kimi web agent-state channel closed before valid state was received.");
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            socket.addEventListener("open", onOpen);
+            socket.addEventListener("message", onMessage);
+            socket.addEventListener("error", onError);
+            socket.addEventListener("close", onClose);
+            if (signal?.aborted === true)
+                onAbort();
+        });
+    }
+    finally {
+        await refreshOwnedDescendants(web);
+    }
+}
+function isAgentStateFrame(frame, sessionId) {
+    return frame.session_id === sessionId &&
+        frame.agent_id === "main" &&
+        typeof frame.event_created_at === "string" &&
+        Number.isFinite(Date.parse(frame.event_created_at)) &&
+        (frame.status === "idle" || frame.status === "running") &&
+        (frame.model === undefined || typeof frame.model === "string") &&
+        (frame.thinking === undefined || typeof frame.thinking === "string") &&
+        (frame.permission_mode === undefined ||
+            frame.permission_mode === "manual" ||
+            frame.permission_mode === "yolo" ||
+            frame.permission_mode === "auto") &&
+        typeof frame.plan_mode === "boolean" &&
+        typeof frame.swarm_mode === "boolean" &&
+        typeof frame.tower_mode === "boolean";
+}
 async function shutdownWeb(web, signal, failureCode) {
     await restData(web, "POST", "/api/v1/shutdown", undefined, signal, failureCode);
     const settlement = await waitForChildClose(web, signal, failureCode);

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

@@ -4,4 +4,4 @@
 // and AGENTS.md on every release. A future improvement would read this from
 // package.json at build time, but that adds a build-step dependency we
 // don't want yet.
-export const KIMI_PLUGIN_CC_VERSION = "2.5.2";
+export const KIMI_PLUGIN_CC_VERSION = "2.5.3";

package/plugins/kimi-dsh/dist/cli-client.js

@@ -65,6 +65,7 @@ export async function runCliPrompt(opts) {
             kimiHome: resolveKimiHome(opts.env, opts.cwd),
             env: opts.env,
             resumeSessionId: opts.resumeSessionId,
+            expectedExecutionRoot: opts.trustedWorkspaceRoot ?? opts.cwd,
             stage: "cli-client.spawn",
         });
     }
@@ -781,6 +782,13 @@ const KIMI_LEGACY_FORCED_VALUE = "1";
 function buildArgs(opts) {
     const args = [...(opts.prefixArgs ?? [])];
     args.push("--output-format", "stream-json");
+    const smokeCandidate = opts.executionPlan.certification === "test-bypass" && opts.env.KIMI_PLUGIN_CC_SMOKE === "1"
+        ? opts.env.KIMI_PLUGIN_CC_SMOKE_V2_CANDIDATE
+        : undefined;
+    if (opts.resumeSessionId === undefined &&
+        ["2.5.0", "2.5.1"].includes(opts.executionPlan.kimiVersion ?? smokeCandidate ?? "")) {
+        args.push("--environment", "local");
+    }
     if (opts.resumeSessionId !== undefined) {
         args.push("-r", opts.resumeSessionId);
     }

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

@@ -28,8 +28,8 @@ import { buildKimiSessionTitle, syncKimiSessionTitle } from "../session-title.js
 // only the wall-clock hard bound. Read/write modes reuse review/rescue lineage,
 // and the mandatory PreToolUse hook enforces read-only policy or trusted-worktree
 // write confinement on the coordinator and every subagent. Write mode requires
-// kimi-code 0.18.0+. Exact 2.3.2, 2.3.3, 2.4.0 and 2.4.1 additionally activate a same-job
-// session through a bounded loopback web lifecycle, then resume it through the normal print path.
+// kimi-code 0.18.0+. Exact 2.3.2, 2.3.3, 2.4.0, 2.4.1, 2.5.0 and 2.5.1 additionally
+// activate a same-job session through a bounded loopback web lifecycle, then resume it through the normal print path.
 const SWARM_SUMMARY_MAX = 120;
 const SWARM_AGENT_PROFILE = "<swarm>";
 const SWARM_WRITE_AGENT_PROFILE = "<swarm-write>";

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

@@ -595,7 +595,8 @@ function validateVersionSensitiveEvents(events, version) {
     // Exact schemas reviewed at 2.0.0 (1b89e4b0), 2.0.1 (caf7d4e2),
     // 2.0.2 (9d07f634), 2.1.0 (52437299), 2.1.1 (f67e6398), 2.2.0 (472192c3),
     // 2.3.0 (b5e28fd6), 2.3.1 (684bae9e), 2.3.2 (b8dd3a13), 2.3.3 (ec495f0c),
-    // 2.4.0 (f26e4d91), and 2.4.1 (2c73f3f5): the additive events and HookDefSchema are unchanged.
+    // 2.4.0 (f26e4d91), 2.4.1 (2c73f3f5), 2.5.0 (41c34143), and 2.5.1 (1b02030d):
+    // the additive events and HookDefSchema are unchanged.
     // Require the full version string AND matching components; no inferred 2.x compatibility.
     if (version.major === 2 && ((version.minor === 0 && ((version.version === "2.0.0" && version.patch === 0) ||
         (version.version === "2.0.1" && version.patch === 1) ||
@@ -608,7 +609,9 @@ function validateVersionSensitiveEvents(events, version) {
             (version.version === "2.3.2" && version.patch === 2) ||
             (version.version === "2.3.3" && version.patch === 3))) ||
         (version.minor === 4 && ((version.version === "2.4.0" && version.patch === 0) ||
-            (version.version === "2.4.1" && version.patch === 1))))) {
+            (version.version === "2.4.1" && version.patch === 1))) ||
+        (version.minor === 5 && ((version.version === "2.5.0" && version.patch === 0) ||
+            (version.version === "2.5.1" && version.patch === 1))))) {
         return { valid: true };
     }
     if (version.major !== 0) {

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

@@ -47,6 +47,7 @@ const RESERVED_PREFIX_FLAGS = new Set([
     "--plan", "--auto", "-y", "--yolo", "--yes", "--auto-approve", "--manual",
     // Model / profile / roots.
     "-m", "--model", "--skills-dir", "--agent", "--agent-file", "--add-dir",
+    "--environment", "--environment-cwd",
     // Terminal informational flags (would replace the run with a banner).
     "-V", "--version", "-h", "--help",
 ]);

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

@@ -45,6 +45,8 @@ export const NATIVE_V2_CERTIFIED_VERSIONS = Object.freeze([
     "2.3.3",
     "2.4.0",
     "2.4.1",
+    "2.5.0",
+    "2.5.1",
 ]);
 /** Per-operation native-v2 certification. One green operation never certifies another. */
 export const NATIVE_V2_CERTIFIED = new Map([
@@ -127,6 +129,7 @@ export async function prepareKimiExecutionPlan(options) {
             kimiHome: resolveKimiHome(options.env, options.cwd),
             env: options.env,
             resumeSessionId: options.resumeSessionId,
+            expectedExecutionRoot: options.cwd,
             stage: "kimi-engine.plan",
         });
     };