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

package/src/index.ts

@@ -6,7 +6,12 @@ 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 { defaultDotEnvPath } from "./config/paths.js";
+import {
+  agentBotHome,
+  defaultConfigPath,
+  defaultDotEnvPath,
+  resolveUserPath,
+} from "./config/paths.js";
 import { ConsoleConnector } from "./console/ConsoleConnector.js";
 import { ConsoleTurnPresenter } from "./console/ConsoleTurnPresenter.js";
 import { CardRenderer } from "./feishu/CardRenderer.js";
@@ -20,6 +25,7 @@ import { requireServerFeishuTransport } from "./feishu/transport.js";
 import { createLogger } from "./logging/logger.js";
 import { OutboundRouter, type OutboundRoute } from "./presentation/OutboundRouter.js";
 import { ProxySessionController } from "./proxy/ProxySessionController.js";
+import type { AgentEnvironmentContext } from "./runtime/agentEnvironment.js";
 import { createAgentRuntimeRegistry } from "./runtime/createAgentRuntimeRegistry.js";
 import { StateStore } from "./state/StateStore.js";
 import { StartupNotifier } from "./startup/StartupNotifier.js";
@@ -55,7 +61,14 @@ const transport = consoleOnly ? "console" : requireServerFeishuTransport(config.
 const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath);
 
-const runtimes = createAgentRuntimeRegistry(config, logger);
+const configuredConfigPath = process.env.AGENT_BOT_CONFIG?.trim();
+const agentEnvironmentContext: AgentEnvironmentContext = {
+  profilePath: agentBotHome(),
+  configPath: configuredConfigPath ? resolveUserPath(configuredConfigPath) : defaultConfigPath(),
+  larkAppId: config.feishu.appId,
+  larkUserOpenId: config.feishu.userOpenId,
+};
+const runtimes = createAgentRuntimeRegistry(config, logger, agentEnvironmentContext);
 
 const routes: OutboundRoute[] = [];
 let feishuConnector: FeishuConnector | undefined;
@@ -116,6 +129,7 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
     if (config.feishu.userOpenId?.startsWith("ou_")) return;
     const persisted = persistFeishuUserOpenIdIfMissing(defaultDotEnvPath(), userOpenId);
     config.feishu.userOpenId = persisted.userOpenId;
+    agentEnvironmentContext.larkUserOpenId = persisted.userOpenId;
     process.env.FEISHU_USER_OPEN_ID = persisted.userOpenId;
     logger.info(
       { status: persisted.status },
@@ -124,7 +138,15 @@ const controller = new ProxySessionController(config, store, runtimes, outbound,
   },
 });
 
-if (feishuOutbound) feishuConnector = new FeishuConnector(config, controller, logger);
+if (feishuOutbound) {
+  feishuConnector = new FeishuConnector(
+    config,
+    controller,
+    logger,
+    undefined,
+    (botOpenId) => { agentEnvironmentContext.larkBotOpenId = botOpenId; },
+  );
+}
 if (consoleEnabled) consoleConnector = new ConsoleConnector(controller, logger);
 
 process.on("SIGINT", () => void shutdown(0));
@@ -224,6 +246,16 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
           startedAt: processStartedAt.toISOString(),
           supervised,
           feishuAppId: config.feishu.appId ?? null,
+          agents: runtimes.entries().map(([name, runtime]) => {
+            const processInfo = runtime.getProcessInfo?.() ?? {};
+            return {
+              name,
+              title: config.agents[name]?.title ?? name,
+              kind: config.agents[name]?.kind ?? runtime.kind,
+              pid: processInfo.pid ?? null,
+              version: processInfo.version ?? null,
+            };
+          }),
           safeRestartScheduled: safeRestart.scheduled,
           safeRestartReason: safeRestart.pendingReason,
           activity: store.getServerActivityState(),

package/src/proxy/ProxySessionController.ts

