blun-king-cli 9.1.286 → 9.1.288

package/bin/launcher-runtime.js

@@ -26,6 +26,7 @@ const {
 const { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
+const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
@@ -923,13 +924,22 @@ async function runLauncher(options = {}) {
     env.BLUN_LOG_HOME = privatePaths.sharedHome;
     env.BLUN_PROFILE = PROFILE.profileName;
     env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
-    process.exitCode = await superviseProtectedCore(
-      ARGS,
+    const mnemoConnect = startMnemoConnectHeartbeat({
       env,
-      callerCwd,
-      releaseNotice,
-      { startupPendingRuntime, staleActiveRuntime },
-    );
+      profileName: PROFILE.profileName,
+      version: readPackageVersion(),
+    });
+    try {
+      process.exitCode = await superviseProtectedCore(
+        ARGS,
+        env,
+        callerCwd,
+        releaseNotice,
+        { startupPendingRuntime, staleActiveRuntime },
+      );
+    } finally {
+      await mnemoConnect.stop();
+    }
   } finally {
     await releaseNotice();
   }

package/bin/mnemo-connect-heartbeat.cjs

@@ -0,0 +1,173 @@
+'use strict';
+
+const os = require('node:os');
+
+const DEFAULT_HEARTBEAT_MS = 60_000;
+const DEFAULT_TIMEOUT_MS = 5_000;
+
+function resolveMnemoHubUrl(env = process.env) {
+  const raw = [
+    env.BLUN_MNEMO_HUB_URL,
+    env.MNEMO_HUB_URL,
+    env.MNEMO_URL,
+  ].find((value) => typeof value === 'string' && value.trim().length > 0);
+  if (!raw) return null;
+
+  try {
+    const url = new URL(raw.trim());
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return null;
+    url.pathname = url.pathname.replace(/\/+$/u, '');
+    url.search = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/u, '');
+  } catch {
+    return null;
+  }
+}
+
+function resolveMnemoAgentName(profileName, env = process.env) {
+  const configured = typeof env.BLUN_MNEMO_AGENT === 'string'
+    ? env.BLUN_MNEMO_AGENT.trim()
+    : '';
+  return configured || String(profileName || '').trim();
+}
+
+async function postMnemoTool(baseUrl, tool, payload, options = {}) {
+  const controller = new AbortController();
+  const timeout = (options.setTimeoutImpl || setTimeout)(
+    () => controller.abort(),
+    options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+  );
+  timeout.unref?.();
+  try {
+    const response = await (options.fetchImpl || fetch)(
+      `${baseUrl}/tool/${encodeURIComponent(tool)}`,
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      },
+    );
+    if (!response.ok) throw new Error(`Mnemo ${tool} HTTP ${response.status}`);
+    const body = await response.json();
+    if (body && body.error) {
+      throw new Error(typeof body.error === 'string' ? body.error : JSON.stringify(body.error));
+    }
+    return body;
+  } finally {
+    (options.clearTimeoutImpl || clearTimeout)(timeout);
+  }
+}
+
+function startMnemoConnectHeartbeat(options = {}) {
+  const env = options.env || process.env;
+  const baseUrl = options.baseUrl || resolveMnemoHubUrl(env);
+  const agentName = options.agentName || resolveMnemoAgentName(options.profileName, env);
+  if (!baseUrl || !agentName) {
+    return Object.freeze({ enabled: false, ready: Promise.resolve(false), stop: async () => {} });
+  }
+
+  const intervalMs = options.intervalMs ?? DEFAULT_HEARTBEAT_MS;
+  const hostname = options.hostname || os.hostname();
+  const pid = options.pid ?? process.pid;
+  const callTool = options.callTool || ((tool, payload) => postMnemoTool(baseUrl, tool, payload, options));
+  const setIntervalImpl = options.setIntervalImpl || setInterval;
+  const clearIntervalImpl = options.clearIntervalImpl || clearInterval;
+  const onState = typeof options.onState === 'function' ? options.onState : () => {};
+  let stopped = false;
+  let registered = false;
+  let inFlight = null;
+
+  const register = async () => {
+    await callTool('mem_connect_register', {
+      agent_name: agentName,
+      display_name: agentName,
+      host: hostname,
+      pid,
+      skills: ['blun-king'],
+      meta: {
+        source: 'blun-king-cli',
+        runtime: 'king',
+        profile: String(options.profileName || agentName),
+        version: options.version || null,
+      },
+    });
+    registered = true;
+    onState({ kind: 'registered', agentName, baseUrl });
+  };
+
+  const runPulse = async () => {
+    if (stopped) return false;
+    if (!registered) await register();
+    const result = await callTool('mem_connect_heartbeat', {
+      agent_name: agentName,
+      status: 'online',
+      meta: {
+        source: 'blun-king-cli',
+        runtime: 'king',
+        profile: String(options.profileName || agentName),
+        version: options.version || null,
+      },
+    });
+    const payload = result && typeof result === 'object' && result.result
+      ? result.result
+      : result;
+    if (payload && payload.updated === false) {
+      registered = false;
+      await register();
+    }
+    onState({ kind: 'heartbeat', agentName, baseUrl });
+    return true;
+  };
+
+  const pulse = () => {
+    if (stopped) return Promise.resolve(false);
+    if (inFlight) return inFlight;
+    inFlight = runPulse()
+      .catch((error) => {
+        registered = false;
+        onState({ kind: 'error', agentName, baseUrl, error });
+        return false;
+      })
+      .finally(() => { inFlight = null; });
+    return inFlight;
+  };
+
+  const ready = pulse();
+  const timer = setIntervalImpl(() => { void pulse(); }, intervalMs);
+  timer.unref?.();
+
+  return Object.freeze({
+    enabled: true,
+    agentName,
+    baseUrl,
+    ready,
+    pulse,
+    async stop(stopOptions = {}) {
+      if (stopped) return;
+      stopped = true;
+      clearIntervalImpl(timer);
+      if (inFlight) await inFlight;
+      if (stopOptions.offline === false || !registered) return;
+      try {
+        await callTool('mem_connect_heartbeat', {
+          agent_name: agentName,
+          status: 'offline',
+          meta: { source: 'blun-king-cli', runtime: 'king' },
+        });
+      } catch (error) {
+        onState({ kind: 'error', agentName, baseUrl, error });
+      }
+    },
+  });
+}
+
+module.exports = {
+  DEFAULT_HEARTBEAT_MS,
+  DEFAULT_TIMEOUT_MS,
+  postMnemoTool,
+  resolveMnemoAgentName,
+  resolveMnemoHubUrl,
+  startMnemoConnectHeartbeat,
+};

