blun-king-cli 9.1.550 → 9.1.562

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

@@ -28,8 +28,10 @@ function hasToolResultOffloadPressure(options = {}) {
   return hasContextPressure(options);
 }
 
-function shouldOffloadToolResult(textLength) {
-  return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
+function shouldOffloadToolResult(textLength, options = {}) {
+  return Number.isFinite(textLength)
+    && textLength > TOOL_RESULT_MAX_CHARS
+    && hasToolResultOffloadPressure(options);
 }
 
 function shouldKeepFreshToolResult(toolName) {
@@ -165,33 +167,8 @@ function compactPersistedToolResultReference(content) {
 }
 
 function compactHistoricalSuccessfulToolResults(messages, options = {}) {
-  if (!Array.isArray(messages) || messages.length === 0) return messages;
-  if (!hasToolResultOffloadPressure(options)) 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;
+  void options;
+  return messages;
 }
 
 function toolCallSignaturesById(messages) {
@@ -280,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;
   }
 

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) {
@@ -1632,6 +1647,7 @@ module.exports = {
   compareSemver,
   createInstallInvocation,
   installPinnedVersion,
+  isInternalPackagePinned,
   preparePinnedInstaller,
   isInteractiveUpdateStart,
   loadReleaseSources,