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

package/src/codex/CodexRuntime.ts

@@ -1112,6 +1112,18 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
   const lastText = [...(lastTurn?.items ?? [])]
     .reverse()
     .find((item) => typeof item.text === "string" && item.text.trim())?.text?.trim();
+  const completedTurns = (thread.turns ?? []).flatMap((turn) => {
+    if (turn.status !== "completed") return [];
+    const startedAt = remoteTurnStartedAt(turn);
+    return [{
+      id: turn.id,
+      prompt: extractTurnUserPrompt(turn),
+      startedAt,
+      completedAt: startedAt === undefined
+        ? undefined
+        : startedAt + Math.max(0, turn.durationMs ?? 0),
+    }];
+  });
   return {
     id: thread.id,
     title: normalizeTaskTitle(thread.name) ?? normalizeTaskTitle(thread.preview),
@@ -1136,25 +1148,41 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
     lastTurnCompletedToolCount: toolCounts?.completed,
     lastTurnFailedToolCount: toolCounts?.failed,
     lastTurnRunningToolCount: toolCounts?.running,
+    completedTurns,
   };
 }
 
 function extractLastUserPrompt(turns: CodexTurnSnapshot[] | undefined): string | undefined {
   for (const turn of [...(turns ?? [])].reverse()) {
-    for (const item of [...(turn.items ?? [])].reverse()) {
-      if (item.type !== "userMessage") continue;
-      const text = item.content
-        ?.filter((content) => content.type === "text" && typeof content.text === "string")
-        .map((content) => content.text!.trim())
-        .filter(Boolean)
-        .join("\n\n")
-        || item.text?.trim();
-      if (text) return text;
-    }
+    const prompt = extractTurnUserPrompt(turn);
+    if (prompt) return prompt;
+  }
+  return undefined;
+}
+
+function extractTurnUserPrompt(turn: CodexTurnSnapshot): string | undefined {
+  for (const item of [...(turn.items ?? [])].reverse()) {
+    if (item.type !== "userMessage") continue;
+    const text = item.content
+      ?.filter((content) => content.type === "text" && typeof content.text === "string")
+      .map((content) => content.text!.trim())
+      .filter(Boolean)
+      .join("\n\n")
+      || item.text?.trim();
+    if (text) return text;
   }
   return undefined;
 }
 
+function remoteTurnStartedAt(turn: CodexTurnSnapshot): number | undefined {
+  return remoteTimestampMs(turn.startedAt ?? undefined);
+}
+
+function remoteTimestampMs(value: number | undefined): number | undefined {
+  if (value === undefined || !Number.isFinite(value)) return undefined;
+  return value >= 10_000_000_000 ? value : value * 1_000;
+}
+
 function summarizeTurnTools(turn: CodexTurnSnapshot): {
   total: number;
   completed: number;

package/src/config/AgentExecutionDefaultsStore.ts

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isMap, parseDocument } from "yaml";
+import type { AgentExecutionDefaults } from "./schema.js";
+
+const DEFAULT_KEYS = ["modelProvider", "model", "reasoningEffort", "permissionMode"] as const;
+
+export function writeAgentExecutionDefaults(
+  configPath: string,
+  agentName: string,
+  defaults: AgentExecutionDefaults,
+): boolean {
+  const original = fs.readFileSync(configPath, "utf8");
+  const document = parseDocument(original);
+  if (document.errors.length > 0) {
+    throw new Error(`Could not update configuration file ${configPath}: ${document.errors[0]?.message ?? "invalid YAML"}`);
+  }
+  if (!isMap(document.contents)) {
+    throw new Error(`Configuration file must contain a YAML mapping: ${configPath}`);
+  }
+  const agent = document.getIn(["agents", agentName], true);
+  if (!isMap(agent)) {
+    throw new Error(`Cannot save defaults for an Agent that is not configured: ${agentName}`);
+  }
+  const existingDefaults = agent.get("defaults", true);
+  if (existingDefaults !== undefined && !isMap(existingDefaults)) {
+    throw new Error(`Configuration agents.${agentName}.defaults must contain a YAML mapping: ${configPath}`);
+  }
+  if (!isMap(existingDefaults)) agent.set("defaults", {});
+  const target = agent.get("defaults", true);
+  if (!isMap(target)) throw new Error(`Could not create defaults for Agent: ${agentName}`);
+
+  for (const key of DEFAULT_KEYS) {
+    const value = defaults[key];
+    if (value !== undefined) target.set(key, value);
+  }
+
+  const updated = document.toString();
+  if (updated === original) return false;
+  writeFileAtomically(configPath, updated);
+  return true;
+}
+
+function writeFileAtomically(filePath: string, contents: string): void {
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  let temporaryFile: number | undefined;
+  try {
+    temporaryFile = fs.openSync(temporaryPath, "wx", fs.statSync(filePath).mode);
+    fs.writeFileSync(temporaryFile, contents, "utf8");
+    fs.fsyncSync(temporaryFile);
+    fs.closeSync(temporaryFile);
+    temporaryFile = undefined;
+    fs.renameSync(temporaryPath, filePath);
+    syncDirectory(path.dirname(filePath));
+  } finally {
+    if (temporaryFile !== undefined) fs.closeSync(temporaryFile);
+    fs.rmSync(temporaryPath, { force: true });
+  }
+}
+
+function syncDirectory(directory: string): void {
+  let handle: number | undefined;
+  try {
+    handle = fs.openSync(directory, "r");
+    fs.fsyncSync(handle);
+  } catch (error) {
+    if (process.platform !== "win32") throw error;
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+  }
+}

