@keyou007/agent-bot 0.1.6 → 0.1.8

package/docs/technical-reference.md

@@ -76,7 +76,9 @@ When complete credentials are absent, initialization uses Feishu one-click regis
 Missing app configuration is handled in two stages:
 
 1. Core configuration is requested and polled until it becomes available.
-2. Remaining optional configuration is requested without blocking initialization.
+2. Remaining optional configuration is requested. The CLI prints its QR code followed by the authorization URL, then immediately polls for up to five minutes. An interactive terminal offers only `Y` to skip optional authorization and continue; otherwise the user completes authorization in the browser while polling continues.
+
+Optional polling failures and timeouts return a partial configuration result instead of failing initialization. When stdin is not an interactive terminal, no skip input is available and polling continues until configuration becomes active or times out. Verification URLs and prompts use stderr, so `--json` keeps its final stdout machine-readable.
 
 The generated authorization links do not contain the app secret.
 
@@ -91,7 +93,8 @@ Core configuration required for basic messaging:
 - Bot capability
 - Persistent-connection event delivery
 - `im.message.receive_v1`
-- Tenant permissions for group @ messages and private messages
+- `im:message.group_msg:readonly` for all user messages in groups containing the bot
+- Tenant permission for private messages
 - `im:message:send_as_bot` or a broader equivalent
 - `application:application:self_manage` so initialization can inspect the published version
 
@@ -118,6 +121,7 @@ feishu:
   appId: "${FEISHU_APP_ID}"
   appSecret: "${FEISHU_APP_SECRET}"
   userOpenId: "${FEISHU_USER_OPEN_ID}"
+  respondToAllGroupMessages: true
 
 console:
   enabled: true
@@ -142,6 +146,8 @@ logging:
   path: "./logs/agent-bot.log"
 ```
 
+`feishu.respondToAllGroupMessages` defaults to `true`. Set it to `false` to ignore group messages unless they mention the current bot. The worker resolves the bot's Open ID at startup so mentioning another member does not trigger it. Private messages are always accepted. Initialization requests all-user group-message delivery regardless of this runtime option, allowing it to be changed later without another authorization.
+
 `agent-bot server start` requires both Feishu credentials. The worker starts the SDK's persistent connection without inspecting SDK logs or private connection state, then sends startup status cards as an outbound readiness check. Each startup card includes the Agent Bot version read from the installed package metadata. It normally targets known private chats and recently active groups. If the database has no known chat yet, it sends the card to `feishu.userOpenId` using an `open_id` private message. When notification targets exist, at least one card must be delivered before the server reports ready; individual target failures remain isolated. If neither a known chat nor `feishu.userOpenId` is available, startup continues without the outbound check. Missing credentials still fail startup with an initialization hint. `agent-bot console` is the explicit local-only path and does not require Feishu credentials.
 
 At least one agent must be configured. `defaults.agent` must name a configured agent.

package/docs/technical-reference.zh.md

@@ -76,7 +76,9 @@ CLI 界面文本不受系统语言影响，统一使用英文。系统生成的
 缺失配置分两阶段处理：
 
 1. 请求核心配置并轮询，直到基础能力生效
-2. 请求其余可选配置，但不阻塞初始化
+2. 请求其余可选配置。CLI 会先显示二维码，随后显示授权链接，然后立即开始最多 5 分钟的轮询。交互式终端只提供 `Y` 选项，用于跳过可选授权并继续；否则用户直接在浏览器中完成授权，轮询会持续进行
+
+可选配置轮询失败或超时会返回部分配置结果，不会导致初始化失败。stdin 不是交互式终端时无法输入跳过指令，轮询会持续到配置生效或超时。验证链接和提示写入 stderr，因此 `--json` 的最终 stdout 仍可直接供程序读取。
 
 生成的授权链接不包含 App Secret。
 
@@ -91,7 +93,8 @@ CLI 界面文本不受系统语言影响，统一使用英文。系统生成的
 - 机器人能力
 - 长连接事件接收
 - `im.message.receive_v1`
-- 接收群聊 @ 消息和私聊消息所需的租户权限
+- `im:message.group_msg:readonly`，用于接收机器人所在群内的全部用户消息
+- 接收私聊消息所需的租户权限
 - `im:message:send_as_bot` 或覆盖它的更大权限
 - `application:application:self_manage`，供初始化检查已发布版本
 
@@ -118,6 +121,7 @@ feishu:
   appId: "${FEISHU_APP_ID}"
   appSecret: "${FEISHU_APP_SECRET}"
   userOpenId: "${FEISHU_USER_OPEN_ID}"
+  respondToAllGroupMessages: true
 
 console:
   enabled: true
@@ -142,6 +146,8 @@ logging:
   path: "./logs/agent-bot.log"
 ```
 
