blun-king-cli 9.1.536 → 9.1.561

package/bin/editable-tool-approval-runtime.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const {
+  canonicalEditedToolInputJson,
+  validateEditedToolInputObject,
+} = require('./editable-tool-approval-policy.cjs');
+
+class EditableToolReprepareError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'EditableToolReprepareError';
+    this.code = code;
+  }
+}
+
+function fail(code, message) {
+  throw new EditableToolReprepareError(code, message);
+}
+
+function buildEditedToolCallPlan({
+  step,
+  call,
+  editedArgs,
+  editCount,
+  preflightToolCall,
+} = {}) {
+  if (editCount !== 0) {
+    fail('EDITED_REPREPARE_ALREADY_EDITED', 'A tool call may be edited at most once.');
+  }
+  if (call?.kind !== 'runnable' || call.toolCall === null || typeof call.toolCall !== 'object' || typeof call.toolCall.id !== 'string' || typeof call.toolCall.name !== 'string') {
+    fail('EDITED_REPREPARE_CALL_INVALID', 'Only a runnable tool call can be re-prepared.');
+  }
+  if (!Array.isArray(step?.toolCalls) || typeof preflightToolCall !== 'function') {
+    fail('EDITED_REPREPARE_CONTEXT_INVALID', 'Edited re-preparation requires the active ordered tool-call list and preflight function.');
+  }
+
+  const matchingIndexes = [];
+  for (let index = 0; index < step.toolCalls.length; index += 1) {
+    if (step.toolCalls[index]?.id === call.toolCall.id) matchingIndexes.push(index);
+  }
+  if (matchingIndexes.length === 0) {
+    fail('EDITED_REPREPARE_IDENTITY_MISSING', 'The edited tool call is absent from the active ordered call list.');
+  }
+  if (matchingIndexes.length !== 1) {
+    fail('EDITED_REPREPARE_IDENTITY_AMBIGUOUS', 'The edited tool-call ID is not unique in the active call list.');
+  }
+  const position = matchingIndexes[0];
+  if (step.toolCalls[position] !== call.toolCall || call.toolName !== call.toolCall.name) {
+    fail('EDITED_REPREPARE_IDENTITY_CHANGED', 'The active tool-call identity changed before re-preparation.');
+  }
+
+  const safeEditedArgs = validateEditedToolInputObject(editedArgs);
+  const patchedToolCall = Object.freeze({
+    ...call.toolCall,
+    id: call.toolCall.id,
+    name: call.toolCall.name,
+    arguments: canonicalEditedToolInputJson(safeEditedArgs),
+  });
+  const patchedToolCalls = step.toolCalls.slice();
+  patchedToolCalls[position] = patchedToolCall;
+  const editedStep = {
+    ...step,
+    toolCalls: Object.freeze(patchedToolCalls),
+  };
+  const repreflight = preflightToolCall(editedStep, patchedToolCall);
+  if (repreflight === null || typeof repreflight !== 'object') {
+    fail('EDITED_REPREPARE_PREFLIGHT_INVALID', 'Edited tool preflight returned no result.');
+  }
+  if (repreflight.toolCall?.id !== call.toolCall.id || repreflight.toolCall?.name !== call.toolCall.name || repreflight.toolName !== call.toolName) {
+    fail('EDITED_REPREPARE_IDENTITY_CHANGED', 'Edited preflight changed the immutable tool identity.');
+  }
+  if (repreflight.kind === 'rejected') {
+    return Object.freeze({
+      kind: 'rejected',
+      step: editedStep,
+      call: repreflight,
+      editCount: 1,
+      output: repreflight.output,
+    });
+  }
+  if (repreflight.kind !== 'runnable') {
+    fail('EDITED_REPREPARE_PREFLIGHT_INVALID', 'Edited preflight returned an unsupported call state.');
+  }
+  if (repreflight.tool !== call.tool) {
+    fail('EDITED_REPREPARE_REGISTRY_CHANGED', 'The authoritative tool registry entry changed during edited approval.');
+  }
+  return Object.freeze({
+    kind: 'runnable',
+    step: editedStep,
+    call: repreflight,
+    editCount: 1,
+  });
+}
+
+module.exports = Object.freeze({
+  EditableToolReprepareError,
+  buildEditedToolCallPlan,
+});
+

package/bin/file-observation-policy.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+function versionFromStat(stat) {
+  if (!stat || typeof stat !== 'object') return null;
+  return [
+    stat.stDev ?? null,
+    stat.stIno ?? null,
+    stat.stSize ?? null,
+    stat.stMtime ?? null,
+  ].join(':');
+}
+
+function isNotFoundError(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
+}
+
+function createFileObservationPolicy(options = {}) {
+  const caseInsensitive = options.pathClass === 'win32';
+  const observations = new Map();
+
+  function key(filePath) {
+    const normalized = String(filePath).replaceAll('\\', '/');
+    return caseInsensitive ? normalized.toLowerCase() : normalized;
+  }
+
+  function recordPresent(filePath, stat) {
+    const version = versionFromStat(stat);
+    if (version === null) throw new TypeError('recordPresent requires a file stat');
+    observations.set(key(filePath), { kind: 'present', version });
+  }
+
+  function recordAbsent(filePath) {
+    observations.set(key(filePath), { kind: 'absent' });
+  }
+
+  function verifyStableRead(filePath, before, after) {
+    const beforeVersion = versionFromStat(before);
+    const afterVersion = versionFromStat(after);
+    if (beforeVersion === null || afterVersion === null || beforeVersion !== afterVersion) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `File changed while reading "${filePath}". Read it again before editing or overwriting it.`,
+      };
+    }
+    recordPresent(filePath, after);
+    return { allowed: true, version: afterVersion };
+  }
+
+  function authorizeEdit(filePath, currentStat) {
+    const prior = observations.get(key(filePath));
+    if (currentStat === null) {
+      return {
+        allowed: false,
+        code: prior?.kind === 'absent' ? 'FS_NOT_FOUND' : 'FS_NOT_OBSERVED',
+        error: prior?.kind === 'absent'
+          ? `Cannot edit "${filePath}": the last Read confirmed that it does not exist.`
+          : `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
+      };
+    }
+    if (prior === undefined) {
+      return {
+        allowed: false,
+        code: 'FS_NOT_OBSERVED',
+        error: `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
+      };
+    }
+    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `"${filePath}" changed since the last Read. Read it again, then retry the Edit.`,
+      };
+    }
+    return { allowed: true, version: prior.version };
+  }
+
+  function authorizeWrite(filePath, currentStat) {
+    const prior = observations.get(key(filePath));
+    if (currentStat === null) {
+      if (prior?.kind === 'present') {
+        return {
+          allowed: false,
+          code: 'FS_STALE_VERSION',
+          error: `"${filePath}" disappeared since the last Read. Read it again before recreating it.`,
+        };
+      }
+      return { allowed: true, version: null, create: true };
+    }
+    if (prior === undefined) {
+      return {
+        allowed: false,
+        code: 'FS_NOT_OBSERVED',
+        error: `Write would replace or append to existing file "${filePath}" without a prior Read. Read it first, then retry.`,
+      };
+    }
+    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `"${filePath}" changed since the last Read. Read it again, then retry the Write.`,
+      };
+    }
+    return { allowed: true, version: prior.version, create: false };
+  }
+
+  function verifyUnchanged(filePath, expectedVersion, currentStat) {
+    const currentVersion = versionFromStat(currentStat);
+    if (expectedVersion === currentVersion) return { allowed: true };
+    return {
+      allowed: false,
+      code: 'FS_STALE_VERSION',
+      error: expectedVersion === null
+        ? `"${filePath}" appeared before the new file could be created. Read it before deciding whether to overwrite it.`
+        : `"${filePath}" changed before the mutation was written. Read it again, then retry.`,
+    };
+  }
+
+  return {
+    authorizeEdit,
+    authorizeWrite,
+    recordAbsent,
+    recordPresent,
+    verifyStableRead,
+    verifyUnchanged,
+  };
+}
+
+module.exports = {
+  createFileObservationPolicy,
+  isNotFoundError,
+  versionFromStat,
+};

package/bin/html-to-research-markdown.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+const { Readability } = require('@mozilla/readability');
+const { parseHTML } = require('linkedom');
+const TurndownService = require('turndown');
+const { tables } = require('turndown-plugin-gfm');
+
+const MAX_LINK_LENGTH = 2_048;
+const JUNK_SELECTORS = Object.freeze([
+  'script',
+  'style',
+  'noscript',
+  'nav',
+  'footer',
+  'header',
+  'aside',
+  'iframe',
+  'svg',
+  'form',
+  'button',
+  'input',
+  '[role="navigation"]',
+  '[role="banner"]',
+  '[role="contentinfo"]',
+  '[aria-hidden="true"]',
+  '[hidden]',
+]);
+
+function canonicalBaseUrl(value) {
+  const parsed = new URL(value);
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error('HTML-to-Markdown base URL must use http or https.');
+  }
+  return parsed.toString();
+}
+
+function safeResolvedLink(raw, baseUrl) {
+  if (typeof raw !== 'string' || raw.trim().length === 0) return null;
+  let resolved;
+  try {
+    resolved = new URL(raw, baseUrl);
+  } catch {
+    return null;
+  }
+  if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:') return null;
+  const value = resolved.toString();
+  return value.length <= MAX_LINK_LENGTH ? value : null;
+}
+
+function removeAll(root, selector) {
+  for (const element of root.querySelectorAll(selector)) element.remove();
+}
+
+function sanitizeTree(root, baseUrl) {
+  for (const selector of JUNK_SELECTORS) removeAll(root, selector);
+
+  for (const element of root.querySelectorAll('[style]')) {
+    const style = element.getAttribute('style') ?? '';
+    if (/display\s*:\s*none|visibility\s*:\s*hidden/iu.test(style)) element.remove();
+  }
+
+  for (const selector of [
+    'sup.reference',
+    'sup.noprint',
+    '.reflist',
+    '.references',
+    '.refbegin',
+    '.catlinks',
+    '.mw-authority-control',
+  ]) removeAll(root, selector);
+
+  for (const anchor of root.querySelectorAll('a[href]')) {
+    const safe = safeResolvedLink(anchor.getAttribute('href'), baseUrl);
+    if (safe === null) anchor.removeAttribute('href');
+    else anchor.setAttribute('href', safe);
+  }
+
+  for (const image of root.querySelectorAll('img')) {
+    const alt = (image.getAttribute('alt') ?? '').trim();
+    if (alt.length > 0) image.replaceWith(image.ownerDocument.createTextNode(alt));
+    else image.remove();
+  }
+}
+
+function createMarkdownService() {
+  const service = new TurndownService({
+    headingStyle: 'atx',
+    codeBlockStyle: 'fenced',
+    bulletListMarker: '-',
+  });
+  service.use(tables);
+  service.remove(['script', 'style', 'noscript', 'iframe', 'svg']);
+  return service;
+}
+
+function withTitle(title, markdown) {
+  const cleanTitle = title.trim();
+  if (cleanTitle.length === 0) return markdown;
+  const titleHeading = `# ${cleanTitle}`;
+  if (markdown === titleHeading || markdown.startsWith(`${titleHeading}\n`)) return markdown;
+  return `${titleHeading}\n\n${markdown}`;
+}
+
+function renderRoot(root, title, safeBaseUrl) {
+  sanitizeTree(root, safeBaseUrl);
+  const fallback = (root.textContent ?? '').replace(/\s+/gu, ' ').trim();
+  let markdown = createMarkdownService().turndown(root.innerHTML).trim();
+  if (markdown.length === 0) markdown = fallback;
+  markdown = markdown.replace(/\n{4,}/gu, '\n\n\n').trim();
+  return withTitle(title, markdown);
+}
+
+function htmlToResearchMarkdown(html, baseUrl) {
+  if (typeof html !== 'string' || html.trim().length === 0) return '';
+  const safeBaseUrl = canonicalBaseUrl(baseUrl);
+  const primary = parseHTML(html);
+  try {
+    const article = new Readability(primary.document, { charThreshold: 0 }).parse();
+    if (article !== null && (article.content ?? '').trim().length > 0) {
+      const extracted = parseHTML(article.content);
+      const extractedRoot = extracted.document.querySelector('body');
+      if (extractedRoot !== null) {
+        const markdown = renderRoot(extractedRoot, article.title ?? '', safeBaseUrl);
+        if (markdown.length > 0) return markdown;
+      }
+    }
+  } catch {
+    // Keep the existing fail-open container fallback.
+  }
+
+  const { document } = parseHTML(html);
+  const title = (document.querySelector('title')?.textContent ?? '').trim();
+  const root = document.querySelector('article')
+    ?? document.querySelector('main')
+    ?? document.querySelector('[role="main"]')
+    ?? document.querySelector('body');
+  return root === null ? '' : renderRoot(root, title, safeBaseUrl);
+}
+
+module.exports = Object.freeze({
+  JUNK_SELECTORS,
+  MAX_LINK_LENGTH,
+  canonicalBaseUrl,
+  htmlToResearchMarkdown,
+  safeResolvedLink,
+});

