@keyou007/agent-bot 0.1.17-alpha.0 → 0.1.17-alpha.2

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";
@@ -131,17 +132,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;
@@ -1675,9 +1671,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 +1687,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),
+        })),
     };
   }
 
@@ -4247,7 +4252,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 +5352,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 +5383,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 +5396,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 +5409,8 @@ export class ProxySessionController {
                 contextKey,
               },
             },
-          }),
+          };
+      }),
     ];
     const navigationActions = directoryPaginationActions(directory, page, totalPages, contextKey);
     const directoryCount = entries.filter((entry) => entry.kind === "directory").length;
@@ -5903,7 +5912,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 +7123,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/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);

package/src/utils/spawnCommand.ts

@@ -20,9 +20,11 @@ export function spawnStdioCommand(
   command: string,
   args: string[],
   env: NodeJS.ProcessEnv,
+  cwd?: string,
 ): ChildProcessWithoutNullStreams {
   const prepared = prepareCommand(command, args);
   return spawn(prepared.command, prepared.args, {
+    cwd,
     env,
     stdio: ["pipe", "pipe", "pipe"],
     windowsHide: true,