@keyou007/agent-bot 0.1.10 → 0.1.12

package/src/runtime/AcpRuntimeAdapter.ts

@@ -190,6 +190,7 @@ export class AcpRuntimeAdapter implements AgentRuntime {
   }
 
   close(): void {
+    this.acp.shutdown();
     this.sessions.clear();
     this.activeTurns.clear();
     this.toolsBySession.clear();

package/src/runtime/AgentRuntimeRegistry.ts

@@ -1,15 +1,16 @@
-import type { AgentConfig } from "../config/schema.js";
 import type { AgentRuntime, RuntimeKind } from "./types.js";
 
 export class AgentRuntimeRegistry {
-  constructor(private readonly runtimes: Record<RuntimeKind, AgentRuntime>) {}
+  constructor(private readonly runtimes: Record<string, AgentRuntime>) {}
 
-  forAgent(agent: Pick<AgentConfig, "kind">): AgentRuntime {
-    return this.runtimes[agent.kind];
+  forAgent(agentName: string): AgentRuntime {
+    const runtime = this.runtimes[agentName];
+    if (!runtime) throw new Error(`Unknown agent runtime: ${agentName}`);
+    return runtime;
   }
 
-  get(kind: RuntimeKind): AgentRuntime {
-    return this.runtimes[kind];
+  entries(kind?: RuntimeKind): Array<[agentName: string, runtime: AgentRuntime]> {
+    return Object.entries(this.runtimes).filter(([, runtime]) => kind === undefined || runtime.kind === kind);
   }
 
   close(): void {

package/src/runtime/createAgentRuntimeRegistry.ts

@@ -0,0 +1,25 @@
+import type { Logger } from "pino";
+import { AcpProcessManager } from "../acp/AcpProcessManager.js";
+import { AcpSessionManager } from "../acp/AcpSessionManager.js";
+import { CodexProcessManager } from "../codex/CodexProcessManager.js";
+import { CodexRuntime } from "../codex/CodexRuntime.js";
+import type { AppConfig } from "../config/schema.js";
+import { AcpRuntimeAdapter } from "./AcpRuntimeAdapter.js";
+import { AgentRuntimeRegistry } from "./AgentRuntimeRegistry.js";
+import type { AgentRuntime } from "./types.js";
+
+export function createAgentRuntimeRegistry(config: AppConfig, logger: Logger): AgentRuntimeRegistry {
+  const runtimes: Record<string, AgentRuntime> = {};
+  for (const [agentName, agent] of Object.entries(config.agents)) {
+    const runtimeLogger = logger.child({ agentName, runtimeKind: agent.kind });
+    if (agent.kind === "app-server") {
+      const processManager = new CodexProcessManager(agent.command, agent.args, agent.env, runtimeLogger);
+      runtimes[agentName] = new CodexRuntime(processManager, runtimeLogger);
+      continue;
+    }
+    const processManager = new AcpProcessManager(runtimeLogger);
+    const sessionManager = new AcpSessionManager(agentName, agent, processManager, runtimeLogger);
+    runtimes[agentName] = new AcpRuntimeAdapter(sessionManager);
+  }
+  return new AgentRuntimeRegistry(runtimes);
+}

package/src/runtime/types.ts

@@ -109,6 +109,7 @@ export interface RemoteSessionSummary {
   cwd: string;
   source: string;
   status: RemoteSessionStatus;
+  modelProvider?: string;
   model?: string;
   reasoningEffort?: string;
   permissionMode?: PermissionMode;
@@ -144,6 +145,7 @@ export interface RuntimeSession {
   agentName: string;
   cwd: string;
   title?: string;
+  modelProvider?: string;
   model?: string;
   reasoningEffort?: string;
   permissionMode: PermissionMode;
@@ -155,6 +157,7 @@ export interface CreateRuntimeSessionInput {
   agentName: string;
   cwd: string;
   title?: string;
+  modelProvider?: string;
   model?: string;
   reasoningEffort?: string;
   permissionMode: PermissionMode;
@@ -180,6 +183,19 @@ export interface ModelOption {
   defaultReasoningEffort?: string;
 }
 
+export interface ModelProviderOption {
+  id: string;
+  displayName?: string;
+  isDefault?: boolean;
+}
+
+export interface RuntimeExecutionSettings {
+  modelProvider: string;
+  model: string;
+  reasoningEffort: string;
+  permissionMode: PermissionMode;
+}
+
 export interface ReasoningEffortOption {
   value: string;
   description?: string;
@@ -208,8 +224,10 @@ export interface AgentRuntime {
   setModel(sessionId: string, model: string): Promise<void>;
   setReasoningEffort(sessionId: string, effort: string): Promise<void>;
   setPermissionMode(sessionId: string, mode: PermissionMode): Promise<void>;
+  setExecutionSettings?(sessionId: string, settings: RuntimeExecutionSettings): Promise<RuntimeSession>;
   respondToApproval(sessionId: string, requestId: string, decision: ApprovalDecision): Promise<void>;
   listModels(): Promise<ModelOption[]>;
+  listModelProviders?(): Promise<ModelProviderOption[]>;
   onEvent(listener: (event: RuntimeEvent) => void): () => void;
   close(): void;
 }

package/src/startup/SessionMetadataHydrator.ts

@@ -16,7 +16,7 @@ export class SessionMetadataHydrator {
       && session.status === "running"
       && session.lastTurnStatus === "running"
     ) {
-      const runtime = this.runtimes.get("codex");
+      const runtime = this.runtimes.forAgent(session.agentName);
       const loaded = runtime.getSession(session.localSessionId) ?? await runtime.resumeSession({
         localSessionId: session.localSessionId,
         remoteSessionId: session.remoteSessionId,
@@ -38,7 +38,7 @@ export class SessionMetadataHydrator {
     }
     if (session.title || !session.runtimeKind || !session.remoteSessionId) return session;
     if (session.runtimeKind === "codex" && !session.lastTurnId) return session;
-    const metadata = await this.runtimes.get(session.runtimeKind).readSessionMetadata(session.remoteSessionId);
+    const metadata = await this.runtimes.forAgent(session.agentName).readSessionMetadata(session.remoteSessionId);
     const title = normalizeTaskTitle(metadata.title);
     if (title) this.store.updateRuntimeSession(session.localSessionId, { title });
     return this.store.getSession(session.localSessionId) ?? session;

package/src/startup/StartupNotifier.ts

@@ -84,6 +84,7 @@ export class StartupNotifier {
           ? {
               id: session.remoteSessionId ?? session.localSessionId,
               title: session.title,
+              modelProvider: session.modelProvider,
               model: session.model,
               reasoningEffort: session.reasoningEffort,
               permissionMode: session.permissionMode,

package/src/state/StateStore.ts

@@ -32,6 +32,7 @@ export interface SessionRecord {
   runtimeKind?: "acp" | "codex";
   remoteSessionId?: string;
   title?: string;
+  modelProvider?: string;
   model?: string;
   reasoningEffort?: string;
   permissionMode?: "auto" | "confirm";
@@ -100,6 +101,7 @@ interface SessionRow {
   runtime_kind: "acp" | "codex" | null;
   remote_session_id: string | null;
   title: string | null;
+  model_provider: string | null;
   model: string | null;
   reasoning_effort: string | null;
   permission_mode: "auto" | "confirm" | null;
@@ -149,10 +151,11 @@ export class StateStore {
     this.ensureTurnSnapshotColumns();
     this.ensureChatContextColumns();
     this.initializeContextSessionMappings();
+    this.db.exec("DROP INDEX IF EXISTS idx_sessions_remote_session_id_unique");
     this.reconcileDuplicateRemoteSessions();
     this.db.exec(`
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_remote_session_id_unique
-      ON sessions(remote_session_id)
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_agent_remote_session_unique
+      ON sessions(agent_name, remote_session_id)
       WHERE remote_session_id IS NOT NULL
     `);
     this.db.exec(`
@@ -520,7 +523,7 @@ export class StateStore {
     patch: Partial<
       Pick<
         SessionRecord,
-        "runtimeKind" | "remoteSessionId" | "title" | "model" | "reasoningEffort" | "permissionMode" | "lastTurnId" | "lastTurnStatus"
+        "runtimeKind" | "remoteSessionId" | "title" | "modelProvider" | "model" | "reasoningEffort" | "permissionMode" | "lastTurnId" | "lastTurnStatus"
       >
     >,
   ): void {
@@ -533,7 +536,7 @@ export class StateStore {
       .prepare(
         `
         UPDATE sessions
-        SET runtime_kind = ?, remote_session_id = ?, title = ?, model = ?, reasoning_effort = ?, permission_mode = ?,
+        SET runtime_kind = ?, remote_session_id = ?, title = ?, model_provider = ?, model = ?, reasoning_effort = ?, permission_mode = ?,
             last_turn_id = ?, last_turn_status = ?, updated_at = ?
         WHERE local_session_id = ?
         `,
@@ -542,6 +545,7 @@ export class StateStore {
         patch.runtimeKind ?? existing.runtimeKind ?? null,
         patch.remoteSessionId ?? existing.remoteSessionId ?? existing.acpSessionId ?? null,
         patch.title ?? existing.title ?? null,
+        patch.modelProvider ?? existing.modelProvider ?? null,
         patch.model ?? existing.model ?? null,
         patch.reasoningEffort ?? existing.reasoningEffort ?? null,
         patch.permissionMode ?? existing.permissionMode ?? null,
@@ -814,7 +818,11 @@ export class StateStore {
     };
   }
 
-  findSessionByRemoteSessionId(remoteSessionId: string, contextKey?: string): SessionRecord | undefined {
+  findSessionByRemoteSessionId(
+    remoteSessionId: string,
+    contextKey?: string,
+    agentName?: string,
+  ): SessionRecord | undefined {
     const row = contextKey
       ? this.db
           .prepare(`
@@ -823,17 +831,20 @@ export class StateStore {
             JOIN context_sessions ON context_sessions.local_session_id = sessions.local_session_id
             WHERE sessions.remote_session_id = ?
               AND context_sessions.context_key = ?
+              AND (? IS NULL OR sessions.agent_name = ?)
               AND sessions.status != 'closed'
             LIMIT 1
           `)
-          .get(remoteSessionId, contextKey) as SessionRow | undefined
+          .get(remoteSessionId, contextKey, agentName ?? null, agentName ?? null) as SessionRow | undefined
       : this.db
           .prepare(`
             SELECT * FROM sessions
-            WHERE remote_session_id = ? AND status != 'closed'
+            WHERE remote_session_id = ?
+              AND (? IS NULL OR agent_name = ?)
+              AND status != 'closed'
             ORDER BY created_at ASC LIMIT 1
           `)
-          .get(remoteSessionId) as SessionRow | undefined;
+          .get(remoteSessionId, agentName ?? null, agentName ?? null) as SessionRow | undefined;
     return row ? { ...mapSession(row), ...(contextKey ? { contextKey } : {}) } : undefined;
   }
 
@@ -1034,21 +1045,21 @@ export class StateStore {
 
   private reconcileDuplicateRemoteSessions(): void {
     const duplicateIds = this.db.prepare(`
-      SELECT remote_session_id
+      SELECT agent_name, remote_session_id
       FROM sessions
       WHERE remote_session_id IS NOT NULL
-      GROUP BY remote_session_id
+      GROUP BY agent_name, remote_session_id
       HAVING count(*) > 1
-    `).all() as Array<{ remote_session_id: string }>;
+    `).all() as Array<{ agent_name: string; remote_session_id: string }>;
     if (duplicateIds.length === 0) return;
 
     const reconcile = this.db.transaction(() => {
-      for (const { remote_session_id: remoteSessionId } of duplicateIds) {
+      for (const { agent_name: agentName, remote_session_id: remoteSessionId } of duplicateIds) {
         const rows = this.db.prepare(`
           SELECT * FROM sessions
-          WHERE remote_session_id = ?
+          WHERE agent_name = ? AND remote_session_id = ?
           ORDER BY created_at ASC
-        `).all(remoteSessionId) as SessionRow[];
+        `).all(agentName, remoteSessionId) as SessionRow[];
         const canonical = rows[0];
         if (!canonical) continue;
         const latest = [...rows].sort((left, right) => right.updated_at.localeCompare(left.updated_at))[0] ?? canonical;
@@ -1086,7 +1097,7 @@ export class StateStore {
 
         this.db.prepare(`
           UPDATE sessions
-          SET agent_name = ?, cwd = ?, acp_session_id = ?, runtime_kind = ?, title = ?, model = ?,
+          SET agent_name = ?, cwd = ?, acp_session_id = ?, runtime_kind = ?, title = ?, model_provider = ?, model = ?,
               reasoning_effort = ?, permission_mode = ?, last_turn_id = ?, last_turn_status = ?,
               status = ?, updated_at = ?
           WHERE local_session_id = ?
@@ -1096,6 +1107,7 @@ export class StateStore {
           latest.acp_session_id,
           latest.runtime_kind,
           latest.title,
+          latest.model_provider,
           latest.model,
           latest.reasoning_effort,
           latest.permission_mode,
@@ -1124,6 +1136,7 @@ export class StateStore {
       ["runtime_kind", "TEXT"],
       ["remote_session_id", "TEXT"],
       ["title", "TEXT"],
+      ["model_provider", "TEXT"],
       ["model", "TEXT"],
       ["reasoning_effort", "TEXT"],
       ["permission_mode", "TEXT"],
@@ -1206,6 +1219,7 @@ function mapSession(row: SessionRow): SessionRecord {
     runtimeKind: row.runtime_kind ?? (row.acp_session_id ? "acp" : undefined),
     remoteSessionId: row.remote_session_id ?? row.acp_session_id ?? undefined,
     title: row.title ?? undefined,
+    modelProvider: row.model_provider ?? undefined,
     model: row.model ?? undefined,
     reasoningEffort: row.reasoning_effort ?? undefined,
     permissionMode: row.permission_mode ?? undefined,

package/src/supervision/SafeRestartScheduler.ts

@@ -64,6 +64,11 @@ export class SafeRestartScheduler {
     this.clear();
   }
 
+  async cancelCurrent(): Promise<boolean> {
+    if (!this.reason) return false;
+    return this.cancelScheduled(this.scheduleId);
+  }
+
   async cancelScheduled(expectedScheduleId: number): Promise<boolean> {
     const reason = this.reason;
     if (!reason || this.scheduleId !== expectedScheduleId) return false;

package/src/supervision/systemEnvironment.ts

@@ -0,0 +1,174 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+export interface WindowsEnvironmentSnapshot {
+  machine: Record<string, string>;
+  user: Record<string, string>;
+}
+
+export interface EnvironmentRefreshResult {
+  environment: NodeJS.ProcessEnv;
+  refreshed: boolean;
+  pathChanged: boolean;
+  error?: string;
+}
+
+type WindowsEnvironmentLoader = () => WindowsEnvironmentSnapshot;
+
+const PROCESS_LOCAL_ENVIRONMENT_PREFIXES = ["AGENT_BOT_", "FEISHU_"];
+
+export function refreshedSystemEnvironment(
+  inherited: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+  loadWindowsEnvironment: WindowsEnvironmentLoader = readWindowsEnvironment,
+): EnvironmentRefreshResult {
+  const fallback = { ...inherited };
+  if (platform !== "win32") {
+    return { environment: fallback, refreshed: false, pathChanged: false };
+  }
+
+  try {
+    const snapshot = loadWindowsEnvironment();
+    const environment = mergeWindowsEnvironment(inherited, snapshot);
+    return {
+      environment,
+      refreshed: true,
+      pathChanged: environmentValue(environment, "Path") !== environmentValue(inherited, "Path"),
+    };
+  } catch (error) {
+    return {
+      environment: fallback,
+      refreshed: false,
+      pathChanged: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export function mergeWindowsEnvironment(
+  inherited: NodeJS.ProcessEnv,
+  snapshot: WindowsEnvironmentSnapshot,
+): NodeJS.ProcessEnv {
+  const environment = { ...inherited };
+  applyEnvironment(environment, snapshot.machine);
+  applyEnvironment(environment, snapshot.user);
+
+  const machinePath = environmentValue(snapshot.machine, "Path")?.trim();
+  const userPath = environmentValue(snapshot.user, "Path")?.trim();
+  if (machinePath || userPath) {
+    const inheritedPath = environmentValue(inherited, "Path")?.trim();
+    setEnvironmentValue(
+      environment,
+      "Path",
+      mergePathValues(
+        expandEnvironmentReferences(
+          [machinePath, userPath, inheritedPath].filter(Boolean).join(";"),
+          environment,
+        ),
+      ),
+    );
+  }
+  return environment;
+}
+
+function readWindowsEnvironment(): WindowsEnvironmentSnapshot {
+  const systemRoot = process.env.SystemRoot ?? "C:\\Windows";
+  const executable = path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const script = [
+    "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+    "$machine = @{}",
+    "foreach ($entry in [Environment]::GetEnvironmentVariables([EnvironmentVariableTarget]::Machine).GetEnumerator()) { $machine[[string]$entry.Key] = [string]$entry.Value }",
+    "$user = @{}",
+    "foreach ($entry in [Environment]::GetEnvironmentVariables([EnvironmentVariableTarget]::User).GetEnumerator()) { $user[[string]$entry.Key] = [string]$entry.Value }",
+    "[pscustomobject]@{ machine = $machine; user = $user } | ConvertTo-Json -Compress -Depth 3",
+  ].join("; ");
+  const result = spawnSync(executable, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    script,
+  ], {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 5_000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(result.stderr.trim() || `PowerShell exited with code ${result.status ?? "unknown"}.`);
+  }
+  const parsed = JSON.parse(result.stdout) as Partial<WindowsEnvironmentSnapshot>;
+  return {
+    machine: environmentRecord(parsed.machine),
+    user: environmentRecord(parsed.user),
+  };
+}
+
+function environmentRecord(value: unknown): Record<string, string> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).flatMap(([name, entry]) =>
+      typeof entry === "string" ? [[name, entry]] : []),
+  );
+}
+
+function applyEnvironment(
+  target: NodeJS.ProcessEnv,
+  source: Record<string, string>,
+): void {
+  for (const [name, value] of Object.entries(source)) {
+    if (name.toLowerCase() === "path" || isProcessLocalEnvironmentName(name)) continue;
+    setEnvironmentValue(target, name, value);
+  }
+}
+
+function isProcessLocalEnvironmentName(name: string): boolean {
+  const normalized = name.toUpperCase();
+  return PROCESS_LOCAL_ENVIRONMENT_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+function setEnvironmentValue(environment: NodeJS.ProcessEnv, name: string, value: string): void {
+  for (const existingName of Object.keys(environment)) {
+    if (existingName !== name && existingName.toLowerCase() === name.toLowerCase()) {
+      delete environment[existingName];
+    }
+  }
+  environment[name] = value;
+}
+
+function environmentValue(
+  environment: NodeJS.ProcessEnv | Record<string, string>,
+  name: string,
+): string | undefined {
+  const key = Object.keys(environment).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key === undefined ? undefined : environment[key];
+}
+
+function expandEnvironmentReferences(value: string, environment: NodeJS.ProcessEnv): string {
+  let expanded = value;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    const next = expanded.replace(/%([^%]+)%/g, (match, name: string) =>
+      environmentValue(environment, name) ?? match);
+    if (next === expanded) break;
+    expanded = next;
+  }
+  return expanded;
+}
+
+function mergePathValues(value: string): string {
+  const seen = new Set<string>();
+  return value
+    .split(";")
+    .map((entry) => entry.trim())
+    .filter((entry) => {
+      if (!entry) return false;
+      const normalized = entry.replace(/[\\/]+$/, "").toLowerCase();
+      if (seen.has(normalized)) return false;
+      seen.add(normalized);
+      return true;
+    })
+    .join(";");
+}

package/src/supervisor.ts

@@ -13,6 +13,7 @@ import {
   STOP_EXIT_CODE,
 } from "./supervision/restartPolicy.js";
 import { SupervisorDiagnostics, nodeDiagnosticReportArguments } from "./supervision/SupervisorDiagnostics.js";
+import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 
 const childEntry = fileURLToPath(new URL("./index.js", import.meta.url));
 const config = loadConfig();
@@ -38,13 +39,23 @@ async function startChild(): Promise<void> {
   const restartReason = nextStartReason;
   nextStartReason = "Supervisor 重新拉起进程";
   const workerStderr = diagnostics.openWorkerStderr();
+  const environmentRefresh = refreshedSystemEnvironment();
+  if (environmentRefresh.error) {
+    writeSupervisorLog("environment_refresh_failed", { error: environmentRefresh.error });
+  } else if (environmentRefresh.refreshed) {
+    writeSupervisorLog("environment_refreshed", { pathChanged: environmentRefresh.pathChanged });
+  }
   try {
     child = spawn(process.execPath, [
       ...nodeDiagnosticReportArguments(diagnostics.paths.crashReportDirectory),
       childEntry,
     ], {
       cwd: process.cwd(),
-      env: { ...process.env, AGENT_BOT_SUPERVISED: "1", AGENT_BOT_RESTART_REASON: restartReason },
+      env: {
+        ...environmentRefresh.environment,
+        AGENT_BOT_SUPERVISED: "1",
+        AGENT_BOT_RESTART_REASON: restartReason,
+      },
       stdio: ["ignore", "ignore", workerStderr],
       windowsHide: true,
     });