blun-king-cli 9.1.536 → 9.1.561

package/bin/tool-file-persistence.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+const { randomBytes } = require('node:crypto');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const WINDOWS_RENAME_RETRY_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);
+const DEFAULT_WINDOWS_RENAME_DELAYS_MS = Object.freeze([10, 25, 50, 100]);
+
+function isAbortError(error) {
+  return error instanceof Error && error.name === 'AbortError';
+}
+
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error('Atomic tool write aborted before publication.');
+  error.name = 'AbortError';
+  throw error;
+}
+
+function isMissing(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
+}
+
+async function existingFileMode(filePath, statFile) {
+  try {
+    const info = await statFile(filePath);
+    if (!info.isFile()) throw Object.assign(new Error(`Cannot replace non-file target: ${filePath}`), { code: 'EISDIR' });
+    return typeof info.mode === 'number' ? info.mode & 0o777 : undefined;
+  } catch (error) {
+    if (isMissing(error)) return undefined;
+    throw error;
+  }
+}
+
+async function resolvePublicationPath(filePath, operations) {
+  try {
+    return await operations.realpathFile(filePath);
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+
+  try {
+    const linkInfo = await operations.lstatFile(filePath);
+    if (linkInfo.isSymbolicLink()) {
+      throw Object.assign(new Error(`Refused atomic replacement through dangling symbolic link: ${filePath}`), { code: 'ELOOP' });
+    }
+  } catch (error) {
+    if (!isMissing(error)) throw error;
+  }
+
+  const realParent = await operations.realpathFile(path.dirname(filePath));
+  return path.join(realParent, path.basename(filePath));
+}
+
+async function renameWithWindowsRetry(source, target, options) {
+  const delays = options.platform === 'win32'
+    ? options.windowsRenameDelaysMs
+    : [];
+  let attempt = 0;
+  while (true) {
+    try {
+      await options.renameFile(source, target);
+      return;
+    } catch (error) {
+      const delayMs = delays[attempt];
+      if (delayMs === undefined || !WINDOWS_RENAME_RETRY_CODES.has(error?.code)) throw error;
+      attempt += 1;
+      throwIfAborted(options.signal);
+      await options.sleep(delayMs);
+    }
+  }
+}
+
+async function writeToolTextAtomic(filePath, content, options = {}) {
+  if (typeof filePath !== 'string' || filePath.length === 0) throw new TypeError('filePath must be a non-empty string');
+  if (typeof content !== 'string' && !Buffer.isBuffer(content)) throw new TypeError('content must be a string or Buffer');
+
+  const openFile = options.openFile || fs.open;
+  const renameFile = options.renameFile || fs.rename;
+  const unlinkFile = options.unlinkFile || fs.unlink;
+  const statFile = options.statFile || fs.stat;
+  const lstatFile = options.lstatFile || fs.lstat;
+  const realpathFile = options.realpathFile || fs.realpath;
+  const syncHandle = options.syncHandle || ((handle) => handle.sync());
+  const sleep = options.sleep || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+  const signal = options.signal;
+  const platform = options.platform || process.platform;
+  const windowsRenameDelaysMs = options.windowsRenameDelaysMs || DEFAULT_WINDOWS_RENAME_DELAYS_MS;
+
+  throwIfAborted(signal);
+  const publicationPath = await resolvePublicationPath(filePath, { lstatFile, realpathFile });
+  const mode = await existingFileMode(publicationPath, statFile);
+  const suffix = `${process.pid}.${randomBytes(6).toString('hex')}`;
+  const temporaryPath = path.join(path.dirname(publicationPath), `.${path.basename(publicationPath)}.${suffix}.tmp`);
+  let handle;
+  let published = false;
+
+  try {
+    handle = await openFile(temporaryPath, 'wx', mode ?? 0o666);
+    await handle.writeFile(content, typeof content === 'string' ? { encoding: 'utf8', signal } : { signal });
+    await syncHandle(handle);
+    if (mode !== undefined && platform !== 'win32') await handle.chmod(mode);
+    await handle.close();
+    handle = undefined;
+
+    throwIfAborted(signal);
+    await renameWithWindowsRetry(temporaryPath, publicationPath, {
+      platform,
+      renameFile,
+      signal,
+      sleep,
+      windowsRenameDelaysMs,
+    });
+    published = true;
+    return { bytesWritten: Buffer.byteLength(content) };
+  } finally {
+    if (handle !== undefined) {
+      try {
+        await handle.close();
+      } catch {}
+    }
+    if (!published) {
+      try {
+        await unlinkFile(temporaryPath);
+      } catch (error) {
+        if (!isMissing(error)) {
+          // The primary write error remains authoritative; stale temp names are unique and never read.
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  DEFAULT_WINDOWS_RENAME_DELAYS_MS,
+  WINDOWS_RENAME_RETRY_CODES,
+  renameWithWindowsRetry,
+  resolvePublicationPath,
+  writeToolTextAtomic,
+};

package/bin/tool-result-offload-policy.cjs

@@ -1,5 +1,10 @@
 'use strict';
 
+const {
+  DEFAULT_CONTEXT_PRESSURE_RATIO,
+  hasContextPressure,
+} = require('./context-pressure-policy.cjs');
+
 const TOOL_RESULT_MAX_CHARS = 12_000;
 const TOOL_RESULT_PREVIEW_CHARS = 2_000;
 const TOOL_RESULT_HISTORICAL_PREVIEW_CHARS = 400;
@@ -16,10 +21,17 @@ const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 1_000;
 const TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES = 12;
 const TOOL_RESULT_HISTORICAL_SUCCESS_MARKER = '[Old tool result content cleared]';
 const TOOL_RESULT_REPEAT_MARKER = '[Repeated tool result omitted]';
+const TOOL_RESULT_OFFLOAD_PRESSURE_RATIO = DEFAULT_CONTEXT_PRESSURE_RATIO;
 const READ_CONTINUATION_LINE_OFFSET_RE = /^Continue reading with line_offset=(\d+)\. Do not assume you have reached the end of the file\.$/mu;
 
-function shouldOffloadToolResult(textLength) {
-  return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
+function hasToolResultOffloadPressure(options = {}) {
+  return hasContextPressure(options);
+}
+
+function shouldOffloadToolResult(textLength, options = {}) {
+  return Number.isFinite(textLength)
+    && textLength > TOOL_RESULT_MAX_CHARS
+    && hasToolResultOffloadPressure(options);
 }
 
 function shouldKeepFreshToolResult(toolName) {
@@ -154,33 +166,9 @@ function compactPersistedToolResultReference(content) {
   return changed ? compacted : content;
 }
 
-function compactHistoricalSuccessfulToolResults(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-
-  const recentStart = Math.max(0, messages.length - TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES);
-  const freshIds = freshToolResultIds(messages);
-  let changed = false;
-  const projected = messages.map((message, index) => {
-    if (
-      index >= recentStart
-      || message?.role !== 'tool'
-      || freshIds.has(message.toolCallId)
-      || message.isError === true
-      || !Array.isArray(message.content)
-      || isPersistedToolResultReference(message.content)
-      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
-    ) return message;
-
-    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
-    if (textChars <= TOOL_RESULT_HISTORICAL_SUCCESS_MARKER.length) return message;
-    changed = true;
-    return {
-      ...message,
-      content: [{ type: 'text', text: TOOL_RESULT_HISTORICAL_SUCCESS_MARKER }],
-    };
-  });
-
-  return changed ? projected : messages;
+function compactHistoricalSuccessfulToolResults(messages, options = {}) {
+  void options;
+  return messages;
 }
 
 function toolCallSignaturesById(messages) {
@@ -269,10 +257,12 @@ function dedupeRepeatedSuccessfulToolResults(sourceMessages, projectedMessages =
       ...projectedMessage,
       content: [{ type: 'text', text: reference }],
     };
-    projected[newest.index] = {
-      ...projected[newest.index],
-      content: sourceMessages[newest.index].content,
-    };
+    if (projected[newest.index] !== sourceMessages[newest.index]) {
+      projected[newest.index] = {
+        ...projected[newest.index],
+        content: sourceMessages[newest.index].content,
+      };
+    }
     changed = true;
   }
 
@@ -326,6 +316,7 @@ function selectHistoricalToolResultOffloads(textLengths) {
 }
 
 module.exports = {
+  TOOL_RESULT_OFFLOAD_PRESSURE_RATIO,
   TOOL_RESULT_BATCH_MAX_CHARS,
   TOOL_RESULT_BATCH_MIN_ITEM_CHARS,
   TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS,
@@ -349,6 +340,7 @@ module.exports = {
   currentUserTurnStartIndex,
   dedupeRepeatedSuccessfulToolResults,
   freshToolResultIds,
+  hasToolResultOffloadPressure,
   isPersistedToolResultReference,
   readContinuationLineOffset,
   selectHistoricalToolResultOffloads,

package/bin/turn-thinking-policy.cjs

@@ -7,9 +7,6 @@ const BOSNIAN_STANDALONE_CHAT = /^(?:zdravo|pozdrav|hvala|ćao|cao)[.!?]*$/iu;
 const IDENTITY_CHAT = /^(?:wer bist du|who are you|wie geht(?: es dir)?|how are you|na|kako si|kako je king|ko si ti|ko stoji iza tebe)[.!?]*$/iu;
 const STATUS_ONLY_CHECK_IN = /(?:\bstandabfrage\b|\bstatusabfrage\b|\bkurzes?\s+update\b|\bwo\s+stehst\s+du\b|\bwie\s+weit\s+bist\s+du\b|\bwhere\s+are\s+you\b|\bquick\s+status\b)/iu;
 const STATUS_FOLLOW_UP_ACTION = /\b(?:aendere|arbeite|baue|build|change|delete|deploy|deploye|fahr|fix|fixe|implement|implementiere|install|installiere|loesche|mach|patch|pruefe|repariere|run|schreibe|setze|start|starte|stop|stoppe|test|teste|write)\b/iu;
-const STANDALONE_CHAT_COMPLETION_TOKENS = 1024;
-const ADAPTIVE_LOW_COMPLETION_TOKENS = 4096;
-const STANDARD_TURN_MAX_COMPLETION_TOKENS = 24_576;
 
 function selectThinkingEffortForTurn(text, originKind) {
   if (originKind !== "user") return undefined;
@@ -45,25 +42,8 @@ function selectThinkingEffortForWorkStep(_stepNumber, _previousToolOutcome) {
 }
 
 function capCompletionBudgetForAdaptiveEffort(budget, thinkingEffort) {
-  if ((thinkingEffort !== "off" && thinkingEffort !== "low") || budget === undefined) return budget;
-  const configuredCap = budget.hardCap ?? budget.fallback;
-  const adaptiveCap = thinkingEffort === "off"
-    ? STANDALONE_CHAT_COMPLETION_TOKENS
-    : ADAPTIVE_LOW_COMPLETION_TOKENS;
-  return {
-    ...budget,
-    hardCap: Math.min(
-      configuredCap ?? adaptiveCap,
-      adaptiveCap,
-    ),
-  };
-}
-
-function capTurnCompletionTokens(maxOutputSize) {
-  if (!Number.isFinite(maxOutputSize) || maxOutputSize <= 0) {
-    return STANDARD_TURN_MAX_COMPLETION_TOKENS;
-  }
-  return Math.min(Math.floor(maxOutputSize), STANDARD_TURN_MAX_COMPLETION_TOKENS);
+  void thinkingEffort;
+  return budget;
 }
 
 function selectThinkingEffortForBufferedSteer(text, originKind) {
@@ -77,12 +57,8 @@ function selectThinkingEffortForBufferedSteer(text, originKind) {
 
 module.exports = {
   ACTIONABLE_PROMPT,
-  ADAPTIVE_LOW_COMPLETION_TOKENS,
   EXPLICIT_THINKING_INTENT,
-  STANDALONE_CHAT_COMPLETION_TOKENS,
-  STANDARD_TURN_MAX_COMPLETION_TOKENS,
   capCompletionBudgetForAdaptiveEffort,
-  capTurnCompletionTokens,
   selectThinkingEffortForBufferedSteer,
   selectThinkingEffortForWorkStep,
   selectThinkingEffortForTurn,

package/bin/update-notice.js

@@ -82,6 +82,15 @@ const ENDPOINT_LIMITS = new Map([
   [FALLBACK_MANIFEST_URL, 64 * 1024],
 ]);
 
+function isInternalPackagePinned(packageRoot) {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    return manifest?.blunUpdateChannel === 'internal';
+  } catch {
+    return false;
+  }
+}
+
 function parseSemver(value) {
   if (typeof value !== 'string' || value.length > 128) return undefined;
   const match = SEMVER_PATTERN.exec(value);
@@ -1393,6 +1402,12 @@ async function runUpdateFlow(options, explicitUpdate) {
   const now = (options.now || Date.now)();
 
   const packageRoot = path.resolve(options.packageRoot || path.resolve(__dirname, '..'));
+  if (isInternalPackagePinned(packageRoot)) {
+    if (explicitUpdate) explicitNoTarget(stdout, 'current', currentVersion, uiLocale);
+    return explicitUpdate
+      ? { kind: 'current', reason: 'internal_channel' }
+      : { kind: 'continue', reason: 'internal_channel' };
+  }
   let leaseResult;
   const ownsNoticeLease = options.noticeLease === undefined;
   if (ownsNoticeLease) {
@@ -1484,20 +1499,6 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitFailure(stderr, 'lease_unavailable', undefined, uiLocale)
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
-    if (!options.installVersion) {
-      installerSession = await (options.prepareInstaller || preparePinnedInstaller)(
-        release.version,
-        { blunDir, packageRoot },
-      );
-      if (!installerSession?.ready) {
-        if (explicitUpdate) {
-          return explicitFailure(stderr, 'installer_unavailable', undefined, uiLocale);
-        }
-        return installerSession?.reason === 'failed'
-          ? { kind: 'continue', reason: 'installer_unavailable' }
-          : { kind: 'update_in_progress' };
-      }
-    }
     let action;
     if (explicitUpdate || options.autoInstall === true) {
       action = 'install';
@@ -1515,10 +1516,6 @@ async function runUpdateFlow(options, explicitUpdate) {
       }
     }
     if (action !== 'install') {
-      if (installerSession?.ready) {
-        await installerSession.cancel();
-        installerSession = undefined;
-      }
       if (action === 'skip-once') {
         return { kind: 'continue', reason: 'skipped_once' };
       }
@@ -1537,6 +1534,20 @@ async function runUpdateFlow(options, explicitUpdate) {
       }
       return { kind: 'continue', reason: 'postponed' };
     }
+    if (!options.installVersion) {
+      installerSession = await (options.prepareInstaller || preparePinnedInstaller)(
+        release.version,
+        { blunDir, packageRoot },
+      );
+      if (!installerSession?.ready) {
+        if (explicitUpdate) {
+          return explicitFailure(stderr, 'installer_unavailable', undefined, uiLocale);
+        }
+        return installerSession?.reason === 'failed'
+          ? { kind: 'continue', reason: 'installer_unavailable' }
+          : { kind: 'update_in_progress' };
+      }
+    }
 
     const updateProgress = createUpdateProgress(stdout);
     updateProgress(1, copy.updateChecked);
@@ -1636,6 +1647,7 @@ module.exports = {
   compareSemver,
   createInstallInvocation,
   installPinnedVersion,
+  isInternalPackagePinned,
   preparePinnedInstaller,
   isInteractiveUpdateStart,
   loadReleaseSources,

package/bin/user-message-offload-policy.cjs

@@ -4,6 +4,7 @@ const {
   hasHistoricalOffloadPressure,
   historyTextChars,
 } = require('./history-offload-pressure-policy.cjs');
+const { hasContextPressure } = require('./context-pressure-policy.cjs');
 
 const USER_MESSAGE_MAX_CHARS = 200_000;
 const HISTORICAL_USER_MESSAGE_MAX_CHARS = 4_000;
@@ -30,7 +31,8 @@ function shouldOffloadHistoricalUserMessage(options = {}) {
     || historyIndex >= historyLength
   ) return false;
   const cutoff = Math.max(0, historyLength - USER_MESSAGE_KEEP_RECENT_MESSAGES);
-  return hasHistoricalOffloadPressure({ historyLength, historyChars })
+  return hasContextPressure(options)
+    && hasHistoricalOffloadPressure({ historyLength, historyChars })
     && historyIndex < cutoff
     && textChars > HISTORICAL_USER_MESSAGE_MAX_CHARS;
 }