@keyou007/agent-bot 0.1.14-alpha.1 → 0.1.14-alpha.3

package/src/cli/FeishuAppConfiguration.ts

@@ -24,6 +24,10 @@ const REQUIRED_SCOPE_REQUIREMENTS: ScopeRequirement[] = [
     requested: "im:chat:create",
     accepted: ["im:chat:create", "im:chat"],
   },
+  {
+    requested: "im:chat:delete",
+    accepted: ["im:chat:delete", "im:chat:operate_as_owner", "im:chat"],
+  },
   {
     requested: "im:chat:read",
     accepted: ["im:chat:read", "im:chat:readonly", "im:chat"],
@@ -72,7 +76,8 @@ const CORE_FEISHU_SCOPES = new Set([
   "im:message:send_as_bot",
 ]);
 const CORE_FEISHU_EVENTS = new Set<string>(["im.message.receive_v1"]);
-const MANUAL_FEISHU_SCOPES = new Set(["im:message.group_msg"]);
+const ALL_GROUP_MESSAGE_SCOPES = new Set(["im:message.group_msg"]);
+const MANUAL_FEISHU_SCOPES = ALL_GROUP_MESSAGE_SCOPES;
 
 export interface FeishuAppConfiguration {
   scopes: string[];
@@ -96,6 +101,7 @@ export interface FeishuConfigurationChallenge {
 export interface EnsureFeishuAppConfigurationOptions {
   fetch?: typeof globalThis.fetch;
   sleep?: (milliseconds: number) => Promise<void>;
+  respondToAllGroupMessages?: boolean;
   signal?: AbortSignal;
   manualPermissionSkipSignal?: AbortSignal;
   optionalSkipSignal?: AbortSignal;
@@ -124,6 +130,9 @@ export async function ensureFeishuAppConfiguration(
   const timeoutMs = positiveInteger(options.timeoutMs) ?? DEFAULT_COMPLETION_TIMEOUT_MS;
   const optionalTimeoutMs = positiveInteger(options.optionalTimeoutMs)
     ?? DEFAULT_OPTIONAL_COMPLETION_TIMEOUT_MS;
+  const excludedScopes = options.respondToAllGroupMessages === false
+    ? ALL_GROUP_MESSAGE_SCOPES
+    : new Set<string>();
 
   let configuration: FeishuAppConfiguration;
   try {
@@ -133,7 +142,7 @@ export async function ensureFeishuAppConfiguration(
     configuration = emptyConfiguration();
   }
 
-  const missing = missingFeishuAppConfiguration(configuration);
+  const missing = withoutIgnoredScopes(missingFeishuAppConfiguration(configuration), excludedScopes);
   if (!hasMissingConfiguration(missing)) {
     return {
       status: "ready",
@@ -154,6 +163,8 @@ export async function ensureFeishuAppConfiguration(
       pollIntervalMs,
       optionalTimeoutMs,
       options,
+      new Set(),
+      excludedScopes,
     );
   }
 
@@ -179,7 +190,7 @@ export async function ensureFeishuAppConfiguration(
 
     try {
       configuration = await readFeishuAppConfiguration(credentials, fetchImpl, options.signal);
-      const remaining = missingFeishuAppConfiguration(configuration);
+      const remaining = withoutIgnoredScopes(missingFeishuAppConfiguration(configuration), excludedScopes);
       const unresolvedCore = coreMissingFeishuAppConfiguration(remaining);
       if (!hasBlockingCoreConfiguration(unresolvedCore, options.manualPermissionSkipSignal)) {
         return completeOptionalFeishuConfiguration(
@@ -192,12 +203,16 @@ export async function ensureFeishuAppConfiguration(
           optionalTimeoutMs,
           options,
           skippedManualScopes(coreMissing, options.manualPermissionSkipSignal),
+          excludedScopes,
         );
       }
       lastError = undefined;
     } catch (error) {
       if (options.signal?.aborted) throw abortError(options.signal);
-      const knownRemaining = missingFeishuAppConfiguration(configuration);
+      const knownRemaining = withoutIgnoredScopes(
+        missingFeishuAppConfiguration(configuration),
+        excludedScopes,
+      );
       if (!hasBlockingCoreConfiguration(
         coreMissingFeishuAppConfiguration(knownRemaining),
         options.manualPermissionSkipSignal,
@@ -212,6 +227,7 @@ export async function ensureFeishuAppConfiguration(
           optionalTimeoutMs,
           options,
           skippedManualScopes(coreMissing, options.manualPermissionSkipSignal),
+          excludedScopes,
         );
       }
       lastError = error;
@@ -267,9 +283,10 @@ async function completeOptionalFeishuConfiguration(
   timeoutMs: number,
   options: EnsureFeishuAppConfigurationOptions,
   ignoredScopes: ReadonlySet<string> = new Set(),
+  excludedScopes: ReadonlySet<string> = new Set(),
 ): Promise<EnsureFeishuAppConfigurationResult> {
   let configuration = initialConfiguration;
-  let remaining = missingFeishuAppConfiguration(configuration);
+  let remaining = withoutIgnoredScopes(missingFeishuAppConfiguration(configuration), excludedScopes);
   const requested = withoutIgnoredScopes(remaining, ignoredScopes);
   if (hasMissingConfiguration(requested)) {
     await requestMissingFeishuConfiguration(
@@ -289,6 +306,7 @@ async function completeOptionalFeishuConfiguration(
         options.signal,
         options.optionalSkipSignal,
         ignoredScopes,
+        excludedScopes,
       );
       configuration = completed.configuration;
       remaining = completed.remaining;
@@ -312,12 +330,13 @@ async function waitForOptionalFeishuConfiguration(
   signal?: AbortSignal,
   optionalSkipSignal?: AbortSignal,
   ignoredScopes: ReadonlySet<string> = new Set(),
+  excludedScopes: ReadonlySet<string> = new Set(),
 ): Promise<{
   configuration: FeishuAppConfiguration;
   remaining: MissingFeishuAppConfiguration;
 }> {
   let configuration = initialConfiguration;
-  let remaining = missingFeishuAppConfiguration(configuration);
+  let remaining = withoutIgnoredScopes(missingFeishuAppConfiguration(configuration), excludedScopes);
   let remainingMs = timeoutMs;
   while (remainingMs > 0 && hasMissingConfiguration(withoutIgnoredScopes(remaining, ignoredScopes))) {
     if (optionalSkipSignal?.aborted) break;
@@ -332,7 +351,7 @@ async function waitForOptionalFeishuConfiguration(
     remainingMs -= waitMs;
     try {
       configuration = await readFeishuAppConfiguration(credentials, fetchImpl, signal);
-      remaining = missingFeishuAppConfiguration(configuration);
+      remaining = withoutIgnoredScopes(missingFeishuAppConfiguration(configuration), excludedScopes);
     } catch (error) {
       if (signal?.aborted) throw abortError(signal);
     }

package/src/cli/Initializer.ts

@@ -43,6 +43,12 @@ export function shouldConfigureAgentsDuringInitialization(status: Initialization
   return status === "created" || status === "reset";
 }
 
+export function shouldConfigureGroupMessagesDuringInitialization(status: InitializationStatus): boolean {
+  return status === "created" || status === "reset";
+}
+
+export type GroupMessageResponseMode = "all" | "mention-only";
+
 export interface ConfiguredAgentOption {
   name: string;
   title: string;
@@ -238,6 +244,57 @@ export function writeConfiguredAgentSelection(
   return true;
 }
 
+export function readGroupMessageResponseMode(configPath: string): GroupMessageResponseMode {
+  const document = parseConfigurationDocument(fs.readFileSync(configPath, "utf8"), configPath);
+  if (!isMap(document.contents)) {
+    throw new Error(cliText(
+      `Configuration file must contain a YAML mapping: ${configPath}`,
+      `配置文件必须包含 YAML 映射：${configPath}`,
+    ));
+  }
+  const feishu = document.contents.get("feishu", true);
+  if (!isMap(feishu)) {
+    throw new Error(cliText(
+      `Configuration feishu must contain a YAML mapping: ${configPath}`,
+      `配置文件的 feishu 必须是 YAML 映射：${configPath}`,
+    ));
+  }
+  const enabled = document.getIn(["feishu", "respondToAllGroupMessages"]);
+  if (typeof enabled !== "boolean") {
+    throw new Error(cliText(
+      `Configuration feishu.respondToAllGroupMessages must be a boolean: ${configPath}`,
+      `配置项 feishu.respondToAllGroupMessages 必须是布尔值：${configPath}`,
+    ));
+  }
+  return enabled ? "all" : "mention-only";
+}
+
+export function writeGroupMessageResponseMode(
+  configPath: string,
+  mode: GroupMessageResponseMode,
+): boolean {
+  const original = fs.readFileSync(configPath, "utf8");
+  const document = parseConfigurationDocument(original, configPath);
+  if (!isMap(document.contents)) {
+    throw new Error(cliText(
+      `Configuration file must contain a YAML mapping: ${configPath}`,
+      `配置文件必须包含 YAML 映射：${configPath}`,
+    ));
+  }
+  const feishu = document.contents.get("feishu", true);
+  if (!isMap(feishu)) {
+    throw new Error(cliText(
+      `Configuration feishu must contain a YAML mapping: ${configPath}`,
+      `配置文件的 feishu 必须是 YAML 映射：${configPath}`,
+    ));
+  }
+  const enabled = mode === "all";
+  if (document.getIn(["feishu", "respondToAllGroupMessages"]) === enabled) return false;
+  feishu.set("respondToAllGroupMessages", enabled);
+  writeFileAtomically(configPath, document.toString());
+  return true;
+}
+
 export function readFeishuCredentials(envPath: string, env: NodeJS.ProcessEnv = process.env): FeishuCredentialState {
   const fileValues = fs.existsSync(envPath) ? parseDotEnv(fs.readFileSync(envPath, "utf8")) : {};
   const appId = firstNonBlank(env.FEISHU_APP_ID, fileValues.FEISHU_APP_ID);