kritya 0.8.51-beta → 0.8.53-beta

package/dist/config/config.js

@@ -101,6 +101,44 @@ export function sanitizeMcpServersRecord(servers, label = "mcpServers") {
     }
     return out;
 }
+/**
+ * Top-level keys `~/.kritya/config.json` understands — keep in sync with
+ * CliConfig. Anything else in the file is silently ignored (the parsed
+ * object is only ever consumed through the typed interface), so a typo like
+ * `maxStep` or `contextwindow` looks like "my config isn't taking effect"
+ * with no clue why. loadConfig warns about those instead.
+ */
+const KNOWN_CONFIG_KEYS = new Set([
+    "apiKey",
+    "model",
+    "baseUrl",
+    "provider",
+    "providers",
+    "customModels",
+    "pricing",
+    "contextWindow",
+    "maxSteps",
+    "tokenBudget",
+    "toolTimeoutSeconds",
+    "subagentConcurrency",
+    "subagentTimeoutSeconds",
+    "subagentMaxSteps",
+    "subagentWriteMaxSteps",
+    "mcpServers",
+    "sandboxExec",
+    "retentionDays",
+    "audit",
+    "otel",
+    "commitAttribution",
+    "privacyMode",
+]);
+/**
+ * Keys in a parsed config object that CliConfig doesn't know — all ignored
+ * by the typed code that consumes it. Exported for tests.
+ */
+export function unknownConfigKeys(parsed) {
+    return Object.keys(parsed).filter((key) => !KNOWN_CONFIG_KEYS.has(key));
+}
 function sanitizeCliConfig(config) {
     if (!config.mcpServers)
         return config;
@@ -218,7 +256,15 @@ export function loadConfig() {
     }
     try {
         assertJsonWithinLimits(raw, "config.json");
-        return sanitizeCliConfig(JSON.parse(raw));
+        const parsed = JSON.parse(raw);
+        const unknown = unknownConfigKeys(parsed);
+        if (unknown.length > 0) {
+            // warnUser dedupes per context, so this prints once per process even
+            // though loadConfig runs often.
+            warnUser(`loadConfig(${CONFIG_FILE})`, new Error(`unknown key(s) ${unknown.map((key) => `"${key}"`).join(", ")} ignored — ` +
+                `check the spelling against the documented config keys`));
+        }
+        return sanitizeCliConfig(parsed);
     }
     catch (err) {
         // Malformed or oversized — worth being able to see when someone reports

package/dist/index.js

@@ -258,7 +258,16 @@ if (args.prompt) {
         trust: args.trust,
         timeoutSeconds: args.timeoutSeconds,
         privacy: args.privacy,
-    }).then((code) => process.exit(code));
+    })
+        .then((code) => process.exit(code))
+        // runHeadless is documented to resolve with an exit code rather than
+        // throw, so reaching here means a bug in that path. Fail loudly with a
+        // non-zero code instead of letting Node print an unhandled-rejection
+        // trace — a CI job reading `$?` deserves a real exit status either way.
+        .catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
 }
 else {
     runInteractive();

package/dist/mcp/client.js

@@ -216,7 +216,14 @@ class McpConnection {
      * server can tell the difference between an unsupported client and a hung one.
      */
     onServerRequest(id, method, params) {
-        const reply = (body) => this.transport.send({ jsonrpc: "2.0", id, ...body }, CONNECT_TIMEOUT_MS).catch(() => { });
+        // Typed void on purpose: every reply is best-effort, its own `.catch`
+        // already keeps a failed send from becoming an unhandled rejection, and no
+        // caller of `reply` has anything to do with the promise. The explicit
+        // return type is what tells that to callers — and to no-floating-promises,
+        // which cannot see through the `.catch` above.
+        const reply = (body) => {
+            void this.transport.send({ jsonrpc: "2.0", id, ...body }, CONNECT_TIMEOUT_MS).catch(() => { });
+        };
         if (method === "roots/list") {
             reply({
                 result: {

package/dist/tools/grep.js

@@ -5,6 +5,14 @@ import { isPathSafe, resolveSafe, safeCompileRegex, truncateResult, meaningfulLi
 import { loadIgnorePatterns } from "./ignore.js";
 const MAX_MATCHES = 200;
 const MAX_FILE_BYTES = 1024 * 1024;
+/**
+ * Longest line regex-tested. A minified file is a single ~1MB line, and
+ * safeCompileRegex only blocks nested-quantifier shapes — any other
+ * ReDoS-shaped pattern tested against that one line spins the event loop,
+ * where the tool timeout can't fire. Skipping the line closes it; a real
+ * match on a line this long is unreadable in the result anyway.
+ */
+const MAX_LINE_CHARS = 10_000;
 export const grepTool = {
     name: "grep",
     description: "Search file contents with a regular expression. Returns 'file:line: text' matches. " +
@@ -74,6 +82,8 @@ export const grepTool = {
             const rel = path.relative(ctx.workspace, abs);
             const lines = content.split("\n");
             for (let i = 0; i < lines.length && matches.length < MAX_MATCHES; i++) {
+                if (lines[i].length > MAX_LINE_CHARS)
+                    continue;
                 if (regex.test(lines[i])) {
                     matches.push(`${rel}:${i + 1}: ${lines[i].slice(0, 250)}`);
                 }

package/dist/tools/read.js

@@ -3,7 +3,7 @@ import { resolveSafe, truncateResult, countLines } from "./common.js";
 export const readFileTool = {
     name: "read_file",
     description: "Read a text file from the workspace. Returns the content with line numbers. " +
-        "Use offset/limit for large files.",
+        "Use offset/limit for large files. Refuses binary files — use read_document for .pdf/.docx/.xlsx/.pptx.",
     parameters: {
         type: "object",
         properties: {
@@ -18,7 +18,15 @@ export const readFileTool = {
     resultSummary: (output) => countLines(output, "line", "lines"),
     async execute(args, ctx) {
         const abs = resolveSafe(ctx.workspace, String(args.path));
-        const content = await fs.readFile(abs, "utf8");
+        const buffer = await fs.readFile(abs);
+        // Binary sniff, same as grep: a NUL byte in the first 8KB means this is
+        // not text. Decoding it as UTF-8 anyway would dump garbage into the
+        // context and burn tokens on bytes no one can read.
+        if (buffer.subarray(0, 8000).includes(0)) {
+            throw new Error(`"${args.path}" looks like a binary file — read_file only reads text. ` +
+                `For .pdf, .docx, .xlsx, or .pptx use read_document instead.`);
+        }
+        const content = buffer.toString("utf8");
         const lines = content.split("\n");
         const offset = Math.max(1, Number(args.offset) || 1);
         const limit = Number(args.limit) || 2000;

package/dist/ui/App.js

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import { glob } from "tinyglobby";
 import stringWidth from "string-width";
 import { gitDiffStat } from "../git/git.js";
+import { debugLog } from "../config/debug.js";
 import { modelDisplaySlug } from "../config/models.js";
 import { setStderrSink } from "../stderr.js";
 import { openInEditor } from "./openInEditor.js";
@@ -145,7 +146,12 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", ...loadIgnorePatterns(workspace)],
         })
             .then((files) => setFileList(files.sort().slice(0, 2000)))
-            .catch(() => { });
+            .catch((err) => {
+            // A failed refresh must not leave the previous workspace's files
+            // behind for @-mentions: clear, and leave a trail in the debug log.
+            debugLog("refreshFileList", err);
+            setFileList([]);
+        });
     }, [workspace]);
     useEffect(refreshFileList, [refreshFileList]);
     const { items, addItem, clearItems, phase, setPhase, stream, thinking, activity, setActivity, runningPhase, setRunningPhase, setChained, workflow, refreshWorkflow, prefill, setPrefill, permission, elicitation, inFlight, model, provider, servedModel, totalUsage, totalCost, tasks, setTasks, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, branch, planMode, setPlanMode, dryRunMode, killed, killReason, engageKill, releaseKill, acceptEdits, setAcceptEdits, bypassMode, setBypassMode, autoApprovedCount, cycleMode, onAcceptEditsConfirm, onBypassModeConfirm, abortRef, setModelEverywhere, setProviderEverywhere, costReport, runAgent, runWebSearch, onPermissionDecision, onElicitationDecision, onResumeSelect, requestPermission, requestElicitation, persistenceWarningCount, } = useAgent({
@@ -576,7 +582,11 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             costReport,
             statusReport,
             gitDiffStat,
-            exit: exitAfterFlush,
+            // exitAfterFlush is async because it waits for Ink to flush the final
+            // render, but `exit` is typed void: no caller can do anything with the
+            // promise, so the detach is marked here rather than by widening the
+            // interface to `void | Promise<void>` to silence the lint rule.
+            exit: () => void exitAfterFlush(),
         };
         void runCommand(cmd, ctx);
     };
@@ -739,7 +749,11 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                                     setInput(v.replace(/\t/g, ""));
                                     setCmdIndex(0);
                                     setFileIndex(0);
-                                }, onSubmit: handleSubmit }, inputKey)] }), suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [suggestionWindow.visible.map((line, i) => {
+                                }, 
+                                // handleSubmit is async only because it awaits runAgent, which
+                                // catches its own errors and renders them as transcript items —
+                                // so there is no rejection left for this callback to surface.
+                                onSubmit: (value) => void handleSubmit(value) }, inputKey)] }), suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [suggestionWindow.visible.map((line, i) => {
                                 if (line.kind === "header") {
                                     return (_jsx(Text, { dimColor: true, wrap: "truncate", children: line.label }, `header:${line.label}`));
                                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.51-beta",
+  "version": "0.8.53-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {