blun-king-cli 9.1.58 → 9.1.61

package/bin/standard-tools-bootstrap.js

@@ -74,6 +74,41 @@ function hasEquivalentServer(servers, name, tool) {
   });
 }
 
+function sameStringArray(left, right) {
+  return Array.isArray(left)
+    && Array.isArray(right)
+    && left.length === right.length
+    && left.every((value, index) => value === right[index]);
+}
+
+function recognizedBundledServer(current, expected) {
+  return isObject(current)
+    && current.transport === expected.transport
+    && current.command === expected.command
+    && sameStringArray(current.args, expected.args);
+}
+
+function migrateBundledTimeouts(name, current, expected) {
+  if (!recognizedBundledServer(current, expected)) return false;
+  let changed = false;
+  if (name === 'agent-browser') {
+    if (current.startupTimeoutMs === 30_000) {
+      current.startupTimeoutMs = expected.startupTimeoutMs;
+      changed = true;
+    }
+    if (current.toolTimeoutMs === 60_000) {
+      current.toolTimeoutMs = expected.toolTimeoutMs;
+      changed = true;
+    }
+  }
+  if (name === 'blun-language-guard'
+    && (current.toolTimeoutMs === 30_000 || current.toolTimeoutMs === 60_000)) {
+    current.toolTimeoutMs = expected.toolTimeoutMs;
+    changed = true;
+  }
+  return changed;
+}
+
 function writeMcpDocument(configPath, document) {
   const temporaryPath = path.join(
     path.dirname(configPath),
@@ -160,21 +195,27 @@ function seedStandardTools({
   const document = readMcpDocument(configPath);
   const servers = { ...document.mcpServers };
   const added = [];
+  const updated = [];
 
   for (const name of selectedNames) {
     const tool = catalogue.tools[name];
-    if (hasEquivalentServer(servers, name, tool)) continue;
-    servers[name] = bundledToolConfig(name, tool, {
+    const expected = bundledToolConfig(name, tool, {
       packageRoot,
       blunDir,
       platform,
       env,
     });
+    if (Object.hasOwn(servers, name)) {
+      if (migrateBundledTimeouts(name, servers[name], expected)) updated.push(name);
+      continue;
+    }
+    if (hasEquivalentServer(servers, name, tool)) continue;
+    servers[name] = expected;
     added.push(name);
   }
 
-  if (added.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
-  return { added, configPath };
+  if (added.length > 0 || updated.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
+  return { added, updated, configPath };
 }
 
 function seedStandardDesignSkill({ packageRoot, blunDir }) {

package/bin/subagent-timeout-policy.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+const DEFAULT_SUBAGENT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
+const MAX_SUBAGENT_TIMEOUT_MINUTES = 7 * 24 * 60;
+const SUBAGENT_TIMEOUT_ENV = "BLUN_SUBAGENT_TIMEOUT_MINUTES";
+
+function resolveSubagentTimeoutMs({ perRunMinutes, env = process.env } = {}) {
+  const raw = perRunMinutes ?? env[SUBAGENT_TIMEOUT_ENV];
+  if (raw === undefined || raw === null || raw === "") {
+    return DEFAULT_SUBAGENT_TIMEOUT_MS;
+  }
+
+  const minutes = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isInteger(minutes) || minutes < 0 || minutes > MAX_SUBAGENT_TIMEOUT_MINUTES) {
+    throw new Error(
+      `${SUBAGENT_TIMEOUT_ENV} must be an integer from 0 to ${MAX_SUBAGENT_TIMEOUT_MINUTES} minutes.`,
+    );
+  }
+  return minutes === 0 ? undefined : minutes * 60 * 1000;
+}
+
+function abortError(reason) {
+  if (reason instanceof Error) return reason;
+  return new Error(reason === undefined ? "Subagent interrupted." : String(reason));
+}
+
+async function runAgentWithTimeoutContinuation({
+  handle,
+  timeoutMs,
+  signal,
+  abortCurrent,
+  retrySameAgent,
+}) {
+  let currentHandle = handle;
+
+  while (true) {
+    let timeout;
+    let removeAbortListener = () => {};
+    const completion = Promise.resolve(currentHandle.completion).then(
+      (outcome) => ({ kind: "completed", outcome }),
+      (error) => ({ kind: "failed", error }),
+    );
+    const timedOut = timeoutMs === undefined
+      ? new Promise(() => {})
+      : new Promise((resolve) => {
+          timeout = setTimeout(() => resolve({ kind: "timed_out" }), timeoutMs);
+        });
+    const interrupted = signal.aborted
+      ? Promise.resolve({ kind: "interrupted", reason: signal.reason })
+      : new Promise((resolve) => {
+          const onAbort = () => resolve({ kind: "interrupted", reason: signal.reason });
+          signal.addEventListener("abort", onAbort, { once: true });
+          removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+        });
+
+    const result = await Promise.race([completion, timedOut, interrupted]);
+    if (timeout !== undefined) clearTimeout(timeout);
+    removeAbortListener();
+
+    if (result.kind === "completed") return { handle: currentHandle, outcome: result.outcome };
+    if (result.kind === "failed") throw result.error;
+    if (result.kind === "interrupted") {
+      abortCurrent(result.reason);
+      await Promise.resolve(currentHandle.completion).catch(() => {});
+      throw abortError(result.reason);
+    }
+
+    const reason = new Error("Subagent continuation interval elapsed.");
+    abortCurrent(reason);
+    await Promise.resolve(currentHandle.completion).catch(() => {});
+    currentHandle = await retrySameAgent(currentHandle.agentId);
+  }
+}
+
+module.exports = {
+  DEFAULT_SUBAGENT_TIMEOUT_MS,
+  resolveSubagentTimeoutMs,
+  runAgentWithTimeoutContinuation,
+};

package/bin/update-notice.js

@@ -54,8 +54,18 @@ const LEGACY_MANIFEST_KEYS = Object.freeze([
   'notesUrl',
   'releasedAt',
 ]);
+const RELEASE_NOTES_MANIFEST_KEYS = Object.freeze([
+  'install',
+  'latest',
+  'minSupported',
+  'name',
+  'notesUrl',
+  'releaseNotes',
+  'releasedAt',
+]);
 const MANIFEST_KEYS = Object.freeze([
   'install',
+  'integrity',
   'latest',
   'minSupported',
   'name',
@@ -214,8 +224,20 @@ function parseReleaseNotes(value) {
   return Object.freeze(notes);
 }
 
+function validIntegrity(value) {
+  if (typeof value !== 'string') return false;
+  const match = /^sha512-([A-Za-z0-9+/]+={0,2})$/u.exec(value);
+  if (!match) return false;
+  try {
+    return Buffer.from(match[1], 'base64').length === 64;
+  } catch {
+    return false;
+  }
+}
+
 function parseFallbackManifest(value) {
   const record = exactDataRecord(value, MANIFEST_KEYS)
+    || exactDataRecord(value, RELEASE_NOTES_MANIFEST_KEYS)
     || exactDataRecord(value, LEGACY_MANIFEST_KEYS);
   const notesUrl = record ? canonicalOfficialNotesUrl(record.notesUrl) : undefined;
   const releaseNotes = record && Object.hasOwn(record, 'releaseNotes')
@@ -228,6 +250,7 @@ function parseFallbackManifest(value) {
     || compareSemver(record.minSupported, record.latest) === 1
     || !isIsoTimestamp(record.releasedAt)
     || !notesUrl
+    || (Object.hasOwn(record, 'integrity') && !validIntegrity(record.integrity))
     || (Object.hasOwn(record, 'releaseNotes') && releaseNotes === undefined)
     || !isBoundedText(record.install, 256)) {
     return undefined;
@@ -238,6 +261,7 @@ function parseFallbackManifest(value) {
     minSupported: record.minSupported,
     releasedAt: record.releasedAt,
     notesUrl,
+    ...(Object.hasOwn(record, 'integrity') ? { integrity: record.integrity } : {}),
     ...(releaseNotes === undefined ? {} : { releaseNotes }),
     install: record.install,
   });