@keyou007/agent-bot 0.1.17-alpha.1 → 0.1.17

package/src/local-files/NetworkAddressSelector.ts

@@ -0,0 +1,111 @@
+import os from "node:os";
+
+export type NetworkConnectionKind = "wired" | "wifi" | "other" | "vpn";
+
+export interface PreferredNetworkAddress {
+  address: string;
+  interfaceName: string;
+  kind: NetworkConnectionKind;
+}
+
+type NetworkInterfaces = ReturnType<typeof os.networkInterfaces>;
+
+const KIND_PRIORITY: Record<NetworkConnectionKind, number> = {
+  wired: 0,
+  wifi: 1,
+  other: 2,
+  vpn: 3,
+};
+
+const VIRTUAL_INTERFACE = /(?:loopback|hyper[- ]?v|vEthernet|vmware|virtualbox|docker|wsl|bluetooth|npcap|container|\bbridge\b|^br[-_]|^virbr|^veth|^awdl|^llw)/iu;
+const VPN_INTERFACE = /(?:\bvpn\b|wireguard|tailscale|zerotier|hamachi|nordlynx|openvpn|anyconnect|fortinet|globalprotect|^utun\d*$|^tun\d*$|^tap\d*$|^wg\d*$|^ppp\d*$|^ipsec\d*$)/iu;
+const WIFI_INTERFACE = /(?:wi-?fi|wireless|wlan|airport|无线|^wl[a-z0-9_-]*)/iu;
+const WIRED_INTERFACE = /(?:ethernet|以太网|local area connection|本地连接|\blan\b|^(?:eth|enp|ens|eno|enx)[a-z0-9_-]*)/iu;
+
+export function selectPreferredNetworkAddress(
+  interfaces: NetworkInterfaces = os.networkInterfaces(),
+): PreferredNetworkAddress | undefined {
+  const candidates: Array<PreferredNetworkAddress & { privateAddress: boolean }> = [];
+
+  for (const [interfaceName, addresses] of Object.entries(interfaces)) {
+    if (!addresses || isExcludedInterface(interfaceName)) continue;
+    const kind = classifyInterface(interfaceName);
+    for (const address of addresses) {
+      if (address.internal || address.family !== "IPv4" || !isUsableIpv4(address.address)) continue;
+      candidates.push({
+        address: address.address,
+        interfaceName,
+        kind,
+        privateAddress: isPrivateIpv4(address.address),
+      });
+    }
+  }
+
+  candidates.sort((left, right) => {
+    const kindDifference = KIND_PRIORITY[left.kind] - KIND_PRIORITY[right.kind];
+    if (kindDifference !== 0) return kindDifference;
+    if (left.privateAddress !== right.privateAddress) return left.privateAddress ? -1 : 1;
+    const interfaceDifference = compareText(left.interfaceName, right.interfaceName);
+    return interfaceDifference !== 0 ? interfaceDifference : compareIpv4(left.address, right.address);
+  });
+
+  const selected = candidates[0];
+  return selected
+    ? { address: selected.address, interfaceName: selected.interfaceName, kind: selected.kind }
+    : undefined;
+}
+
+export function classifyInterface(interfaceName: string): NetworkConnectionKind {
+  if (VPN_INTERFACE.test(interfaceName)) return "vpn";
+  if (WIFI_INTERFACE.test(interfaceName)) return "wifi";
+  if (WIRED_INTERFACE.test(interfaceName)) return "wired";
+  return "other";
+}
+
+function isExcludedInterface(interfaceName: string): boolean {
+  return /^lo\d*$/iu.test(interfaceName) || VIRTUAL_INTERFACE.test(interfaceName);
+}
+
+function isUsableIpv4(address: string): boolean {
+  const parts = ipv4Parts(address);
+  if (!parts) return false;
+  const [first, second] = parts;
+  return first !== 0
+    && first !== 127
+    && first < 224
+    && !(first === 169 && second === 254);
+}
+
+function isPrivateIpv4(address: string): boolean {
+  const parts = ipv4Parts(address);
+  if (!parts) return false;
+  const [first, second] = parts;
+  return first === 10
+    || (first === 172 && second >= 16 && second <= 31)
+    || (first === 192 && second === 168)
+    || (first === 100 && second >= 64 && second <= 127);
+}
+
+function ipv4Parts(address: string): [number, number, number, number] | undefined {
+  const values = address.split(".").map((part) => Number(part));
+  if (values.length !== 4 || values.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) {
+    return undefined;
+  }
+  return values as [number, number, number, number];
+}
+
+function compareText(left: string, right: string): number {
+  const normalizedLeft = left.toLocaleLowerCase("en-US");
+  const normalizedRight = right.toLocaleLowerCase("en-US");
+  return normalizedLeft < normalizedRight ? -1 : normalizedLeft > normalizedRight ? 1 : 0;
+}
+
+function compareIpv4(left: string, right: string): number {
+  const leftParts = ipv4Parts(left) ?? [0, 0, 0, 0];
+  const rightParts = ipv4Parts(right) ?? [0, 0, 0, 0];
+  for (let index = 0; index < leftParts.length; index += 1) {
+    const difference = leftParts[index]! - rightParts[index]!;
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}

package/src/proxy/ProxySessionController.ts

@@ -41,6 +41,7 @@ import {
 } from "../feishu/GroupNameFormatter.js";
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
+import { classifyFileContent } from "../local-files/LocalFileViewerServer.js";
 import type { OutboundRouter } from "../presentation/OutboundRouter.js";
 import type { TurnActivity, TurnViewState } from "../presentation/turnViewTypes.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
@@ -124,6 +125,7 @@ const SESSION_PROMPT_PREVIEW_LENGTH = 50;
 const DIRECTORY_PAGE_SIZE = 15;
 const RESET_HISTORY_PAGE_SIZE = 10;
 const MAX_LLM_TURN_RETRIES = 3;
+const QUEUED_PROMPT_RETRY_DELAY_MS = 5_000;
 const RECOVERY_ACTIVITY_WINDOW_MS = 10 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
 const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
@@ -131,17 +133,12 @@ const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
 const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
+const TURN_STOP_REQUESTED_MESSAGE = "已发送停止信号，任务会自动停止。";
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
 const WINDOWS_DRIVES_DIRECTORY = "agentbot://windows-drives";
 const IMAGE_FILE_EXTENSIONS = new Set([
   ".avif", ".bmp", ".gif", ".heic", ".heif", ".ico", ".jpeg", ".jpg", ".png", ".svg", ".tif", ".tiff", ".webp",
 ]);
-const BINARY_FILE_EXTENSIONS = new Set([
-  ".7z", ".a", ".apk", ".avi", ".bin", ".bz2", ".class", ".dat", ".db", ".deb", ".dll", ".dmg", ".doc", ".docx",
-  ".dylib", ".eot", ".exe", ".flac", ".gz", ".ico", ".ipa", ".iso", ".jar", ".lib", ".mdb", ".mkv", ".mov", ".mp3",
-  ".mp4", ".msi", ".o", ".obj", ".ogg", ".otf", ".pdf", ".ppt", ".pptx", ".rar", ".rpm", ".so", ".sqlite", ".tar",
-  ".ttf", ".wav", ".webm", ".woff", ".woff2", ".xls", ".xlsx", ".xz", ".zip", ".zst",
-]);
 
 interface HelpCommandDefinition {
   command: string;
@@ -432,6 +429,7 @@ export class ProxySessionController {
   private readonly threadInitializations = new Map<string, Promise<void>>();
   private readonly llmRetryingSessions = new Set<string>();
   private readonly retriedFailureTurnIds = new Set<string>();
+  private readonly queuedPromptRetryTimers = new Map<string, NodeJS.Timeout>();
   private readonly recoveryRetryTimers = new Map<string, NodeJS.Timeout>();
   private readonly pendingMergedForwards = new Map<string, PendingForwardAttachment>();
   private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
@@ -1101,6 +1099,8 @@ export class ProxySessionController {
     for (const pending of this.pendingResourceForwards.values()) pending.resolveAttachment(undefined);
     this.pendingResourceForwards.clear();
     this.relatedReactionMessageIds.clear();
+    for (const timer of this.queuedPromptRetryTimers.values()) clearTimeout(timer);
+    this.queuedPromptRetryTimers.clear();
     for (const timer of this.recoveryRetryTimers.values()) clearTimeout(timer);
     this.recoveryRetryTimers.clear();
     for (const [jobId] of this.shellCommandJobMonitors) this.stopShellCommandJobMonitor(jobId);
@@ -1675,9 +1675,10 @@ export class ProxySessionController {
     await this.assertBrowsableDirectory(directory);
     const entries = (await fs.readdir(directory, { withFileTypes: true }))
       .map((entry) => ({
+        dirent: entry,
         name: entry.name,
         path: path.join(directory, entry.name),
-        kind: directoryBrowserEntryKind(entry),
+        kind: entry.isDirectory() ? "directory" as const : "file" as const,
       }))
       .sort((left, right) => Number(right.kind === "directory") - Number(left.kind === "directory")
         || left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" }));
@@ -1690,7 +1691,15 @@ export class ProxySessionController {
       page,
       totalPages,
       totalEntries: entries.length,
-      entries: entries.slice(page * DIRECTORY_PAGE_SIZE, (page + 1) * DIRECTORY_PAGE_SIZE),
+      entries: entries
+        .slice(page * DIRECTORY_PAGE_SIZE, (page + 1) * DIRECTORY_PAGE_SIZE)
+        .map((entry) => ({
+          name: entry.name,
+          path: entry.path,
+          kind: entry.kind === "directory"
+            ? "directory" as const
+            : directoryBrowserEntryKind(entry.dirent, entry.path),
+        })),
     };
   }
 
@@ -3988,6 +3997,11 @@ export class ProxySessionController {
   }
 
   private scheduleNextQueuedPrompt(sessionId: string): Promise<void> {
+    const retryTimer = this.queuedPromptRetryTimers.get(sessionId);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.queuedPromptRetryTimers.delete(sessionId);
+    }
     const previous = this.queuedPromptStarts.get(sessionId) ?? Promise.resolve();
     const next = previous.catch(() => undefined).then(() => this.startNextQueuedPromptIfIdle(sessionId));
     this.queuedPromptStarts.set(sessionId, next);
@@ -3996,6 +4010,23 @@ export class ProxySessionController {
     });
   }
 
+  private scheduleQueuedPromptRetry(sessionId: string): void {
+    if (this.queuedPromptRetryTimers.has(sessionId)) return;
+    if (this.store.countQueuedPrompts(sessionId) === 0) return;
+    const timer = setTimeout(() => {
+      this.queuedPromptRetryTimers.delete(sessionId);
+      void this.scheduleNextQueuedPrompt(sessionId).catch((error: unknown) => {
+        this.logger.warn(
+          { error, errorMessage: runtimeErrorMessage(error), sessionId },
+          "Failed to retry queued prompt start.",
+        );
+        this.scheduleQueuedPromptRetry(sessionId);
+      });
+    }, QUEUED_PROMPT_RETRY_DELAY_MS);
+    timer.unref?.();
+    this.queuedPromptRetryTimers.set(sessionId, timer);
+  }
+
   private async startNextQueuedPromptIfIdle(sessionId: string): Promise<void> {
     if (this.store.countQueuedPrompts(sessionId) === 0) return;
     const baseRecord = this.store.getSession(sessionId);
@@ -4023,10 +4054,22 @@ export class ProxySessionController {
       );
       if (prompt.messageId) await this.bindMessageReactionToTurn(prompt.messageId, sessionId, turnId);
     } catch (error) {
-      this.logger.warn({ error, sessionId }, "Failed to start queued prompt.");
-      if (prompt?.messageId) await this.finalizeStandaloneMessageReaction(prompt.messageId, "failed");
-      if (prompt) await this.sendError(prompt.contextKey, error);
-      if (prompt && this.store.countQueuedPrompts(sessionId) > 0) {
+      this.logger.warn(
+        {
+          error,
+          errorMessage: runtimeErrorMessage(error),
+          phase: prompt ? "start" : "preflight",
+          sessionId,
+        },
+        "Failed to start queued prompt.",
+      );
+      if (!prompt) {
+        this.scheduleQueuedPromptRetry(sessionId);
+        return;
+      }
+      if (prompt.messageId) await this.finalizeStandaloneMessageReaction(prompt.messageId, "failed");
+      await this.sendError(prompt.contextKey, error);
+      if (this.store.countQueuedPrompts(sessionId) > 0) {
         queueMicrotask(() => void this.scheduleNextQueuedPrompt(sessionId));
       }
     }
@@ -4247,7 +4290,7 @@ export class ProxySessionController {
         remoteSessionId: record.remoteSessionId,
         turnId,
       });
-      await this.outbound.sendText(record.contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
+      await this.outbound.sendText(record.contextKey, TURN_STOP_REQUESTED_MESSAGE);
       return;
     }
 
@@ -5347,9 +5390,10 @@ export class ProxySessionController {
     }
     const entries = directoryEntries
       .map((entry) => ({
+        dirent: entry,
         name: entry.name,
         path: path.join(directory, entry.name),
-        kind: directoryBrowserEntryKind(entry),
+        kind: entry.isDirectory() ? "directory" as const : "file" as const,
       }))
       .sort((left, right) => Number(right.kind === "directory") - Number(left.kind === "directory")
         || left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" }));
@@ -5377,8 +5421,9 @@ export class ProxySessionController {
       ...parentEntries,
       ...entries
       .slice(offset, offset + pageSize)
-      .map((entry): DirectoryBrowserCardEntry => entry.kind === "directory"
-        ? {
+      .map((entry): DirectoryBrowserCardEntry => {
+        if (entry.kind === "directory") {
+          return {
             name: entry.name,
             kind: entry.kind,
             openAction: {
@@ -5389,10 +5434,11 @@ export class ProxySessionController {
                 contextKey,
               },
             },
-          }
-        : {
+          };
+        }
+        return {
             name: entry.name,
-            kind: entry.kind,
+            kind: directoryBrowserEntryKind(entry.dirent, entry.path),
             openAction: {
               text: entry.name,
               value: {
@@ -5401,7 +5447,8 @@ export class ProxySessionController {
                 contextKey,
               },
             },
-          }),
+          };
+      }),
     ];
     const navigationActions = directoryPaginationActions(directory, page, totalPages, contextKey);
     const directoryCount = entries.filter((entry) => entry.kind === "directory").length;
@@ -5903,7 +5950,7 @@ export class ProxySessionController {
       turnId,
       source: "sessions_card",
     });
-    await this.outbound.sendText(contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
+    await this.outbound.sendText(contextKey, TURN_STOP_REQUESTED_MESSAGE);
   }
 
   private async archiveSessionReference(
@@ -7114,12 +7161,16 @@ function isWindowsDriveRoot(directory: string): boolean {
   return /^[a-z]:\\$/iu.test(path.win32.normalize(directory));
 }
 
-function directoryBrowserEntryKind(entry: Dirent): DirectoryBrowserCardEntry["kind"] {
+function directoryBrowserEntryKind(entry: Dirent, filePath: string): DirectoryBrowserCardEntry["kind"] {
   if (entry.isDirectory()) return "directory";
+  try {
+    if (classifyFileContent(filePath).kind === "text") return "file";
+  } catch {
+    return "file";
+  }
   const extension = path.extname(entry.name).toLowerCase();
   if (IMAGE_FILE_EXTENSIONS.has(extension)) return "image";
-  if (BINARY_FILE_EXTENSIONS.has(extension)) return "binary";
-  return "file";
+  return "binary";
 }
 
 function directoryActionPath(value: unknown): string {

package/src/startup/StartupNotifier.ts

@@ -48,8 +48,13 @@ export class StartupNotifier {
           .filter((chat) => !isThreadContextKey(chat.contextKey))
           .map((chat) => [chat.contextKey, chat]),
       );
+      const knownPrivateChats = new Map(
+        this.store.listChatContexts("p2p")
+          .filter((chat) => !isThreadContextKey(chat.contextKey))
+          .map((chat) => [chat.contextKey, chat]),
+      );
       const targetsByContext = new Map<string, StartupNotificationTarget>();
-      for (const chat of this.store.listChatContexts("p2p")) {
+      for (const chat of knownPrivateChats.values()) {
         targetsByContext.set(chat.contextKey, {
           contextKey: chat.contextKey,
           context: this.store.getUserContext(chat.contextKey),
@@ -71,10 +76,11 @@ export class StartupNotifier {
         if (!contextKey) continue;
         if (isThreadContextKey(contextKey)) {
           const baseContextKey = baseChatContextKey(contextKey);
-          if (!knownGroups.has(baseContextKey)) continue;
+          const parentChat = knownGroups.get(baseContextKey) ?? knownPrivateChats.get(baseContextKey);
+          if (!parentChat) continue;
           const replyMessageId = target.replyMessageId?.trim();
           if (replyMessageId) {
-            if (!explicitBaseContextKeys.has(baseContextKey)) {
+            if (parentChat.chatType === "group" && !explicitBaseContextKeys.has(baseContextKey)) {
               targetsByContext.delete(baseContextKey);
             }
             targetsByContext.set(contextKey, {
@@ -83,7 +89,6 @@ export class StartupNotifier {
               context: this.store.getUserContext(contextKey),
             });
           } else {
-            const group = knownGroups.get(baseContextKey)!;
             targetsByContext.set(baseContextKey, {
               contextKey: baseContextKey,
               context: this.store.getUserContext(baseContextKey),

package/src/supervision/SafeRestartScheduler.ts

@@ -35,6 +35,10 @@ export interface SafeRestartSchedulerOptions {
   pollIntervalMs?: number;
 }
 
+export interface SafeRestartScheduleOptions {
+  restartImmediatelyIfIdle?: boolean;
+}
+
 export class SafeRestartScheduler {
   private timer?: NodeJS.Timeout;
   private polling?: Promise<void>;
@@ -44,6 +48,7 @@ export class SafeRestartScheduler {
   private idleSince?: number;
   private idleInboundAt?: string;
   private scheduleId = 0;
+  private restartImmediatelyIfIdle = false;
 
   constructor(private readonly options: SafeRestartSchedulerOptions) {}
 
@@ -55,10 +60,17 @@ export class SafeRestartScheduler {
     return this.reason;
   }
 
-  schedule(reason: string, notificationTarget?: RestartNotificationTarget): boolean {
+  schedule(
+    reason: string,
+    notificationTarget?: RestartNotificationTarget,
+    options: SafeRestartScheduleOptions = {},
+  ): boolean {
     const newlyScheduled = !this.reason;
     if (newlyScheduled) {
       this.notificationTargets = [];
+      this.restartImmediatelyIfIdle = options.restartImmediatelyIfIdle === true;
+    } else if (options.restartImmediatelyIfIdle) {
+      this.restartImmediatelyIfIdle = true;
     }
     this.scheduleId += 1;
     this.addNotificationTarget(notificationTarget, reason);
@@ -104,6 +116,7 @@ export class SafeRestartScheduler {
     this.notificationTargets = [];
     this.idleSince = undefined;
     this.idleInboundAt = undefined;
+    this.restartImmediatelyIfIdle = false;
   }
 
   private async poll(): Promise<void> {
@@ -123,6 +136,10 @@ export class SafeRestartScheduler {
       });
       return;
     }
+    if (this.restartImmediatelyIfIdle) {
+      await this.restart(reason, scheduleId, state);
+      return;
+    }
     const quietPeriodMs = this.options.quietPeriodMs ?? 15_000;
     const latestInboundAt = state.latestInboundAt ?? "";
     if (this.idleSince === undefined || this.idleInboundAt !== latestInboundAt) {
@@ -178,6 +195,10 @@ export class SafeRestartScheduler {
       }
       return;
     }
+    await this.restart(reason, scheduleId, confirmed);
+  }
+
+  private async restart(reason: string, scheduleId: number, activity: ServerActivityState): Promise<void> {
     const notificationTargets = this.notificationTargetsSnapshot();
     this.clear();
     await this.emitStatus({
@@ -185,7 +206,7 @@ export class SafeRestartScheduler {
       reason,
       notificationTargets,
       phase: "restarting",
-      activity: confirmed,
+      activity,
       remainingMs: 0,
     });
     await this.options.onReady(reason, notificationTargets);