kimi-plugin-cc 2.4.5 → 2.5.2

package/plugins/kimi-dsh/dist/plugin-data.js

@@ -0,0 +1,98 @@
+import { existsSync, lstatSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimeError } from "./errors.js";
+// Use the loaded module, not the shared PLUGIN_ROOT/CLAUDE_PLUGIN_ROOT variables.
+// Both source and compiled modules live one directory below the package root.
+const loadedPackageRoot = fileURLToPath(new URL("../", import.meta.url));
+/** Resolve state without silently trusting a different plugin's shared env. */
+export function resolvePluginDataRoot(env, packageRoot = loadedPackageRoot) {
+    const explicit = env.KIMI_PLUGIN_CC_DATA;
+    if (explicit !== undefined) {
+        if (!path.isAbsolute(explicit)) {
+            throw new RuntimeError("INVALID_PLUGIN_DATA", "KIMI_PLUGIN_CC_DATA must be an absolute directory path, not an empty or relative value.", "paths");
+        }
+        return path.normalize(explicit);
+    }
+    const expected = installedDataRoot(packageRoot);
+    const shared = [env.CLAUDE_PLUGIN_DATA, env.PLUGIN_DATA].filter((value) => Boolean(value));
+    if (expected) {
+        if (shared.some((value) => !path.isAbsolute(value) || !sameDataRoot(value, expected))) {
+            throw new RuntimeError("PLUGIN_DATA_CONFLICT", "Shared plugin data variables do not match this installation. Remove the conflicting variables or set KIMI_PLUGIN_CC_DATA to the intended Kimi data directory. No data was moved.", "paths", { details: { expected_data_root: expected, override_variable: "KIMI_PLUGIN_CC_DATA" } });
+        }
+        return expected;
+    }
+    // Checkout/custom launch compatibility: we cannot infer ownership from an
+    // arbitrary directory or from a marker that may not exist on first setup.
+    // Preserve the old location when unambiguous; require an explicit choice otherwise.
+    if (shared.length === 2 && !sameDataRoot(shared[0], shared[1])) {
+        throw new RuntimeError("PLUGIN_DATA_CONFLICT", "CLAUDE_PLUGIN_DATA and PLUGIN_DATA disagree. Set KIMI_PLUGIN_CC_DATA to the intended Kimi data directory before retrying. No data was moved.", "paths");
+    }
+    if (shared[0])
+        return shared[0];
+    if (env.KIMI_PLUGIN_CC_SHELL_LAUNCH === "1" && (env.CODEX_HOME || env.HOME)) {
+        const dataRoot = env.CODEX_HOME
+            ? path.join(env.CODEX_HOME, "plugins", "data")
+            : path.join(env.HOME, ".codex", "plugins", "data");
+        return path.join(dataRoot, "kimi-marketplace-kimi");
+    }
+    throw new RuntimeError("MISSING_PLUGIN_DATA", "Set KIMI_PLUGIN_CC_DATA to an absolute writable data directory. Custom launches may also use an unambiguous CLAUDE_PLUGIN_DATA or PLUGIN_DATA value.", "paths");
+}
+function installedDataRoot(packageRoot) {
+    const root = path.resolve(packageRoot);
+    const pluginDir = path.dirname(root);
+    const marketplaceDir = path.dirname(pluginDir);
+    const cacheDir = path.dirname(marketplaceDir);
+    const pluginsDir = path.dirname(cacheDir);
+    if (path.basename(pluginDir) !== "kimi" || path.basename(cacheDir) !== "cache" || path.basename(pluginsDir) !== "plugins") {
+        return undefined;
+    }
+    const marketplace = path.basename(marketplaceDir);
+    if (existsSync(path.join(root, ".codex-plugin", "plugin.json"))) {
+        return path.join(pluginsDir, "data", `${marketplace}-kimi`);
+    }
+    if (existsSync(path.join(root, ".claude-plugin", "plugin.json"))) {
+        // Claude documents plugin-id sanitization for persistent data directories.
+        const id = `kimi@${marketplace}`.replace(/[^a-zA-Z0-9_-]/g, "-");
+        return path.join(pluginsDir, "data", id);
+    }
+    return undefined;
+}
+function sameDataRoot(left, right) {
+    if (path.resolve(left) === path.resolve(right))
+        return true;
+    const canonicalLeft = canonicalDataRoot(left);
+    return canonicalLeft !== undefined && canonicalLeft === canonicalDataRoot(right);
+}
+/** Resolve existing ancestors without creating a first-run data directory. */
+function canonicalDataRoot(value) {
+    let cursor = path.resolve(value);
+    const missing = [];
+    for (;;) {
+        try {
+            const resolved = realpathSync(cursor);
+            if (missing.length > 0 && !statSync(cursor).isDirectory())
+                return undefined;
+            return path.join(resolved, ...missing);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return undefined;
+            // ENOENT can also mean a dangling symlink. Do not treat an existing
+            // link as a missing directory and accidentally bypass its destination.
+            try {
+                lstatSync(cursor);
+                return undefined;
+            }
+            catch (statError) {
+                if (statError.code !== "ENOENT")
+                    return undefined;
+            }
+            const parent = path.dirname(cursor);
+            if (parent === cursor)
+                return undefined;
+            missing.unshift(path.basename(cursor));
+            cursor = parent;
+        }
+    }
+}