+`feishu.respondToAllGroupMessages` 默认为 `true`。设为 `false` 后，未 @ 当前机器人的群消息会被忽略；Worker 启动时会解析机器人的 Open ID，因此 @ 其他成员不会误触发。私聊始终正常处理。无论该运行时配置如何，初始化都会申请接收全部群消息的权限，之后切换配置无需再次授权。
+
 `agent-bot server start` 要求同时配置飞书 `appId` 和 `appSecret`。Worker 启动 SDK 长连接时不读取 SDK 日志或私有连接状态，随后通过发送启动状态卡片检查出站能力。每张启动卡片都会显示从已安装包元数据读取的 Agent Bot 版本。通知通常发往已知私聊和最近活跃的群聊；数据库里尚无已知会话时，改用 `feishu.userOpenId`，按 `open_id` 私聊发送。存在通知目标时，至少一张卡片发送成功后 Server 才报告就绪，单个目标发送失败仍相互隔离。如果既没有已知会话，也没有 `feishu.userOpenId`，启动会跳过出站检查并继续。缺少凭据时仍会启动失败并提示先初始化。`agent-bot console` 是明确的纯本地入口，不需要飞书凭据。
 
 必须至少配置一个 Agent，`defaults.agent` 必须指向已配置的 Agent。

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.6",
+      "version": "0.1.8",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Using Codex in Lark/Feishu feels just like using native Codex.",
   "license": "GPL-3.0-only",

package/skills/agent-bot/SKILL.md