package/bin/launcher-runtime.js

@@ -539,7 +539,6 @@ async function runLauncher(options = {}) {
     env.BLUN_SHARED_HOME = privatePaths.sharedHome;
     env.BLUN_LOG_HOME = privatePaths.sharedHome;
     env.BLUN_PROFILE = PROFILE.profileName;
-    env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
     const mnemoConnect = startMnemoConnectHeartbeat({
       env,
       profileName: PROFILE.profileName,

package/bin/micro-compaction-policy.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { createHash } = require('node:crypto');
+
 const MICRO_COMPACTION_PRESSURE_RATIO = 0.75;
 const MICRO_COMPACTION_MIN_ADVANCE_MESSAGES = 20;
 const MICRO_COMPACTION_RECENT_MESSAGES = 4;
@@ -46,6 +48,66 @@ function selectMicroCompactionCutoff(options = {}) {
   };
 }
 
+function redundantHistoricalToolResultIds(messages, cutoff) {
+  return new Set(redundantHistoricalToolResultReferences(messages, cutoff).keys());
+}
+
+function redundantHistoricalToolResultReferences(messages, cutoff) {
+  if (!Array.isArray(messages)) return new Map();
+
+  const historicalCutoff = Math.min(messages.length, nonNegativeInteger(cutoff));
+  const callSignatures = new Map();
+  for (const message of messages) {
+    if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      if (
+        typeof call?.id !== 'string'
+        || typeof call.name !== 'string'
+        || typeof call.arguments !== 'string'
+      ) {
+        continue;
+      }
+      callSignatures.set(call.id, JSON.stringify([call.name, call.arguments]));
+    }
+  }
+
+  const resultsBySignature = new Map();
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== 'tool' || typeof message.toolCallId !== 'string') continue;
+    const callSignature = callSignatures.get(message.toolCallId);
+    if (callSignature === undefined || !Array.isArray(message.content)) continue;
+
+    let resultSignature;
+    try {
+      resultSignature = createHash('sha256')
+        .update(callSignature)
+        .update('\0')
+        .update(JSON.stringify(message.content))
+        .digest('hex');
+    } catch {
+      continue;
+    }
+
+    const entries = resultsBySignature.get(resultSignature) ?? [];
+    entries.push({ index, toolCallId: message.toolCallId });
+    resultsBySignature.set(resultSignature, entries);
+  }
+
+  const redundantIds = new Map();
+  for (const entries of resultsBySignature.values()) {
+    if (entries.length < 2) continue;
+    const newestToolCallId = entries.at(-1)?.toolCallId;
+    if (newestToolCallId === undefined) continue;
+    for (const entry of entries.slice(0, -1)) {
+      if (entry.index < historicalCutoff) {
+        redundantIds.set(entry.toolCallId, newestToolCallId);
+      }
+    }
+  }
+  return redundantIds;
+}
+
 function finiteOr(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) ? number : fallback;
@@ -77,5 +139,7 @@ module.exports = {
   MICRO_COMPACTION_RECENT_MESSAGES,
   MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED,
   MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS,
+  redundantHistoricalToolResultIds,
+  redundantHistoricalToolResultReferences,
   selectMicroCompactionCutoff,
 };

package/bin/mnemo-connect-heartbeat.cjs

@@ -5,7 +5,6 @@ const os = require('node:os');
 
 const DEFAULT_HEARTBEAT_MS = 60_000;
 const DEFAULT_TIMEOUT_MS = 5_000;
-const DEFAULT_INTERNAL_HUB_URL = 'http://100.85.21.103:7117';
 
 function resolveMnemoHubUrl(env = process.env) {
   const raw = [
@@ -51,7 +50,7 @@ function resolveMnemoProfileConnectConfig(configPath) {
     ].some((value) => typeof value === 'string' && value.trim().length > 0);
     const baseUrl = resolveMnemoHubUrl(server.env);
     if (configuredUrl && !baseUrl) return null;
-    return { agentName, baseUrl: baseUrl || DEFAULT_INTERNAL_HUB_URL };
+    return baseUrl ? { agentName, baseUrl } : null;
   } catch {
     return null;
   }
@@ -196,7 +195,6 @@ function startMnemoConnectHeartbeat(options = {}) {
 
 module.exports = {
   DEFAULT_HEARTBEAT_MS,
-  DEFAULT_INTERNAL_HUB_URL,
   DEFAULT_TIMEOUT_MS,
   postMnemoTool,
   resolveMnemoAgentName,