kimi-plugin-cc 2.3.1 → 2.4.1

package/dist/mcp/tool-result.js

@@ -0,0 +1,7 @@
+export function textResult(text, structuredContent, isError = false) {
+    return {
+        content: [{ type: "text", text }],
+        ...(structuredContent ? { structuredContent } : {}),
+        isError,
+    };
+}

package/dist/mcp/workspace.js

@@ -0,0 +1,34 @@
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { RuntimeError } from "../errors.js";
+import { resolveRepoIdentity } from "../git.js";
+export async function resolveMcpWorkspace(env, requested) {
+    const defaultCandidate = env.KIMI_PLUGIN_CC_MCP_WORKSPACE;
+    const candidate = requested ?? defaultCandidate;
+    if (!candidate) {
+        throw new RuntimeError("MCP_WORKSPACE_REQUIRED", "This MCP server has no default workspace. Supply the absolute workspace directory explicitly; Codex calls normally require it.", "mcp.workspace");
+    }
+    const cwd = await canonicalDirectory(candidate, "workspace");
+    if (defaultCandidate) {
+        const defaultCwd = await canonicalDirectory(defaultCandidate, "host workspace");
+        const relative = path.relative(defaultCwd, cwd);
+        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new RuntimeError("MCP_WORKSPACE_OUTSIDE_DEFAULT", `workspace must be the host workspace or one of its descendants, not ${cwd} (host: ${defaultCwd}).`, "mcp.workspace");
+        }
+    }
+    return { cwd, repo: await resolveRepoIdentity(cwd) };
+}
+async function canonicalDirectory(candidate, label) {
+    if (!path.isAbsolute(candidate)) {
+        throw new RuntimeError("MCP_WORKSPACE_NOT_ABSOLUTE", `${label} must be an absolute existing directory.`, "mcp.workspace");
+    }
+    try {
+        const cwd = await realpath(candidate);
+        if (!(await stat(cwd)).isDirectory())
+            throw new Error("not a directory");
+        return cwd;
+    }
+    catch (error) {
+        throw new RuntimeError("MCP_WORKSPACE_INVALID", `${label} is not an accessible existing directory: ${candidate}`, "mcp.workspace", error instanceof Error ? { cause: error } : undefined);
+    }
+}

package/dist/model-command.js

@@ -0,0 +1,32 @@
+import { runAsk } from "./commands/ask.js";
+import { notImplementedCompanionCommand } from "./commands/not-implemented.js";
+import { runPursue } from "./commands/pursue.js";
+import { runRescue } from "./commands/rescue.js";
+import { runReview } from "./commands/review.js";
+import { runSwarm } from "./commands/swarm.js";
+export async function runModelCommand(argv, context) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case "review":
+            return `${await runReview(rest, context, "review")}\n`;
+        case "ask":
+            return `${await runAsk(rest, context)}\n`;
+        case "task": {
+            const [taskType, ...taskArgs] = rest;
+            switch (taskType) {
+                case "rescue":
+                    return runRescue(taskArgs, context);
+                case "challenge":
+                    return `${await runReview(taskArgs, context, "challenge")}\n`;
+                case "pursue":
+                    return runPursue(taskArgs, context);
+                case "swarm":
+                    return runSwarm(taskArgs, context);
+                default:
+                    notImplementedCompanionCommand(taskType ? `task ${taskType}` : "task");
+            }
+        }
+        default:
+            return undefined;
+    }
+}

package/dist/process-tree.js

@@ -6,7 +6,7 @@ const MAX_DESCENDANT_DEPTH = 8;
 const MAX_DESCENDANT_PIDS = 512;
 const PROCESS_EXIT_POLL_MS = 10;
 const PROCESS_SNAPSHOT_TIMEOUT_MS = 1_000;
