nextclaw 0.6.9 → 0.6.11

package/dist/cli/index.js

@@ -1788,6 +1788,23 @@ import { resolve as resolve6 } from "path";
 import { getDataDir as getDataDir4 } from "@nextclaw/core";
 var RESTART_SENTINEL_FILENAME = "restart-sentinel.json";
 var PENDING_SYSTEM_EVENTS_KEY = "pending_system_events";
+var RESTART_REASON_MAX_CHARS = 240;
+var RESTART_NOTE_MAX_CHARS = 600;
+var RESTART_OUTBOUND_MAX_CHARS = 1200;
+function trimTo(value, maxChars) {
+  const text = value.trim();
+  if (!text) {
+    return "";
+  }
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+}
+function normalizeLine(value, maxChars) {
+  const trimmed = trimTo(value, maxChars);
+  return trimmed ? trimmed : null;
+}
 function resolveRestartSentinelPath() {
   return resolve6(getDataDir4(), "run", RESTART_SENTINEL_FILENAME);
 }
@@ -1822,7 +1839,7 @@ async function consumeRestartSentinel() {
   }
 }
 function summarizeRestartSentinel(payload) {
-  const reason = payload.stats?.reason?.trim();
+  const reason = normalizeLine(payload.stats?.reason ?? "", RESTART_REASON_MAX_CHARS);
   if (payload.kind === "update.run") {
     return payload.status === "ok" ? "\u2705 NextClaw update completed and service restarted." : "\u26A0\uFE0F NextClaw update finished with issues.";
   }
@@ -1836,15 +1853,16 @@ function summarizeRestartSentinel(payload) {
 }
 function formatRestartSentinelMessage(payload) {
   const lines = [summarizeRestartSentinel(payload)];
-  const note = payload.message?.trim();
+  const note = normalizeLine(payload.message ?? "", RESTART_NOTE_MAX_CHARS);
   if (note) {
     lines.push(note);
   }
-  const reason = payload.stats?.reason?.trim();
+  const reason = normalizeLine(payload.stats?.reason ?? "", RESTART_REASON_MAX_CHARS);
   if (reason && !lines.some((line) => line.includes(reason))) {
     lines.push(`Reason: ${reason}`);
   }
-  return lines.join("\n");
+  const message = lines.join("\n").trim();
+  return trimTo(message, RESTART_OUTBOUND_MAX_CHARS);
 }
 function parseSessionKey(sessionKey) {
   const value = sessionKey?.trim();
@@ -2481,7 +2499,7 @@ var ServiceCommands = class {
         }
       }
       await reloader.getChannels().startAll();
-      await this.wakeFromRestartSentinel({ bus, sessionManager });
+      await this.wakeFromRestartSentinel({ channels: reloader.getChannels(), sessionManager });
       await agent.run();
     } finally {
       await stopPluginChannelGateways(pluginGatewayHandles);
@@ -2495,6 +2513,72 @@ var ServiceCommands = class {
     const trimmed = value.trim();
     return trimmed || void 0;
   }
+  async sleep(ms) {
+    await new Promise((resolve10) => setTimeout(resolve10, ms));
+  }
+  resolveMostRecentRoutableSessionKey(sessionManager) {
+    const sessions = sessionManager.listSessions();
+    let best = null;
+    for (const session of sessions) {
+      const key = this.normalizeOptionalString(session.key);
+      if (!key || key.startsWith("cli:")) {
+        continue;
+      }
+      const metadataRaw = session.metadata;
+      const metadata = metadataRaw && typeof metadataRaw === "object" && !Array.isArray(metadataRaw) ? metadataRaw : {};
+      const contextRaw = metadata.last_delivery_context;
+      const context = contextRaw && typeof contextRaw === "object" && !Array.isArray(contextRaw) ? contextRaw : {};
+      const hasRoute = Boolean(this.normalizeOptionalString(context.channel)) && Boolean(this.normalizeOptionalString(context.chatId));
+      const hasFallbackRoute = Boolean(this.normalizeOptionalString(metadata.last_channel)) && Boolean(this.normalizeOptionalString(metadata.last_to));
+      if (!hasRoute && !hasFallbackRoute) {
+        continue;
+      }
+      const updatedAtRaw = this.normalizeOptionalString(session.updated_at);
+      const updatedAt = updatedAtRaw ? Date.parse(updatedAtRaw) : Number.NaN;
+      const score = Number.isFinite(updatedAt) ? updatedAt : 0;
+      if (!best || score >= best.updatedAt) {
+        best = { key, updatedAt: score };
+      }
+    }
+    return best?.key;
+  }
+  async sendRestartSentinelNotice(params) {
+    const outboundBase = {
+      channel: params.channel,
+      chatId: params.chatId,
+      content: params.content,
+      media: [],
+      metadata: params.metadata
+    };
+    const variants = params.replyTo ? [
+      { ...outboundBase, replyTo: params.replyTo },
+      { ...outboundBase }
+    ] : [{ ...outboundBase }];
+    for (let variantIndex = 0; variantIndex < variants.length; variantIndex += 1) {
+      const outbound = variants[variantIndex];
+      const isLastVariant = variantIndex === variants.length - 1;
+      for (let attempt = 1; attempt <= 3; attempt += 1) {
+        try {
+          const delivered = await params.channels.deliver(outbound);
+          if (delivered) {
+            return true;
+          }
+          return false;
+        } catch (error) {
+          if (attempt < 3) {
+            await this.sleep(attempt * 500);
+            continue;
+          }
+          if (isLastVariant) {
+            console.warn(
+              `Warning: restart sentinel notify failed for ${params.channel}:${params.chatId} (attempt ${attempt}): ${String(error)}`
+            );
+          }
+        }
+      }
+    }
+    return false;
+  }
   async wakeFromRestartSentinel(params) {
     const sentinel = await consumeRestartSentinel();
     if (!sentinel) {
@@ -2503,7 +2587,12 @@ var ServiceCommands = class {
     await new Promise((resolve10) => setTimeout(resolve10, 750));
     const payload = sentinel.payload;
     const message = formatRestartSentinelMessage(payload);
-    const sessionKey = this.normalizeOptionalString(payload.sessionKey) ?? "cli:default";
+    const sentinelSessionKey = this.normalizeOptionalString(payload.sessionKey);
+    const fallbackSessionKey = sentinelSessionKey ? void 0 : this.resolveMostRecentRoutableSessionKey(params.sessionManager);
+    if (!sentinelSessionKey && fallbackSessionKey) {
+      console.warn(`Warning: restart sentinel missing sessionKey; fallback to ${fallbackSessionKey}.`);
+    }
+    const sessionKey = sentinelSessionKey ?? fallbackSessionKey ?? "cli:default";
     const parsedSession = parseSessionKey(sessionKey);
     const context = payload.deliveryContext;
     const channel = this.normalizeOptionalString(context?.channel) ?? parsedSession?.channel ?? this.normalizeOptionalString((params.sessionManager.getIfExists(sessionKey)?.metadata ?? {}).last_channel);
@@ -2519,16 +2608,15 @@ var ServiceCommands = class {
       enqueuePendingSystemEvent(params.sessionManager, sessionKey, message);
       return;
     }
-    try {
-      await params.bus.publishOutbound({
-        channel,
-        chatId,
-        content: message,
-        ...replyTo ? { replyTo } : {},
-        media: [],
-        metadata
-      });
-    } catch {
+    const delivered = await this.sendRestartSentinelNotice({
+      channels: params.channels,
+      channel,
+      chatId,
+      content: message,
+      ...replyTo ? { replyTo } : {},
+      metadata
+    });
+    if (!delivered) {
       enqueuePendingSystemEvent(params.sessionManager, sessionKey, message);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextclaw",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "description": "Lightweight personal AI assistant with CLI, multi-provider routing, and channel integrations.",
   "private": false,
   "type": "module",
@@ -38,7 +38,7 @@
   "dependencies": {
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
-    "@nextclaw/core": "^0.6.8",
+    "@nextclaw/core": "^0.6.9",
     "@nextclaw/server": "^0.4.2",
     "@nextclaw/openclaw-compat": "^0.1.5"
   },