kimi-plugin-cc 2.0.7

package/dist/jobs.js

@@ -0,0 +1,202 @@
+import { createHash } from "node:crypto";
+import { RuntimeError } from "./errors.js";
+import { renderTerminalJobArtifact, writeArtifact } from "./render.js";
+export function digestPrompt(prompt) {
+    return createHash("sha256").update(prompt).digest("hex");
+}
+export function normalizeJobError(error) {
+    if (error instanceof RuntimeError) {
+        const normalized = {
+            code: error.code,
+            message: error.message,
+            stage: error.stage,
+        };
+        if (Object.keys(error.details).length > 0) {
+            normalized.details = error.details;
+        }
+        return normalized;
+    }
+    if (error instanceof Error) {
+        return {
+            code: "UNEXPECTED_ERROR",
+            message: error.message,
+            stage: "runtime",
+        };
+    }
+    return {
+        code: "UNEXPECTED_ERROR",
+        message: String(error),
+        stage: "runtime",
+    };
+}
+export async function markJobFailed(store, paths, job, error, summary = "Job failed.", options) {
+    const normalized = normalizeJobError(error);
+    const phase = options?.phase;
+    const artifactJob = {
+        ...job,
+        status: "failed",
+        summary,
+        error: normalized,
+        final_output_path: null,
+        pid: null,
+        kimi_pid: null,
+        ...(phase !== undefined ? { phase } : {}),
+    };
+    const artifactPath = await writeArtifact(paths, artifactJob, renderTerminalJobArtifact(artifactJob));
+    return (store.markFailed(job.job_id, {
+        summary,
+        error: normalized,
+        final_output_path: artifactPath,
+        ...(phase !== undefined ? { phase } : {}),
+    }) ?? artifactJob);
+}
+export async function markJobCancelled(store, paths, job, summary, error, options) {
+    const normalized = error ? normalizeJobError(error) : null;
+    const phase = options?.phase;
+    const artifactJob = {
+        ...job,
+        status: "cancelled",
+        summary,
+        error: normalized,
+        final_output_path: null,
+        pid: null,
+        kimi_pid: null,
+        ...(phase !== undefined ? { phase } : {}),
+    };
+    const artifactPath = await writeArtifact(paths, artifactJob, renderTerminalJobArtifact(artifactJob));
+    return (store.markCancelled(job.job_id, {
+        summary,
+        error: normalized,
+        final_output_path: artifactPath,
+        ...(phase !== undefined ? { phase } : {}),
+    }) ?? artifactJob);
+}
+export async function sweepStaleJobs(store, paths) {
+    for (const job of store.listRunningJobsWithProcessHints()) {
+        if (!isStaleEnoughToSweep(job)) {
+            continue;
+        }
+        const companionMissing = job.pid !== null && !isPidAlive(job.pid);
+        const kimiMissing = job.kimi_pid !== null && !isPidAlive(job.kimi_pid);
+        if (job.background) {
+            if (!companionMissing && !kimiMissing) {
+                continue;
+            }
+            terminateRecordedProcesses(job);
+            await markJobFailed(store, paths, job, new RuntimeError(companionMissing ? "WORKER_DISAPPEARED" : "KIMI_PROCESS_DISAPPEARED", companionMissing
+                ? `Background worker pid ${job.pid} is no longer running.`
+                : `Kimi pid ${job.kimi_pid} is no longer running while background worker pid ${job.pid} is still recorded.`, "jobs.sweep"), companionMissing
+                ? "Background worker disappeared before reporting a terminal state."
+                : "Kimi process disappeared before reporting a terminal state.", job.command_type === "ask" || job.command_type === "rescue" ? { phase: "failed" } : undefined);
+            continue;
+        }
+        if (!companionMissing && !kimiMissing) {
+            continue;
+        }
+        // Sweep-vs-live-companion race fix: if the foreground companion pid is
+        // still alive, the companion process is microseconds-to-seconds away
+        // from writing its own terminal state. SIGTERMing it here would kill
+        // its render path mid-flight (and from a sibling shell's read-only
+        // /kimi:status, no less). Skip — let the companion finish on its own.
+        if (!companionMissing && job.pid !== null) {
+            continue;
+        }
+        terminateRecordedProcesses(job);
+        await markJobFailed(store, paths, job, new RuntimeError("FOREGROUND_PROCESS_DISAPPEARED", describeMissingForegroundProcess(job, companionMissing, kimiMissing), "jobs.sweep"), "Foreground Kimi job disappeared before reporting a terminal state.", job.command_type === "ask" || job.command_type === "rescue" ? { phase: "failed" } : undefined);
+    }
+}
+const STALE_SWEEP_GRACE_MS = 15_000;
+function isStaleEnoughToSweep(job) {
+    const updatedAt = Date.parse(job.updated_at);
+    return Number.isFinite(updatedAt) && Date.now() - updatedAt >= STALE_SWEEP_GRACE_MS;
+}
+function describeMissingForegroundProcess(job, companionMissing, kimiMissing) {
+    if (companionMissing && kimiMissing) {
+        return `Foreground companion pid ${job.pid} and Kimi pid ${job.kimi_pid} are no longer running.`;
+    }
+    if (companionMissing) {
+        return `Foreground companion pid ${job.pid} is no longer running.`;
+    }
+    return `Kimi pid ${job.kimi_pid} is no longer running.`;
+}
+function terminateRecordedProcesses(job) {
+    const pids = new Set();
+    if (job.pid !== null)
+        pids.add(job.pid);
+    if (job.kimi_pid !== null)
+        pids.add(job.kimi_pid);
+    for (const pid of pids) {
+        if (!isPidAlive(pid)) {
+            continue;
+        }
+        killPid(pid, "SIGTERM");
+        // SIGKILL escalation: if the process ignores SIGTERM (stuck Kimi child,
+        // uninterruptible sleep, signal mask), force-kill after 2s. The job is
+        // already determined stale at this point, so leaving a survivor running
+        // would just orphan resources. Timer is unref'd so it doesn't keep the
+        // process alive.
+        const timer = setTimeout(() => {
+            if (isPidAlive(pid)) {
+                killPid(pid, "SIGKILL");
+            }
+        }, 2_000);
+        timer.unref();
+    }
+}
+function killPid(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        const code = error.code;
+        // ESRCH: process already gone. EPERM: pid was likely reused by an
+        // unrelated process we don't own — silently skip.
+        if (code !== "ESRCH" && code !== "EPERM") {
+            throw error;
+        }
+    }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        // ESRCH: no such process — definitively dead.
+        // EPERM: process exists but we can't signal it. We treat this as "dead
+        // for our purposes" because it most likely means the pid was reused by
+        // an unrelated higher-privilege process. The companion stores its own
+        // pid in v0.2.2+; under normal usage we should always have permission
+        // to signal our own descendants. Returning true here lets stale jobs
+        // hide forever (the sweeper relies on isPidAlive=false to flip them to
+        // failed). signalJobProcesses and killPid already swallow EPERM
+        // consistently — this brings the read path in line with the write path.
+        if (code === "ESRCH" || code === "EPERM") {
+            return false;
+        }
+        return true;
+    }
+}
+export async function waitForTerminalJob(storeFactory, jobId, timeoutMs = 60_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const store = storeFactory();
+        try {
+            const job = store.getJob(jobId);
+            if (job && job.status !== "running") {
+                return job;
+            }
+        }
+        finally {
+            store.close();
+        }
+        await sleep(200);
+    }
+    throw new RuntimeError("JOB_WAIT_TIMEOUT", `Timed out after ${timeoutMs}ms while waiting for job ${jobId} to finish. The worker may still be running; use /kimi:status ${jobId} to check progress or /kimi:result ${jobId} once it completes.`, "jobs.wait");
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/kimi-command.js

