kimi-plugin-cc 2.4.4 → 2.5.1

package/plugins/kimi-dsh/dist/schemas/review-gate-output.js

@@ -0,0 +1,43 @@
+import { RuntimeError } from "../errors.js";
+const ALLOWED_DECISIONS = new Set(["ALLOW", "BLOCK"]);
+const ALLOWED_SEVERITIES = new Set(["low", "medium", "high"]);
+const ALLOWED_CONFIDENCE = new Set(["low", "medium", "high"]);
+export function parseReviewGateOutput(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new RuntimeError("REVIEW_GATE_PARSE_FAILED", `Review gate output is not valid JSON: ${error.message}`, "review_gate.parse", { cause: error });
+    }
+    if (!isObject(parsed)) {
+        throw new RuntimeError("REVIEW_GATE_PARSE_FAILED", "Review gate output must be a JSON object.", "review_gate.parse");
+    }
+    const { decision, confidence, summary, issues } = parsed;
+    if (!ALLOWED_DECISIONS.has(String(decision)) ||
+        !ALLOWED_CONFIDENCE.has(String(confidence)) ||
+        typeof summary !== "string" ||
+        !Array.isArray(issues)) {
+        throw new RuntimeError("REVIEW_GATE_PARSE_FAILED", "Review gate output must contain decision, confidence, summary, and issues.", "review_gate.parse");
+    }
+    return {
+        decision: decision,
+        confidence: confidence,
+        summary,
+        issues: issues.map((issue, index) => normalizeIssue(issue, index)),
+    };
+}
+function normalizeIssue(issue, index) {
+    if (!isObject(issue)) {
+        throw new RuntimeError("REVIEW_GATE_PARSE_FAILED", `Review gate issue ${index + 1} must be an object.`, "review_gate.parse");
+    }
+    if (typeof issue.title !== "string" ||
+        typeof issue.body !== "string" ||
+        !ALLOWED_SEVERITIES.has(String(issue.severity))) {
+        throw new RuntimeError("REVIEW_GATE_PARSE_FAILED", `Review gate issue ${index + 1} is missing a required field.`, "review_gate.parse");
+    }
+    return issue;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/plugins/kimi-dsh/dist/session-recovery.js

@@ -0,0 +1,200 @@
+import { constants } from "node:fs";
+import { lstat, open, opendir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { digestPrompt } from "./jobs.js";
+// Total entries visited across both enumeration levels. The cap guards against
+// a pathological tree rather than budgeting normal store size. opendir streams,
+// so entries are not buffered. Dot-entries (`.index-dirty`, `.index-cache`) are
+// upstream index state, never workspaces, and are skipped without being counted.
+// Directories whose mtime predates the spawn cannot have been created by this
+// run and are skipped before any read, so the byte budget scales with concurrent
+// activity, not with store size.
+const DIR_ENUM_CAP = 65_536;
+const STATE_MAX_BYTES = 1024 * 1024;
+const JOURNAL_PREFIX_BYTES = 4 * 1024 * 1024; // The prompt is argv-bounded (< 1 MiB); the first user message follows a few config records.
+const SCAN_MAX_BYTES = 64 * 1024 * 1024;
+const MTIME_SLACK_MS = 1000; // Filesystems with coarse mtime granularity.
+const SESSION_ID = /^session_[0-9a-f-]{36}$/;
+/** Metadata recovery only, never a substitute for resume lineage/plan scans.
+ * A capped or unreadable enumeration cannot establish uniqueness and refuses;
+ * skipping symlinked or dot entries is not partial — neither can be a session
+ * the child created.
+ *
+ * A candidate is bound to THIS job by content, not only by time: the first
+ * user message in the session's main journal must carry a text item whose
+ * sha256 equals the job's `prompt_digest` (the exact `-p` argument). Time and
+ * cwd alone would admit a concurrent TUI session, another host's finished job
+ * (host-local stores cannot see each other's session ids), or a `state.json`
+ * planted by repository code running under rescue. The digest is not unique
+ * on its own either (the same prompt can run twice), so the window and the
+ * exactly-one rule stay in force. */
+export async function recoverSessionIdFromStore(options) {
+    const entryCap = options.entryCap ?? DIR_ENUM_CAP;
+    let entries = 0;
+    let bytes = 0;
+    let digestMismatches = 0;
+    let missingJournals = 0;
+    const candidates = [];
+    const capped = new Error("enumeration_capped");
+    async function* directories(dir) {
+        if ((await lstat(dir)).isSymbolicLink())
+            throw new Error("unreadable");
+        const handle = await opendir(dir);
+        for await (const entry of handle) {
+            if (entry.name.startsWith("."))
+                continue;
+            if (++entries > entryCap)
+                throw capped;
+            // A symlinked entry is never a session the child created; skipping it
+            // keeps one stray link from disabling recovery host-wide. Directories
+            // we descend are still lstat-anchored above.
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                yield entry.name;
+        }
+    }
+    // Bounded no-follow read of a regular file. Returns undefined when the file
+    // is absent; throws "unreadable" for anything that is not a plain file. With
+    // `prefix`, a larger file yields its first `maxBytes` instead of refusing.
+    async function readBounded(file, maxBytes, prefix = false) {
+        let handle;
+        try {
+            handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || (stat.size > maxBytes && !prefix))
+                throw new Error("unreadable");
+            const size = Math.min(stat.size, maxBytes);
+            bytes += size;
+            if (bytes > SCAN_MAX_BYTES)
+                throw capped;
+            const buffer = Buffer.alloc(size);
+            let offset = 0;
+            while (offset < buffer.length) {
+                const read = await handle.read(buffer, offset, buffer.length - offset, offset);
+                if (!read.bytesRead)
+                    break;
+                offset += read.bytesRead;
+            }
+            return buffer.subarray(0, offset);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    try {
+        if (!Number.isFinite(options.spawnedAt) || !Number.isFinite(options.settledAt) ||
+            options.settledAt < options.spawnedAt || !/^[0-9a-f]{64}$/.test(options.promptDigest)) {
+            return { reason: "none" };
+        }
+        const cwd = await realpath(options.cwd);
+        const sessions = path.join(options.kimiHome, "sessions");
+        // Missing nested dirs mean an incomplete scan; only a missing root is normal.
+        try {
+            await lstat(sessions);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { reason: "none" };
+            throw error;
+        }
+        for await (const workspace of directories(sessions)) {
+            const workspacePath = path.join(sessions, workspace);
+            for await (const session of directories(workspacePath)) {
+                if (!SESSION_ID.test(session))
+                    continue;
+                const sessionPath = path.join(workspacePath, session);
+                // A directory this run created was modified at or after the spawn.
+                if ((await lstat(sessionPath)).mtimeMs < options.spawnedAt - MTIME_SLACK_MS)
+                    continue;
+                const raw = await readBounded(path.join(sessionPath, "state.json"), STATE_MAX_BYTES);
+                if (!raw)
+                    continue;
+                let state;
+                try {
+                    state = JSON.parse(raw.toString("utf8"));
+                }
+                catch {
+                    continue;
+                }
+                if (!state || typeof state !== "object")
+                    continue;
+                const value = state;
+                // The child writes createdAt after the parent stamped spawnedAt on the
+                // same clock, so causality orders them; no pre-spawn slack is justified.
+                if (value.version !== 2 || typeof value.cwd !== "string" || !path.isAbsolute(value.cwd) ||
+                    typeof value.id !== "string" || !SESSION_ID.test(value.id) || value.id !== session ||
+                    typeof value.createdAt !== "number" || !Number.isFinite(value.createdAt) ||
+                    value.createdAt < options.spawnedAt || value.createdAt > options.settledAt)
+                    continue;
+                let stateCwd;
+                try {
+                    stateCwd = await realpath(value.cwd);
+                }
+                catch {
+                    continue;
+                }
+                if (stateCwd !== cwd || options.store.hasSessionId(value.id, options.jobId))
+                    continue;
+                const journal = await readBounded(path.join(sessionPath, "agents", "main", "wire.jsonl"), JOURNAL_PREFIX_BYTES, true);
+                if (!journal) {
+                    missingJournals += 1;
+                    continue;
+                }
+                // A prefix cut mid-record must never be parsed as a complete line.
+                const text = journal.length === JOURNAL_PREFIX_BYTES
+                    ? journal.subarray(0, journal.lastIndexOf(0x0a) + 1).toString("utf8") : journal.toString("utf8");
+                if (!firstUserMessageMatches(text, options.promptDigest)) {
+                    digestMismatches += 1;
+                    continue;
+                }
+                candidates.push(value.id);
+            }
+        }
+        if (candidates.length === 1)
+            return { sessionId: candidates[0] };
+        if (candidates.length > 1)
+            return { reason: `ambiguous:${candidates.length}` };
+        if (digestMismatches > 0)
+            return { reason: `digest_mismatch:${digestMismatches}` };
+        return { reason: missingJournals > 0 ? `journal_missing:${missingJournals}` : "none" };
+    }
+    catch (error) {
+        return { reason: error === capped ? "enumeration_capped" : "unreadable" };
+    }
+}
+/** True when the FIRST user message in a native-v2 main journal carries a
+ * text item equal to the prompt the job spawned with. Later user turns are
+ * never consulted: only the opening prompt binds a session to its spawn. */
+export function firstUserMessageMatches(journal, promptDigest) {
+    for (const line of journal.split("\n")) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!record || typeof record !== "object")
+            continue;
+        const message = record.message;
+        if (!message || typeof message !== "object" || message.role !== "user")
+            continue;
+        const content = message.content;
+        if (!Array.isArray(content))
+            return false;
+        return content.some((item) => item && typeof item === "object" && item.type === "text" &&
+            typeof item.text === "string" &&
+            digestPrompt(item.text) === promptDigest);
+    }
+    return false;
+}

package/plugins/kimi-dsh/dist/session-title.js

@@ -0,0 +1,293 @@
+import { basename, isAbsolute, relative, resolve } from "node:path";
+import path from "node:path";
+import { constants } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { resolveKimiHome } from "./kimi-home.js";
+export const KIMI_SESSION_TITLE_MAX_LENGTH = 120;
+const SESSION_INDEX_MAX_BYTES = 16 * 1024 * 1024;
+const SESSION_INDEX_LINE_MAX_BYTES = 1024 * 1024;
+const SESSION_STATE_MAX_BYTES = 1024 * 1024;
+const DISPLAY_NAMES = {
+    ask: "Ask",
+    review: "Review",
+    challenge: "Challenge",
+    rescue: "Rescue",
+    pursue: "Pursue",
+    swarm: "Swarm",
+    "swarm-write": "Swarm Write",
+};
+export function buildKimiSessionTitle(command, summary) {
+    const prefix = `Kimi ${DISPLAY_NAMES[command] ?? "Session"}`;
+    const normalized = promptMetadataText(summary ?? "") ?? "";
+    return shortenForTitle(normalized ? `${prefix}: ${normalized}` : prefix, KIMI_SESSION_TITLE_MAX_LENGTH);
+}
+export function normalizeTitleFragment(text) {
+    return text
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** Mirrors kimi-code 2.0.0 promptMetadataTextFromText: redact BEFORE truncating. */
+export function promptMetadataText(text) {
+    const sanitized = text
+        .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi, "[redacted]")
+        .replace(/\b(authorization)\s*:\s*bearer\s+\S+/gi, "$1: Bearer [redacted]")
+        .replace(/\b(api[_-]?key|token|secret|password|passwd|pwd)\b\s*[:=]\s*(?:"[^"]*"|'[^']*'|\S+)/gi, "$1=[redacted]")
+        .replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, "[redacted]")
+        .replace(/\b[A-Za-z0-9][A-Za-z0-9+/=_-]{39,}\b/g, "[redacted]")
+        .replace(/\p{Cc}+/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return sanitized ? sanitized.slice(0, 4000) : undefined;
+}
+export function shortenForTitle(text, maxLength) {
+    const normalized = normalizeTitleFragment(text);
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+export async function syncKimiSessionTitle(options) {
+    const sessionId = options.sessionId?.trim();
+    if (!sessionId) {
+        return "missing-session-id";
+    }
+    if (sessionId === "." || sessionId === ".." || /[/\\\p{Cc}]/u.test(sessionId)) {
+        warn(options.stderr, `session metadata sync skipped for ${formatSessionIdForLog(sessionId)}: unsafe session id`);
+        return "unsafe-entry";
+    }
+    const kimiHome = resolveKimiHome(options.env, options.cwd);
+    const sessionsRoot = path.join(kimiHome, "sessions");
+    const indexPath = path.join(kimiHome, "session_index.jsonl");
+    const indexRead = await readUtf8FileCapped(indexPath, SESSION_INDEX_MAX_BYTES);
+    if (!indexRead.ok) {
+        if (indexRead.reason === "too-large") {
+            warn(options.stderr, `session title sync skipped: session_index.jsonl is too large`);
+        }
+        return "missing-index";
+    }
+    const entry = findSessionIndexEntry(indexRead.text, sessionId, options.stderr);
+    if (!entry) {
+        return "missing-entry";
+    }
+    const safeSessionId = formatSessionIdForLog(sessionId);
+    const sessionDir = resolve(entry.sessionDir);
+    if (!isAbsolute(entry.sessionDir) ||
+        !isPathInside(sessionsRoot, sessionDir) ||
+        basename(sessionDir) !== sessionId) {
+        warn(options.stderr, `session title sync skipped for ${safeSessionId}: unsafe session index entry`);
+        return "unsafe-entry";
+    }
+    if (!(await isSafeSessionsRoot(sessionsRoot))) {
+        warn(options.stderr, `session title sync skipped for ${safeSessionId}: unsafe sessions root`);
+        return "unsafe-entry";
+    }
+    if (!(await isRealPathInside(sessionsRoot, sessionDir))) {
+        warn(options.stderr, `session title sync skipped for ${safeSessionId}: unsafe session index target`);
+        return "unsafe-entry";
+    }
+    const statePath = path.join(sessionDir, "state.json");
+    const stateFileMode = await readSafeStateFileMode(statePath, options.stderr, sessionId);
+    if (stateFileMode === null) {
+        return "unsafe-entry";
+    }
+    let parsed;
+    const stateRead = await readUtf8FileCapped(statePath, SESSION_STATE_MAX_BYTES);
+    if (!stateRead.ok) {
+        const reason = stateRead.reason === "too-large" ? "oversized state.json" : "missing or invalid state.json";
+        warn(options.stderr, `session title sync skipped for ${safeSessionId}: ${reason}`);
+        return "missing-state";
+    }
+    try {
+        parsed = JSON.parse(stateRead.text);
+    }
+    catch {
+        warn(options.stderr, `session title sync skipped for ${safeSessionId}: missing or invalid state.json`);
+        return "missing-state";
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        warn(options.stderr, `session title sync skipped for ${safeSessionId}: invalid state.json shape`);
+        return "invalid-state";
+    }
+    const state = parsed;
+    const nativeV2 = state.version === 2;
+    if (options.requireNativeV2 && !nativeV2)
+        return "unsupported-state";
+    if (nativeV2 && typeof state.id === "string" && state.id !== sessionId)
+        return "invalid-state";
+    // Custom-title normalization also recognizes titleKind and the older customTitle.
+    const customTitle = state.isCustomTitle === true || state.titleKind === "custom" ||
+        (typeof state.customTitle === "string" && state.customTitle.trim().length > 0);
+    const generatedTitle = state.titleKind === "generated";
+    const next = { ...state };
+    const preview = options.promptText === undefined ? undefined : promptMetadataText(options.promptText);
+    if (nativeV2 && preview && (typeof state.lastPrompt !== "string" || !state.lastPrompt.trim())) {
+        next.lastPrompt = preview;
+    }
+    if (!options.preserveTitle && !customTitle && !generatedTitle) {
+        next.title = promptMetadataText(options.title)?.slice(0, KIMI_SESSION_TITLE_MAX_LENGTH) ?? "Kimi Session";
+        // Native UI generation must remain eligible; a deterministic fallback is not
+        // a human rename. Legacy engines retain their existing custom-title behavior.
+        next.isCustomTitle = !nativeV2;
+        if (nativeV2)
+            next.titleKind = "replaceable";
+    }
+    const changed = JSON.stringify(next) !== JSON.stringify(state);
+    if (options.dryRun)
+        return changed ? "would-update" : "unchanged";
+    try {
+        if (changed && !(await writeStateFileAtomic(statePath, `${JSON.stringify(next, null, 2)}\n`, stateFileMode, stateRead.text))) {
+            warn(options.stderr, "session metadata sync skipped: state changed concurrently; retry after the session is idle");
+            return "state-changed";
+        }
+    }
+    catch {
+        warn(options.stderr, `session metadata sync skipped for ${safeSessionId}: failed to write state.json`);
+        return "write-failed";
+    }
+    if (nativeV2) {
+        try {
+            // Also re-mark unchanged metadata, so a previous invalidation failure is
+            // repairable without rewriting the state or changing a manual title.
+            await markSessionIndexDirty(sessionsRoot, sessionId);
+        }
+        catch {
+            warn(options.stderr, `session metadata saved for ${safeSessionId}, but index notification failed; retry repair-sessions --apply when idle`);
+            return "index-failed";
+        }
+    }
+    return changed ? "updated" : customTitle && !options.preserveTitle ? "custom-title" : "unchanged";
+}
+function findSessionIndexEntry(indexText, sessionId, stderr) {
+    for (const line of indexText.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (Buffer.byteLength(trimmed, "utf8") > SESSION_INDEX_LINE_MAX_BYTES) {
+            warn(stderr, `session title sync skipped oversized session index line`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            warn(stderr, `session title sync skipped malformed session index line`);
+            continue;
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            continue;
+        }
+        const entry = parsed;
+        if (entry.sessionId === sessionId &&
+            typeof entry.sessionDir === "string") {
+            return {
+                sessionId,
+                sessionDir: entry.sessionDir,
+            };
+        }
+    }
+    return null;
+}
+function isPathInside(parent, child) {
+    const rel = relative(resolve(parent), resolve(child));
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function isSafeSessionsRoot(sessionsRoot) {
+    try {
+        const stats = await lstat(sessionsRoot);
+        return stats.isDirectory() && !stats.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+async function isRealPathInside(parent, child) {
+    try {
+        let current = parent;
+        for (const part of relative(parent, child).split(path.sep)) {
+            current = path.join(current, part);
+            const info = await lstat(current);
+            if (!info.isDirectory() || info.isSymbolicLink())
+                return false;
+        }
+        const realParent = await realpath(parent);
+        const realChild = await realpath(child);
+        return isPathInside(realParent, realChild);
+    }
+    catch {
+        return false;
+    }
+}
+async function readSafeStateFileMode(statePath, stderr, sessionId) {
+    try {
+        const stats = await lstat(statePath);
+        if (stats.isSymbolicLink() || !stats.isFile()) {
+            warn(stderr, `session title sync skipped for ${formatSessionIdForLog(sessionId)}: unsafe state.json`);
+            return null;
+        }
+        return stats.mode & 0o777;
+    }
+    catch {
+        return 0o600;
+    }
+}
+async function writeStateFileAtomic(statePath, contents, mode, expected) {
+    const tmpPath = `${statePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(tmpPath, contents, { encoding: "utf8", mode, flag: "wx" });
+        const current = await readUtf8FileCapped(statePath, SESSION_STATE_MAX_BYTES);
+        if (!current.ok || current.text !== expected)
+            return false;
+        await rename(tmpPath, statePath);
+        return true;
+    }
+    finally {
+        await rm(tmpPath, { force: true }).catch(() => { });
+    }
+}
+async function markSessionIndexDirty(sessionsRoot, sessionId) {
+    if (!(await isSafeSessionsRoot(sessionsRoot)))
+        throw new Error("Unsafe sessions root");
+    const dir = path.join(sessionsRoot, ".index-dirty");
+    await mkdir(dir, { mode: 0o700 }).catch((error) => {
+        if (error.code !== "EEXIST")
+            throw error;
+    });
+    if (!(await isRealPathInside(sessionsRoot, dir)))
+        throw new Error("Unsafe dirty journal");
+    // Upstream splits at the LAST dot; the unique suffix must contain no dots.
+    const file = await open(path.join(dir, `${sessionId}.${Date.now()}-${randomUUID()}`), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    await file.close();
+}
+async function readUtf8FileCapped(filePath, maxBytes) {
+    let file;
+    try {
+        file = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch {
+        return { ok: false, reason: "missing" };
+    }
+    try {
+        const stats = await file.stat();
+        if (!stats.isFile()) {
+            return { ok: false, reason: "not-file" };
+        }
+        if (stats.size > maxBytes) {
+            return { ok: false, reason: "too-large" };
+        }
+        const buffer = Buffer.alloc(stats.size);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+        return { ok: true, text: buffer.subarray(0, bytesRead).toString("utf8") };
+    }
+    finally {
+        await file.close();
+    }
+}
+function formatSessionIdForLog(sessionId) {
+    return JSON.stringify(normalizeTitleFragment(sessionId));
+}
+function warn(stderr, message) {
+    stderr?.write(`[kimi-plugin-cc] ${message}.\n`);
+}