package/plugins/kimi-dsh/dist/process-tree.js

@@ -0,0 +1,479 @@
+import { execFile } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+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 = 1_000;
+const PROBE_TIMEOUT = Symbol("process-probe-timeout");
+/**
+ * Capture descendant ancestry and reusable identities in the same bounded
+ * process-table snapshot. There is no PID-only handoff: on Linux, PPID, PGID,
+ * state, and start time come from one /proc/<pid>/stat read per row; other
+ * POSIX systems use one ps invocation for the whole table.
+ */
+export async function collectDescendantIdentities(rootPid) {
+    if (!Number.isInteger(rootPid) || rootPid <= 0 || process.platform === "win32")
+        return [];
+    const snapshot = await raceValueWithTimeout(collectVerifiedDescendantIdentities(rootPid), PROCESS_SNAPSHOT_TIMEOUT_MS);
+    if (snapshot === PROBE_TIMEOUT) {
+        throw new Error(`process snapshot exceeded ${PROCESS_SNAPSHOT_TIMEOUT_MS}ms`);
+    }
+    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
+ * cannot be separated by a PID-reuse window.
+ */
+export async function collectDescendants(rootPid) {
+    try {
+        return (await collectDescendantIdentities(rootPid)).map((identity) => identity.pid);
+    }
+    catch {
+        return [];
+    }
+}
+/** 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 { complete: true };
+    const read = process.platform === "linux"
+        ? readProcessIdentityBatchFromProc([pid])
+        : readProcessIdentityBatchWithPs([pid]);
+    const batch = await raceValueWithTimeout(read, PROCESS_IDENTITY_PROBE_TIMEOUT_MS);
+    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
+ * default path batches ps fallback reads; an injected per-pid reader is fanned
+ * out with Promise.all rather than multiplied by descendant count.
+ */
+export async function revalidateProcessIdentities(expectedIdentities, options = {}) {
+    const expected = dedupeIdentities(expectedIdentities);
+    if (expected.length === 0)
+        return { identities: [], complete: true };
+    const timeoutMs = Math.max(0, options.timeoutMs ?? PROCESS_IDENTITY_PROBE_TIMEOUT_MS);
+    const read = options.identityReader === undefined
+        ? readCurrentIdentityBatch(expected)
+        : readIdentityBatchWithReader(expected, options.identityReader);
+    const batch = await raceValueWithTimeout(read, timeoutMs);
+    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 ||
+            isQuiescentState(current.state)) {
+            continue;
+        }
+        if (current.processGroupId !== expectedIdentity.processGroupId) {
+            groupChanged.push(current);
+        }
+        else {
+            identities.push(current);
+        }
+    }
+    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) {
+    const validation = await revalidateProcessIdentities([expected], { identityReader });
+    return validation.identities[0];
+}
+/**
+ * Wait until the direct child and every captured identity are quiescent.
+ * Every probe is bounded even when the overall wait is infinite, and an
+ * incomplete probe is conservatively treated as still active.
+ */
+export async function waitForProcessTreeExit(identities, timeoutMs, options = {}) {
+    const targets = dedupeIdentities(identities);
+    const finiteTimeout = Number.isFinite(timeoutMs);
+    const deadline = finiteTimeout ? Date.now() + Math.max(0, timeoutMs) : Number.POSITIVE_INFINITY;
+    while (true) {
+        const rootAlive = options.isRootAlive?.() === true;
+        if (!rootAlive && targets.length === 0)
+            return true;
+        const remainingMs = deadline - Date.now();
+        if (finiteTimeout && remainingMs <= 0)
+            return false;
+        let active = rootAlive;
+        if (!active) {
+            const probeTimeoutMs = finiteTimeout
+                ? Math.min(PROCESS_IDENTITY_PROBE_TIMEOUT_MS, remainingMs)
+                : PROCESS_IDENTITY_PROBE_TIMEOUT_MS;
+            const validation = await revalidateProcessIdentities(targets, {
+                identityReader: options.identityReader,
+                timeoutMs: probeTimeoutMs,
+            });
+            active = !validation.complete || validation.identities.length > 0 || (validation.groupChanged?.length ?? 0) > 0;
+        }
+        if (!active)
+            return true;
+        const afterProbeRemainingMs = deadline - Date.now();
+        if (finiteTimeout && afterProbeRemainingMs <= 0)
+            return false;
+        await sleep(Math.min(PROCESS_EXIT_POLL_MS, afterProbeRemainingMs));
+    }
+}
+async function collectVerifiedDescendantIdentities(rootPid) {
+    const initialRows = await collectProcessSnapshotRows();
+    if (initialRows === undefined)
+        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: 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);
+    const stableRows = verificationRows.filter((current) => {
+        const expected = expectedByPid.get(current.pid);
+        return (expected !== undefined &&
+            current.startToken === expected.startToken &&
+            !isQuiescentState(current.state));
+    });
+    return stableRows.map(toProcessIdentity);
+}
+function descendantRowsFromSnapshot(rootPid, rows) {
+    const root = rows.find((row) => row.pid === rootPid);
+    if (root === undefined || isQuiescentState(root.state))
+        return [];
+    const childrenByParent = new Map();
+    for (const row of rows) {
+        if (row.pid <= 0 || row.parentPid <= 0 || row.pid === row.parentPid)
+            continue;
+        const children = childrenByParent.get(row.parentPid);
+        if (children === undefined)
+            childrenByParent.set(row.parentPid, [row]);
+        else
+            children.push(row);
+    }
+    const descendants = [];
+    const seen = new Set([rootPid]);
+    let frontier = [rootPid];
+    for (let depth = 0; depth < MAX_DESCENDANT_DEPTH && frontier.length > 0; depth += 1) {
+        const next = [];
+        for (const parentPid of frontier) {
+            for (const child of childrenByParent.get(parentPid) ?? []) {
+                if (seen.has(child.pid))
+                    continue;
+                seen.add(child.pid);
+                descendants.push(child);
+                if (descendants.length >= MAX_DESCENDANT_PIDS)
+                    return descendants;
+                next.push(child.pid);
+            }
+        }
+        frontier = next;
+    }
+    return descendants;
+}
+async function readCurrentSnapshotRows(expectedRows) {
+    const procPids = [];
+    const psPids = [];
+    for (const row of expectedRows) {
+        if (process.platform === "linux" && row.startToken.startsWith("proc:")) {
+            procPids.push(row.pid);
+        }
+        else {
+            psPids.push(row.pid);
+        }
+    }
+    const [procOutcomes, psRows] = await Promise.all([
+        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 ?? []),
+    ];
+}
+async function collectProcessSnapshotRows() {
+    if (process.platform === "linux") {
+        const procRows = await collectProcessSnapshotRowsFromProc();
+        if (procRows !== undefined)
+            return procRows;
+    }
+    return collectProcessSnapshotRowsFromPs();
+}
+async function collectProcessSnapshotRowsFromProc() {
+    let entries;
+    try {
+        entries = await readdir("/proc");
+    }
+    catch (err) {
+        if (isErrnoException(err, "ENOENT") || isErrnoException(err, "EPERM"))
+            return undefined;
+        return undefined;
+    }
+    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) {
+    const uniquePids = pids === undefined ? undefined : uniqueValidPids(pids);
+    if (uniquePids !== undefined && uniquePids.length === 0)
+        return [];
+    let stdout;
+    try {
+        const result = await execFileAsync("ps", uniquePids === undefined
+            ? ["-axo", "pid=,ppid=,pgid=,state=,lstart="]
+            : ["-o", "pid=,ppid=,pgid=,state=,lstart=", "-p", uniquePids.join(",")], {
+            timeout: uniquePids === undefined
+                ? PROCESS_SNAPSHOT_TIMEOUT_MS
+                : PROCESS_IDENTITY_PROBE_TIMEOUT_MS,
+            maxBuffer: uniquePids === undefined ? 2 * 1024 * 1024 : 256 * 1024,
+        });
+        stdout = result.stdout;
+    }
+    catch {
+        return undefined;
+    }
+    return parsePsSnapshotRows(stdout);
+}
+async function readCurrentIdentityBatch(expected) {
+    if (process.platform !== "linux") {
+        return readProcessIdentityBatchWithPs(expected.map((identity) => identity.pid));
+    }
+    const procPids = [];
+    const psPids = [];
+    for (const identity of expected) {
+        if (identity.startToken.startsWith("proc:"))
+            procPids.push(identity.pid);
+        else
+            psPids.push(identity.pid);
+    }
+    const [procBatch, psBatch] = await Promise.all([
+        readProcessIdentityBatchFromProc(procPids),
+        readProcessIdentityBatchWithPs(psPids),
+    ]);
+    return mergeIdentityBatches(procBatch, psBatch);
+}
+async function readProcessIdentityBatchFromProc(pids) {
+    if (pids.length === 0)
+        return { identities: new Map(), complete: true };
+    const outcomes = await Promise.all(pids.map((pid) => readProcRow(pid)));
+    const identities = new Map();
+    let complete = true;
+    for (const outcome of outcomes) {
+        if (outcome.status === "found") {
+            identities.set(outcome.row.pid, toProcessIdentity(outcome.row));
+        }
+        else if (outcome.status === "error") {
+            complete = false;
+        }
+    }
+    return { identities, complete };
+}
+async function readProcessIdentityBatchWithPs(pids) {
+    const uniquePids = uniqueValidPids(pids);
+    if (uniquePids.length === 0)
+        return { identities: new Map(), complete: true };
+    let stdout;
+    try {
+        const result = await execFileAsync("ps", ["-o", "pid=,pgid=,state=,lstart=", "-p", uniquePids.join(",")], { timeout: PROCESS_IDENTITY_PROBE_TIMEOUT_MS, maxBuffer: 256 * 1024 });
+        stdout = result.stdout;
+    }
+    catch (err) {
+        if (isExitCode(err, 1))
+            return { identities: new Map(), complete: true };
+        return { identities: new Map(), complete: false };
+    }
+    const identities = new Map();
+    for (const line of stdout.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+        if (match === null)
+            continue;
+        const pid = Number.parseInt(match[1], 10);
+        const processGroupId = Number.parseInt(match[2], 10);
+        if (!Number.isInteger(pid) || !Number.isInteger(processGroupId) || processGroupId <= 0) {
+            continue;
+        }
+        identities.set(pid, {
+            pid,
+            processGroupId,
+            state: match[3],
+            startToken: psStartToken(match[4]),
+        });
+    }
+    return { identities, complete: true };
+}
+async function readIdentityBatchWithReader(expected, identityReader) {
+    const outcomes = await Promise.all(expected.map(async (identity) => {
+        try {
+            return { identity: await identityReader(identity.pid), failed: false };
+        }
+        catch {
+            return { identity: undefined, failed: true };
+        }
+    }));
+    const identities = new Map();
+    let complete = true;
+    for (const outcome of outcomes) {
+        if (outcome.failed)
+            complete = false;
+        if (outcome.identity !== undefined)
+            identities.set(outcome.identity.pid, outcome.identity);
+    }
+    return { identities, complete };
+}
+async function readProcRow(pid) {
+    let stat;
+    try {
+        stat = await readFile(`/proc/${pid}/stat`, "utf8");
+    }
+    catch (err) {
+        if (isErrnoException(err, "ENOENT") || isErrnoException(err, "ESRCH")) {
+            return { status: "missing" };
+        }
+        return { status: "error" };
+    }
+    const closeParen = stat.lastIndexOf(")");
+    const openParen = stat.indexOf("(");
+    if (openParen < 1 || closeParen < openParen)
+        return { status: "error" };
+    const parsedPid = Number.parseInt(stat.slice(0, openParen).trim(), 10);
+    const fields = stat.slice(closeParen + 1).trim().split(/\s+/);
+    const state = fields[0];
+    const parentPid = Number.parseInt(fields[1] ?? "", 10);
+    const processGroupId = Number.parseInt(fields[2] ?? "", 10);
+    const startTimeTicks = fields[19];
+    if (parsedPid !== pid ||
+        state === undefined ||
+        startTimeTicks === undefined ||
+        !Number.isInteger(parentPid) ||
+        !Number.isInteger(processGroupId) ||
+        processGroupId <= 0) {
+        return { status: "error" };
+    }
+    return {
+        status: "found",
+        row: {
+            pid,
+            parentPid,
+            processGroupId,
+            startToken: `proc:${startTimeTicks}`,
+            state,
+        },
+    };
+}
+function parsePsSnapshotRows(stdout) {
+    const rows = [];
+    for (const line of stdout.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+        if (match === null)
+            continue;
+        const pid = Number.parseInt(match[1], 10);
+        const parentPid = Number.parseInt(match[2], 10);
+        const processGroupId = Number.parseInt(match[3], 10);
+        if (!Number.isInteger(pid) ||
+            !Number.isInteger(parentPid) ||
+            !Number.isInteger(processGroupId) ||
+            processGroupId <= 0) {
+            continue;
+        }
+        rows.push({
+            pid,
+            parentPid,
+            processGroupId,
+            state: match[4],
+            startToken: psStartToken(match[5]),
+        });
+    }
+    return rows;
+}
+function mergeIdentityBatches(first, second) {
+    return {
+        identities: new Map([...first.identities, ...second.identities]),
+        complete: first.complete && second.complete,
+    };
+}
+function toProcessIdentity(row) {
+    return {
+        pid: row.pid,
+        processGroupId: row.processGroupId,
+        startToken: row.startToken,
+        state: row.state,
+    };
+}
+function dedupeIdentities(identities) {
+    const seen = new Set();
+    const deduped = [];
+    for (const identity of identities) {
+        const key = `${identity.pid}:${identity.startToken}:${identity.processGroupId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(identity);
+    }
+    return deduped;
+}
+function uniqueValidPids(pids) {
+    return [...new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0))];
+}
+function psStartToken(value) {
+    return `ps:${value.replace(/\s+/g, " ").trim()}`;
+}
+function isQuiescentState(state) {
+    const normalized = state.trim().toUpperCase();
+    return normalized.startsWith("Z") || normalized.startsWith("X");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function raceValueWithTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(PROBE_TIMEOUT), Math.max(0, timeoutMs));
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function isErrnoException(err, code) {
+    return typeof err === "object" && err !== null && "code" in err && err.code === code;
+}
+function isExitCode(err, code) {
+    return typeof err === "object" && err !== null && "code" in err && err.code === code;
+}

package/plugins/kimi-dsh/dist/prompt-size.js

@@ -0,0 +1,18 @@
+import { RuntimeError } from "./errors.js";
+// Node/libuv's default CreateProcess argument quoting (UTF-16 code units).
+export function windowsCommandLineLength(command, args) {
+    const quotedLength = (value) => {
+        if (value.length > 0 && !/[\s"]/u.test(value))
+            return value.length;
+        return 2 + value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1').length;
+    };
+    return [command, ...args].reduce((size, value) => size + quotedLength(value) + 1, 0);
+}
+export function assertPromptFitsCommandLine(command, args, platform = process.platform) {
+    if (platform !== "win32")
+        return;
+    const size = windowsCommandLineLength(command, args);
+    if (size <= 32_767)
+        return;
+    throw new RuntimeError("CLI_COMMAND_LINE_TOO_LONG", "The Kimi prompt exceeds the Windows command-line limit; the CLI was not started. Narrow the review or split it into smaller scopes. A short ask prompt can reference a saved diff inside the workspace. Reinstalling Kimi or running setup will not fix this. The current print transport does not support stdin prompts.", "cli-client.pre-spawn", { details: { command_line_utf16_units: size, limit_utf16_units: 32_767, platform } });
+}