blun-king-cli 9.1.298 → 9.1.300

package/bin/native-large-file-io.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const { createHash, randomUUID } = require('node:crypto');
+const { appendFile, copyFile, readFile, unlink, writeFile } = require('node:fs/promises');
+
+async function writeNativeLargeContentOnDisk({ safePath, chunks, mode, atomicWrite }) {
+  if (!Array.isArray(chunks) || !chunks.every(Buffer.isBuffer)) {
+    throw new TypeError('chunks must be an array of buffers');
+  }
+  if (mode !== 'overwrite' && mode !== 'append') throw new TypeError('mode must be overwrite or append');
+  if (typeof atomicWrite !== 'function') throw new TypeError('atomicWrite must be a function');
+
+  const stagingPath = `${safePath}.blun-large-write-${String(process.pid)}-${randomUUID()}.tmp`;
+  try {
+    if (mode === 'append') {
+      try {
+        await copyFile(safePath, stagingPath);
+      } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+        await writeFile(stagingPath, Buffer.alloc(0), { flag: 'wx', mode: 0o600 });
+      }
+    } else {
+      await writeFile(stagingPath, Buffer.alloc(0), { flag: 'wx', mode: 0o600 });
+    }
+    for (const chunk of chunks) await appendFile(stagingPath, chunk);
+
+    const assembled = await readFile(stagingPath);
+    const sha256 = createHash('sha256').update(assembled).digest('hex');
+    await atomicWrite(safePath, assembled);
+    const persistedSha256 = createHash('sha256').update(await readFile(safePath)).digest('hex');
+    if (persistedSha256 !== sha256) {
+      throw new Error(`assembled SHA-256 ${sha256}, persisted SHA-256 ${persistedSha256}`);
+    }
+    return { sha256, bytes: assembled.length, fragments: chunks.length };
+  } finally {
+    try {
+      await unlink(stagingPath);
+    } catch {}
+  }
+}
+
+module.exports = { writeNativeLargeContentOnDisk };

package/bin/read-continuation-policy.cjs

@@ -1,18 +1,28 @@
 "use strict";
 
 const READ_LINE_CAP = 1000;
+const READ_MODEL_VISIBLE_BYTES = 10 * 1024;
 
 function readContinuationNotice(input) {
-  if (input?.maxLinesReached !== true) return undefined;
   if (!Number.isSafeInteger(input.lineOffset) || input.lineOffset < 1) return undefined;
-  if (!Number.isSafeInteger(input.effectiveLimit) || input.effectiveLimit < READ_LINE_CAP) return undefined;
+  let readLines;
+  if (input?.maxBytesReached === true) {
+    if (!Number.isSafeInteger(input.renderedLineCount) || input.renderedLineCount < 1) return undefined;
+    readLines = input.renderedLineCount;
+  } else if (input?.maxLinesReached === true) {
+    if (!Number.isSafeInteger(input.effectiveLimit) || input.effectiveLimit < READ_LINE_CAP) return undefined;
+    readLines = input.effectiveLimit;
+  } else {
+    return undefined;
+  }
 
-  const nextLineOffset = input.lineOffset + input.effectiveLimit;
+  const nextLineOffset = input.lineOffset + readLines;
   if (!Number.isSafeInteger(nextLineOffset)) return undefined;
   return `Continue reading with line_offset=${String(nextLineOffset)}. Do not assume you have reached the end of the file.`;
 }
 
 module.exports = {
   READ_LINE_CAP,
+  READ_MODEL_VISIBLE_BYTES,
   readContinuationNotice,
 };

package/bin/write-continuation-policy.cjs

@@ -49,7 +49,21 @@ function resolvePlainWriteContract({
   };
 }
 
+function splitNativeWriteBytes(content, maxChunkBytes) {
+  if (typeof content !== 'string') throw new TypeError('content must be a string');
+  if (!Number.isSafeInteger(maxChunkBytes) || maxChunkBytes < 1) {
+    throw new TypeError('maxChunkBytes must be a positive safe integer');
+  }
+  const bytes = Buffer.from(content, 'utf8');
+  const chunks = [];
+  for (let offset = 0; offset < bytes.length; offset += maxChunkBytes) {
+    chunks.push(bytes.subarray(offset, Math.min(bytes.length, offset + maxChunkBytes)));
+  }
+  return chunks;
+}
+
 module.exports = {
   resolvePlainWriteContract,
   resolveWriteContinuationContract,
+  splitNativeWriteBytes,
 };

package/blun.mjs

@@ -253233,6 +253233,11 @@ function evaluateSourceFileLineLimit(path, nextContent, options = {}) {
 		allowed: true,
 		lineCount
 	};
+	if (options.nativeLargeFile === true) return {
+		allowed: true,
+		lineCount,
+		notice: `Native large-file write accepted ${String(lineCount)} source lines; content was fragmented, assembled, and verified by SHA-256.`
+	};
 	const currentLineCount = options.currentContent === void 0 ? void 0 : countFileLines(options.currentContent);
 	if (currentLineCount !== void 0 && currentLineCount > 500 && lineCount < currentLineCount) return {
 		allowed: true,
@@ -258997,14 +259002,14 @@ function renderEntries(entries, lineEndingStyle) {
 	for (const entry of entries) {
 		const rendered = renderLine(entry, lineEndingStyle);
 		const lineBytes = renderedLineBytes(rendered.line, renderedLines.length === 0);
-		if (renderedLines.length > 0 && bytes + lineBytes > 102400) {
+		if (renderedLines.length > 0 && bytes + lineBytes > MAX_BYTES) {
 			maxBytesReached = true;
 			break;
 		}
 		if (rendered.wasTruncated) truncatedLineNumbers.push(entry.lineNo);
 		renderedLines.push(rendered.line);
 		bytes += lineBytes;
-		if (bytes >= 102400) {
+		if (bytes >= MAX_BYTES) {
 			maxBytesReached = true;
 			break;
 		}
@@ -259035,7 +259040,7 @@ function containsNulByte(text) {
 function notReadableFileOutput(path) {
 	return `"${path}" is not readable as UTF-8 text. If it is an image or video, use ReadMediaFile. For other binary formats, use Bash or an MCP tool if available.`;
 }
-var MAX_LINES$1, MAX_LINE_LENGTH, MAX_BYTES, S_IFMT$1, S_IFREG, PositiveLineOffsetSchema, TailLineOffsetSchema, ReadInputSchema, READ_DESCRIPTION, ReadTool, readContinuationNotice;
+var MAX_LINES$1, MAX_LINE_LENGTH, MAX_BYTES, S_IFMT$1, S_IFREG, PositiveLineOffsetSchema, TailLineOffsetSchema, ReadInputSchema, READ_DESCRIPTION, ReadTool, readContinuationNotice, READ_MODEL_VISIBLE_BYTES;
 var init_read = __esmMin((() => {
 	init_zod$1();
 	init_tool_access();
@@ -259046,10 +259051,10 @@ var init_read = __esmMin((() => {
 	init_rule_match();
 	init_line_endings();
 	init_read$1();
-	({ readContinuationNotice } = createRequire(import.meta.url)("./bin/read-continuation-policy.cjs"));
+	({ readContinuationNotice, READ_MODEL_VISIBLE_BYTES } = createRequire(import.meta.url)("./bin/read-continuation-policy.cjs"));
 	MAX_LINES$1 = 1e3;
 	MAX_LINE_LENGTH = 2e3;
-	MAX_BYTES = 100 * 1024;
+	MAX_BYTES = READ_MODEL_VISIBLE_BYTES;
 	S_IFMT$1 = 61440;
 	S_IFREG = 32768;
 	PositiveLineOffsetSchema = number$1().int().min(1);
@@ -259297,7 +259302,7 @@ var init_read = __esmMin((() => {
 			let totalBytes = 0;
 			for (const [index, candidate] of renderedCandidates.entries()) totalBytes += renderedLineBytes(candidate.rendered.line, index === 0);
 			let maxBytesReached = false;
-			if (totalBytes > 102400) {
+			if (totalBytes > MAX_BYTES) {
 				maxBytesReached = true;
 				const kept = [];
 				let bytes = 0;
@@ -259305,7 +259310,7 @@ var init_read = __esmMin((() => {
 					const candidate = renderedCandidates[i];
 					if (candidate === void 0) continue;
 					const lineBytes = renderedLineBytes(candidate.rendered.line, kept.length === 0);
-					if (bytes + lineBytes > 102400) break;
+					if (bytes + lineBytes > MAX_BYTES) break;
 					kept.unshift(candidate);
 					bytes += lineBytes;
 				}
@@ -259343,7 +259348,10 @@ var init_read = __esmMin((() => {
 			if (input.maxLinesReached) parts.push(`Max ${String(MAX_LINES$1)} lines reached.`);
 			else if (input.maxBytesReached) parts.push(`Max ${String(MAX_BYTES)} bytes reached.`);
 			else if (lineCount < input.requestedLines) parts.push("End of file reached.");
-			const continuationNotice = readContinuationNotice(input);
+			const continuationNotice = readContinuationNotice({
+				...input,
+				renderedLineCount: lineCount
+			});
 			if (continuationNotice !== void 0) parts.push(continuationNotice);
 			if (input.truncatedLineNumbers.length > 0) parts.push(`Lines [${input.truncatedLineNumbers.join(", ")}] were truncated.`);
 			if (input.lineEndingStyle === "mixed") parts.push("Mixed or lone carriage-return line endings are shown as \\r. Use exact \\r\\n or \\r escapes in Edit.old_string for those lines.");
@@ -259613,7 +259621,7 @@ var init_write$1 = __esmMin((() => {
 }));
 //#endregion
 write_default = "Create, append to, or completely replace a file. Missing parent directories are created automatically. Overwrite is the default; append adds content at EOF without adding a newline.\n\nUse Write for a new file or a complete replacement. For every incremental change to an existing file, Use Edit instead, even when it is small. Read before overwriting an existing file. Do not create unsolicited documentation, README, summary, or report files unless the user or project instructions require them.\n\nContent is written literally. Never include Read/Edit line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nWrite complete files up to 4,096 UTF-8 bytes atomically. For a larger new or completely replaced file, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Set exact `expected_lines` and, when available, `expected_sha256`. Part 1 uses overwrite, `part=1`, and `start_line=1`; every later part uses append, the next consecutive part, and the exact `next_start_line` returned by Write. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. After an oversized plain Write is refused, that path accepts only continuation calls until the sequence completes. Restart an unfinished sequence only with part 1, overwrite, `start_line=1`, and `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
-write_default = "Create, append to, or replace a whole file. Missing parent directories are created automatically. Overwrite is default; append adds content at EOF without a newline.\n\nUse Write only for new files or complete replacements. Use Edit for every incremental change, even a small one. Read before overwriting an existing file. Do not create unsolicited documentation unless the user or project instructions require it.\n\nContent is literal. Never include line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nWrite complete files up to 4,096 UTF-8 bytes atomically. For a larger new or completely replaced file, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Optionally set exact `expected_lines` and, when available, `expected_sha256`. Part number, start line, and mode are derived from actually staged content when omitted. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. After an oversized plain Write is refused, that path accepts only continuation calls until the sequence completes. Restart an unfinished sequence with `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
+write_default = "Create, append to, or replace a whole file. Missing parent directories are created automatically. Overwrite is default; append adds content at EOF without a newline.\n\nUse Write only for new files or complete replacements. Use Edit for every incremental change, even a small one. Read before overwriting an existing file. Do not create unsolicited documentation unless the user or project instructions require it.\n\nContent is literal. Never include line prefixes. Supplied LF and CRLF endings are preserved. Large files and source files over 500 lines are accepted natively: the runtime fragments them on disk, assembles them through atomic replacement, and verifies the persisted SHA-256. No manual continuation calls or `single_file_override` are required.\n\nThe explicit `continuation` protocol remains available for streamed generation across several tool calls. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Optionally set exact `expected_lines` and, when available, `expected_sha256`. Part number, start line, and mode are derived from actually staged content when omitted. Set `final=true` only on the complete final part. The target file remains unchanged until final line-count and optional SHA-256 checks pass. Restart an unfinished sequence with `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
 //#region ../../packages/agent-core/src/tools/builtin/file/generated-source-health.ts
 /**
 * Find runaway generated identifiers while ignoring comments and strings.
@@ -259736,7 +259744,7 @@ function countCompletedLines(content) {
 	for (const character of content) if (character === "\n") count += 1;
 	return count;
 }
-var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract, resolvePlainWriteContract;
+var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract, resolvePlainWriteContract, splitNativeWriteBytes, writeNativeLargeContentOnDisk;
 var init_write = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -259748,7 +259756,8 @@ var init_write = __esmMin((() => {
 	init_write$1();
 	init_generated_source_health();
 	init_lsp_diagnostics();
-	({ resolveWriteContinuationContract, resolvePlainWriteContract } = createRequire(import.meta.url)("./bin/write-continuation-policy.cjs"));
+	({ resolveWriteContinuationContract, resolvePlainWriteContract, splitNativeWriteBytes } = createRequire(import.meta.url)("./bin/write-continuation-policy.cjs"));
+	({ writeNativeLargeContentOnDisk } = createRequire(import.meta.url)("./bin/native-large-file-io.cjs"));
 	S_IFMT = 61440;
 	S_IFDIR = 16384;
 	DEFAULT_CONTINUATION_CHUNK_BYTES = 2048;
@@ -259965,7 +259974,8 @@ bytesWritten: number$1().int().nonnegative() });
 			const lineLimit = evaluateSourceFileLineLimit(safePath, mode === "append" ? `${currentContent ?? ""}${args.content}` : args.content, {
 				currentContent,
 				singleFileOverride: args.single_file_override,
-				history: this.history
+				history: this.history,
+				nativeLargeFile: true
 			});
 			if (!lineLimit.allowed) return {
 				isError: true,
@@ -259978,12 +259988,14 @@ bytesWritten: number$1().int().nonnegative() });
 				continuationRequired: this.continuationRequiredPaths.has(safePath)
 			});
 			if (!allowLargeContent && !plainWrite.allowed) {
-				if (plainWrite.reason === "too_large") this.continuationRequiredPaths.add(safePath);
-				const reason = plainWrite.reason === "continuation_required" ? "an earlier oversized Write locked this path to the continuation protocol" : `the content is ${String(contentBytes)} UTF-8 bytes, above the ${String(plainWrite.directWriteLimit)}-byte direct-write limit`;
-				return {
-					isError: true,
-					output: `Refused to write ${args.path}: ${reason}. Start or resume continuation with {\"path\":${JSON.stringify(args.path)},\"content\":\"<complete-line chunk ending in \\\\n>\",\"continuation\":{}}. Each chunk may contain at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} UTF-8 bytes. No file was written.`
-				};
+				const chunks = splitNativeWriteBytes(args.content, this.maxContinuationChunkBytes);
+				const nativeResult = await this.writeNativeLargeContent(safePath, chunks, mode);
+				if (nativeResult.isError === true) return nativeResult;
+				this.continuationRequiredPaths.delete(safePath);
+				const notice = lineLimit.notice === void 0 ? "" : ` ${lineLimit.notice}`;
+				return appendLspDiagnostics({
+					output: `Native large-file write complete: ${String(contentBytes)} bytes in ${String(chunks.length)} fragments, SHA-256 ${nativeResult.sha256}.${notice}`
+				}, safePath, this.lsp);
 			}
 			const parentError = await this.ensureParentDirectory(safePath);
 			if (parentError !== void 0) return {
@@ -260007,6 +260019,22 @@ bytesWritten: number$1().int().nonnegative() });
 				};
 			}
 		}
+		async writeNativeLargeContent(safePath, chunks, mode) {
+			try {
+				const result = await writeNativeLargeContentOnDisk({
+					safePath,
+					chunks,
+					mode,
+					atomicWrite
+				});
+				return { isError: false, sha256: result.sha256 };
+			} catch (error) {
+				return {
+					isError: true,
+					output: `Native large-file write failed: ${error instanceof Error ? error.message : String(error)}. The target was left unchanged when atomic replacement had not completed.`
+				};
+			}
+		}
 		/**
 		* Best-effort check that the parent directory is usable, creating it when
 		* it is missing.
@@ -295887,7 +295915,7 @@ var init_connection_manager = __esmMin((() => {
 	init_public_display();
 	init_types$1();
 	DEFAULT_STARTUP_TIMEOUT_MS$1 = 3e4;
-	MCP_AUTO_RECONNECT_DELAYS_MS = [1e4];
+	MCP_AUTO_RECONNECT_DELAYS_MS = [1e4, 1e4, 1e4];
 	McpConnectionManager = class {
 		options;
 		entries = /* @__PURE__ */ new Map();
@@ -507411,7 +507439,7 @@ var SessionEventHandler = class {
 	renderedMcpServerStatusKeys = /* @__PURE__ */ new Map();
 	mcpServerStatusSpinners = /* @__PURE__ */ new Map();
 	mcpServers = /* @__PURE__ */ new Map();
-	mcpInventoryLogged = false;
+	mcpInventorySignature;
 	goalCompletionAwaitingClear = false;
 	goalCompletionTurnEnded = false;
 	currentTurnHasAssistantText = false;
@@ -507433,7 +507461,7 @@ var SessionEventHandler = class {
 		this.renderedPluginCommandActivationIds.clear();
 		this.renderedMcpServerStatusKeys.clear();
 		this.mcpServers.clear();
-		this.mcpInventoryLogged = false;
+		this.mcpInventorySignature = void 0;
 		this.goalCompletionAwaitingClear = false;
 		this.goalCompletionTurnEnded = false;
 		this.currentTurnHasAssistantText = false;
@@ -508224,10 +508252,12 @@ var SessionEventHandler = class {
 		}
 	}
 	logMcpInventoryIfReady(servers) {
-		if (this.mcpInventoryLogged || servers.some((server) => server.status === "pending")) return;
+		if (servers.some((server) => server.status === "pending")) return;
 		const inventory = mcpStartupInventory(servers);
+		const signature = `${inventory.serverCount}:${inventory.toolCount}`;
+		if (this.mcpInventorySignature === signature) return;
 		log.info("mcp startup inventory", inventory);
-		this.mcpInventoryLogged = true;
+		this.mcpInventorySignature = signature;
 	}
 	showMcpServerStatusSpinner(name) {
 		const { state } = this.host;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.298",
+  "version": "9.1.300",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {