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

package/src/supervision/SafeRestartScheduler.ts

@@ -11,9 +11,15 @@ export type SafeRestartPhase =
   | "restarting"
   | "cancelled";
 
+export interface RestartNotificationTarget {
+  contextKey: string;
+  replyMessageId?: string;
+}
+
 export interface SafeRestartStatus {
   scheduleId: number;
   reason: string;
+  notificationTargets?: RestartNotificationTarget[];
   phase: SafeRestartPhase;
   activity: ServerActivityState;
   remainingMs?: number;
@@ -21,7 +27,7 @@ export interface SafeRestartStatus {
 
 export interface SafeRestartSchedulerOptions {
   readActivity(): ServerActivityState;
-  onReady(reason: string): void | Promise<void>;
+  onReady(reason: string, notificationTargets: RestartNotificationTarget[]): void | Promise<void>;
   onStatus?(status: SafeRestartStatus): void | Promise<void>;
   onStatusError?(error: unknown): void;
   quietPeriodMs?: number;
@@ -33,6 +39,7 @@ export class SafeRestartScheduler {
   private polling?: Promise<void>;
   private pollAgain = false;
   private reason?: string;
+  private notificationTargets: RestartNotificationTarget[] = [];
   private idleSince?: number;
   private idleInboundAt?: string;
   private scheduleId = 0;
@@ -47,9 +54,13 @@ export class SafeRestartScheduler {
     return this.reason;
   }
 
-  schedule(reason: string): boolean {
+  schedule(reason: string, notificationTarget?: RestartNotificationTarget): boolean {
     const newlyScheduled = !this.reason;
-    if (newlyScheduled) this.scheduleId += 1;
+    if (newlyScheduled) {
+      this.scheduleId += 1;
+      this.notificationTargets = [];
+    }
+    this.addNotificationTarget(notificationTarget);
     this.reason = reason;
     this.idleSince = undefined;
     this.idleInboundAt = undefined;
@@ -73,10 +84,12 @@ export class SafeRestartScheduler {
     const reason = this.reason;
     if (!reason || this.scheduleId !== expectedScheduleId) return false;
     const activity = this.options.readActivity();
+    const notificationTargets = this.notificationTargetsSnapshot();
     this.clear();
     await this.emitStatus({
       scheduleId: expectedScheduleId,
       reason,
+      notificationTargets,
       phase: "cancelled",
       activity,
     });
@@ -87,6 +100,7 @@ export class SafeRestartScheduler {
     if (this.timer) clearInterval(this.timer);
     this.timer = undefined;
     this.reason = undefined;
+    this.notificationTargets = [];
     this.idleSince = undefined;
     this.idleInboundAt = undefined;
   }
@@ -101,6 +115,7 @@ export class SafeRestartScheduler {
       await this.emitStatus({
         scheduleId: this.scheduleId,
         reason,
+        notificationTargets: this.notificationTargetsSnapshot(),
         phase: state.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
         activity: state,
       });
@@ -111,12 +126,26 @@ export class SafeRestartScheduler {
     if (this.idleSince === undefined || this.idleInboundAt !== latestInboundAt) {
       this.idleSince = Date.now();
       this.idleInboundAt = latestInboundAt;
-      await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "countdown", activity: state, remainingMs: quietPeriodMs });
+      await this.emitStatus({
+        scheduleId: this.scheduleId,
+        reason,
+        notificationTargets: this.notificationTargetsSnapshot(),
+        phase: "countdown",
+        activity: state,
+        remainingMs: quietPeriodMs,
+      });
       return;
     }
     const remainingMs = Math.max(0, quietPeriodMs - (Date.now() - this.idleSince));
     if (remainingMs > 0) {
-      await this.emitStatus({ scheduleId: this.scheduleId, reason, phase: "countdown", activity: state, remainingMs });
+      await this.emitStatus({
+        scheduleId: this.scheduleId,
+        reason,
+        notificationTargets: this.notificationTargetsSnapshot(),
+        phase: "countdown",
+        activity: state,
+        remainingMs,
+      });
       return;
     }
     const confirmed = this.options.readActivity();
@@ -131,6 +160,7 @@ export class SafeRestartScheduler {
         await this.emitStatus({
           scheduleId: this.scheduleId,
           reason,
+          notificationTargets: this.notificationTargetsSnapshot(),
           phase: confirmed.runningSessions > 0 ? "waiting_tasks" : "waiting_delivery",
           activity: confirmed,
         });
@@ -138,6 +168,7 @@ export class SafeRestartScheduler {
         await this.emitStatus({
           scheduleId: this.scheduleId,
           reason,
+          notificationTargets: this.notificationTargetsSnapshot(),
           phase: "countdown",
           activity: confirmed,
           remainingMs: quietPeriodMs,
@@ -146,9 +177,17 @@ export class SafeRestartScheduler {
       return;
     }
     const scheduleId = this.scheduleId;
+    const notificationTargets = this.notificationTargetsSnapshot();
     this.clear();
-    await this.emitStatus({ scheduleId, reason, phase: "restarting", activity: confirmed, remainingMs: 0 });
-    await this.options.onReady(reason);
+    await this.emitStatus({
+      scheduleId,
+      reason,
+      notificationTargets,
+      phase: "restarting",
+      activity: confirmed,
+      remainingMs: 0,
+    });
+    await this.options.onReady(reason, notificationTargets);
   }
 
   private requestPoll(): void {
@@ -175,4 +214,36 @@ export class SafeRestartScheduler {
       this.options.onStatusError?.(error);
     });
   }
+
+  private addNotificationTarget(value: RestartNotificationTarget | undefined): void {
+    const target = normalizedNotificationTarget(value);
+    if (!target) return;
+    const existingIndex = this.notificationTargets.findIndex(
+      (candidate) => candidate.contextKey === target.contextKey,
+    );
+    if (existingIndex < 0) {
+      this.notificationTargets.push(target);
+      return;
+    }
+    const existing = this.notificationTargets[existingIndex]!;
+    if (!existing.replyMessageId && target.replyMessageId) {
+      this.notificationTargets[existingIndex] = target;
+    }
+  }
+
+  private notificationTargetsSnapshot(): RestartNotificationTarget[] {
+    return this.notificationTargets.map((target) => ({ ...target }));
+  }
+}
+
+function normalizedNotificationTarget(
+  value: RestartNotificationTarget | undefined,
+): RestartNotificationTarget | undefined {
+  const contextKey = value?.contextKey.trim();
+  if (!contextKey) return undefined;
+  const replyMessageId = value?.replyMessageId?.trim();
+  return {
+    contextKey,
+    ...(replyMessageId ? { replyMessageId } : {}),
+  };
 }

package/src/supervision/replacementSupervisor.ts

@@ -1,10 +1,36 @@
+export const RESTART_GROUP_CONTEXTS_ENV = "AGENT_BOT_RESTART_GROUP_CONTEXTS";
+
 export function replacementSupervisorEnvironment(
   restartReason: string,
   environment: NodeJS.ProcessEnv = process.env,
+  restartGroupContextKeys: readonly string[] = [],
 ): NodeJS.ProcessEnv {
-  return {
+  const result: NodeJS.ProcessEnv = {
     ...environment,
     AGENT_BOT_START_DELAY_MS: "250",
     AGENT_BOT_RESTART_REASON: restartReason,
   };
+  const normalized = normalizedContextKeys(restartGroupContextKeys);
+  if (normalized.length > 0) {
+    result[RESTART_GROUP_CONTEXTS_ENV] = JSON.stringify(normalized);
+  } else {
+    delete result[RESTART_GROUP_CONTEXTS_ENV];
+  }
+  return result;
+}
+
+export function restartGroupContextKeysFromEnvironment(value: string | undefined): string[] {
+  if (!value?.trim()) return [];
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return Array.isArray(parsed)
+      ? normalizedContextKeys(parsed.filter((entry): entry is string => typeof entry === "string"))
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+function normalizedContextKeys(values: readonly string[]): string[] {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }

package/src/supervisor.ts

@@ -14,6 +14,10 @@ import {
 } from "./supervision/restartPolicy.js";
 import { SupervisorDiagnostics, nodeDiagnosticReportArguments } from "./supervision/SupervisorDiagnostics.js";
 import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
+import {
+  RESTART_GROUP_CONTEXTS_ENV,
+  restartGroupContextKeysFromEnvironment,
+} from "./supervision/replacementSupervisor.js";
 
 const childEntry = fileURLToPath(new URL("./index.js", import.meta.url));
 const config = loadConfig();
@@ -24,9 +28,13 @@ const diagnostics = new SupervisorDiagnostics(config);
 diagnostics.initialize();
 let child: ChildProcess | undefined;
 let restartTimer: NodeJS.Timeout | undefined;
+let restartGroupContextExpiryTimer: NodeJS.Timeout | undefined;
 let stopping = false;
 let consecutiveFailures = 0;
 let nextStartReason = process.env.AGENT_BOT_RESTART_REASON?.trim() || "Supervisor 启动";
+let nextRestartGroupContextKeys = restartGroupContextKeysFromEnvironment(
+  process.env[RESTART_GROUP_CONTEXTS_ENV],
+);
 
 async function startChild(): Promise<void> {
   if (stopping || child) return;
@@ -37,6 +45,7 @@ async function startChild(): Promise<void> {
   }
   const startedAt = Date.now();
   const restartReason = nextStartReason;
+  const restartGroupContextKeys = nextRestartGroupContextKeys;
   nextStartReason = "Supervisor 重新拉起进程";
   const workerStderr = diagnostics.openWorkerStderr();
   const environmentRefresh = refreshedSystemEnvironment();
@@ -51,11 +60,11 @@ async function startChild(): Promise<void> {
       childEntry,
     ], {
       cwd: process.cwd(),
-      env: {
+      env: workerEnvironment({
         ...environmentRefresh.environment,
         AGENT_BOT_SUPERVISED: "1",
         AGENT_BOT_RESTART_REASON: restartReason,
-      },
+      }, restartGroupContextKeys),
       stdio: ["ignore", "ignore", workerStderr],
       windowsHide: true,
     });
@@ -66,6 +75,7 @@ async function startChild(): Promise<void> {
   writeSupervisorLog("started", {
     pid: child.pid,
     restartReason,
+    restartGroupContextKeys,
     workerStderrPath: diagnostics.paths.workerStderrPath,
     crashReportDirectory: diagnostics.paths.crashReportDirectory,
   });
@@ -76,6 +86,26 @@ async function startChild(): Promise<void> {
   child.once("exit", (code, signal) => {
     void handleChildExit(code, signal, startedAt, workerPid);
   });
+  if (restartGroupContextKeys.length > 0) {
+    if (restartGroupContextExpiryTimer) clearTimeout(restartGroupContextExpiryTimer);
+    restartGroupContextExpiryTimer = setTimeout(() => {
+      nextRestartGroupContextKeys = [];
+      restartGroupContextExpiryTimer = undefined;
+    }, STABLE_UPTIME_MS);
+  }
+}
+
+function workerEnvironment(
+  environment: NodeJS.ProcessEnv,
+  restartGroupContextKeys: readonly string[],
+): NodeJS.ProcessEnv {
+  const result = { ...environment };
+  if (restartGroupContextKeys.length > 0) {
+    result[RESTART_GROUP_CONTEXTS_ENV] = JSON.stringify(restartGroupContextKeys);
+  } else {
+    delete result[RESTART_GROUP_CONTEXTS_ENV];
+  }
+  return result;
 }
 
 async function handleChildExit(
@@ -134,6 +164,7 @@ function stop(signal: NodeJS.Signals): void {
   if (stopping) return;
   stopping = true;
   if (restartTimer) clearTimeout(restartTimer);
+  if (restartGroupContextExpiryTimer) clearTimeout(restartGroupContextExpiryTimer);
   if (child && !child.killed) {
     child.kill(signal);
     return;