@keyou007/agent-bot 0.1.11 → 0.1.13-alpha.0

package/src/cli.ts

@@ -2,19 +2,23 @@
 import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
 import { loadConfig, loadConfigWithoutEnvironmentMutation } from "./config/loadConfig.js";
 import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.js";
 import {
   controlEndpoint,
   type ControlResponse,
+  type TaskGroupControlData,
   type TaskStatusControlData,
 } from "./cli/controlProtocol.js";
 import {
   acquireInitializationLock,
   cleanupFeishuCredentialTemporaryFiles,
   initializeAgentBot,
+  readConfiguredAgentSelection,
   readFeishuCredentials,
   shouldCreateFeishuApp,
+  writeDefaultAgent,
   writeFeishuCredentials,
   type InitializationResult,
   type InitializationStatus,
@@ -37,6 +41,18 @@ import {
 } from "./cli/FeishuAppConfiguration.js";
 import { renderCliHelp } from "./cli/help.js";
 import { cliLanguage, cliText, localizeCliErrorMessage } from "./cli/i18n.js";
+import {
+  inspectSupportedAgent,
+  inspectSupportedAgents,
+  runSupportedAgentMaintenance,
+  type SupportedAgentInspection,
+} from "./cli/AgentPrerequisites.js";
+import {
+  parseMaintenanceSelection,
+  resolveDefaultAgentChoice,
+  selectableDefaultAgents,
+  type SelectableDefaultAgent,
+} from "./cli/DefaultAgentSelection.js";
 import { formatServerStatus, withConfiguredFeishuAppId } from "./cli/serverStatus.js";
 import { resolveSystemSkillsRoot, SkillRegistry, type SkillRegistrationStatus } from "./cli/SkillRegistry.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
@@ -49,6 +65,11 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
+import {
+  parseTaskForkGroupOptions,
+  parseTaskNewGroupOptions,
+} from "./cli/taskGroupOptions.js";
 import { StateStore, type SessionRecord } from "./state/StateStore.js";
 import {
   nodeDiagnosticReportArguments,
@@ -99,14 +120,19 @@ async function main(input: string[]): Promise<void> {
     return;
   }
   throw new Error(cliText(
-    `Unknown command: ${command}. Run agent-bot --help for usage.`,
-    `未知命令：${command}。运行 agent-bot --help 查看用法。`,
+    `Unknown command: ${command}. Run agentbot --help for usage.`,
+    `未知命令：${command}。运行 agentbot --help 查看用法。`,
   ));
 }
 
 type FeishuInitializationStatus = "created" | "existing" | "skipped";
 
 interface InitCommandResult extends InitializationResult {
+  agents: InitializedAgent[];
+  defaultAgent: {
+    name: string;
+    status: "selected" | "existing";
+  };
   feishu: {
     status: FeishuInitializationStatus;
     appId?: string;
@@ -115,6 +141,13 @@ interface InitCommandResult extends InitializationResult {
   server: InitializationServerResult;
 }
 
+interface InitializedAgent extends SupportedAgentInspection {
+  assistance?: {
+    status: "completed" | "skipped" | "unavailable" | "failed";
+    error?: string;
+  };
+}
+
 async function initCommand(
   input: string[],
   configPath: string | undefined,
@@ -130,13 +163,15 @@ async function initCommand(
     if (options.reset) await assertResetProfileServerStopped(configPath);
     paths = initializeAgentBot({ configPath, reset: options.reset });
     if (!options.json) printInitializationPaths(paths);
+    const agents = await initializeSupportedAgents(options.json);
+    const defaultAgent = await selectDefaultAgent(paths.config.path, agents, options.json);
     initializationLock ??= acquireInitializationLock(paths.home.path);
     cleanupFeishuCredentialTemporaryFiles(paths.env.path);
     const feishu = await initializeFeishu(
       paths,
       options,
     );
-    initialized = { ...paths, feishu };
+    initialized = { ...paths, agents, defaultAgent, feishu };
   } finally {
     initializationLock?.release();
   }
@@ -151,6 +186,259 @@ async function initCommand(
   else printInitializationServerResult(server);
 }
 
+async function initializeSupportedAgents(json: boolean): Promise<InitializedAgent[]> {
+  const output = json ? process.stderr : process.stdout;
+  output.write(cliText(
+    "\nAgent setup\nChecking Codex and TraeX...\n",
+    "\nAgent 设置\n正在检查 Codex 和 TraeX...\n",
+  ));
+  const inspections = await inspectSupportedAgents();
+  for (const inspection of inspections) printAgentInspection(inspection, output);
+  const actionable = inspections.filter((inspection) => inspection.action);
+  if (actionable.length === 0) return inspections;
+
+  output.write(cliText("\nAvailable actions:\n", "\n可执行的操作：\n"));
+  for (const [index, inspection] of actionable.entries()) {
+    output.write(cliText(
+      `  ${index + 1}. ${inspection.action?.kind === "install" ? "Install" : "Upgrade"} ${inspection.name}: ${inspection.action?.command}\n`,
+      `  ${index + 1}. ${inspection.action?.kind === "install" ? "安装" : "升级"} ${inspection.name}：${inspection.action?.command}\n`,
+    ));
+  }
+
+  let selected = new Set<number>();
+  if (!process.stdin.isTTY) {
+    output.write(cliText(
+      "No interactive terminal is available. Run the commands above manually if needed.\n",
+      "当前没有交互式终端，如有需要请手动执行上面的命令。\n",
+    ));
+  } else {
+    selected = new Set(await promptForAgentMaintenance(actionable.length));
+    if (selected.size === 0) {
+      output.write(cliText("No Agent changes selected.\n", "已跳过 Agent 安装和升级。\n"));
+    }
+  }
+
+  const initialized: InitializedAgent[] = [];
+  for (const inspection of inspections) {
+    if (!inspection.action) {
+      initialized.push(inspection);
+      continue;
+    }
+    const actionIndex = actionable.indexOf(inspection);
+    if (!selected.has(actionIndex)) {
+      initialized.push({
+        ...inspection,
+        assistance: { status: process.stdin.isTTY ? "skipped" : "unavailable" },
+      });
+      continue;
+    }
+
+    output.write(cliText(
+      `\nRunning ${inspection.name} ${inspection.action.kind}: ${inspection.action.command}\n`,
+      `\n正在${inspection.action.kind === "install" ? "安装" : "升级"} ${inspection.name}：${inspection.action.command}\n`,
+    ));
+    const maintenance = await runSupportedAgentMaintenance(inspection.id, inspection.action.kind);
+    if (maintenance.status !== 0 || maintenance.error) {
+      const error = maintenance.error ?? cliText(
+        `Command exited with code ${maintenance.status ?? "unknown"}.`,
+        `命令退出码为 ${maintenance.status ?? "未知"}。`,
+      );
+      output.write(cliText(
+        `${inspection.name} ${inspection.action.kind} did not complete; initialization will continue.\n`,
+        `${inspection.name}${inspection.action.kind === "install" ? "安装" : "升级"}未完成，初始化将继续。\n`,
+      ));
+      initialized.push({ ...inspection, assistance: { status: "failed", error } });
+      continue;
+    }
+
+    refreshCurrentProcessPath();
+    const refreshed = await inspectSupportedAgent(inspection.id);
+    if (refreshed.installedVersion) {
+      output.write(cliText(
+        `${inspection.name} is ready (${refreshed.installedVersion}).\n`,
+        `${inspection.name} 已就绪（${refreshed.installedVersion}）。\n`,
+      ));
+    } else {
+      output.write(cliText(
+        `${inspection.name} command completed, but the CLI is not visible in this process. Open a new terminal and run agentbot init again.\n`,
+        `${inspection.name} 命令已完成，但当前进程仍无法找到该 CLI。请打开新终端后重新运行 agentbot init。\n`,
+      ));
+    }
+    initialized.push({ ...refreshed, assistance: { status: "completed" } });
+  }
+  return initialized;
+}
+
+async function selectDefaultAgent(
+  configPath: string,
+  inspections: InitializedAgent[],
+  json: boolean,
+): Promise<InitCommandResult["defaultAgent"]> {
+  const output = json ? process.stderr : process.stdout;
+  const configured = readConfiguredAgentSelection(configPath);
+  const choices = selectableDefaultAgents(configured.agents, inspections);
+  if (!process.stdin.isTTY) {
+    if (!configured.defaultAgent || !configured.agents.some((agent) => agent.name === configured.defaultAgent)) {
+      throw new Error(cliText(
+        "A default Agent is not configured. Run agentbot init in an interactive terminal and select one.",
+        "尚未配置默认 Agent。请在交互式终端中运行 agentbot init 并选择一个 Agent。",
+      ));
+    }
+    output.write(cliText(
+      `Default Agent: ${configured.defaultAgent} (kept because no interactive terminal is available)\n`,
+      `默认 Agent：${configured.defaultAgent}（当前没有交互式终端，已保留现有设置）\n`,
+    ));
+    return { name: configured.defaultAgent, status: "existing" };
+  }
+  if (choices.length === 0) {
+    throw new Error(cliText(
+      "No available configured Agent can be selected. Install Codex or TraeX, then run agentbot init again.",
+      "没有可选择的已配置 Agent。请安装 Codex 或 TraeX，然后重新运行 agentbot init。",
+    ));
+  }
+
+  output.write(cliText("\nSelect the default Agent:\n", "\n请选择默认 Agent：\n"));
+  for (const [index, choice] of choices.entries()) {
+    const version = choice.installedVersion ? ` (${choice.installedVersion})` : "";
+    const current = choice.name === configured.defaultAgent
+      ? cliText(" [current]", " [当前]")
+      : "";
+    output.write(`  ${index + 1}. ${choice.name} - ${choice.title}${version}${current}\n`);
+  }
+  const selected = choices[await promptForDefaultAgent(choices, configured.defaultAgent)];
+  if (!selected) throw new Error(cliText("Default Agent selection failed.", "默认 Agent 选择失败。"));
+  const updated = writeDefaultAgent(configPath, selected.name);
+  output.write(updated
+    ? cliText(`Saved default Agent: ${selected.name}\n`, `已保存默认 Agent：${selected.name}\n`)
+    : cliText(`Default Agent unchanged: ${selected.name}\n`, `默认 Agent 保持不变：${selected.name}\n`));
+  return { name: selected.name, status: updated ? "selected" : "existing" };
+}
+
+function promptForAgentMaintenance(choiceCount: number): Promise<number[]> {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (selection: number[]): void => {
+      settled = true;
+      readline.close();
+      resolve(selection);
+    };
+    const ask = (): void => {
+      readline.question(cliText(
+        "Enter action numbers separated by commas, type all, or press Enter to skip: ",
+        "请输入要执行的操作编号（多个用逗号分隔），输入 all 选择全部，直接回车跳过：",
+      ), (answer) => {
+        const selection = parseMaintenanceSelection(answer, choiceCount);
+        if (selection) {
+          finish(selection);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Enter numbers from 1 to ${choiceCount}, all, or press Enter to skip.\n`,
+          `请输入 1 到 ${choiceCount} 之间的编号、all，或直接回车跳过。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
+function promptForDefaultAgent(
+  choices: SelectableDefaultAgent[],
+  currentAgent?: string,
+): Promise<number> {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (index: number): void => {
+      settled = true;
+      readline.close();
+      resolve(index);
+    };
+    const ask = (): void => {
+      const currentAvailable = choices.some((choice) => choice.name === currentAgent);
+      readline.question(cliText(
+        `Enter a number or Agent name${currentAvailable ? ` [${currentAgent}]` : ""}: `,
+        `请输入编号或 Agent 标准名${currentAvailable ? ` [${currentAgent}]` : ""}：`,
+      ), (answer) => {
+        const index = resolveDefaultAgentChoice(answer, choices, currentAgent);
+        if (index !== undefined) {
+          finish(index);
+          return;
+        }
+        process.stderr.write(cliText(
+          `Enter a number from 1 to ${choices.length} or an Agent standard name.\n`,
+          `请输入 1 到 ${choices.length} 之间的编号，或 Agent 标准名。\n`,
+        ));
+        ask();
+      });
+    };
+    listenForPromptCancellation(readline, () => {
+      settled = true;
+      reject(new Error(cliText("Initialization was cancelled.", "初始化已取消。")));
+    }, () => settled);
+    ask();
+  });
+}
+
+function listenForPromptCancellation(
+  readline: ReturnType<typeof createInterface>,
+  cancel: () => void,
+  isSettled: () => boolean,
+): void {
+  readline.once("SIGINT", () => {
+    if (!isSettled()) cancel();
+    readline.close();
+  });
+  readline.once("close", () => {
+    if (!isSettled()) cancel();
+  });
+}
+
+function printAgentInspection(
+  inspection: SupportedAgentInspection,
+  output: NodeJS.WriteStream,
+): void {
+  if (inspection.state === "missing") {
+    output.write(cliText(
+      `  ${inspection.name}: not installed\n`,
+      `  ${inspection.name}：未安装\n`,
+    ));
+    return;
+  }
+  if (inspection.state === "outdated") {
+    output.write(cliText(
+      `  ${inspection.name}: ${inspection.installedVersion}; update available (${inspection.latestVersion})\n`,
+      `  ${inspection.name}：${inspection.installedVersion}；可升级到 ${inspection.latestVersion}\n`,
+    ));
+    return;
+  }
+  if (inspection.latestCheckFailed) {
+    output.write(cliText(
+      `  ${inspection.name}: ${inspection.installedVersion}; latest-version check unavailable\n`,
+      `  ${inspection.name}：${inspection.installedVersion}；无法检查最新版本\n`,
+    ));
+    return;
+  }
+  output.write(cliText(
+    `  ${inspection.name}: ${inspection.installedVersion} (up to date)\n`,
+    `  ${inspection.name}：${inspection.installedVersion}（已是最新）\n`,
+  ));
+}
+
+function refreshCurrentProcessPath(): void {
+  const refreshed = refreshedSystemEnvironment();
+  if (!refreshed.refreshed) return;
+  const pathEntry = Object.entries(refreshed.environment)
+    .find(([name]) => name.toLowerCase() === "path");
+  if (pathEntry?.[1]) process.env.PATH = pathEntry[1];
+}
+
 async function initializeFeishu(
   paths: InitializationResult,
   options: InitCommandOptions,
@@ -162,6 +450,9 @@ async function initializeFeishu(
       ...(existing.appId ? { appId: existing.appId } : {}),
     };
   }
+  if (!options.json) {
+    process.stdout.write(cliText("\nLark setup\n", "\n飞书设置\n"));
+  }
 
   const controller = new AbortController();
   const onInterrupt = (): void => controller.abort(new Error(cliText(
@@ -197,8 +488,8 @@ async function initializeFeishu(
 
     if (!options.json) {
       process.stdout.write(cliText(
-        "\nChecking Lark app permissions, events, and callbacks...\n",
-        "\n正在检查飞书应用权限、事件和回调...\n",
+        "Checking app permissions, events, and callbacks...\n",
+        "正在检查应用权限、事件和回调...\n",
       ));
     }
     const manualPermissionSkip = new AbortController();
@@ -246,8 +537,8 @@ async function assertResetProfileServerStopped(configPath?: string): Promise<voi
     if (await isServerReachable(endpoint)) {
       throw new Error(
         cliText(
-          "Cannot reset a running profile. Stop it with agent-bot --profile <directory> server stop, then try again.",
-          "无法重置正在运行的 Profile。请先执行 agent-bot --profile <目录> server stop，然后重试。",
+          "Cannot reset a running profile. Stop it with agentbot --profile <directory> server stop, then try again.",
+          "无法重置正在运行的 Profile。请先执行 agentbot --profile <目录> server stop，然后重试。",
         ),
       );
     }
@@ -410,6 +701,51 @@ async function taskCommand(input: string[]): Promise<void> {
       process.stdout.write(cliText("Prompt submitted.\n", "提示词已提交。\n"));
       return;
     }
+    if (action === "newgroup") {
+      const options = parseTaskNewGroupOptions(rest);
+      const session = resolveTask(allSessions, options.reference);
+      const targetAgentName = options.agentName ?? session.agentName;
+      const targetAgent = config.agents[targetAgentName];
+      if (!targetAgent) {
+        throw new Error(cliText(
+          `Unknown Agent standard name: ${targetAgentName}.`,
+          `未知的 Agent 标准名：${targetAgentName}。`,
+        ));
+      }
+      if (options.projectless && targetAgent.kind !== "app-server") {
+        throw new Error(cliText(
+          "task newgroup --nodir is only available for App Server agents.",
+          "task newgroup --nodir 仅适用于 App Server Agent。",
+        ));
+      }
+      requireCliGroupUser(config.feishu.userOpenId);
+      const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+        action: "task_new_group",
+        localSessionId: session.localSessionId,
+        ...(options.title ? { title: options.title } : {}),
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        ...(options.agentName ? { agentName: options.agentName } : {}),
+        ...(options.projectless ? { projectless: true } : {}),
+      }, 120_000);
+      const result = taskGroupControlData(response);
+      if (options.json) printJson(result);
+      else printTaskGroupResult(result, "newgroup");
+      return;
+    }
+    if (action === "forkgroup") {
+      const options = parseTaskForkGroupOptions(rest);
+      const session = resolveTask(allSessions, options.reference);
+      requireCliGroupUser(config.feishu.userOpenId);
+      const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+        action: "task_fork_group",
+        localSessionId: session.localSessionId,
+        ...(options.title ? { title: options.title } : {}),
+      }, 120_000);
+      const result = taskGroupControlData(response);
+      if (options.json) printJson(result);
+      else printTaskGroupResult(result, "forkgroup");
+      return;
+    }
     const sessions = filterSessions(allSessions, rest);
     if (action === "list") {
       if (rest.includes("--json")) printJson(sessions);
@@ -574,8 +910,8 @@ function printSkillStatus(status: SkillRegistrationStatus): void {
 
 function printInitializationPaths(result: InitializationResult): void {
   process.stdout.write(cliText(
-    "Preparing the Agent Bot user environment...\n",
-    "正在准备 Agent Bot 用户环境...\n",
+    "Profile setup\n",
+    "Profile 设置\n",
   ));
   if (result.reset) {
     process.stdout.write(`${cliText("Reset backup: ", "重置备份：")}${result.reset.backupPath}\n`);
@@ -592,6 +928,7 @@ function printInitializationResult(result: Omit<InitCommandResult, "server">): v
     "\nAgent Bot initialization completed.\n",
     "\nAgent Bot 初始化完成。\n",
   ));
+  process.stdout.write(`${cliText("Default Agent: ", "默认 Agent：")}${result.defaultAgent.name}\n`);
   if (result.feishu.status === "created") {
     process.stdout.write(cliText(
       `Lark app: created and credentials saved (${result.feishu.appId})\n`,
@@ -802,6 +1139,7 @@ function feishuFeatureWarnings(missing: FeishuConfigurationChallenge["missing"])
 
 function initializationStatusLabel(status: InitializationStatus): string {
   if (status === "created") return cliText("created", "已创建");
+  if (status === "updated") return cliText("updated with missing settings", "已补全缺失配置");
   if (status === "reset") return cliText("reset from template", "已从模板重置");
   return cliText("already exists; unchanged", "已存在，未修改");
 }
@@ -840,6 +1178,50 @@ function ensureOk(response: ControlResponse): void {
       ));
 }
 
+function requireCliGroupUser(userOpenId: string | undefined): asserts userOpenId is string {
+  if (userOpenId?.startsWith("ou_")) return;
+  throw new Error(cliText(
+    "The profile has no authorizing Lark user to invite. Run agentbot init again or configure FEISHU_USER_OPEN_ID.",
+    "当前 Profile 没有可邀请的飞书授权用户。请重新运行 agentbot init，或配置 FEISHU_USER_OPEN_ID。",
+  ));
+}
+
+function taskGroupControlData(response: ControlResponse): TaskGroupControlData {
+  ensureOk(response);
+  const data = response.data as Partial<TaskGroupControlData> | undefined;
+  if (
+    !data
+    || typeof data.sourceLocalSessionId !== "string"
+    || !data.group
+    || typeof data.group.chatId !== "string"
+    || typeof data.group.contextKey !== "string"
+    || typeof data.group.name !== "string"
+    || !data.task
+    || typeof data.task.localSessionId !== "string"
+  ) {
+    throw new Error(cliText(
+      "Agent Bot returned an invalid task-group result.",
+      "Agent Bot 返回了无效的任务群结果。",
+    ));
+  }
+  return data as TaskGroupControlData;
+}
+
+function printTaskGroupResult(
+  result: TaskGroupControlData,
+  action: "newgroup" | "forkgroup",
+): void {
+  process.stdout.write(cliText(
+    `${action === "forkgroup" ? "Fork group" : "Lark group"} created: ${result.group.name}\n`,
+    `${action === "forkgroup" ? "Fork 群" : "飞书群"}已创建：${result.group.name}\n`,
+  ));
+  process.stdout.write(`${cliText("Chat ID: ", "群 ID：")}${result.group.chatId}\n`);
+  process.stdout.write(`${cliText("Task ID: ", "任务 ID：")}${result.task.localSessionId}\n`);
+  if (result.task.remoteSessionId) {
+    process.stdout.write(`${cliText("Agent task ID: ", "Agent 任务 ID：")}${result.task.remoteSessionId}\n`);
+  }
+}
+
 function optionValue(args: string[], name: string): string | undefined {
   const index = args.indexOf(name);
   return index >= 0 ? args[index + 1] : undefined;

package/src/codex/AppServerConnection.ts

@@ -108,7 +108,7 @@ export class AppServerConnection {
       try {
         message = JSON.parse(line) as AppServerMessage;
       } catch (error) {
-        this.logger.warn({ line, error }, "Ignoring non-JSON Codex App Server stdout line.");
+        this.logger.warn({ line, error }, "Ignoring non-JSON App Server stdout line.");
         return;
       }
       this.handleMessage(message);
@@ -128,7 +128,7 @@ export class AppServerConnection {
       for (const listener of this.notificationListeners) listener(message.method, message.params);
       return;
     }
-    this.logger.warn({ message }, "Ignoring unknown Codex App Server message shape.");
+    this.logger.warn({ message }, "Ignoring unknown App Server message shape.");
   }
 
   private handleResponse(message: AppServerResponse): void {
@@ -139,7 +139,7 @@ export class AppServerConnection {
           responseId: message.id,
           responseKind: "error" in message ? "error" : "result",
         },
-        "Received Codex App Server response for unknown request.",
+        "Received App Server response for unknown request.",
       );
       return;
     }

package/src/codex/CodexProcessManager.ts

@@ -27,15 +27,15 @@ export class CodexProcessManager implements AppServerClientProvider {
     const client = new AppServerConnection(child, this.logger.child({ component: "codex-app-server" }));
     this.client = client;
     readline.createInterface({ input: child.stderr, crlfDelay: Infinity }).on("line", (line) => {
-      this.logger.debug({ line }, "Codex App Server stderr.");
+      this.logger.debug({ line }, "App Server stderr.");
     });
-    child.once("error", (error) => this.logger.error({ error }, "Codex App Server process error."));
+    child.once("error", (error) => this.logger.error({ error }, "App Server process error."));
     child.once("exit", (code, signal) => {
-      this.logger.warn({ code, signal }, "Codex App Server process exited.");
+      this.logger.warn({ code, signal }, "App Server process exited.");
       client.close();
       if (this.client === client) this.client = undefined;
       if (this.child === child) this.child = undefined;
-      const error = new Error(`Codex App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
+      const error = new Error(`App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
       for (const listener of this.disconnectListeners) listener(error);
     });
     await client.request("initialize", {