kimi-plugin-cc 2.3.1 → 2.4.1

package/dist/mcp/job-control.js

@@ -0,0 +1,345 @@
+import { formatError, RuntimeError } from "../errors.js";
+import { markJobFailed, STALE_SWEEP_GRACE_MS } from "../jobs.js";
+import { JobStore, parseHookEscapes, renderBudgetSource, } from "../job-store.js";
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { readProcessIdentity, revalidateProcessIdentities, revalidateProcessIdentity, } from "../process-tree.js";
+import { readArtifact, renderTerminalJobArtifact } from "../render.js";
+import { runCancel } from "../commands/cancel.js";
+import { assertMcpJobBinding, mcpCompanionIdentity, mcpKimiIdentity } from "./binding.js";
+import { readJobControlArguments } from "./operations.js";
+import { textResult } from "./tool-result.js";
+import { resolveMcpWorkspace } from "./workspace.js";
+export async function getMcpJobStatus(env, input) {
+    const { task, job } = await loadMcpJob(env, input);
+    const metadata = mcpJobMetadata(task, job);
+    return textResult(`${JSON.stringify(metadata, null, 2)}\n`, metadata);
+}
+export async function getMcpJobResult(env, input) {
+    const { task, job } = await loadMcpJob(env, input);
+    if (!job) {
+        if (task.launch_error)
+            return launchFailureResult(task);
+        throw new RuntimeError("JOB_NOT_TERMINAL", `MCP job ${task.task_id} is still starting.`, "mcp.result");
+    }
+    if (job.status === "running") {
+        throw new RuntimeError("JOB_NOT_TERMINAL", `Job ${job.job_id} is still running.`, "mcp.result");
+    }
+    return terminalJobResult(task, job);
+}
+export async function cancelMcpJob(env, input) {
+    const { task, job } = await loadMcpJob(env, input);
+    if (!job) {
+        if (task.launch_error)
+            return launchFailureResult(task);
+        throw new RuntimeError("JOB_NOT_TERMINAL", `MCP job ${task.task_id} has not attached to a companion job.`, "mcp.cancel");
+    }
+    if (job.status !== "running") {
+        const metadata = mcpJobMetadata(task, job);
+        return textResult(`${JSON.stringify({ ...metadata, message: "cancel is a no-op for terminal jobs." }, null, 2)}\n`, metadata);
+    }
+    const output = await runCancel([task.task_id], {
+        cwd: task.workspace_cwd,
+        env,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        mcpCompanionIdentity: mcpCompanionIdentity(task),
+        mcpKimiIdentity: mcpKimiIdentity(task, job),
+    });
+    const current = await loadMcpJob(env, input);
+    const metadata = mcpJobMetadata(current.task, current.job);
+    return textResult(output, { ...metadata, cancellation: JSON.parse(output) });
+}
+export async function getMcpTaskView(env, input) {
+    let boundTask;
+    try {
+        const { task, job } = await loadMcpJob(env, input, (found) => { boundTask = found; });
+        if (!job) {
+            if (task.launch_error) {
+                return taskView(task, null, "completed", launchFailureResult(task), task.launch_error);
+            }
+            return taskView(task, null, "working", undefined, "Starting the supervised companion.");
+        }
+        switch (job.status) {
+            case "running":
+                return taskView(task, job, "working", undefined, `${task.operation_kind}: ${job.phase ?? "running"}`);
+            case "completed":
+                return taskView(task, job, "completed", await terminalJobResult(task, job), job.summary);
+            case "failed":
+                return taskView(task, job, "completed", await terminalJobResult(task, job), job.summary);
+            case "cancelled":
+                return taskView(task, job, "cancelled", undefined, job.summary);
+        }
+    }
+    catch (error) {
+        if (boundTask && error instanceof RuntimeError && error.code === "MCP_PROCESS_IDENTITY_UNAVAILABLE") {
+            return taskView(boundTask, null, "working", undefined, formatError(error));
+        }
+        if (boundTask && error instanceof RuntimeError && error.code !== "JOB_NOT_FOUND") {
+            return {
+                taskId: boundTask.task_id,
+                status: "failed",
+                createdAt: boundTask.created_at,
+                lastUpdatedAt: new Date().toISOString(),
+                ttlMs: null,
+                pollIntervalMs: 2_000,
+                error: {
+                    code: -32_603,
+                    message: formatError(error),
+                    data: { job_id: boundTask.task_id, operation_kind: boundTask.operation_kind },
+                },
+            };
+        }
+        throw error;
+    }
+}
+async function loadMcpJob(env, input, observeTask) {
+    const args = readJobControlArguments(input);
+    const paths = resolvePluginPaths(env);
+    await ensurePluginPaths(paths);
+    const store = new JobStore(paths);
+    try {
+        let task = store.getMcpTask(args.jobId);
+        if (!task) {
+            throw new RuntimeError("JOB_NOT_FOUND", `MCP job ${args.jobId} was not found.`, "mcp.lookup");
+        }
+        const workspace = await resolveMcpWorkspace(env, args.workspace ?? task.workspace_cwd);
+        if (task.workspace_cwd !== workspace.cwd || task.repo_id !== workspace.repo.repoId) {
+            throw new RuntimeError("JOB_NOT_FOUND", `MCP job ${args.jobId} was not found in this workspace.`, "mcp.lookup");
+        }
+        observeTask?.(task);
+        let job = store.getJob(task.task_id);
+        if (!job) {
+            task = await reconcileUnattachedTask(store, task);
+            return { task, job: null };
+        }
+        await assertMcpJobBinding(task, job);
+        if (task.launch_state === "starting") {
+            let identity;
+            if (job.status === "running") {
+                const expected = mcpCompanionIdentity(task);
+                if (expected) {
+                    const validation = await revalidateProcessIdentities([expected]);
+                    if (!validation.complete) {
+                        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The companion identity probe was inconclusive; the starting task was not attached or changed.", "mcp.reconcile");
+                    }
+                    if (validation.identities.length === 0) {
+                        const taskUpdatedAt = Date.parse(task.updated_at);
+                        const jobUpdatedAt = Date.parse(job.updated_at);
+                        const stale = Number.isFinite(taskUpdatedAt) && Number.isFinite(jobUpdatedAt) &&
+                            Date.now() - taskUpdatedAt >= STALE_SWEEP_GRACE_MS &&
+                            Date.now() - jobUpdatedAt >= STALE_SWEEP_GRACE_MS;
+                        if (!stale) {
+                            throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", "The recorded companion process identity no longer matches; the starting task was not attached and no process was adopted.", "mcp.reconcile");
+                        }
+                        task = await reconcileStaleCompanion(store, paths, task, job);
+                        job = store.getJob(task.task_id);
+                        return { task, job };
+                    }
+                    identity = validation.identities[0];
+                }
+                else if (job.pid !== null) {
+                    const updatedAt = Date.parse(task.updated_at);
+                    if (!Number.isFinite(updatedAt) || Date.now() - updatedAt >= STALE_SWEEP_GRACE_MS) {
+                        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The starting task has no reusable identity after the attach grace period; refusing to adopt a process by PID alone.", "mcp.reconcile");
+                    }
+                    identity = await readProcessIdentity(job.pid);
+                }
+            }
+            if (job.status !== "running" || identity) {
+                task = store.updateMcpTask(task.task_id, {
+                    launch_state: "attached",
+                    attached_at: new Date().toISOString(),
+                    companion_pid: job.pid ?? task.companion_pid,
+                    ...(identity ? { companion_identity: JSON.stringify(identity) } : {}),
+                });
+            }
+        }
+        else if (task.launch_error) {
+            throw new RuntimeError("MCP_JOB_BINDING_FAILED", task.launch_error, "mcp.binding");
+        }
+        if (job.status === "running") {
+            task = await refreshCompanionIdentity(store, task, job);
+            task = await captureKimiIdentity(store, task, job);
+            task = await reconcileStaleCompanion(store, paths, task, job);
+            job = store.getJob(task.task_id);
+        }
+        return { task, job };
+    }
+    finally {
+        store.close();
+    }
+}
+async function reconcileUnattachedTask(store, task) {
+    if (task.launch_state !== "starting")
+        return task;
+    const updatedAt = Date.parse(task.updated_at);
+    const fresh = Number.isFinite(updatedAt) && Date.now() - updatedAt < STALE_SWEEP_GRACE_MS;
+    if (task.companion_identity === null) {
+        if (fresh) {
+            if (task.companion_pid === null)
+                return task;
+            const current = await readProcessIdentity(task.companion_pid);
+            return current
+                ? store.updateMcpTask(task.task_id, { companion_identity: JSON.stringify(current) })
+                : task;
+        }
+        if (task.companion_pid !== null) {
+            throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The unattached companion has no reusable identity; refusing to adopt a process by PID alone.", "mcp.reconcile");
+        }
+        return store.updateMcpTask(task.task_id, {
+            launch_state: "exited",
+            launch_error: `No companion process was recorded before creating job ${task.task_id}.`,
+        });
+    }
+    if (fresh)
+        return task;
+    const validation = await revalidateProcessIdentities([mcpCompanionIdentity(task)]);
+    if (!validation.complete) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The unattached companion identity probe was inconclusive; the task was not changed.", "mcp.reconcile");
+    }
+    if (validation.identities.length > 0)
+        return task;
+    return store.updateMcpTask(task.task_id, {
+        launch_state: "exited",
+        launch_error: `Companion pid ${task.companion_pid} disappeared before creating job ${task.task_id}.`,
+    });
+}
+async function refreshCompanionIdentity(store, task, job) {
+    if (task.companion_identity !== null || job.pid === null)
+        return task;
+    const updatedAt = Date.parse(task.updated_at);
+    if (!Number.isFinite(updatedAt) || Date.now() - updatedAt >= STALE_SWEEP_GRACE_MS) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The companion identity is missing after the attach grace period; refusing to adopt a process by PID alone.", "mcp.reconcile");
+    }
+    const identity = await readProcessIdentity(job.pid);
+    if (!identity)
+        return task;
+    return store.updateMcpTask(task.task_id, {
+        companion_pid: job.pid,
+        companion_identity: JSON.stringify(identity),
+    });
+}
+async function captureKimiIdentity(store, task, job) {
+    if (task.kimi_identity !== null)
+        return task;
+    const companion = mcpCompanionIdentity(task);
+    if (!companion || !(await revalidateProcessIdentity(companion)))
+        return task;
+    const identity = job.kimi_pid !== null
+        ? await readProcessIdentity(job.kimi_pid)
+        : undefined;
+    if (!identity)
+        return task;
+    return store.updateMcpTask(task.task_id, { kimi_identity: JSON.stringify(identity) });
+}
+async function reconcileStaleCompanion(store, paths, task, job) {
+    const updatedAt = Date.parse(job.updated_at);
+    if (!Number.isFinite(updatedAt) || Date.now() - updatedAt < STALE_SWEEP_GRACE_MS)
+        return task;
+    const companion = mcpCompanionIdentity(task);
+    if (!companion) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The stale companion has no reusable process identity; refusing PID-only reconciliation.", "mcp.reconcile");
+    }
+    const validation = await revalidateProcessIdentities([companion]);
+    if (!validation.complete) {
+        throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The companion process identity probe was inconclusive; no process was signalled and the job was not changed.", "mcp.reconcile");
+    }
+    if (validation.identities.length > 0)
+        return task;
+    const orphanWarning = await terminateRecordedKimi(task, job);
+    await markJobFailed(store, paths, job, new RuntimeError("MCP_COMPANION_DISAPPEARED", `The supervised companion disappeared before settling the job.${orphanWarning ? ` ${orphanWarning}` : ""}`, "mcp.reconcile", orphanWarning ? { details: { orphan_warning: orphanWarning, kimi_pid: job.kimi_pid } } : undefined), "Supervised MCP companion disappeared before reporting a terminal state.", { phase: "failed" });
+    return store.getMcpTask(task.task_id);
+}
+async function terminateRecordedKimi(task, job) {
+    const identity = mcpKimiIdentity(task, job);
+    if (!identity) {
+        return job.kimi_pid === null
+            ? null
+            : `Kimi pid ${job.kimi_pid} was not signalled because no verified identity had been captured.`;
+    }
+    if (!(await revalidateProcessIdentity(identity)))
+        return null;
+    signalVerifiedIdentity(identity, "SIGTERM");
+    await sleep(1_500);
+    if (await revalidateProcessIdentity(identity))
+        signalVerifiedIdentity(identity, "SIGKILL");
+    return null;
+}
+function signalVerifiedIdentity(identity, signal) {
+    try {
+        process.kill(identity.processGroupId === identity.pid ? -identity.processGroupId : identity.pid, signal);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ESRCH" && code !== "EPERM")
+            throw error;
+    }
+}
+async function terminalJobResult(task, job) {
+    const metadata = mcpJobMetadata(task, job);
+    const body = job.final_output_path
+        ? await readArtifact(job.final_output_path)
+        : `${renderTerminalJobArtifact(job)}\n`;
+    return textResult(body, {
+        ...metadata,
+        artifact_path: job.final_output_path,
+        partial_output: job.status === "failed" && Number(job.error?.details?.partial_output_chars ?? 0) > 0,
+    }, job.status !== "completed");
+}
+function launchFailureResult(task) {
+    const message = task.launch_error ?? "The companion failed before creating its job.";
+    return textResult(message, {
+        job_id: task.task_id,
+        operation_kind: task.operation_kind,
+        launch_state: task.launch_state,
+        error: { code: "MCP_CHILD_LAUNCH_FAILED", message },
+    }, true);
+}
+function mcpJobMetadata(task, job) {
+    if (!job) {
+        return {
+            job_id: task.task_id,
+            operation_kind: task.operation_kind,
+            workspace: task.workspace_cwd,
+            status: task.launch_error ? "failed" : "starting",
+            launch_state: task.launch_state,
+            created_at: task.created_at,
+            updated_at: task.updated_at,
+            error: task.launch_error,
+        };
+    }
+    return {
+        job_id: job.job_id,
+        operation_kind: job.operation_kind,
+        command_type: job.command_type,
+        workspace: task.workspace_cwd,
+        status: job.status,
+        phase: job.phase,
+        summary: job.summary,
+        created_at: job.created_at,
+        updated_at: job.updated_at,
+        budget_ms: job.budget_ms,
+        budget_source: renderBudgetSource(job),
+        model: job.model,
+        thinking_effort_requested: job.thinking_effort ?? null,
+        kimi_session_id: job.kimi_session_id,
+        kimi_session_id_source: job.kimi_session_id_source,
+        hook_escapes: parseHookEscapes(job.hook_escapes),
+        error: job.error,
+    };
+}
+function taskView(task, job, status, result, statusMessage) {
+    return {
+        taskId: task.task_id,
+        status,
+        ...(statusMessage ? { statusMessage } : {}),
+        createdAt: task.created_at,
+        lastUpdatedAt: job?.updated_at ?? task.updated_at,
+        ttlMs: null,
+        pollIntervalMs: 2_000,
+        ...(result ? { result: { resultType: "complete", ...result } } : {}),
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/mcp/launcher.js

@@ -0,0 +1,257 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { access, open, stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimeError } from "../errors.js";
+import { preferStableNodePath } from "../hooks/install-paths.js";
+import { JobStore } from "../job-store.js";
+import { markJobFailed } from "../jobs.js";
+import { resolveKimiHome } from "../kimi-home.js";
+import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
+import { readProcessIdentity, revalidateProcessIdentities, } from "../process-tree.js";
+import { assertMcpJobBinding, mcpCompanionIdentity } from "./binding.js";
+import { resolveMcpWorkspace } from "./workspace.js";
+const compiled = import.meta.url.endsWith(".js");
+const companionEntrypoint = fileURLToPath(new URL(compiled ? "../companion.js" : "../companion.ts", import.meta.url));
+const companionProjectRoot = path.resolve(path.dirname(companionEntrypoint), "..");
+export async function launchMcpOperation(invocation, env, options) {
+    const attachTimeoutMs = options?.attachTimeoutMs ?? 60_000;
+    const readIdentity = options?.identityReader ?? readProcessIdentity;
+    let preserveStartingTask = false;
+    const attachDeadline = Date.now() + attachTimeoutMs;
+    const paths = resolvePluginPaths(env);
+    await ensurePluginPaths(paths);
+    const workspace = await resolveMcpWorkspace(env, invocation.workspace);
+    const taskId = randomUUID();
+    const stdoutPath = path.join(paths.logsDir, `mcp-${taskId}.stdout.log`);
+    const stderrPath = path.join(paths.logsDir, `mcp-${taskId}.stderr.log`);
+    const store = new JobStore(paths);
+    let child;
+    let stdoutHandle;
+    let stderrHandle;
+    let exited;
+    let spawnError;
+    try {
+        const task = store.createMcpTask({
+            task_id: taskId,
+            operation_kind: invocation.operationKind,
+            repo_id: workspace.repo.repoId,
+            workspace_cwd: workspace.cwd,
+            stdout_path: stdoutPath,
+            stderr_path: stderrPath,
+        });
+        stdoutHandle = await open(stdoutPath, "wx", 0o600);
+        stderrHandle = await open(stderrPath, "wx", 0o600);
+        const nodeBinary = await resolveNodeBinary(env);
+        const args = compiled
+            ? [companionEntrypoint, "mcp-child", taskId, ...invocation.argv]
+            : ["--import", "tsx", companionEntrypoint, "mcp-child", taskId, ...invocation.argv];
+        const childEnv = sanitizedChildEnv(env, paths, workspace.cwd);
+        child = spawn(nodeBinary, args, {
+            cwd: companionProjectRoot,
+            detached: process.platform !== "win32",
+            stdio: ["ignore", stdoutHandle.fd, stderrHandle.fd],
+            env: childEnv,
+        });
+        child.once("error", (error) => { spawnError = error; });
+        child.once("close", (code, signal) => { exited = { code, signal }; });
+        if (child.pid !== undefined) {
+            const identity = await readIdentity(child.pid);
+            store.updateMcpTask(taskId, {
+                companion_pid: child.pid,
+                ...(identity ? { companion_identity: JSON.stringify(identity) } : {}),
+            });
+        }
+        await stdoutHandle.close();
+        await stderrHandle.close();
+        stdoutHandle = undefined;
+        stderrHandle = undefined;
+        for (;;) {
+            if (spawnError)
+                throw await markLaunchFailure(store, task, spawnError);
+            const job = store.getJob(taskId);
+            if (job && (job.status !== "running" || job.phase === "turn-running" || job.phase === "worker-running")) {
+                const currentTask = store.getMcpTask(taskId) ?? task;
+                await assertMcpJobBinding(currentTask, job);
+                let identity;
+                if (job.status === "running") {
+                    const expected = mcpCompanionIdentity(currentTask);
+                    if (expected) {
+                        const validation = await revalidateProcessIdentities([expected], {
+                            identityReader: options?.identityReader,
+                        });
+                        if (!validation.complete) {
+                            preserveStartingTask = true;
+                            throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The attachment identity probe was inconclusive; the launch record was preserved.", "mcp.launch", { details: { job_id: taskId, operation_kind: invocation.operationKind } });
+                        }
+                        if (validation.identities.length === 0) {
+                            preserveStartingTask = true;
+                            throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", "The recorded companion process identity changed before attachment; no process was adopted and the launch record was preserved.", "mcp.launch", { details: { job_id: taskId, operation_kind: invocation.operationKind } });
+                        }
+                        identity = validation.identities[0];
+                    }
+                    else if (child.pid !== undefined) {
+                        identity = await readIdentity(child.pid);
+                    }
+                }
+                const attached = store.updateMcpTask(taskId, {
+                    launch_state: "attached",
+                    attached_at: new Date().toISOString(),
+                    ...(identity ? { companion_identity: JSON.stringify(identity) } : {}),
+                });
+                child.unref();
+                return { task: attached, job };
+            }
+            if (exited) {
+                const diagnostic = await readTail(stderrPath);
+                const error = new RuntimeError("MCP_CHILD_LAUNCH_FAILED", `The companion exited before creating its job (code ${exited.code ?? "unknown"}${exited.signal ? `, signal ${exited.signal}` : ""}).${diagnostic ? `\n${diagnostic}` : ""}`, "mcp.launch", { details: { job_id: taskId, operation_kind: invocation.operationKind, exit_code: exited.code, signal: exited.signal } });
+                throw await markLaunchFailure(store, task, error, diagnostic);
+            }
+            if (Date.now() >= attachDeadline) {
+                const aborted = await abortMcpLaunch(store, paths, task, job, attachTimeoutMs, options?.identityReader);
+                if ("result" in aborted) {
+                    child.unref();
+                    return aborted.result;
+                }
+                preserveStartingTask = aborted.preserveStarting;
+                throw aborted.error;
+            }
+            await sleep(25);
+        }
+    }
+    catch (error) {
+        if (!preserveStartingTask && store.getMcpTask(taskId)?.launch_state === "starting") {
+            store.updateMcpTask(taskId, {
+                launch_state: "exited",
+                launch_error: (error instanceof Error ? error.message : String(error)).slice(-8_000),
+            });
+        }
+        child?.unref();
+        throw error;
+    }
+    finally {
+        store.close();
+        await stdoutHandle?.close().catch(() => undefined);
+        await stderrHandle?.close().catch(() => undefined);
+    }
+}
+async function abortMcpLaunch(store, paths, task, job, timeoutMs, identityReader) {
+    let signalDelivered = false;
+    let preserveStarting = true;
+    try {
+        const current = store.getMcpTask(task.task_id) ?? task;
+        const identity = mcpCompanionIdentity(current);
+        if (identity) {
+            const validation = await revalidateProcessIdentities([identity], { identityReader });
+            if (!validation.complete) {
+                throw new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The companion identity probe was inconclusive; no signal was sent and the launch record was preserved.", "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind } });
+            }
+            if (validation.identities.length === 0) {
+                throw new RuntimeError("MCP_PROCESS_IDENTITY_MISMATCH", "The recorded companion process identity no longer matches; no signal was sent and the launch record was preserved.", "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind } });
+            }
+            signalVerifiedIdentity(identity, "SIGTERM");
+            signalDelivered = true;
+            await sleep(1_500);
+            const remaining = await revalidateProcessIdentities([identity], { identityReader });
+            if (!remaining.complete) {
+                const error = new RuntimeError("MCP_PROCESS_IDENTITY_UNAVAILABLE", "The post-signal companion identity probe was inconclusive; the launch record was preserved.", "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind } });
+                if (job) {
+                    await assertMcpJobBinding(current, job);
+                    return { result: { task: current, job } };
+                }
+                return { error, preserveStarting };
+            }
+            if (remaining.identities.length > 0) {
+                signalVerifiedIdentity(identity, "SIGKILL");
+            }
+            preserveStarting = false;
+        }
+        const error = new RuntimeError("MCP_LAUNCH_TIMEOUT", `The companion did not become cancellation-ready within ${timeoutMs}ms.${signalDelivered ? " The companion was signalled." : " No verified process identity was available, so no signal was sent."}`, "mcp.launch", { details: { job_id: task.task_id, operation_kind: task.operation_kind, timeout_ms: timeoutMs, signal_delivered: signalDelivered } });
+        if (signalDelivered) {
+            if (job) {
+                await markJobFailed(store, paths, job, error, "MCP launch timed out before cancellation was ready.", { phase: "failed" });
+            }
+            return { error: await markLaunchFailure(store, current, error), preserveStarting };
+        }
+        if (job) {
+            await assertMcpJobBinding(current, job);
+            return { result: { task: current, job } };
+        }
+        return { error, preserveStarting };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error : new Error(String(error)), preserveStarting };
+    }
+}
+function signalVerifiedIdentity(identity, signal) {
+    try {
+        process.kill(identity.processGroupId === identity.pid ? -identity.processGroupId : identity.pid, signal);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ESRCH")
+            throw error;
+    }
+}
+async function resolveNodeBinary(env) {
+    const override = env.KIMI_PLUGIN_CC_NODE_BIN;
+    const binary = override ? override : preferStableNodePath(process.execPath);
+    if (binary.includes("/") || binary.includes("\\")) {
+        try {
+            await access(binary, fsConstants.X_OK);
+        }
+        catch (error) {
+            throw new RuntimeError("MCP_NODE_BIN_INVALID", `Configured Node binary is not executable: ${binary}`, "mcp.launch", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    return binary;
+}
+function sanitizedChildEnv(env, paths, workspace) {
+    return {
+        ...env,
+        KIMI_PLUGIN_CC_WORKSPACE_CWD: workspace,
+        KIMI_PLUGIN_CC_MCP_WORKSPACE: workspace,
+        KIMI_PLUGIN_CC_DATA: path.resolve(paths.claudePluginData),
+        KIMI_CODE_HOME: resolveKimiHome(env, workspace),
+        KIMI_PLUGIN_CC_WORKSPACE_ROOT: undefined,
+        KIMI_PLUGIN_CC_CMD: undefined,
+        KIMI_PLUGIN_CC_OPERATION: undefined,
+        KIMI_PLUGIN_CC_SKIP_HOOK_CHECK: undefined,
+        KIMI_PLUGIN_CC_SKIP_VERSION_PROBE: undefined,
+        KIMI_CODE_TRUST_WORKSPACE: undefined,
+        KIMI_CODE_EXPERIMENTAL_FLAG: undefined,
+    };
+}
+async function markLaunchFailure(store, task, error, diagnostic) {
+    const failure = error instanceof Error ? error : new Error(String(error));
+    store.updateMcpTask(task.task_id, {
+        launch_state: "exited",
+        launch_error: (diagnostic || failure.message).slice(-8_000),
+    });
+    return failure;
+}
+async function readTail(filePath, maximum = 8_000) {
+    try {
+        const info = await stat(filePath);
+        const handle = await open(filePath, "r");
+        try {
+            const length = Math.min(maximum, info.size);
+            const buffer = Buffer.alloc(length);
+            await handle.read(buffer, 0, length, Math.max(0, info.size - length));
+            return buffer.toString("utf8").trim();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}