-const PROCESS_IDENTITY_PROBE_TIMEOUT_MS = 250;
+const PROCESS_IDENTITY_PROBE_TIMEOUT_MS = 1_000;
 const PROBE_TIMEOUT = Symbol("process-probe-timeout");
 /**
  * Capture descendant ancestry and reusable identities in the same bounded
@@ -23,6 +23,18 @@ export async function collectDescendantIdentities(rootPid) {
     }
     return snapshot;
 }
+/** Return current members of the selected process groups, or undefined when unreadable. */
+export async function collectProcessGroupsIdentities(processGroupIds) {
+    if (process.platform === "win32")
+        return undefined;
+    const groups = new Set(processGroupIds.filter((id) => Number.isInteger(id) && id > 0));
+    if (groups.size === 0)
+        return [];
+    const rows = await raceValueWithTimeout(collectProcessSnapshotRows(), PROCESS_SNAPSHOT_TIMEOUT_MS);
+    if (rows === PROBE_TIMEOUT || rows === undefined)
+        return undefined;
+    return rows.filter((row) => groups.has(row.processGroupId)).map(toProcessIdentity);
+}
 /**
  * Compatibility surface for callers that only need numeric process listings.
  * Cancellation must use collectDescendantIdentities so ancestry and identity
@@ -36,15 +48,21 @@ export async function collectDescendants(rootPid) {
         return [];
     }
 }
-/** Read one reusable process identity. PID alone is not stable across teardown. */
-export async function readProcessIdentity(pid) {
+/** Distinguish a missing process from a failed or timed-out identity probe. */
+export async function probeProcessIdentity(pid) {
     if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32")
-        return undefined;
+        return { complete: true };
     const read = process.platform === "linux"
         ? readProcessIdentityBatchFromProc([pid])
         : readProcessIdentityBatchWithPs([pid]);
     const batch = await raceValueWithTimeout(read, PROCESS_IDENTITY_PROBE_TIMEOUT_MS);
-    return batch === PROBE_TIMEOUT ? undefined : batch.identities.get(pid);
+    if (batch === PROBE_TIMEOUT)
+        return { complete: false };
+    return { identity: batch.identities.get(pid), complete: batch.complete };
+}
+/** Read one reusable process identity. PID alone is not stable across teardown. */
+export async function readProcessIdentity(pid) {
+    return (await probeProcessIdentity(pid)).identity;
 }
 /**
  * Revalidate all captured identities concurrently under one deadline. The
@@ -63,16 +81,26 @@ export async function revalidateProcessIdentities(expectedIdentities, options =
     if (batch === PROBE_TIMEOUT)
         return { identities: [], complete: false };
     const identities = [];
+    const groupChanged = [];
     for (const expectedIdentity of expected) {
         const current = batch.identities.get(expectedIdentity.pid);
-        if (current !== undefined &&
-            current.startToken === expectedIdentity.startToken &&
-            current.processGroupId === expectedIdentity.processGroupId &&
-            !isQuiescentState(current.state)) {
+        if (current === undefined ||
+            current.startToken !== expectedIdentity.startToken ||
+            isQuiescentState(current.state)) {
+            continue;
+        }
+        if (current.processGroupId !== expectedIdentity.processGroupId) {
+            groupChanged.push(current);
+        }
+        else {
             identities.push(current);
         }
     }
-    return { identities, complete: batch.complete };
+    return {
+        identities,
+        complete: batch.complete,
+        ...(groupChanged.length > 0 ? { groupChanged } : {}),
+    };
 }
 /** Return the current identity only when pid, start token, and PGID still match. */
 export async function revalidateProcessIdentity(expected, identityReader) {
@@ -104,7 +132,7 @@ export async function waitForProcessTreeExit(identities, timeoutMs, options = {}
                 identityReader: options.identityReader,
                 timeoutMs: probeTimeoutMs,
             });
-            active = !validation.complete || validation.identities.length > 0;
+            active = !validation.complete || validation.identities.length > 0 || (validation.groupChanged?.length ?? 0) > 0;
         }
         if (!active)
             return true;
@@ -117,13 +145,13 @@ export async function waitForProcessTreeExit(identities, timeoutMs, options = {}
 async function collectVerifiedDescendantIdentities(rootPid) {
     const initialRows = await collectProcessSnapshotRows();
     if (initialRows === undefined)
-        return [];
+        throw new Error("process snapshot unavailable");
     const candidateRows = descendantRowsFromSnapshot(rootPid, initialRows);
     const initialRoot = initialRows.find((row) => row.pid === rootPid);
     if (initialRoot === undefined || candidateRows.length === 0)
         return [];
-    // A second, targeted snapshot closes the cross-row /proc race: every child
-    // identity and every numeric parent edge must still match before acceptance.
+    // A second, targeted snapshot closes the cross-row /proc race: each child
+    // must retain its PID and start token. Reparenting and PGID changes are not exit.
     const expectedRows = [initialRoot, ...candidateRows];
     const expectedByPid = new Map(expectedRows.map((row) => [row.pid, row]));
     const verificationRows = await readCurrentSnapshotRows(expectedRows);
@@ -131,11 +159,9 @@ async function collectVerifiedDescendantIdentities(rootPid) {
         const expected = expectedByPid.get(current.pid);
         return (expected !== undefined &&
             current.startToken === expected.startToken &&
-            current.processGroupId === expected.processGroupId &&
-            current.parentPid === expected.parentPid &&
             !isQuiescentState(current.state));
     });
-    return descendantRowsFromSnapshot(rootPid, stableRows).map(toProcessIdentity);
+    return stableRows.map(toProcessIdentity);
 }
 function descendantRowsFromSnapshot(rootPid, rows) {
     const root = rows.find((row) => row.pid === rootPid);
@@ -186,6 +212,9 @@ async function readCurrentSnapshotRows(expectedRows) {
         Promise.all(procPids.map((pid) => readProcRow(pid))),
         collectProcessSnapshotRowsFromPs(psPids),
     ]);
+    if (procOutcomes.some((outcome) => outcome.status === "error") || (psPids.length > 0 && psRows === undefined)) {
+        throw new Error("process identity verification failed");
+    }
     return [
         ...procOutcomes.flatMap((outcome) => outcome.status === "found" ? [outcome.row] : []),
         ...(psRows ?? []),
@@ -212,6 +241,8 @@ async function collectProcessSnapshotRowsFromProc() {
     const outcomes = await Promise.all(entries
         .filter((entry) => /^\d+$/.test(entry))
         .map((entry) => readProcRow(Number.parseInt(entry, 10))));
+    if (outcomes.some((outcome) => outcome.status === "error"))
+        return undefined;
     return outcomes.flatMap((outcome) => outcome.status === "found" ? [outcome.row] : []);
 }
 async function collectProcessSnapshotRowsFromPs(pids) {