@@ -46,11 +46,15 @@ Run initialization once after installing or linking the CLI:
 agent-bot init
 ```
 
-Initialization creates the Agent Bot home, `config.yaml`, `.env`, `data/`, and `logs/` from the bundled examples. If Feishu credentials are absent, it starts Feishu one-click app registration, prints an authorization URL and QR code, waits for the user to approve the request, and stores the returned app ID and secret in `.env`. It then audits the app's currently published tenant permissions, event subscriptions, and callbacks. Core and optional missing items produce separate incremental-configuration URLs so optional approval cannot block core setup.
+Initialization creates the Agent Bot home, `config.yaml`, `.env`, `data/`, and `logs/` from the bundled examples. If Feishu credentials are absent, it starts Feishu one-click app registration, prints a QR code followed by its authorization URL, waits for the user to approve the request, and stores the returned app ID and secret in `.env`. It then audits the app's currently published tenant permissions, event subscriptions, and callbacks. Core and optional missing items produce separate incremental-configuration URLs. Core configuration is always polled until ready. For optional configuration, the CLI prints the QR code followed by the authorization URL and immediately waits up to five minutes for activation. The only terminal choice is `Y`, which skips optional authorization and continues initialization.
+
+Core messaging configuration includes `im:message.group_msg:readonly`, not merely the narrower group-mention scope. Agent Bot groups accept ordinary messages without requiring users to @ the bot, so initialization must keep waiting until all-user group-message delivery is active.
+
+Initialization always requests all-user group-message delivery. The runtime option `feishu.respondToAllGroupMessages` controls whether Agent Bot uses it: the default `true` responds to ordinary group messages, while `false` requires a mention of the current bot. Private messages are unaffected.
 
 After Feishu initialization succeeds, `init` releases its initialization lock and automatically starts the selected profile's server, waiting until it is ready. It does not create another supervisor when that profile is already running. `init --skip-feishu` is the exception: it prepares Console-only files and does not start the server. With `--json`, inspect `server.status` for `started`, `already-running`, or `skipped`.
 
-When running `init` on the user's behalf, relay every exact authorization or incremental-configuration URL and let the user complete it in their own browser. The command waits only for core message receipt and delivery capabilities. Optional capabilities such as group creation, group-title synchronization, reactions, images, and card actions do not block initialization; relay the final affected-feature warnings when they remain unavailable. Neither URL contains the app secret, and the secret itself is never printed.
+When running `init` on the user's behalf, relay every exact authorization or incremental-configuration URL and let the user complete it in their own browser. Optional polling starts automatically after the link is shown. Do not enter `Y` unless the user explicitly asks to skip optional authorization; there is no separate accept action. Optional capabilities such as group creation, group-title synchronization, reactions, images, and card actions never block initialization when skipped, timed out, or still unavailable; relay the final affected-feature warnings. In a non-interactive terminal, optional polling continues until activation or timeout because skip input is unavailable. Neither URL contains the app secret, and the secret itself is never printed.
 
 Existing complete Feishu credentials are preserved but still audited and repaired when needed. Missing or incomplete credentials mean app creation did not complete, so a later `init` starts a new registration instead of resuming the previous device code. Once both credentials are durably saved, an interrupted permission audit resumes against the same remote app. `init` also holds a local lock to prevent concurrent registrations. Use `agent-bot init --skip-feishu` only for console-only initialization because it skips both registration and configuration auditing. Use `agent-bot init --reconfigure-feishu` only when the user explicitly wants to replace existing complete credentials. The command respects `AGENT_BOT_HOME`, `AGENT_BOT_CONFIG`, and `--config <path>`. Use `agent-bot init --json` when structured final output helps.
 
@@ -151,7 +155,7 @@ Keep action labels placed to the right of card content or at the bottom of a car
 
 Messages whose trimmed text starts with `/` are always parsed as Agent Bot commands. Unknown slash commands are reported to the user with a `/help` hint and must never fall through to the model, including slash-prefixed messages that also contain images.
 
-When a group body has a current task, renaming the Feishu group to `[agent-name] new title` also renames that current task if the prefix matches the task's configured agent. Malformed names, agent mismatches, empty groups, and thread-specific tasks are ignored.
+When a group body has a current task, renaming the Feishu group to `[agent-name] [project directory] new title` also renames that current task if the Agent prefix matches the task's configured agent. Only `new title` is written to the task; the Agent and project-directory prefixes remain group metadata. The older `[agent-name] new title` shape remains supported. Malformed names, agent mismatches, empty groups, and thread-specific tasks are ignored.
 
 Use `--context <key>` or `--status <status>` to narrow `task list`. Use `--profile <directory>` before the command when controlling an isolated Agent Bot instance, or `--config <path>` for only a non-default configuration.
 

package/src/cli/FeishuAppConfiguration.ts

@@ -6,6 +6,7 @@ const TENANT_TOKEN_PATH = "/open-apis/auth/v3/tenant_access_token/internal";
 const APPLICATION_PATH_PREFIX = "/open-apis/application/v6/applications";
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const DEFAULT_COMPLETION_TIMEOUT_MS = 10 * 60_000;
+const DEFAULT_OPTIONAL_COMPLETION_TIMEOUT_MS = 5 * 60_000;
 const REQUEST_TIMEOUT_MS = 30_000;
 
 interface ScopeRequirement {
@@ -27,11 +28,8 @@ const REQUIRED_SCOPE_REQUIREMENTS: ScopeRequirement[] = [
     accepted: ["im:chat:read", "im:chat:readonly", "im:chat"],
   },
   {
-    requested: "im:message.group_at_msg:readonly",
+    requested: "im:message.group_msg:readonly",
     accepted: [
-      "im:message.group_at_msg:readonly",
-      "im:message.group_at_msg.include_bot:readonly",
-      "im:message.group_at_msg",
       "im:message.group_msg:readonly",
       "im:message.group_msg",
     ],
@@ -68,7 +66,7 @@ export const REQUIRED_FEISHU_CALLBACKS = ["card.action.trigger"] as const;
 
 const CORE_FEISHU_SCOPES = new Set([
   "application:application:self_manage",
-  "im:message.group_at_msg:readonly",
+  "im:message.group_msg:readonly",
   "im:message.p2p_msg:readonly",
   "im:message:send_as_bot",
 ]);
@@ -96,8 +94,10 @@ export interface EnsureFeishuAppConfigurationOptions {
   fetch?: typeof globalThis.fetch;
   sleep?: (milliseconds: number) => Promise<void>;
   signal?: AbortSignal;
+  optionalSkipSignal?: AbortSignal;
   pollIntervalMs?: number;
   timeoutMs?: number;
+  optionalTimeoutMs?: number;
   onVerification?: (challenge: FeishuConfigurationChallenge) => void | Promise<void>;
 }
 
@@ -118,6 +118,8 @@ export async function ensureFeishuAppConfiguration(
   const sleep = options.sleep ?? delay;
   const pollIntervalMs = positiveInteger(options.pollIntervalMs) ?? DEFAULT_POLL_INTERVAL_MS;
   const timeoutMs = positiveInteger(options.timeoutMs) ?? DEFAULT_COMPLETION_TIMEOUT_MS;
+  const optionalTimeoutMs = positiveInteger(options.optionalTimeoutMs)
+    ?? DEFAULT_OPTIONAL_COMPLETION_TIMEOUT_MS;
 
   let configuration: FeishuAppConfiguration;
   try {
@@ -139,13 +141,16 @@ export async function ensureFeishuAppConfiguration(
 
   const coreMissing = coreMissingFeishuAppConfiguration(missing);
   if (!hasMissingConfiguration(coreMissing)) {
-    await requestMissingFeishuConfiguration(credentials.appId, missing, false, options.onVerification);
-    return {
-      status: "partial",
+    return completeOptionalFeishuConfiguration(
+      credentials,
       configuration,
-      added: emptyConfiguration(),
-      remaining: missing,
-    };
+      missing,
+      fetchImpl,
+      sleep,
+      pollIntervalMs,
+      optionalTimeoutMs,
+      options,
+    );
   }
 
   await requestMissingFeishuConfiguration(credentials.appId, coreMissing, true, options.onVerification);
@@ -161,15 +166,16 @@ export async function ensureFeishuAppConfiguration(
       configuration = await readFeishuAppConfiguration(credentials, fetchImpl, options.signal);
       const remaining = missingFeishuAppConfiguration(configuration);
       if (!hasMissingConfiguration(coreMissingFeishuAppConfiguration(remaining))) {
-        if (hasMissingConfiguration(remaining)) {
-          await requestMissingFeishuConfiguration(credentials.appId, remaining, false, options.onVerification);
-        }
-        return {
-          status: hasMissingConfiguration(remaining) ? "partial" : "updated",
+        return completeOptionalFeishuConfiguration(
+          credentials,
           configuration,
-          added: resolvedMissingConfiguration(missing, remaining),
-          remaining,
-        };
+          missing,
+          fetchImpl,
+          sleep,
+          pollIntervalMs,
+          optionalTimeoutMs,
+          options,
+        );
       }
       lastError = undefined;
     } catch (error) {
@@ -192,6 +198,112 @@ async function requestMissingFeishuConfiguration(
   await onVerification?.({ verificationUrl, missing, blocking });
 }
 
+async function completeOptionalFeishuConfiguration(
+  credentials: FeishuAppCredentials,
+  initialConfiguration: FeishuAppConfiguration,
+  initialMissing: MissingFeishuAppConfiguration,
+  fetchImpl: typeof globalThis.fetch,
+  sleep: (milliseconds: number) => Promise<void>,
+  pollIntervalMs: number,
+  timeoutMs: number,
+  options: EnsureFeishuAppConfigurationOptions,
+): Promise<EnsureFeishuAppConfigurationResult> {
+  let configuration = initialConfiguration;
+  let remaining = missingFeishuAppConfiguration(configuration);
+  if (hasMissingConfiguration(remaining)) {
+    await requestMissingFeishuConfiguration(
+      credentials.appId,
+      remaining,
+      false,
+      options.onVerification,
+    );
+    if (!options.optionalSkipSignal?.aborted) {
+      const completed = await waitForOptionalFeishuConfiguration(
+        credentials,
+        configuration,
+        fetchImpl,
+        sleep,
+        pollIntervalMs,
+        timeoutMs,
+        options.signal,
+        options.optionalSkipSignal,
+      );
+      configuration = completed.configuration;
+      remaining = completed.remaining;
+    }
+  }
+  return {
+    status: hasMissingConfiguration(remaining) ? "partial" : "updated",
+    configuration,
+    added: resolvedMissingConfiguration(initialMissing, remaining),
+    remaining,
+  };
+}
+
+async function waitForOptionalFeishuConfiguration(
+  credentials: FeishuAppCredentials,
+  initialConfiguration: FeishuAppConfiguration,
+  fetchImpl: typeof globalThis.fetch,
+  sleep: (milliseconds: number) => Promise<void>,
+  pollIntervalMs: number,
+  timeoutMs: number,
+  signal?: AbortSignal,
+  optionalSkipSignal?: AbortSignal,
+): Promise<{
+  configuration: FeishuAppConfiguration;
+  remaining: MissingFeishuAppConfiguration;
+}> {
+  let configuration = initialConfiguration;
+  let remaining = missingFeishuAppConfiguration(configuration);
+  let remainingMs = timeoutMs;
+  while (remainingMs > 0 && hasMissingConfiguration(remaining)) {
+    if (optionalSkipSignal?.aborted) break;
+    const waitMs = Math.min(pollIntervalMs, remainingMs);
+    const waitResult = await sleepWithOptionalSkip(
+      sleep,
+      waitMs,
+      signal,
+      optionalSkipSignal,
+    );
+    if (waitResult === "skipped") break;
+    remainingMs -= waitMs;
+    try {
+      configuration = await readFeishuAppConfiguration(credentials, fetchImpl, signal);
+      remaining = missingFeishuAppConfiguration(configuration);
+    } catch (error) {
+      if (signal?.aborted) throw abortError(signal);
+    }
+  }
+  return { configuration, remaining };
+}
+
+async function sleepWithOptionalSkip(
+  sleep: (milliseconds: number) => Promise<void>,
+  milliseconds: number,
+  signal?: AbortSignal,
+  optionalSkipSignal?: AbortSignal,
+): Promise<"elapsed" | "skipped"> {
+  if (!optionalSkipSignal) {
+    await sleepWithAbort(sleep, milliseconds, signal);
+    return "elapsed";
+  }
+  if (optionalSkipSignal.aborted) return "skipped";
+
+  let onSkip: (() => void) | undefined;
+  const skipped = new Promise<"skipped">((resolve) => {
+    onSkip = () => resolve("skipped");
+    optionalSkipSignal.addEventListener("abort", onSkip, { once: true });
+  });
+  try {
+    return await Promise.race([
+      sleepWithAbort(sleep, milliseconds, signal).then(() => "elapsed" as const),
+      skipped,
+    ]);
+  } finally {
+    if (onSkip) optionalSkipSignal.removeEventListener("abort", onSkip);
+  }
+}
+
 export function missingFeishuAppConfiguration(configuration: FeishuAppConfiguration): MissingFeishuAppConfiguration {
   const scopes = new Set(configuration.scopes);
   const events = new Set(configuration.events);

package/src/cli/OptionalAuthorizationSkip.ts

@@ -0,0 +1,38 @@
+import { createInterface, type Interface } from "node:readline";
+
+export interface OptionalAuthorizationSkipListener {
+  close(): void;
+}
+
+export function listenForOptionalAuthorizationSkip(
+  onSkip: () => void,
+): OptionalAuthorizationSkipListener {
+  if (!process.stdin.isTTY) return { close: () => undefined };
+
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+  const onLine = (value: string): void => {
+    if (!isOptionalAuthorizationSkip(value)) {
+      process.stderr.write("Enter Y to skip optional authorization, or keep waiting.\n");
+      return;
+    }
+    process.stderr.write("Optional authorization skipped. Initialization will continue.\n");
+    onSkip();
+  };
+  readline.on("line", onLine);
+  process.stderr.write("Skip optional authorization? Enter Y and press Enter to skip.\n");
+  return {
+    close: () => closeReadline(readline, onLine),
+  };
+}
+
+export function isOptionalAuthorizationSkip(value: string): boolean {
+  return value.trim().toLowerCase() === "y";
+}
+
+function closeReadline(readline: Interface, onLine: (value: string) => void): void {
+  readline.removeListener("line", onLine);
+  readline.close();
+}

package/src/cli/VerificationOutput.ts

@@ -0,0 +1,22 @@
+import qrcode from "qrcode-terminal";
+
+export interface VerificationOutputOptions {
+  verificationUrl: string;
+  json: boolean;
+  qrInstruction: string;
+}
+
+export function printVerificationQrAndLink(
+  options: VerificationOutputOptions,
+  write: (value: string) => void = (value) => process.stderr.write(value),
+  renderQr: (
+    value: string,
+    callback: (output: string) => void,
+  ) => void = (value, callback) => qrcode.generate(value, { small: true }, callback),
+): void {
+  if (!options.json) {
+    write(`\n${options.qrInstruction}\n\n`);
+    renderQr(options.verificationUrl, (output) => write(`${output}\n`));
+  }
+  write(`Authorization link:\n${options.verificationUrl}\n\n`);
+}

package/src/cli.ts

@@ -2,7 +2,6 @@
 import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import qrcode from "qrcode-terminal";
 import { loadConfig, loadConfigWithoutEnvironmentMutation } from "./config/loadConfig.js";
 import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.js";
 import {
@@ -21,6 +20,10 @@ import {
   type InitializationStatus,
 } from "./cli/Initializer.js";
 import { parseInitCommandOptions, type InitCommandOptions } from "./cli/initOptions.js";
+import {
+  listenForOptionalAuthorizationSkip,
+  type OptionalAuthorizationSkipListener,
+} from "./cli/OptionalAuthorizationSkip.js";
 import {
   registerFeishuApp,
   type FeishuAppCredentials,
@@ -36,6 +39,7 @@ import { formatServerStatus, withConfiguredFeishuAppId } from "./cli/serverStatu
 import { resolveSystemSkillsRoot, SkillRegistry, type SkillRegistrationStatus } from "./cli/SkillRegistry.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
 import { applyExplicitProfile, parseGlobalOptions } from "./cli/profile.js";
+import { printVerificationQrAndLink } from "./cli/VerificationOutput.js";
 import {
   startInitializedServer,
   startServer,
@@ -178,10 +182,18 @@ async function initializeFeishu(
     }
 
     if (!options.json) process.stdout.write("\nChecking Lark app permissions, events, and callbacks...\n");
+    const optionalSkip = new AbortController();
+    let skipListener: OptionalAuthorizationSkipListener | undefined;
     const configuration = await ensureFeishuAppConfiguration(credentials, {
       signal: controller.signal,
-      onVerification: (challenge) => printFeishuConfigurationVerification(challenge, options.json),
-    });
+      optionalSkipSignal: optionalSkip.signal,
+      onVerification: (challenge) => {
+        printFeishuConfigurationVerification(challenge, options.json);
+        if (!challenge.blocking) {
+          skipListener = listenForOptionalAuthorizationSkip(() => optionalSkip.abort());
+        }
+      },
+    }).finally(() => skipListener?.close());
     return {
       status,
       appId: credentials.appId,
@@ -544,13 +556,13 @@ function printServerStartResult(result: ServerStartResult): void {
 }
 
 function printFeishuVerification(challenge: FeishuAppRegistrationChallenge, json: boolean): void {
-  process.stderr.write("\nScan with Lark or open the link below in a browser to create the bot app:\n\n");
-  process.stderr.write(`${challenge.verificationUrl}\n\n`);
-  if (!json) {
-    qrcode.generate(challenge.verificationUrl, { small: true }, (output) => {
-      process.stderr.write(`${output}\n`);
-    });
-  }
+  printVerificationQrAndLink(
+    {
+      verificationUrl: challenge.verificationUrl,
+      json,
+      qrInstruction: "Scan this QR code with Lark to create the bot app:",
+    },
+  );
   process.stderr.write(`The link expires in about ${Math.ceil(challenge.expiresIn / 60)} minutes. Waiting for confirmation...\n`);
 }
 
@@ -568,17 +580,17 @@ function printFeishuConfigurationVerification(
   if (challenge.missing.callbacks.length > 0) {
     process.stderr.write(`Callbacks: ${challenge.missing.callbacks.join(", ")}\n`);
   }
-  process.stderr.write("\nScan with Lark or open the link below in a browser to complete the configuration:\n\n");
-  process.stderr.write(`${challenge.verificationUrl}\n\n`);
-  if (!json) {
-    qrcode.generate(challenge.verificationUrl, { small: true }, (output) => {
-      process.stderr.write(`${output}\n`);
-    });
-  }
+  printVerificationQrAndLink(
+    {
+      verificationUrl: challenge.verificationUrl,
+      json,
+      qrInstruction: "Scan this QR code with Lark to complete the configuration:",
+    },
+  );
   if (challenge.blocking) {
     process.stderr.write("Waiting for the core scopes and message event to become active...\n");
   } else {
-    process.stderr.write("These optional items do not block basic messaging. Initialization will continue; grant them later using the link.\n");
+    process.stderr.write("Waiting up to 5 minutes for these optional items to become active...\n");
   }
 }
 

package/src/codex/CodexEventMapper.ts

@@ -201,6 +201,19 @@ function mapTool(
       completedAt,
     };
   }
+  if (type === "imageGeneration") {
+    const imagePath = nonEmptyString(item.savedPath);
+    return {
+      id,
+      title: "生成图片",
+      kind: "image_generation",
+      status,
+      command: nonEmptyString(item.revisedPrompt),
+      imagePath,
+      startedAt,
+      completedAt,
+    };
+  }
   return undefined;
 }
 

package/src/codex/CodexRuntime.ts

@@ -17,6 +17,7 @@ import type {
   RuntimeSession,
   RuntimeSessionMetadata,
 } from "../runtime/types.js";
+import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
@@ -59,6 +60,7 @@ interface CodexSession extends RuntimeSession {
   activeTurnStartedAt?: number;
   terminalTurnIds: Set<string>;
   finalText: string;
+  generatedImagePaths: string[];
   messagePhases: Map<string, "commentary" | "final_answer">;
   needsResume: boolean;
 }
@@ -548,6 +550,14 @@ export class CodexRuntime implements AgentRuntime {
     } else if (mapped.kind === "plan") {
       this.emit({ type: "plan_updated", sessionId, turnId: mapped.turnId, steps: mapped.steps });
     } else if (mapped.kind === "tool") {
+      if (
+        mapped.phase === "updated"
+        && mapped.tool.kind === "image_generation"
+        && mapped.tool.status === "completed"
+        && mapped.tool.imagePath
+      ) {
+        session.generatedImagePaths = uniqueStrings([...session.generatedImagePaths, mapped.tool.imagePath]);
+      }
       this.emit({
         type: mapped.phase === "started" ? "tool_started" : "tool_updated",
         sessionId,
@@ -572,14 +582,16 @@ export class CodexRuntime implements AgentRuntime {
       } else if (mapped.status === "failed") {
         this.emit({ type: "turn_failed", sessionId, turnId: mapped.turnId, message: mapped.error ?? "Codex turn failed." });
       } else {
+        const finalResponse = appendGeneratedImageMarkdown(session.finalText, session.generatedImagePaths);
         this.emit({
           type: "turn_completed",
           sessionId,
           turnId: mapped.turnId,
-          finalResponse: session.finalText,
+          finalResponse,
           durationMs: mapped.durationMs,
         });
       }
+      session.generatedImagePaths = [];
     }
   }
 
@@ -693,6 +705,7 @@ export class CodexRuntime implements AgentRuntime {
     session.activeTurnId = turnId;
     session.activeTurnStartedAt = startedAt;
     session.finalText = "";
+    session.generatedImagePaths = [];
     session.messagePhases.clear();
     this.emit({ type: "turn_started", sessionId: session.localSessionId, turnId, startedAt });
   }
@@ -726,8 +739,16 @@ export class CodexRuntime implements AgentRuntime {
       });
       return;
     }
-    const finalResponse = extractFinalResponse(turn) || session.finalText;
+    const generatedImagePaths = uniqueStrings([
+      ...session.generatedImagePaths,
+      ...extractGeneratedImagePaths(turn),
+    ]);
+    const finalResponse = appendGeneratedImageMarkdown(
+      extractFinalResponse(turn) || session.finalText,
+      generatedImagePaths,
+    );
     session.finalText = finalResponse;
+    session.generatedImagePaths = [];
     this.emit({
       type: "turn_completed",
       sessionId: session.localSessionId,
@@ -765,6 +786,7 @@ export class CodexRuntime implements AgentRuntime {
           : [],
       ),
       finalText: "",
+      generatedImagePaths: [],
       messagePhases: new Map(),
       needsResume: false,
     };
@@ -796,6 +818,7 @@ export class CodexRuntime implements AgentRuntime {
       if (!turnId) continue;
       session.activeTurnId = undefined;
       session.activeTurnStartedAt = undefined;
+      session.generatedImagePaths = [];
       this.emit({
         type: "turn_failed",
         sessionId: session.localSessionId,
@@ -841,7 +864,13 @@ interface CodexThreadSnapshot {
 interface CodexTurnSnapshot {
   id: string;
   status: "completed" | "interrupted" | "failed" | "inProgress";
-  items?: Array<{ type?: string; text?: string; phase?: string | null; status?: string }>;
+  items?: Array<{
+    type?: string;
+    text?: string;
+    phase?: string | null;
+    status?: string;
+    savedPath?: string;
+  }>;
   error?: { message?: string } | null;
   startedAt?: number | null;
   durationMs?: number | null;
@@ -893,6 +922,17 @@ function extractFinalResponse(turn: CodexTurnSnapshot): string {
     .join("\n\n");
 }
 
+function extractGeneratedImagePaths(turn: CodexTurnSnapshot): string[] {
+  return uniqueStrings((turn.items ?? []).flatMap((item) => {
+    const savedPath = stringValue(item.savedPath)?.trim();
+    return item.type === "imageGeneration" && item.status !== "failed" && savedPath ? [savedPath] : [];
+  }));
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+
 function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary {
   const lastTurn = thread.turns?.at(-1);
   const lastCompletedTurn = [...(thread.turns ?? [])]
@@ -923,7 +963,9 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
     lastCompletedTurnId: lastCompletedTurn?.id,
     lastTurnStatus,
     lastActivity: lastText,
-    finalResponse: lastTurn && lastTurn.status !== "inProgress" ? extractFinalResponse(lastTurn) || undefined : undefined,
+    finalResponse: lastTurn && lastTurn.status !== "inProgress"
+      ? appendGeneratedImageMarkdown(extractFinalResponse(lastTurn), extractGeneratedImagePaths(lastTurn)) || undefined
+      : undefined,
     lastError: lastTurn?.error?.message,
     lastTurnToolCount: toolCounts?.total,
     lastTurnCompletedToolCount: toolCounts?.completed,
@@ -956,7 +998,8 @@ function isToolItemType(type: string | undefined): boolean {
     || type === "mcpToolCall"
     || type === "dynamicToolCall"
     || type === "webSearch"
-    || type === "imageView";
+    || type === "imageView"
+    || type === "imageGeneration";
 }
 
 function mergeRemoteSessionSummary(