@keyou007/agent-bot 0.1.24-alpha.4 → 0.1.24-alpha.6

package/src/cli/controlProtocol.ts

@@ -9,7 +9,7 @@ import type {
   RemoteSessionSummary,
   RuntimeGoal,
 } from "../runtime/types.js";
-import type { SessionRecord } from "../state/StateStore.js";
+import type { SessionRecord, PendingProviderSettings } from "../state/StateStore.js";
 import type { ShellCommandResult } from "../utils/executeShellCommand.js";
 
 export type ControlRequest =
@@ -136,6 +136,7 @@ export interface TaskAgentControlData {
 }
 
 export interface TaskSettingsControlData {
+  pendingProvider?: PendingProviderSettings;
   session: SessionRecord;
   providers: ModelProviderOption[];
   models: ModelOption[];

package/src/cli/serverStatus.ts

@@ -38,6 +38,7 @@ export function formatServerStatus(data: unknown, language: CliLanguage = cliLan
     `${cliText("Supervisor: ", "Supervisor：", language)}${value.supervised ? cliText("enabled", "已启用", language) : cliText("disabled", "未启用", language)}`,
     ...agents,
     `${cliText("Running tasks: ", "运行中任务：", language)}${activity.runningSessions ?? 0}`,
+    ...(activity.activeTerminals ? [`${cliText("Active terminals: ", "活动终端：", language)}${activity.activeTerminals}`] : []),
     `${cliText("Pending final deliveries: ", "待发送最终结果：", language)}${activity.pendingFinalDeliveries ?? 0}`,
     `${cliText("Safe restart: ", "安全重启：", language)}${safeRestart}`,
     "",

package/src/cli.ts

@@ -1832,7 +1832,12 @@ function printTaskSettings(
   result: TaskSettingsControlData,
   setting: "provider" | "model" | "thinking" | "permissions",
 ): void {
-  const session = result.session;
+  const session = result.pendingProvider?.settings ?? result.session;
+  if (result.pendingProvider) {
+    const status = cliText("Pending Provider switch (after current turn)", "Provider 待切换（本轮结束后生效）");
+    const error = result.pendingProvider.error ? `: ${result.pendingProvider.error}` : "";
+    process.stdout.write(`${status}${error}\n`);
+  }
   process.stdout.write(`${cliText("Provider: ", "Provider：")}${session.modelProvider ?? cliText("Agent default", "Agent 默认")}\n`);
   process.stdout.write(`${cliText("Model: ", "模型：")}${session.model ?? cliText("default", "默认")}\n`);
   process.stdout.write(`${cliText("Thinking: ", "思考强度：")}${session.reasoningEffort ?? cliText("automatic", "自动")}\n`);

package/src/codex/AppServerPermissions.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+const workspacePolicySchema = z.object({
+  type: z.literal("workspaceWrite"),
+  writableRoots: z.array(z.string().min(1)),
+  networkAccess: z.boolean(),
+  excludeTmpdirEnvVar: z.boolean(),
+  excludeSlashTmp: z.boolean(),
+});
+
+const workspaceConfigSchema = z.object({
+  sandbox_workspace_write: z.object({
+    writable_roots: z.array(z.string().min(1)).default([]),
+    network_access: z.boolean().default(false),
+    exclude_tmpdir_env_var: z.boolean().default(false),
+    exclude_slash_tmp: z.boolean().default(false),
+  }).nullish(),
+});
+
+export type WorkspaceSandboxPolicy = z.infer<typeof workspacePolicySchema>;
+export type TurnSandboxPolicy = WorkspaceSandboxPolicy | { type: "dangerFullAccess" };
+
+export function workspaceSandboxFromResponse(sandbox: unknown): WorkspaceSandboxPolicy | undefined {
+  const parsed = workspacePolicySchema.safeParse(sandbox);
+  return parsed.success ? parsed.data : undefined;
+}
+
+export function workspaceSandboxFromConfig(config: unknown): WorkspaceSandboxPolicy {
+  const parsed = workspaceConfigSchema.safeParse(config);
+  if (!parsed.success) throw new Error("App Server 返回了无效的工作区沙箱配置，未启动新轮次。");
+  const settings = parsed.data.sandbox_workspace_write;
+  return {
+    type: "workspaceWrite",
+    writableRoots: settings?.writable_roots ?? [],
+    networkAccess: settings?.network_access ?? false,
+    excludeTmpdirEnvVar: settings?.exclude_tmpdir_env_var ?? false,
+    excludeSlashTmp: settings?.exclude_slash_tmp ?? false,
+  };
+}

package/src/codex/CodexLocalActivityDetector.ts

@@ -2,8 +2,10 @@ import { open } from "node:fs/promises";
 import path from "node:path";
 import Database from "better-sqlite3";
 import type { PermissionMode } from "../runtime/types.js";
+import { SystemThreadWriterProcessController, threadWriterLockPath } from "./ThreadWriterProcess.js";
 
 const READ_CHUNK_SIZE = 64 * 1024;
+const WRITER_CHECK_CACHE_MS = 5_000;
 const TASK_STARTED = Buffer.from('"type":"task_started"');
 const TASK_COMPLETE = Buffer.from('"type":"task_complete"');
 const TURN_ABORTED = Buffer.from('"type":"turn_aborted"');
@@ -46,7 +48,14 @@ export interface CodexLocalThreadSettings {
  */
 export class CodexLocalActivityDetector {
   private readonly rollouts = new Map<string, RolloutState>();
-  constructor(private readonly codexHome: string) {}
+  private readonly writerChecks = new Map<string, { expiresAt: number; result: Promise<boolean> }>();
+  constructor(
+    private readonly codexHome: string,
+    private readonly hasWriter: (threadId: string) => Promise<boolean> = async (threadId) => {
+      const lockPath = threadWriterLockPath(codexHome, threadId);
+      return Boolean(lockPath && (await new SystemThreadWriterProcessController().inspect(lockPath)).length > 0);
+    },
+  ) {}
 
   async activeThreadIds(threadIds: string[]): Promise<Set<string>> {
     return new Set((await this.activeThreads(threadIds)).keys());
@@ -74,13 +83,34 @@ export class CodexLocalActivityDetector {
     }
 
     const active = new Map<string, string | undefined>();
-    for (const row of rows) {
-      const task = await latestTask(row.rollout_path, this.rollouts);
-      if (task.active) active.set(row.id, task.turnId);
+    for (let index = 0; index < rows.length; index += 4) {
+      await Promise.all(rows.slice(index, index + 4).map(async (row) => {
+        const task = await latestTask(row.rollout_path, this.rollouts);
+        // An unpaired start survives a crash. It is not evidence of a live process.
+        if (task.active && await this.hasLiveWriter(row.id)) active.set(row.id, task.turnId);
+      }));
     }
     return active;
   }
 
+  private async hasLiveWriter(threadId: string): Promise<boolean> {
+    const cached = this.writerChecks.get(threadId);
+    if (cached && cached.expiresAt > Date.now()) return cached.result;
+    const result = this.hasWriter(threadId).catch((error: unknown) => {
+      throw new Error("无法确认任务的写入进程是否仍在运行，请稍后重试。", { cause: error });
+    });
+    const entry = { expiresAt: Date.now() + WRITER_CHECK_CACHE_MS, result };
+    this.writerChecks.delete(threadId);
+    this.writerChecks.set(threadId, entry);
+    if (this.writerChecks.size > 512) this.writerChecks.delete(this.writerChecks.keys().next().value!);
+    try {
+      return await result;
+    } catch (error) {
+      if (this.writerChecks.get(threadId) === entry) this.writerChecks.delete(threadId);
+      throw error;
+    }
+  }
+
   async threadSettings(threadIds: string[]): Promise<Map<string, CodexLocalThreadSettings>> {
     const ids = [...new Set(threadIds.filter(Boolean))];
     if (ids.length === 0) return new Map();