@@ -0,0 +1,72 @@
+import { RuntimeError } from "./errors.js";
+export function resolveKimiCliCommand(env) {
+    const command = env.KIMI_PLUGIN_CC_KIMI_BIN || "kimi";
+    const raw = env.KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS;
+    if (!raw) {
+        return { command, prefixArgs: [] };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        // Plain-text fallback. Mirrors v0.4's permissive shape so users with
+        // an existing `KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS="--import tsx ..."`
+        // export don't have to migrate to JSON for v1.0.
+        const plainArgs = raw.split(" ").filter(Boolean);
+        assertPrefixArgsSafe(plainArgs, raw);
+        return { command, prefixArgs: plainArgs };
+    }
+    if (!Array.isArray(parsed)) {
+        throw new RuntimeError("INVALID_ENV", "KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS must be a JSON array of strings.", "kimi-command.env", { details: { env_var: "KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS", value: raw, retryable_after_setup: false } });
+    }
+    for (const entry of parsed) {
+        if (typeof entry !== "string") {
+            throw new RuntimeError("INVALID_ENV", "KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS entries must be strings.", "kimi-command.env", { details: { env_var: "KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS", value: raw, retryable_after_setup: false } });
+        }
+    }
+    const prefixArgs = parsed;
+    assertPrefixArgsSafe(prefixArgs, raw);
+    return { command, prefixArgs };
+}
+/**
+ * Flags the plugin owns on the `kimi -p` argv. The prefix is only a launcher
+ * shim (e.g. `["run", "<companion-dist>"]`); it must never carry a kimi flag
+ * that changes the session, engine, plan, prompt, or output format. In
+ * particular a smuggled `-r <session>` would resume a session the plugin never
+ * scanned for plan-mode taint (the journal scan keys only on the plugin-chosen
+ * resumeSessionId), so it is refused here — the single resolution point reached
+ * by both foreground and detached-worker spawns.
+ */
+const RESERVED_PREFIX_FLAGS = new Set([
+    // Session selection — incl. the HIDDEN `-C` alias of `--continue`
+    // (apps/kimi-code/src/cli/commands.ts), which resumes the latest session for
+    // the cwd without any plugin-chosen resumeSessionId, so no journal scan runs.
+    "-r", "--resume", "-S", "--session", "-c", "-C", "--continue",
+    // Prompt / output.
+    "-p", "--prompt", "--output-format",
+    // Permission / plan mode.
+    "--plan", "--auto", "-y", "--yolo", "--yes", "--auto-approve", "--manual",
+    // Model / profile / roots.
+    "-m", "--model", "--skills-dir", "--agent", "--agent-file", "--add-dir",
+    // Terminal informational flags (would replace the run with a banner).
+    "-V", "--version", "-h", "--help",
+]);
+export function assertPrefixArgsSafe(prefixArgs, raw) {
+    for (const token of prefixArgs) {
+        // Compare the flag name only, so `--session=x` is caught as well as `-S x`.
+        const flag = token.startsWith("-") ? token.split("=", 1)[0] : token;
+        if (RESERVED_PREFIX_FLAGS.has(flag)) {
+            throw new RuntimeError("INVALID_ENV", `KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS must not contain the reserved kimi flag "${flag}". ` +
+                "The prefix is a launcher shim only; session, engine, plan, prompt, model, and " +
+                "output-format flags are owned by the plugin and would bypass its safety checks.", "kimi-command.env", {
+                details: {
+                    env_var: "KIMI_PLUGIN_CC_KIMI_PREFIX_ARGS",
+                    reserved_flag: flag,
+                    value: raw,
+                    retryable_after_setup: false,
+                },
+            });
+        }
+    }
+}