@@ -17,6 +17,7 @@ import {
   CardRenderer,
   type CardSection,
   type ExecutionSettingsTab,
+  type HelpCardSection,
   type ResetHistoryCardEntry,
   type TaskListCardAction,
   type TaskListCardEntry,
@@ -67,6 +68,123 @@ const SESSION_PAGE_SIZE = 5;
 const RESET_HISTORY_PAGE_SIZE = 10;
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
 
+interface HelpCommandDefinition {
+  command: string;
+  usage?: string;
+  description: string;
+  requiresArgument?: boolean;
+}
+
+const HELP_COMMAND_SECTIONS: Array<{
+  title: string;
+  commands: HelpCommandDefinition[];
+}> = [
+  {
+    title: "任务管理",
+    commands: [
+      {
+        command: "/new",
+        usage: "[title] [--dir &#60;cwd&#62; | --nodir]",
+        description: "使用默认 Agent 创建任务；--nodir 创建 Projectless 任务",
+      },
+      {
+        command: "/newgroup",
+        usage: "[title] [--dir &#60;cwd&#62; | --nodir]",
+        description: "创建飞书群和新任务",
+      },
+      {
+        command: "/forkgroup",
+        usage: "[title]",
+        description: "从当前任务最近完成轮次创建分支群",
+      },
+      {
+        command: "/fork",
+        usage: "[序号或任务 ID]",
+        description: "从当前或指定任务最近完成轮次创建分支",
+      },
+      { command: "/turns", description: "浏览历史轮次，并可 Reset 对话上下文" },
+      {
+        command: "/title",
+        usage: "&#60;新标题&#62;",
+        description: "修改当前任务标题",
+        requiresArgument: true,
+      },
+      { command: "/sessions", usage: "[关键词]", description: "查找本机任务" },
+      {
+        command: "/switch",
+        usage: "[序号或任务 ID]",
+        description: "切换任务；不填参数切回上一个任务",
+      },
+    ],
+  },
+  {
+    title: "执行设置",
+    commands: [
+      {
+        command: "!",
+        usage: "&#60;命令&#62;",
+        description: "在当前任务目录执行本地命令",
+        requiresArgument: true,
+      },
+      { command: "/stop", description: "停止当前执行" },
+      {
+        command: "/queue",
+        usage: "&#60;prompt&#62;",
+        description: "将 Prompt 排队为后续轮次",
+        requiresArgument: true,
+      },
+      {
+        command: "/nosteer",
+        usage: "&#60;prompt&#62;",
+        description: "与 /queue 相同",
+        requiresArgument: true,
+      },
+      {
+        command: "/goal",
+        usage: "&#60;目标或操作&#62;",
+        description: "查看或创建长任务 Goal；支持 pause、resume、edit、clear",
+        requiresArgument: true,
+      },
+      { command: "/provider", description: "选择 AI 服务提供商" },
+      { command: "/model", description: "选择当前任务使用的模型" },
+      { command: "/thinking", description: "设置模型的思考强度" },
+      { command: "/permissions", description: "设置执行工具前是否需要确认" },
+    ],
+  },
+  {
+    title: "Agent",
+    commands: [
+      {
+        command: "/agent",
+        usage: "[name]",
+        description: "选择新任务使用的默认 Agent",
+      },
+    ],
+  },
+  {
+    title: "系统",
+    commands: [
+      {
+        command: "/status",
+        usage: "[序号或任务 ID]",
+        description: "查看当前或指定任务状态",
+      },
+      {
+        command: "/restart",
+        usage: "[--force]",
+        description: "默认安全重启；--force 立即重启",
+      },
+      { command: "/help", description: "显示本帮助" },
+    ],
+  },
+];
+
+const HELP_DEFAULT_COMMANDS = new Set(
+  HELP_COMMAND_SECTIONS.flatMap((section) => section.commands)
+    .filter((command) => !command.requiresArgument)
+    .map((command) => command.command),
+);
+
 interface AgentRemoteSession {
   agentName: string;
   runtime: AgentRuntime;
@@ -365,7 +483,9 @@ export class ProxySessionController {
     await this.outbound.withReplyTarget(contextKey, replyTarget, async () => {
       try {
         const kind = String(scopedAction.value.action ?? "");
-        if (kind === "turn_details") {
+        if (kind === "help_command") {
+          await this.executeHelpCommandAction(scopedAction, contextKey, replyTarget);
+        } else if (kind === "turn_details") {
           await this.outbound.showDetails(contextKey, String(scopedAction.value.turnId ?? ""));
         } else if (kind === "activity_history") {
           const requestedPage = String(scopedAction.value.page ?? "0");
@@ -2111,7 +2231,7 @@ export class ProxySessionController {
         this.store.saveTurnParent(
           event.turnId,
           event.sessionId,
-          source?.lastTurnStatus === "completed" ? source.lastTurnId : undefined,
+          this.completedParentTurnId(source),
         );
       }
     }
@@ -2209,6 +2329,13 @@ export class ProxySessionController {
     }
   }
 
+  private completedParentTurnId(source: SessionRecord | undefined): string | undefined {
+    if (!source?.lastTurnId) return undefined;
+    if (source.lastTurnStatus === "completed") return source.lastTurnId;
+    const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(source.lastTurnId));
+    return snapshot?.status === "completed" ? source.lastTurnId : undefined;
+  }
+
   private async finalizeStandaloneMessageReaction(
     messageId: string,
     status: "completed" | "failed" | "cancelled",
@@ -3191,11 +3318,9 @@ export class ProxySessionController {
       [
         ...(remoteHint ? [remoteHint] : []),
         `第 ${page + 1} 页 · 每页 ${SESSION_PAGE_SIZE} 个任务${hasNext ? "" : ` · 当前共 ${entries.length} 个任务`}`,
-        "点击 **New** 在对应任务的项目中创建新任务；点击 **Switch** 快速切换；点击 **Fork** 从任务最新已完成轮次创建分支；外部正在运行的任务显示 **Stop**，点击后发送 Interrupt 并变为 **Switch**。",
-        "点击 **NewGroup** 在对应任务的项目中创建新群和新任务；点击 **ForkGroup** 从对应任务最新已完成轮次创建分支群。",
-        "也可发送 **/switch [序号或任务 ID]**；不带参数切回上一个任务。外部正在执行的回合不会被接管。",
-        "发送 **/fork [序号或任务 ID]**，可从当前或指定任务创建分支；任务运行中时使用最近已完成轮次。",
-        "点击 **Status**，或发送 **/status [序号或任务 ID]**，查看当前或指定任务状态。",
+        "",
+        "> **Switch** 切换任务；**Stop** 停止运行；**Status** 查看状态。",
+        "> **New** / **Fork** 新建 / 分支任务；**NewGroup** / **ForkGroup** 新建 / 分支群。",
       ],
       [
         ...(hasPrevious ? [{
@@ -3657,59 +3782,61 @@ export class ProxySessionController {
     else await this.outbound.sendInteractiveCard(contextKey, card);
   }
 
+  private async executeHelpCommandAction(
+    action: CardAction,
+    contextKey: string,
+    replyTarget?: MessageReplyTarget,
+  ): Promise<void> {
+    const commandText = typeof action.value.command === "string"
+      ? action.value.command.trim()
+      : "";
+    if (!HELP_DEFAULT_COMMANDS.has(commandText)) {
+      throw new Error("帮助卡片中的命令无效，请发送 /help 获取最新卡片。");
+    }
+    const command = this.router.parse(commandText);
+    await this.execute(
+      contextKey,
+      command,
+      undefined,
+      replyTarget,
+      undefined,
+      action.userId,
+    );
+  }
+
   private async help(contextKey: string): Promise<void> {
-    const sections: CardSection[] = [
-      {
-        lines: [
-          "直接发送消息即可继续当前任务；执行中发送的新消息会追加到本次任务。",
-          "> 命令前缀示例：/sess 等同于 /sessions。",
-          "> 命令缩写示例：/fg 等同于 /forkgroup。",
-          "前缀或缩写匹配多个命令时，需要输入更长的形式。",
-          "**[参数]** 可选　**&#60;参数&#62;** 必填",
-        ],
-      },
-      {
-        title: "任务管理",
-        lines: [
-          "**/new [title] [--dir &#60;cwd&#62; | --nodir]**　使用默认 Agent 创建任务；--nodir 强制创建 Projectless 任务",
-          "**/newgroup [title] [--dir &#60;cwd&#62; | --nodir]**　创建飞书群和新任务；参数与 /new 相同",
-          "**/forkgroup [title]**　从当前任务最新已完成轮次创建分支并绑定到新群",
-          "**/fork [序号或任务 ID]**　从当前或指定任务创建分支；运行中使用最近已完成轮次",
-          "**/turns**　浏览当前任务的历史对话轮次，并可将对话上下文恢复到所选轮次",
-          "**/title &#60;新标题&#62;**　修改当前任务的标题",
-          "**/sessions [关键词]**　查找本机任务",
-          "**/switch [序号或任务 ID]**　不填参数切回上一个任务",
-        ],
-      },
-      {
-        title: "执行设置",
-        lines: [
-          "**! &#60;命令&#62;**　在当前任务目录直接执行本地命令",
-          "**/stop**　停止当前执行",
-          "**/queue &#60;prompt&#62;**（兼容 **/nosteer**）　不追加到当前轮次，按顺序排队为后续轮次",
-          "**/goal [目标]**　查看或创建长任务 Goal；支持 pause、resume、edit、clear",
-          "**/provider**　选择 AI 服务提供商；没有其他候选时仅显示当前 Provider",
-          "**/model**　选择当前任务使用的模型",
-          "**/thinking**　设置模型的思考强度",
-          "**/permissions**　设置执行工具前是否需要确认",
-        ],
-      },
-      {
-        title: "Agent",
-        lines: [
-          "**/agent [name]**　选择新任务使用的默认 Agent；仅配置一个时直接显示当前 Agent",
-        ],
-      },
-      {
-        title: "系统",
-        lines: [
-          "**/status [序号或任务 ID]**　查看当前或指定任务的详细状态",
-          "**/restart [--force]**　默认安全重启；--force 立即重启",
-          "**/help**　显示本帮助",
-        ],
-      },
-    ];
-    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderSectionsCard("Agent Bot 使用帮助", sections));
+    const sections: HelpCardSection[] = HELP_COMMAND_SECTIONS.map((section) => ({
+      title: section.title,
+      commands: section.commands.map((command) => ({
+        text: command.command,
+        ...(command.requiresArgument
+          ? {}
+          : {
+              action: {
+                text: command.command,
+                value: {
+                  action: "help_command",
+                  command: command.command,
+                  contextKey,
+                },
+              },
+            }),
+        ...(command.usage ? { usage: command.usage } : {}),
+        description: command.description,
+      })),
+    }));
+    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard(
+      "Agent Bot 使用帮助",
+      [
+        "直接发送消息即可继续当前任务；执行中发送的新消息会追加到本次任务。",
+        "点击命令按钮可执行默认形式；有必填参数的命令需要手动发送。",
+        "> 命令前缀示例：/sess 等同于 /sessions。",
+        "> 命令缩写示例：/fg 等同于 /forkgroup。",
+        "前缀或缩写匹配多个命令时，需要输入更长的形式。",
+        "**[参数]** 可选　**&#60;参数&#62;** 必填",
+      ],
+      sections,
+    ));
   }
 
   private ensureAgent(agentName: string) {

package/src/runtime/AcpRuntimeAdapter.ts

@@ -3,6 +3,7 @@ import { AcpSessionManager } from "../acp/AcpSessionManager.js";
 import { createId } from "../utils/id.js";
 import type {
   AgentRuntime,
+  AgentProcessInfo,
   ApprovalDecision,
   CreateRuntimeSessionInput,
   ModelOption,
@@ -37,6 +38,10 @@ export class AcpRuntimeAdapter implements AgentRuntime {
     return this.sessions.get(localSessionId);
   }
 
+  getProcessInfo(): AgentProcessInfo {
+    return this.acp.getProcessInfo();
+  }
+
   async createSession(input: CreateRuntimeSessionInput): Promise<RuntimeSession> {
     const created = await this.acp.create({
       localSessionId: input.localSessionId,

package/src/runtime/agentEnvironment.ts

@@ -2,13 +2,51 @@ export const AGENT_BOT_ENVIRONMENT = Object.freeze({
   AGENT_BOT: "1",
 });
 
+export interface AgentEnvironmentContext {
+  profilePath?: string;
+  configPath?: string;
+  agentName?: string;
+  larkAppId?: string;
+  larkBotOpenId?: string;
+  larkUserOpenId?: string;
+}
+
+const RESERVED_ENVIRONMENT_PREFIXES = ["AGENT_BOT_", "FEISHU_"];
+
 export function agentBotEnvironment(
   baseEnv: NodeJS.ProcessEnv,
   agentEnv: Record<string, string>,
+  context: AgentEnvironmentContext = {},
 ): NodeJS.ProcessEnv {
-  return {
-    ...baseEnv,
-    ...agentEnv,
+  const environment: NodeJS.ProcessEnv = {
+    ...withoutReservedEnvironment(baseEnv),
+    ...withoutReservedEnvironment(agentEnv),
     ...AGENT_BOT_ENVIRONMENT,
   };
+  setNonBlank(environment, "AGENT_BOT_HOME", context.profilePath);
+  setNonBlank(environment, "AGENT_BOT_CONFIG", context.configPath);
+  setNonBlank(environment, "AGENT_BOT_AGENT_NAME", context.agentName);
+  setNonBlank(environment, "AGENT_BOT_LARK_APP_ID", context.larkAppId);
+  setNonBlank(environment, "AGENT_BOT_LARK_BOT_OPEN_ID", context.larkBotOpenId);
+  setNonBlank(environment, "AGENT_BOT_LARK_USER_OPEN_ID", context.larkUserOpenId);
+  return environment;
+}
+
+function withoutReservedEnvironment(
+  environment: NodeJS.ProcessEnv | Record<string, string>,
+): NodeJS.ProcessEnv {
+  return Object.fromEntries(
+    Object.entries(environment).filter(([name, value]) =>
+      value !== undefined && !isReservedEnvironmentName(name)),
+  );
+}
+
+function isReservedEnvironmentName(name: string): boolean {
+  const normalized = name.toUpperCase();
+  return normalized === "AGENT_BOT"
+    || RESERVED_ENVIRONMENT_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+function setNonBlank(environment: NodeJS.ProcessEnv, name: string, value: string | undefined): void {
+  if (value?.trim()) environment[name] = value;
 }

package/src/runtime/createAgentRuntimeRegistry.ts

@@ -5,19 +5,34 @@ 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 type { AgentEnvironmentContext } from "./agentEnvironment.js";
 import { AgentRuntimeRegistry } from "./AgentRuntimeRegistry.js";
 import type { AgentRuntime } from "./types.js";
 
-export function createAgentRuntimeRegistry(config: AppConfig, logger: Logger): AgentRuntimeRegistry {
+export function createAgentRuntimeRegistry(
+  config: AppConfig,
+  logger: Logger,
+  environmentContext: AgentEnvironmentContext = {},
+): AgentRuntimeRegistry {
   const runtimes: Record<string, AgentRuntime> = {};
   for (const [agentName, agent] of Object.entries(config.agents)) {
     const runtimeLogger = logger.child({ agentName, runtimeKind: agent.kind });
+    const runtimeEnvironmentContext = (): AgentEnvironmentContext => ({
+      ...environmentContext,
+      agentName,
+    });
     if (agent.kind === "app-server") {
-      const processManager = new CodexProcessManager(agent.command, agent.args, agent.env, runtimeLogger);
+      const processManager = new CodexProcessManager(
+        agent.command,
+        agent.args,
+        agent.env,
+        runtimeLogger,
+        runtimeEnvironmentContext,
+      );
       runtimes[agentName] = new CodexRuntime(processManager, runtimeLogger);
       continue;
     }
-    const processManager = new AcpProcessManager(runtimeLogger);
+    const processManager = new AcpProcessManager(runtimeLogger, runtimeEnvironmentContext);
     const sessionManager = new AcpSessionManager(agentName, agent, processManager, runtimeLogger);
     runtimes[agentName] = new AcpRuntimeAdapter(sessionManager);
   }

package/src/runtime/types.ts

@@ -1,4 +1,8 @@
 export type RuntimeKind = "acp" | "codex";
+export interface AgentProcessInfo {
+  pid?: number;
+  version?: string;
+}
 export type PermissionMode = "auto" | "confirm";
 export type ApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
 export type ToolStatus = "running" | "completed" | "failed";
@@ -203,6 +207,7 @@ export interface ReasoningEffortOption {
 
 export interface AgentRuntime {
   readonly kind: RuntimeKind;
+  getProcessInfo?(): AgentProcessInfo;
   createSession(input: CreateRuntimeSessionInput): Promise<RuntimeSession>;
   resumeSession(input: ResumeRuntimeSessionInput): Promise<RuntimeSession>;
   forkSession?(input: ForkRuntimeSessionInput): Promise<RuntimeSession>;

package/src/state/StateStore.ts

@@ -658,9 +658,13 @@ export class StateStore {
 
   saveTurnParent(turnId: string, localSessionId: string, parentTurnId?: string): void {
     this.db.prepare(`
-      INSERT OR IGNORE INTO turn_parent_links (
+      INSERT INTO turn_parent_links (
         turn_id, local_session_id, parent_turn_id, created_at
       ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(turn_id) DO UPDATE SET
+        parent_turn_id = excluded.parent_turn_id
+      WHERE turn_parent_links.parent_turn_id IS NULL
+        AND excluded.parent_turn_id IS NOT NULL
     `).run(turnId, localSessionId, parentTurnId ?? null, new Date().toISOString());
   }
 
@@ -780,9 +784,6 @@ export class StateStore {
     `).all(localSessionId) as Array<{ turn_id: string; started_at: number }>;
     if (turns.length === 0) return;
 
-    const existing = new Set((this.db.prepare(`
-      SELECT turn_id FROM turn_parent_links WHERE local_session_id = ?
-    `).all(localSessionId) as Array<{ turn_id: string }>).map((row) => row.turn_id));
     const resets = (this.db.prepare(`
       SELECT payload_json, created_at
       FROM audit_events
@@ -802,10 +803,14 @@ export class StateStore {
 
     let headTurnId: string | undefined;
     let resetIndex = 0;
-    const insert = this.db.prepare(`
-      INSERT OR IGNORE INTO turn_parent_links (
+    const upsert = this.db.prepare(`
+      INSERT INTO turn_parent_links (
         turn_id, local_session_id, parent_turn_id, created_at
       ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(turn_id) DO UPDATE SET
+        parent_turn_id = excluded.parent_turn_id
+      WHERE turn_parent_links.parent_turn_id IS NULL
+        AND excluded.parent_turn_id IS NOT NULL
     `);
     const backfill = this.db.transaction(() => {
       for (const turn of turns) {
@@ -813,9 +818,7 @@ export class StateStore {
           headTurnId = resets[resetIndex]!.resetTurnId;
           resetIndex += 1;
         }
-        if (!existing.has(turn.turn_id)) {
-          insert.run(turn.turn_id, localSessionId, headTurnId ?? null, new Date().toISOString());
-        }
+        upsert.run(turn.turn_id, localSessionId, headTurnId ?? null, new Date().toISOString());
         headTurnId = turn.turn_id;
       }
     });