package/src/config/loadConfig.ts

@@ -38,6 +38,12 @@ agents:
       - "--listen"
       - "stdio://"
     env: {}
+    # Updated automatically by the Provider, Model, Thinking, and Permission settings.
+    defaults:
+      # modelProvider: "openai"
+      # model: "gpt-5"
+      # reasoningEffort: "high"
+      permissionMode: "auto"
 
   traex:
     kind: "app-server"
@@ -48,6 +54,8 @@ agents:
       - "--listen"
       - "stdio://"
     env: {}
+    defaults:
+      permissionMode: "auto"
 
 defaults:
   agent: "codex"

package/src/config/schema.ts

@@ -40,12 +40,20 @@ const agentKindSchema = z.union([
   z.literal("codex").transform(() => "app-server" as const),
 ]).default("acp");
 
+export const agentExecutionDefaultsSchema = z.object({
+  modelProvider: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  reasoningEffort: z.string().min(1).optional(),
+  permissionMode: z.enum(["auto", "confirm"]).optional(),
+}).default({});
+
 export const agentConfigSchema = z.object({
   kind: agentKindSchema,
   title: z.string().min(1),
   command: z.string().min(1),
   args: z.array(z.string()).default([]),
   env: envRecordSchema,
+  defaults: agentExecutionDefaultsSchema,
 });
 
 export const appConfigSchema = z.object({
@@ -84,6 +92,10 @@ export const appConfigSchema = z.object({
   }).default({ level: "info", path: DEFAULT_LOG_PATH }),
 });
 
-export type AgentConfig = z.infer<typeof agentConfigSchema>;
+export type AgentExecutionDefaults = z.infer<typeof agentExecutionDefaultsSchema>;
+type ParsedAgentConfig = z.infer<typeof agentConfigSchema>;
+export type AgentConfig = Omit<ParsedAgentConfig, "defaults"> & {
+  defaults?: AgentExecutionDefaults;
+};
 export type GroupNameFormatConfig = z.infer<typeof groupNameFormatSchema>;
 export type AppConfig = z.infer<typeof appConfigSchema>;

package/src/feishu/CardRenderer.ts

@@ -225,7 +225,9 @@ export interface ResetHistoryCardEntry extends TaskListCardEntry {
   sequence: number;
   graphNodeLine: string;
   graphConnectorLine?: string;
+  timestamp?: string;
   running?: boolean;
+  resetting?: boolean;
 }
 
 export interface ResetHistoryCardView {
@@ -1328,9 +1330,11 @@ export class CardRenderer {
           entry.graphNodeLine,
           entry.graphConnectorLine,
           entry.lines,
+          entry.timestamp,
           action,
           entry.current === true,
           entry.running === true,
+          entry.resetting === true,
         ));
       });
     }
