kimi-plugin-cc 2.0.8 → 2.2.1

package/plugins/kimi-codex/dist/parsing.js

@@ -21,38 +21,30 @@ function looksLikeFlag(token) {
     // Short flag: a single dash followed by exactly one letter (`-r`, `-m`).
     return /^-[a-zA-Z]$/.test(token);
 }
-export const ASK_SUPPORTED_FLAGS = "-m/--model <name>, --budget <30m|1h|90s>, --background, --wait, --fresh, -r, --resume <job-id|session-id>";
-export const RESCUE_SUPPORTED_FLAGS = "-m/--model <name>, --budget <30m|1h|90s>, --background, --wait, --fresh, -r, --resume <job-id|session-id>";
-export const REVIEW_SUPPORTED_FLAGS = "--base <ref>, -m/--model <name>, --budget <30m|1h|90s>";
+export const ASK_SUPPORTED_FLAGS = "-m/--model <name>, --thinking <off|low|medium|high>, --budget <30m|1h|90s>, --background, --wait, --fresh, -r, --resume <job-id|session-id>";
+export const RESCUE_SUPPORTED_FLAGS = "-m/--model <name>, --thinking <off|low|medium|high>, --budget <30m|1h|90s>, --background, --wait, --fresh, -r, --resume <job-id|session-id>";
+export const REVIEW_SUPPORTED_FLAGS = "--base <ref>, -m/--model <name>, --thinking <off|low|medium|high>, --budget <30m|1h|90s>";
 export const JOB_LOOKUP_SUPPORTED_FLAGS = "--type <review|challenge|rescue|review_gate|ask>, --json";
 export const SETUP_SUPPORTED_FLAGS = "--check, --uninstall, --all (with --uninstall), --enable-review-gate, --disable-review-gate, --models [--json] (without other setup flags)";
 export const REPAIR_SESSIONS_SUPPORTED_FLAGS = "--apply, --all";
 export const REPLAY_SUPPORTED_FLAGS = "none (one job-id required)";
-// Thinking-on is always-on for user-facing commands in v1.0. review-gate
-// pins thinking=false via the cli-client options bag instead of an argv
-// flag (see runtime/cli-client.ts::CliClientOptions). The parser rejects
-// --thinking and --no-thinking with a hard error so a documented-removed
-// flag doesn't get silently accepted as a no-op. Both bare (`--thinking`)
-// and assignment (`--thinking=true`) forms are rejected — otherwise the
-// assignment form would fall through to the generic "Unknown flag" path
-// and a wrapper agent reading the error would think the cure is to drop
-// the `=value` rather than the flag itself.
-const THINKING_FLAG_REMOVED_MESSAGE = "--thinking / --no-thinking were removed in v1.0. Thinking is always on for user-facing commands.";
-function isRemovedThinkingFlag(token) {
-    return (token === "--thinking" ||
-        token === "--no-thinking" ||
-        token.startsWith("--thinking=") ||
-        token.startsWith("--no-thinking="));
+/** Validate syntax only; upstream per-model supportEfforts remains authoritative. */
+export function validateThinkingEffort(value, stage = "args.parse", lowercase = true) {
+    const effort = lowercase ? value?.toLowerCase() : value;
+    if (!effort || !/^[a-z][a-z0-9-]{0,31}$/.test(effort)) {
+        throw new RuntimeError("INVALID_ARGS", "--thinking requires an effort matching [a-z][a-z0-9-]{0,31} (e.g. off, low, medium, high).", stage);
+    }
+    return effort;
 }
-export const PURSUE_SUPPORTED_FLAGS = "-m/--model <name>, --budget <30m|1h|90s>, --turns <N>";
-export const SWARM_SUPPORTED_FLAGS = "-m/--model <name>, --budget <30m|1h|90s>, --cap <N>, --max-concurrency <N>, --write";
+export const PURSUE_SUPPORTED_FLAGS = "-m/--model <name>, --thinking <off|low|medium|high>, --budget <30m|1h|90s>, --turns <N>";
+export const SWARM_SUPPORTED_FLAGS = "-m/--model <name>, --thinking <off|low|medium|high>, --budget <30m|1h|90s>, --cap <N>, --max-concurrency <N>, --write";
 /**
  * Parser for /kimi:swarm (read-only parallel fan-out). Foreground-only:
  * no --background/--fresh/--resume. Trailing tokens are the objective.
  */
 export function parseSwarmArgs(argv) {
     let model;
-    const thinking = true;
+    let thinkingEffort;
     let budgetMs;
     let cap;
     let maxConcurrency;
@@ -60,6 +52,13 @@ export function parseSwarmArgs(argv) {
     let trailingTokens;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
+        if (token === "--thinking" || token.startsWith("--thinking=")) {
+            thinkingEffort = validateThinkingEffort(token === "--thinking" ? argv[++index] : token.slice("--thinking=".length));
+            continue;
+        }
+        if (token === "--no-thinking" || token.startsWith("--no-thinking=")) {
+            throw new RuntimeError("INVALID_ARGS", "--no-thinking is unsupported; use --thinking off", "args.parse");
+        }
         if (token === "--") {
             trailingTokens = argv.slice(index + 1);
             break;
@@ -105,9 +104,6 @@ export function parseSwarmArgs(argv) {
                 break;
             }
             default:
-                if (isRemovedThinkingFlag(token)) {
-                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "swarm.parse");
-                }
                 if (looksLikeFlag(token)) {
                     throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for swarm. Supported flags: ${SWARM_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped objective text to pass it through.`, "swarm.parse");
                 }
@@ -122,7 +118,7 @@ export function parseSwarmArgs(argv) {
         maxConcurrency,
         write,
         model,
-        thinking,
+        thinkingEffort,
         objective: trailingTokens?.join(" "),
     };
 }
@@ -186,12 +182,19 @@ export function parseDurationMs(token, flag, stage, budgetKind) {
  */
 export function parsePursueArgs(argv) {
     let model;
-    const thinking = true;
+    let thinkingEffort;
     let budgetMs;
     let turns;
     let trailingTokens;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
+        if (token === "--thinking" || token.startsWith("--thinking=")) {
+            thinkingEffort = validateThinkingEffort(token === "--thinking" ? argv[++index] : token.slice("--thinking=".length));
+            continue;
+        }
+        if (token === "--no-thinking" || token.startsWith("--no-thinking=")) {
+            throw new RuntimeError("INVALID_ARGS", "--no-thinking is unsupported; use --thinking off", "args.parse");
+        }
         if (token === "--") {
             trailingTokens = argv.slice(index + 1);
             break;
@@ -237,9 +240,6 @@ export function parsePursueArgs(argv) {
                 break;
             }
             default:
-                if (isRemovedThinkingFlag(token)) {
-                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "pursue.parse");
-                }
                 if (looksLikeFlag(token)) {
                     throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for pursue. Supported flags: ${PURSUE_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped objective text to pass it through.`, "pursue.parse");
                 }
@@ -252,12 +252,12 @@ export function parsePursueArgs(argv) {
         budgetMs,
         turns,
         model,
-        thinking,
+        thinkingEffort,
         objective: trailingTokens?.join(" "),
     };
 }
 /** Help before -- wins even over malformed flags or prose trailing-token mode. */
-const VALUE_TAKING_FLAGS = new Set(["-m", "--model", "--budget", "--resume", "--base", "--cap", "--max-concurrency", "--turns", "--type"]);
+const VALUE_TAKING_FLAGS = new Set(["--thinking", "-m", "--model", "--budget", "--resume", "--base", "--cap", "--max-concurrency", "--turns", "--type"]);
 /**
  * `--help` / `-h` counts only inside the leading flag region: before `--`
  * and before the first prose token. The value of a value-taking flag is
@@ -289,10 +289,7 @@ export function parseAskArgs(argv) {
         return { help: true, background: false, wait: false, fresh: false, resume: false };
     let budgetMs;
     let model;
-    // Thinking is on by default across ask/review/challenge/rescue. The
-    // parser rejects --thinking / --no-thinking; review-gate's runtime
-    // caller pins thinking=false via CliClientOptions instead.
-    let thinking = true;
+    let thinkingEffort;
     let background = false;
     let wait = false;
     let fresh = false;
@@ -302,6 +299,13 @@ export function parseAskArgs(argv) {
     let trailingTokens;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
+        if (token === "--thinking" || token.startsWith("--thinking=")) {
+            thinkingEffort = validateThinkingEffort(token === "--thinking" ? argv[++index] : token.slice("--thinking=".length));
+            continue;
+        }
+        if (token === "--no-thinking" || token.startsWith("--no-thinking=")) {
+            throw new RuntimeError("INVALID_ARGS", "--no-thinking is unsupported; use --thinking off", "args.parse");
+        }
         if (token === "--") {
             trailingTokens = argv.slice(index + 1);
             break;
@@ -357,9 +361,6 @@ export function parseAskArgs(argv) {
                 break;
             }
             default:
-                if (isRemovedThinkingFlag(token)) {
-                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "args.parse");
-                }
                 if (looksLikeFlag(token)) {
                     throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for ask. Supported flags: ${ASK_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped prompt text to pass it through.`, "args.parse");
                 }
@@ -382,7 +383,7 @@ export function parseAskArgs(argv) {
         resume,
         resumeTarget,
         model,
-        thinking,
+        thinkingEffort,
         prompt: trailingTokens?.join(" "),
     };
 }
@@ -394,7 +395,7 @@ export function parseReviewArgs(argv, commandName = "review") {
         background: parsed.background,
         wait: parsed.wait,
         model: parsed.model,
-        thinking: parsed.thinking,
+        thinkingEffort: parsed.thinkingEffort,
         focus: parsed.trailingText,
     };
 }
@@ -403,7 +404,7 @@ export function parseRescueArgs(argv) {
         return { help: true, background: false, wait: false, fresh: false, resume: false };
     let budgetMs;
     let model;
-    let thinking = true;
+    let thinkingEffort;
     let background = false;
     let wait = false;
     let fresh = false;
@@ -413,6 +414,13 @@ export function parseRescueArgs(argv) {
     let trailingTokens;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
+        if (token === "--thinking" || token.startsWith("--thinking=")) {
+            thinkingEffort = validateThinkingEffort(token === "--thinking" ? argv[++index] : token.slice("--thinking=".length));
+            continue;
+        }
+        if (token === "--no-thinking" || token.startsWith("--no-thinking=")) {
+            throw new RuntimeError("INVALID_ARGS", "--no-thinking is unsupported; use --thinking off", "args.parse");
+        }
         if (token === "--") {
             trailingTokens = argv.slice(index + 1);
             break;
@@ -468,9 +476,6 @@ export function parseRescueArgs(argv) {
                 break;
             }
             default:
-                if (isRemovedThinkingFlag(token)) {
-                    throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "args.parse");
-                }
                 if (looksLikeFlag(token)) {
                     throw new RuntimeError("INVALID_ARGS", `Unknown flag ${token} for rescue. Supported flags: ${RESCUE_SUPPORTED_FLAGS}. Use \`--\` before flag-shaped prompt text to pass it through.`, "args.parse");
                 }
@@ -493,7 +498,7 @@ export function parseRescueArgs(argv) {
         resume,
         resumeTarget,
         model,
-        thinking,
+        thinkingEffort,
         prompt: trailingTokens?.join(" "),
     };
 }
@@ -540,21 +545,25 @@ function isManagedCommandType(value) {
 function parseKnownFlags(argv, knownFlags, commandName) {
     let budgetMs;
     let model;
-    let thinking = true;
+    let thinkingEffort;
     let base;
     let background = false;
     let wait = false;
     let trailingTokens;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
+        if (token === "--thinking" || token.startsWith("--thinking=")) {
+            thinkingEffort = validateThinkingEffort(token === "--thinking" ? argv[++index] : token.slice("--thinking=".length));
+            continue;
+        }
+        if (token === "--no-thinking" || token.startsWith("--no-thinking=")) {
+            throw new RuntimeError("INVALID_ARGS", "--no-thinking is unsupported; use --thinking off", "args.parse");
+        }
         if (token === "--") {
             trailingTokens = argv.slice(index + 1);
             break;
         }
         if (!knownFlags.has(token)) {
-            if (isRemovedThinkingFlag(token)) {
-                throw new RuntimeError("INVALID_ARGS", THINKING_FLAG_REMOVED_MESSAGE, "args.parse");
-            }
             if (looksLikeFlag(token)) {
                 // Wrapper agents routinely hallucinate flags like `--file` /
                 // `--context` because that shape is common in other CLIs. Silently
@@ -610,9 +619,6 @@ function parseKnownFlags(argv, knownFlags, commandName) {
             // The early `if (!knownFlags.has(token))` gate above means we only
             // reach this switch with tokens that ARE in knownFlags, and every
             // member is handled above. A `default` arm would be unreachable.
-            // --thinking and --no-thinking are NOT in knownFlags any more (v1.0
-            // removed them); the early gate above hard-fails on them with
-            // THINKING_FLAG_REMOVED_MESSAGE.
         }
     }
     return {
@@ -621,7 +627,7 @@ function parseKnownFlags(argv, knownFlags, commandName) {
         background,
         wait,
         model,
-        thinking,
+        thinkingEffort,
         trailingText: trailingTokens?.join(" "),
     };
 }

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

@@ -0,0 +1,203 @@
+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. A real store holds a
+// few thousand sessions (2,494 entries on the reference host when this was
+// written, growing by one per plugin run), so the preflight's 4,096 would have
+// switched recovery off within months; the cap is a guard against a
+// pathological tree, not a size budget. opendir streams, nothing is 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-codex/dist/vendor/smol-toml/date.js

@@ -25,39 +25,68 @@
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
 export class TomlDate extends Date {
     #hasDate = false;
     #hasTime = false;
     #offset = null;
-    constructor(date) {
+    constructor(date, fasttype, unsafeDelim) {
         let hasDate = true;
         let hasTime = true;
         let offset = 'Z';
+        let c;
         if (typeof date === 'string') {
-            let match = date.match(DATE_TIME_RE);
-            if (match) {
-                if (!match[1]) {
-                    hasDate = false;
-                    date = `0000-01-01T${date}`;
+            if (fasttype)
+                prep: {
+                    // Date-time
+                    if (fasttype < 3) {
+                        if (+date.slice(11, 13) > 23) {
+                            date = '';
+                            break prep;
+                        }
+                        // Local
+                        if (fasttype === 2) {
+                            offset = null;
+                            date += 'Z';
+                        }
+                        // Offset; keep track of offset if not Z
+                        else if ((c = date.charCodeAt(date.length - 1)) !== 0x5a /* Z */ && c !== 0x7a /* z */) {
+                            offset = date.slice(date.length - 6);
+                        }
+                        if (unsafeDelim)
+                            date = date.slice(0, 10) + 'T' + date.slice(11);
+                    }
+                    // Time
+                    else if (fasttype === 4) {
+                        date = +date.slice(0, 2) > 23 ? '' : `0000-01-01T${date}Z`;
+                    }
+                    hasDate = fasttype !== 4;
+                    hasTime = fasttype !== 3;
                 }
-                hasTime = !!match[2];
-                // Make sure to use T instead of a space. Breaks in case of extreme values otherwise.
-                hasTime && date[10] === ' ' && (date = date.replace(' ', 'T'));
-                // Do not allow rollover hours.
-                if (match[2] && +match[2] > 23) {
-                    date = '';
+            else {
+                let match = date.match(DATE_TIME_RE);
+                if (match) {
+                    if (!match[1]) {
+                        hasDate = false;
+                        date = `0000-01-01T${date}`;
+                    }
+                    hasTime = !!match[2];
+                    // Make sure to use T instead of a space. Breaks in case of extreme values otherwise.
+                    hasTime && date[10] === ' ' && (date = date.replace(' ', 'T'));
+                    // Do not allow rollover hours.
+                    if (match[2] && +match[2] > 23) {
+                        date = '';
+                    }
+                    else {
+                        offset = match[3] || null;
+                        if (!offset && hasTime)
+                            date += 'Z';
+                    }
                 }
                 else {
-                    offset = match[3] || null;
-                    date = date.toUpperCase();
-                    if (!offset && hasTime)
-                        date += 'Z';
+                    date = '';
                 }
             }
-            else {
-                date = '';
-            }
         }
         super(date);
         if (!isNaN(this.getTime())) {
@@ -93,7 +122,7 @@ export class TomlDate extends Date {
         if (this.#offset === null)
             return iso.slice(0, -1);
         // Offset DateTime
-        if (this.#offset === 'Z')
+        if (this.#offset === 'Z' || this.#offset === 'z')
             return iso;
         // This part is quite annoying: JS strips the original timezone from the ISO string representation
         // Instead of using a "modified" date and "Z", we restore the representation "as authored"

package/plugins/kimi-codex/dist/vendor/smol-toml/error.js

@@ -26,11 +26,11 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 function getLineColFromPtr(string, ptr) {
-    let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+    let lines = string.slice(0, ptr).split(/\r?\n/);
     return [lines.length, lines.pop().length + 1];
 }
 function makeCodeBlock(string, line, column) {
-    let lines = string.split(/\r\n|\n|\r/g);
+    let lines = string.split(/\r?\n/);
     let codeblock = '';
     let numberLen = (Math.log10(line + 1) | 0) + 1;
     for (let i = line - 1; i <= line + 1; i++) {
@@ -60,4 +60,8 @@ export class TomlError extends Error {
         this.column = column;
         this.codeblock = codeblock;
     }
+    /** @internal */
+    static x(message, ctx, ptr) {
+        throw new TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+    }
 }