package/bin/turn-tool-performance-policy.cjs

@@ -4,6 +4,7 @@ const TOOL_SCHEMA_BUDGET_RATIO = 0.25;
 const TOOL_SCHEMA_MAX_TOKENS = 32_000;
 const DEFERRED_TOOL_LOADER_NAME = 'ToolSearch';
 const MAX_PERSISTENT_DEFERRED_TOOLS = 4;
+const MAX_TOOL_SEARCH_QUERY_CHARS = 1_000;
 const TOOL_SEARCH_INTENT_WORDS = new Set([
   'find', 'fetch', 'get', 'holen', 'list', 'read', 'search', 'show', 'anzeigen', 'lesen', 'suchen',
 ]);
@@ -83,8 +84,18 @@ function deferredToolCatalog(tools) {
     .sort((left, right) => left.localeCompare(right));
 }
 
+function normalizeDeferredToolQuery(value) {
+  const query = String(value ?? '').trim();
+  if (query.length <= MAX_TOOL_SEARCH_QUERY_CHARS) return query;
+  const bounded = query.slice(0, MAX_TOOL_SEARCH_QUERY_CHARS);
+  const wordBoundary = bounded.lastIndexOf(' ');
+  return (wordBoundary >= MAX_TOOL_SEARCH_QUERY_CHARS * 0.8
+    ? bounded.slice(0, wordBoundary)
+    : bounded).trimEnd();
+}
+
 function searchDeferredTools(tools, query) {
-  const normalized = String(query || '').trim().toLowerCase();
+  const normalized = normalizeDeferredToolQuery(query).toLowerCase();
   if (!normalized) return [];
   if (normalized.startsWith('select:')) {
     const selector = normalized.slice('select:'.length).trim();
@@ -132,7 +143,7 @@ function relatedSearchTerms(token) {
 }
 
 function searchRelatedDeferredTools(tools, query, options = {}) {
-  const normalized = String(query || '').trim().toLowerCase();
+  const normalized = normalizeDeferredToolQuery(query).toLowerCase();
   if (!normalized || normalized.startsWith('select:')) return [];
   const tokens = normalized.split(/\s+/).filter(Boolean);
   const requestedNameTokens = tokens
@@ -230,6 +241,7 @@ function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames
       properties: {
         query: {
           type: 'string',
+          maxLength: MAX_TOOL_SEARCH_QUERY_CHARS,
           description: 'Exact selection or keyword query, for example select:download_attachment or +slack send.',
         },
       },
@@ -237,7 +249,7 @@ function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames
       additionalProperties: false,
     },
     resolveExecution(args) {
-      const query = String(args?.query || '').trim();
+      const query = normalizeDeferredToolQuery(args?.query);
       return {
         description: query ? `Searching tool schemas for ${query}` : 'Searching tool schemas',
         approvalRule: DEFERRED_TOOL_LOADER_NAME,
@@ -302,12 +314,14 @@ module.exports = {
   CORE_TOOL_NAMES,
   DEFERRED_TOOL_LOADER_NAME,
   MAX_PERSISTENT_DEFERRED_TOOLS,
+  MAX_TOOL_SEARCH_QUERY_CHARS,
   TOOL_SCHEMA_BUDGET_RATIO,
   TOOL_SCHEMA_MAX_TOKENS,
   createDeferredToolLoader,
   deferredToolCatalog,
   deferredToolNames,
   mediaGenerationToolNamesForText,
+  normalizeDeferredToolQuery,
   rememberDeferredToolAfterNotFound,
   toolSchemaBudgetTokens,
 };

package/blun.mjs

@@ -295851,7 +295851,7 @@ async function withTimeout(promise, timeoutMs, onTimeout) {
 		if (timer !== void 0) clearTimeout(timer);
 	}
 }
-var DEFAULT_STARTUP_TIMEOUT_MS$1, McpConnectionManager;
+var DEFAULT_STARTUP_TIMEOUT_MS$1, MCP_AUTO_RECONNECT_DELAYS_MS, McpConnectionManager;
 var init_connection_manager = __esmMin((() => {
 	init_errors$8();
 	init_logger$1();
@@ -295863,10 +295863,12 @@ var init_connection_manager = __esmMin((() => {
 	init_public_display();
 	init_types$1();
 	DEFAULT_STARTUP_TIMEOUT_MS$1 = 3e4;
+	MCP_AUTO_RECONNECT_DELAYS_MS = [1e3, 3e3];
 	McpConnectionManager = class {
 		options;
 		entries = /* @__PURE__ */ new Map();
 		listeners = /* @__PURE__ */ new Set();
+		reconnectTimers = /* @__PURE__ */ new Map();
 		initialLoad = Promise.resolve();
 		initialLoadAttemptId = 0;
 		initialLoadStartedAt;
@@ -295941,6 +295943,7 @@ var init_connection_manager = __esmMin((() => {
 			return initialLoad;
 		}
 		async connect(name, config) {
+			this.clearReconnectTimer(name);
 			const previous = this.entries.get(name);
 			if (previous !== void 0) await this.closeClient(previous);
 			const disabled = config.enabled === false;
@@ -295948,6 +295951,7 @@ var init_connection_manager = __esmMin((() => {
 				name,
 				config,
 				attemptId: 0,
+				autoReconnectAttempt: 0,
 				status: disabled ? "disabled" : "pending"
 			};
 			this.entries.set(name, entry);
@@ -295955,6 +295959,7 @@ var init_connection_manager = __esmMin((() => {
 			if (!disabled) await this.connectOne(entry, this.beginConnectAttempt(entry));
 		}
 		async remove(name) {
+			this.clearReconnectTimer(name);
 			const entry = this.entries.get(name);
 			if (entry === void 0) return false;
 			await this.closeClient(entry);
@@ -295984,6 +295989,7 @@ var init_connection_manager = __esmMin((() => {
 					name,
 					config,
 					attemptId: 0,
+					autoReconnectAttempt: 0,
 					status: disabled ? "disabled" : "pending"
 				};
 				this.entries.set(name, entry);
@@ -295996,6 +296002,8 @@ var init_connection_manager = __esmMin((() => {
 			const entry = this.entries.get(name);
 			if (entry === void 0) throw new BlunError(ErrorCodes.MCP_SERVER_NOT_FOUND, `Unknown MCP server: ${name}`);
 			if (entry.config.enabled === false) throw new BlunError(ErrorCodes.MCP_SERVER_DISABLED, `MCP server is disabled: ${name}`);
+			this.clearReconnectTimer(name);
+			entry.autoReconnectAttempt = 0;
 			const attemptId = this.beginConnectAttempt(entry);
 			await this.closeClient(entry);
 			if (!this.isCurrent(entry, attemptId)) return;
@@ -296013,6 +296021,7 @@ var init_connection_manager = __esmMin((() => {
 			}
 		}
 		async shutdown() {
+			for (const name of this.reconnectTimers.keys()) this.clearReconnectTimer(name);
 			const entries = Array.from(this.entries.values());
 			this.entries.clear();
 			const tasks = entries.map((entry) => this.closeClient(entry));
@@ -296035,6 +296044,8 @@ var init_connection_manager = __esmMin((() => {
 				entry.tools = tools;
 				entry.enabledNames = computeEnabledNames(entry.config, tools);
 				entry.status = "connected";
+				entry.autoReconnectAttempt = 0;
+				this.clearReconnectTimer(entry.name);
 				this.watchForUnexpectedClose(entry, startupClient, attemptId);
 			} catch (error) {
 				if (!this.isCurrent(entry, attemptId)) {
@@ -296054,6 +296065,7 @@ var init_connection_manager = __esmMin((() => {
 			}
 			if (!this.isCurrent(entry, attemptId)) return;
 			this.emit(entry);
+			this.scheduleReconnectIfNeeded(entry);
 		}
 		watchForUnexpectedClose(entry, client, attemptId) {
 			client.onUnexpectedClose((reason) => {
@@ -296066,8 +296078,35 @@ var init_connection_manager = __esmMin((() => {
 				entry.client = void 0;
 				this.closeRuntimeClient(client);
 				this.emit(entry);
+				this.scheduleReconnectIfNeeded(entry);
 			});
 		}
+		clearReconnectTimer(name) {
+			const timer = this.reconnectTimers.get(name);
+			if (timer === void 0) return;
+			clearTimeout(timer);
+			this.reconnectTimers.delete(name);
+		}
+		scheduleReconnectIfNeeded(entry) {
+			if (entry.status !== "failed" || entry.config.enabled === false) return;
+			if (this.reconnectTimers.has(entry.name)) return;
+			const retryIndex = entry.autoReconnectAttempt ?? 0;
+			if (retryIndex >= MCP_AUTO_RECONNECT_DELAYS_MS.length) return;
+			entry.autoReconnectAttempt = retryIndex + 1;
+			const timer = setTimeout(() => {
+				this.reconnectTimers.delete(entry.name);
+				if (this.entries.get(entry.name) !== entry || entry.config.enabled === false) return;
+				const attemptId = this.beginConnectAttempt(entry);
+				entry.status = "pending";
+				entry.tools = void 0;
+				entry.enabledNames = void 0;
+				entry.error = void 0;
+				this.emit(entry);
+				void this.connectOne(entry, attemptId);
+			}, MCP_AUTO_RECONNECT_DELAYS_MS[retryIndex]);
+			timer.unref?.();
+			this.reconnectTimers.set(entry.name, timer);
+		}
 		beginConnectAttempt(entry) {
 			entry.attemptId += 1;
 			return entry.attemptId;
@@ -504339,7 +504378,7 @@ var EditorKeyboardController = class {
 				this.clearPendingUndoEsc();
 				return;
 			}
-			if (host.streamingUI.hasActiveTurn() || host.state.appState.streamingPhase !== "idle") {
+			if (host.queueSteerInFlight !== void 0 || host.streamingUI.hasActiveTurn() || host.state.appState.streamingPhase !== "idle") {
 				this.cancelCurrentStream();
 				this.clearPendingUndoEsc();
 				return;

package/package.json

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