@@ -2415,15 +2419,8 @@ function inlineCode(value: string): string {
 }
 
 function formatStartupTime(value: Date): string {
-  return new Intl.DateTimeFormat("zh-CN", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hourCycle: "h23",
-  }).format(value);
+  const pad = (part: number) => String(part).padStart(2, "0");
+  return `${value.getFullYear()}/${pad(value.getMonth() + 1)}/${pad(value.getDate())} ${pad(value.getHours())}:${pad(value.getMinutes())}:${pad(value.getSeconds())}`;
 }
 
 function permissionModeLabel(mode?: PermissionMode): string {
@@ -2633,16 +2630,30 @@ function resetHistoryEntryRow(
   graphNodeLine: string,
   graphConnectorLine: string | undefined,
   lines: string[],
+  timestamp: string | undefined,
   action: TaskListCardAction | undefined,
   current: boolean,
   running: boolean,
+  resetting: boolean,
 ): Record<string, unknown> {
+  const branchConnectorLine = graphConnectorLine && /[╱╲]/u.test(graphConnectorLine)
+    ? graphConnectorLine
+    : undefined;
   const graph = [
-    `<font color='${current ? "green" : running ? "orange" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
-    ...(graphConnectorLine
-      ? [`<font color='grey'>${escapeCardHtml(graphConnectorLine)}</font>`]
+    `<font color='${current ? "green" : running || resetting ? "orange" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
+    ...(branchConnectorLine
+      ? [`<font color='grey'>${escapeCardHtml(branchConnectorLine)}</font>`]
       : []),
   ].join("\n");
+  const trailingElements = current
+    ? [markdown("✅ 当前")]
+    : resetting
+      ? [markdown("⏳ 正在 Reset")]
+      : running
+        ? [markdown("⏳ 运行中")]
+        : action
+          ? [taskActionElement(action)]
+          : [];
   return {
     tag: "column_set",
     flex_mode: "none",
@@ -2664,25 +2675,22 @@ function resetHistoryEntryRow(
         weight: 1,
         vertical_align: "top",
         elements: [
-          markdown(lines[0] ?? ""),
+          markdown([
+            lines[0] ?? "",
+            ...(timestamp ? [`<font color='grey'>${escapeCardHtml(timestamp)}</font>`] : []),
+          ].join(" ")),
           ...lines.slice(1).map((line) => ({
             ...markdown(`<font color='grey'>${line}</font>`),
             text_size: "notation",
           })),
         ],
       },
-      {
+      ...(trailingElements.length > 0 ? [{
         tag: "column",
         width: "auto",
         vertical_align: "top",
-        elements: current
-          ? [markdown("✅ 当前")]
-          : running
-            ? [markdown("⏳ 运行中")]
-          : action
-            ? [taskActionElement(action)]
-            : [],
-      },
+        elements: trailingElements,
+      }] : []),
     ],
   };
 }

package/src/index.ts

@@ -6,6 +6,7 @@ import { controlEndpoint, type ControlRequest, type ControlResponse } from "./cl
 import { readPackageVersion } from "./cli/packageVersion.js";
 import { loadConfig } from "./config/loadConfig.js";
 import { persistFeishuUserOpenIdIfMissing } from "./config/FeishuUserOpenIdStore.js";
+import { writeAgentExecutionDefaults } from "./config/AgentExecutionDefaultsStore.js";
 import {
   agentBotHome,
   defaultConfigPath,
@@ -42,6 +43,7 @@ import {
 import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
 import type { RestartNotificationTarget } from "./supervision/SafeRestartScheduler.js";
 import { SafeRestartNotifier } from "./supervision/SafeRestartNotifier.js";
+import { privateRestartNotificationTarget } from "./supervision/restartNotificationTarget.js";
 import {
   nodeDiagnosticReportArguments,
   prepareCrashReportDirectory,
@@ -72,9 +74,10 @@ const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath);
 
 const configuredConfigPath = process.env.AGENT_BOT_CONFIG?.trim();
+const activeConfigPath = configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath();
 const agentEnvironmentContext: AgentEnvironmentContext = {
   profilePath: agentBotHome(),
-  configPath: configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath(),
+  configPath: activeConfigPath,
   larkAppId: config.feishu.appId,
   larkUserOpenId: config.feishu.userOpenId,
 };
@@ -156,6 +159,10 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
       "Stored the default Lark user Open ID from the first private chat message.",
     );
   },
+  persistAgentExecutionDefaults: (agentName, defaults) => {
+    const changed = writeAgentExecutionDefaults(activeConfigPath, agentName, defaults);
+    logger.info({ agentName, changed }, "Stored Agent execution defaults.");
+  },
 });
 
 if (feishuOutbound) {
@@ -362,7 +369,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       if (pendingSelfUpdatePlanPath) {
         return { ok: false, message: "An Agent Bot update is already pending." };
       }
-      const notificationTarget = inferControlRestartTarget(request.notificationSessionId);
+      const notificationTarget = inferServerRestartTarget(request.notificationSessionId);
       if (request.mode === "safe") {
         const newlyScheduled = safeRestart.schedule(request.reason, notificationTarget);
         return {
@@ -571,6 +578,14 @@ function inferControlRestartTarget(notificationSessionId?: string): RestartNotif
   return session ? restartNotificationTargetForSession(session) : undefined;
 }
 
+function inferServerRestartTarget(notificationSessionId?: string): RestartNotificationTarget {
+  if (notificationSessionId?.trim()) {
+    const target = inferControlRestartTarget(notificationSessionId);
+    if (target) return target;
+  }
+  return privateRestartNotificationTarget(config.feishu.userOpenId);
+}
+
 function restartNotificationTargetForSession(
   session: { localSessionId: string; contextKey: string },
 ): RestartNotificationTarget {