macroclaw 0.12.0 → 0.13.0

package/src/setup.test.ts

@@ -1,14 +1,15 @@
 import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import type { SetupIO } from "./setup";
+import type { SetupIo } from "./setup";
 
 // Mock child_process so resolveClaudePath doesn't hit real `which`
+const mockExecSync = mock((_cmd: string, _opts?: object) => "/mock/bin/claude\n");
 mock.module("node:child_process", () => ({
-  execSync: (_cmd: string) => "/mock/bin/claude\n",
+  execSync: mockExecSync,
 }));
 
 // Mock Grammy Bot
 const mockBotInit = mock(async () => {});
-const mockBotStart = mock(() => {});
+const mockBotStart = mock(async () => {});
 const mockBotStop = mock(async () => {});
 const mockSetMyCommands = mock(async () => {});
 let mockBotCatchHandler: Function | null = null;
@@ -37,8 +38,8 @@ mock.module("grammy", () => ({
       await mockBotInit();
     }
 
-    start() {
-      mockBotStart();
+    async start() {
+      await mockBotStart();
     }
 
     async stop() {
@@ -55,23 +56,30 @@ function createMockServiceInstaller() {
   };
 }
 
-const { resolveClaudePath, runSetupWizard } = await import("./setup");
+const { SetupWizard } = await import("./setup");
 
-function createMockIO(inputs: string[]): SetupIO & { written: string[]; closed: boolean } {
+async function runSetup(io: SetupIo, opts?: ConstructorParameters<typeof SetupWizard>[1]) {
+  const wizard = new SetupWizard(io, opts);
+  const settings = await wizard.collectSettings();
+  await wizard.installService();
+  return settings;
+}
+
+function createMockIO(inputs: string[]): SetupIo & { written: string[] } {
   let index = 0;
   const written: string[] = [];
   const io = {
+    open: () => {},
+    close: () => {},
     ask: async () => inputs[index++] ?? "",
     write: (msg: string) => { written.push(msg); },
-    close: () => { io.closed = true; },
     written,
-    closed: false,
   };
   return io;
 }
 
 // Save/restore env vars
-const envVars = ["TELEGRAM_BOT_TOKEN", "AUTHORIZED_CHAT_ID", "MODEL", "WORKSPACE", "OPENAI_API_KEY"];
+const envVars = ["TELEGRAM_BOT_TOKEN", "AUTHORIZED_CHAT_ID", "MODEL", "WORKSPACE", "OPENAI_API_KEY", "LOG_LEVEL"];
 const savedEnv: Record<string, string | undefined> = {};
 
 beforeEach(() => {
@@ -79,6 +87,7 @@ beforeEach(() => {
     savedEnv[v] = process.env[v];
     delete process.env[v];
   }
+  mockExecSync.mockImplementation((_cmd: string, _opts?: object) => "/mock/bin/claude\n");
   mockBotInit.mockImplementation(async () => {});
   mockBotStart.mockClear();
   mockBotStop.mockClear();
@@ -95,7 +104,7 @@ afterEach(() => {
   }
 });
 
-describe("runSetupWizard", () => {
+describe("SetupWizard", () => {
   it("collects all required fields via prompts", async () => {
     const io = createMockIO([
       "123:ABC",   // bot token
@@ -106,19 +115,19 @@ describe("runSetupWizard", () => {
       "",          // no service install
     ]);
 
-    const settings = await runSetupWizard(io);
+    const settings = await runSetup(io);
 
     expect(settings.botToken).toBe("123:ABC");
     expect(settings.chatId).toBe("12345678");
     expect(settings.model).toBe("opus");
     expect(settings.workspace).toBe("/my/ws");
     expect(settings.openaiApiKey).toBe("sk-test");
-    expect(settings.logLevel).toBe("debug");
+    expect(settings.logLevel).toBe("info");
   });
 
   it("uses defaults from env vars when user presses enter", async () => {
     process.env.TELEGRAM_BOT_TOKEN = "env-token";
-    process.env.AUTHORIZED_CHAT_ID = "env-chat";
+    process.env.AUTHORIZED_CHAT_ID = "99887766";
     process.env.MODEL = "haiku";
     process.env.WORKSPACE = "/env/ws";
     process.env.OPENAI_API_KEY = "sk-env";
@@ -132,10 +141,10 @@ describe("runSetupWizard", () => {
       "",  // no service install
     ]);
 
-    const settings = await runSetupWizard(io);
+    const settings = await runSetup(io);
 
     expect(settings.botToken).toBe("env-token");
-    expect(settings.chatId).toBe("env-chat");
+    expect(settings.chatId).toBe("99887766");
     expect(settings.model).toBe("haiku");
     expect(settings.workspace).toBe("/env/ws");
     expect(settings.openaiApiKey).toBe("sk-env");
@@ -151,7 +160,7 @@ describe("runSetupWizard", () => {
       "",       // no service install
     ]);
 
-    const settings = await runSetupWizard(io);
+    const settings = await runSetup(io);
 
     expect(settings.model).toBe("sonnet");
     expect(settings.workspace).toBe("~/.macroclaw-workspace");
@@ -168,7 +177,7 @@ describe("runSetupWizard", () => {
       "",  // no service install
     ]);
 
-    await runSetupWizard(io);
+    await runSetup(io);
 
     expect(mockBotInit).toHaveBeenCalled();
     expect(mockBotStart).toHaveBeenCalled();
@@ -192,7 +201,7 @@ describe("runSetupWizard", () => {
       "",  // no service install
     ]);
 
-    const settings = await runSetupWizard(io);
+    const settings = await runSetup(io);
 
     expect(settings.botToken).toBe("good-token");
     expect(callCount).toBe(2);
@@ -209,7 +218,7 @@ describe("runSetupWizard", () => {
       "",  // no service install
     ]);
 
-    const settings = await runSetupWizard(io);
+    const settings = await runSetup(io);
 
     expect(settings.botToken).toBe("actual-token");
   });
@@ -225,85 +234,82 @@ describe("runSetupWizard", () => {
       "",  // no service install
     ]);
 
-    const settings = await runSetupWizard(io);
+    const settings = await runSetup(io);
 
     expect(settings.chatId).toBe("456");
   });
 
-  it("registers and uses catch handler on setup bot", async () => {
+  it("re-prompts when chat ID is not numeric", async () => {
     const io = createMockIO([
       "tok",
-      "123",
+      "not-a-number",  // invalid — re-prompt
+      "456",
       "",
       "",
       "",
       "",  // no service install
     ]);
 
-    await runSetupWizard(io);
+    const settings = await runSetup(io);
 
-    // The catch handler was registered
-    expect(mockBotCatchHandler).not.toBeNull();
-    // Calling it should not throw (it logs internally)
-    expect(() => mockBotCatchHandler!(new Error("test error"))).not.toThrow();
+    expect(settings.chatId).toBe("456");
+    expect(io.written).toContainEqual(expect.stringContaining("Invalid value"));
   });
 
-  it("registers /chatid command handler on setup bot", async () => {
+  it("re-prompts when model is invalid", async () => {
     const io = createMockIO([
       "tok",
       "123",
-      "",
+      "xxx",     // invalid — re-prompt
+      "opus",    // valid
       "",
       "",
       "",  // no service install
     ]);
 
-    await runSetupWizard(io);
+    const settings = await runSetup(io);
 
-    expect(mockBotCommandHandler).not.toBeNull();
-    const mockReply = mock(() => {});
-    mockBotCommandHandler!({ chat: { id: 12345 }, reply: mockReply });
-    expect(mockReply).toHaveBeenCalledWith("12345");
+    expect(settings.model).toBe("opus");
+    expect(io.written).toContainEqual(expect.stringContaining("Invalid value"));
   });
 
-  it("calls onSettingsReady before service install prompt", async () => {
-    const order: string[] = [];
-    const installer = { install: () => { order.push("install"); return ""; } };
-    const onSettingsReady = () => { order.push("save"); };
+  it("registers and uses catch handler on setup bot", async () => {
     const io = createMockIO([
       "tok",
       "123",
       "",
       "",
       "",
-      "y",
-      "sk-test-token",  // oauth token (macOS)
+      "",  // no service install
     ]);
 
-    await runSetupWizard(io, { serviceInstaller: installer, onSettingsReady, platform: "darwin" });
+    await runSetup(io);
 
-    expect(order).toEqual(["save", "install"]);
+    // The catch handler was registered
+    expect(mockBotCatchHandler).not.toBeNull();
+    // Calling it should not throw (it logs internally)
+    expect(() => mockBotCatchHandler!(new Error("test error"))).not.toThrow();
   });
 
-  it("closes io before running service install", async () => {
-    let closedBeforeInstall = false;
+  it("registers /chatid command handler on setup bot", async () => {
     const io = createMockIO([
       "tok",
       "123",
       "",
       "",
       "",
-      "y",
-      "sk-test-token",  // oauth token (macOS)
+      "",  // no service install
     ]);
-    const installer = { install: () => { closedBeforeInstall = io.closed; return ""; } };
 
-    await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+    await runSetup(io);
 
-    expect(closedBeforeInstall).toBe(true);
+    expect(mockBotCommandHandler).not.toBeNull();
+    const mockReply = mock(() => {});
+    mockBotCommandHandler!({ chat: { id: 12345 }, reply: mockReply });
+    expect(mockReply).toHaveBeenCalledWith("12345");
   });
 
-  it("installs service when user answers yes", async () => {
+it("installs service when user answers yes", async () => {
     mockInstall.mockClear();
     const installer = createMockServiceInstaller();
     const io = createMockIO([
@@ -316,7 +322,7 @@ describe("runSetupWizard", () => {
       "sk-test-token",  // oauth token (macOS)
     ]);
 
-    await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+    await runSetup(io, { serviceInstaller: installer, platform: "darwin" });
 
     expect(mockInstall).toHaveBeenCalled();
     expect(io.written).toContainEqual(expect.stringContaining("Service installed and started."));
@@ -334,10 +340,9 @@ describe("runSetupWizard", () => {
       "n",  // no to service install
     ]);
 
-    await runSetupWizard(io, { serviceInstaller: installer });
+    await runSetup(io, { serviceInstaller: installer });
 
     expect(mockInstall).not.toHaveBeenCalled();
-    expect(io.closed).toBe(true);
   });
 
   it("skips service install when oauth token is empty on macOS", async () => {
@@ -353,7 +358,7 @@ describe("runSetupWizard", () => {
       "",  // empty oauth token
     ]);
 
-    const settings = await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+    const settings = await runSetup(io, { serviceInstaller: installer, platform: "darwin" });
 
     expect(mockInstall).not.toHaveBeenCalled();
     expect(io.written).toContainEqual(expect.stringContaining("No token provided"));
@@ -373,26 +378,17 @@ describe("runSetupWizard", () => {
       "sk-test-token",  // oauth token (macOS)
     ]);
 
-    await runSetupWizard(io, { serviceInstaller: installer, platform: "darwin" });
+    await runSetup(io, { serviceInstaller: installer, platform: "darwin" });
 
     expect(io.written).toContainEqual(expect.stringContaining("Service installation failed: Permission denied"));
   });
 
   it("fails fast when claude CLI is not found", async () => {
+    mockExecSync.mockImplementation(() => { throw new Error("not found"); });
     const io = createMockIO([]);
     await expect(
-      runSetupWizard(io, { resolveClaude: () => { throw new Error("Claude Code CLI not found."); } }),
+      runSetup(io),
     ).rejects.toThrow("Claude Code CLI not found.");
   });
 
-  it("resolveClaudePath returns trimmed path on success", () => {
-    const result = resolveClaudePath(() => "/usr/local/bin/claude\n");
-    expect(result).toBe("/usr/local/bin/claude");
-  });
-
-  it("resolveClaudePath throws when claude is not found", () => {
-    expect(() => resolveClaudePath(() => { throw new Error("not found"); })).toThrow(
-      "Claude Code CLI not found.",
-    );
-  });
 });

package/src/setup.ts

@@ -1,149 +1,191 @@
 import { execSync } from "node:child_process";
 import { Bot } from "grammy";
 import { createLogger } from "./logger";
-import { maskValue, type Settings, settingsSchema } from "./settings";
+import { maskValue, type Settings, SettingsManager, settingsSchema } from "./settings";
 
 const log = createLogger("setup");
 
-export interface SetupIO {
+type SetupField = keyof typeof settingsSchema.shape;
+
+export interface SetupIo {
+  open: () => void;
+  close: () => void;
   ask: (question: string) => Promise<string>;
   write: (msg: string) => void;
-  close?: () => void;
-}
-
-async function startSetupBot(token: string): Promise<Bot> {
-  const bot = new Bot(token);
-  bot.command("chatid", (ctx) => {
-    ctx.reply(ctx.chat.id.toString());
-  });
-  bot.catch((err) => {
-    log.debug({ err }, "Setup bot error");
-  });
-
-  await bot.init();
-  await bot.api.setMyCommands([{ command: "chatid", description: "Get your chat ID" }]);
-  bot.start();
-  return bot;
 }
 
 export interface ServiceInstaller {
   install: (oauthToken?: string) => string;
 }
 
-export interface SetupDefaults {
-  botToken?: string;
-  chatId?: string;
-  model?: string;
-  workspace?: string;
-  openaiApiKey?: string;
-}
-
-export function resolveClaudePath(exec: (cmd: string) => string = (cmd) => execSync(cmd, { encoding: "utf-8" })): string {
-  try {
-    return exec("which claude").trim();
-  } catch {
-    throw new Error("Claude Code CLI not found. Install it first: https://docs.anthropic.com/en/docs/claude-code");
+export class SetupWizard {
+  readonly #io: SetupIo;
+  readonly #serviceInstaller?: ServiceInstaller;
+  readonly #platform: string;
+  #defaults: Record<string, unknown> = {};
+
+  constructor(io: SetupIo, opts?: {
+    serviceInstaller?: ServiceInstaller;
+    platform?: string;
+  }) {
+    this.#io = io;
+    this.#serviceInstaller = opts?.serviceInstaller;
+    this.#platform = opts?.platform ?? process.platform;
   }
-}
-
-export async function runSetupWizard(io: SetupIO, opts?: { defaults?: SetupDefaults; serviceInstaller?: ServiceInstaller; onSettingsReady?: (settings: Settings) => void; resolveClaude?: () => string; platform?: string }): Promise<Settings> {
-  const { ask, write } = io;
-  const prev = opts?.defaults ?? {};
 
-  // Fail fast if claude CLI is not installed
-  const resolve = opts?.resolveClaude ?? resolveClaudePath;
-  resolve();
-
-  write("\n=== Macroclaw Setup ===\n\n");
-
-  // Bot token
-  const defaultToken = prev.botToken || process.env.TELEGRAM_BOT_TOKEN || "";
-  const tokenPrompt = defaultToken ? `Bot token [${maskValue("botToken", defaultToken)}]: ` : "Bot token: ";
-  let botToken = await ask(tokenPrompt) || defaultToken;
-
-  // Validate token by starting a temporary bot
-  let setupBot: Bot | null = null;
-  while (true) {
-    if (!botToken) {
-      botToken = await ask("Bot token (required): ");
-      continue;
-    }
+  #resolveClaudePath(): void {
     try {
-      setupBot = await startSetupBot(botToken);
-      write(`Bot @${setupBot.botInfo.username} connected. Send /chatid to the bot to get your chat ID.\n`);
-      break;
+      execSync("which claude", { encoding: "utf-8" });
     } catch {
-      write("Invalid bot token. Please try again.\n");
-      botToken = await ask("Bot token: ");
+      throw new Error("Claude Code CLI not found. Install it first: https://docs.anthropic.com/en/docs/claude-code");
     }
   }
 
-  // Chat ID
-  const defaultChatId = prev.chatId || process.env.AUTHORIZED_CHAT_ID || "";
-  const chatIdPrompt = defaultChatId ? `Chat ID [${defaultChatId}]: ` : "Chat ID: ";
-  let chatId = await ask(chatIdPrompt) || defaultChatId;
-  while (!chatId) {
-    chatId = await ask("Chat ID (required): ");
+  #default(key: string, fallback?: string): string {
+    const envVar = SettingsManager.envMapping[key as keyof Settings];
+    return (this.#defaults[key] as string) || (envVar && process.env[envVar]) || fallback || "";
   }
 
-  // Stop setup bot
-  if (setupBot) {
-    await setupBot.stop();
+  async collectSettings(defaults?: Record<string, unknown>): Promise<Settings> {
+    this.#defaults = defaults ?? {};
+    this.#io.open();
+    try {
+      this.#resolveClaudePath();
+
+      this.#io.write("\n=== Macroclaw ===\n\n");
+      this.#io.write("Personal AI assistant, powered by Claude Code, delivered through Telegram.\n\n");
+      this.#io.write("=== Setup ===\n\n");
+
+      // Bot token
+      this.#io.write("First, set up a Telegram bot:\n");
+      this.#io.write("  1. Open Telegram and message @BotFather\n");
+      this.#io.write("  2. Send /newbot and follow the instructions\n");
+      this.#io.write("  3. Copy the token it gives you (looks like 123456:ABC-DEF...)\n\n");
+      const { botToken, bot } = await this.#askBotToken();
+
+      // Chat ID
+      this.#io.write("Next, we need a chat ID. Macroclaw only accepts messages from a single\n");
+      this.#io.write("authorized chat — send /chatid to the bot in Telegram to get yours.\n\n");
+      const defaultChatId = this.#default("chatId");
+      const chatIdPrompt = defaultChatId ? `Chat ID [${defaultChatId}]: ` : "Chat ID: ";
+      const chatId = await this.#askValidated("chatId", chatIdPrompt, defaultChatId);
+
+      // Stop setup bot after chat ID is collected
+      await bot.stop();
+
+      // Model
+      this.#io.write("\nThe default Claude model for conversations (haiku, sonnet, opus).\n\n");
+      const defaultModel = this.#default("model", "sonnet");
+      const model = await this.#askValidated("model", `Model [${defaultModel}]: `, defaultModel);
+
+      // Workspace
+      this.#io.write("\nThe workspace directory where Claude Code runs — instructions, skills,\n");
+      this.#io.write("memory, and cron definitions all live here.\n\n");
+      const defaultWorkspace = this.#default("workspace", "~/.macroclaw-workspace");
+      const workspace = await this.#askValidated("workspace", `Workspace [${defaultWorkspace}]: `, defaultWorkspace);
+
+      // OpenAI API key
+      this.#io.write("\nMacroclaw uses OpenAI's Whisper API to transcribe voice messages.\n");
+      this.#io.write("Without this key, voice messages will be ignored.\n\n");
+      const defaultOpenai = this.#default("openaiApiKey");
+      const openaiPrompt = defaultOpenai ? `OpenAI API key [${maskValue("openaiApiKey", defaultOpenai)}] (optional): ` : "OpenAI API key (optional): ";
+      const openaiApiKey = await this.#askValidated("openaiApiKey", openaiPrompt, defaultOpenai) || undefined;
+
+      // Log level (non interactive)
+      const logLevel = this.#default("logLevel");
+
+      const settings: Settings = settingsSchema.parse({
+        botToken,
+        chatId,
+        model,
+        workspace,
+        openaiApiKey,
+        ...(logLevel && { logLevel }),
+      });
+
+      this.#io.write("\nSetup complete!\n\n");
+      return settings;
+    } finally {
+      this.#io.close();
+    }
   }
 
-  // Model
-  const defaultModel = prev.model || process.env.MODEL || "sonnet";
-  const model = await ask(`Model [${defaultModel}]: `) || defaultModel;
-
-  // Workspace
-  const defaultWorkspace = prev.workspace || process.env.WORKSPACE || "~/.macroclaw-workspace";
-  const workspace = await ask(`Workspace [${defaultWorkspace}]: `) || defaultWorkspace;
-
-  // OpenAI API key
-  const defaultOpenai = prev.openaiApiKey || process.env.OPENAI_API_KEY || "";
-  const openaiPrompt = defaultOpenai ? `OpenAI API key [${maskValue("openaiApiKey", defaultOpenai)}] (optional): ` : "OpenAI API key (optional): ";
-  const openaiApiKey = await ask(openaiPrompt) || defaultOpenai || undefined;
-
-  const settings: Settings = settingsSchema.parse({
-    botToken,
-    chatId,
-    model,
-    workspace,
-    openaiApiKey,
-    logLevel: "debug",
-  });
-
-  // Persist settings before service install prompt so ServiceManager can find them
-  opts?.onSettingsReady?.(settings);
-
-  write("\nSetup complete!\n\n");
-
-  // Optional service installation
-  const installAnswer = await ask("Install as a system service? [Y/n]: ");
-  let oauthToken: string | undefined;
-  if (installAnswer.toLowerCase() !== "n" && installAnswer.toLowerCase() !== "no") {
-    if ((opts?.platform ?? process.platform) === "darwin") {
-      write("\nmacOS requires a long-lived OAuth token for the service.\n");
-      write("Run `claude setup-token` in another terminal, then paste the token here.\n\n");
-      oauthToken = await ask("OAuth token: ");
-      if (!oauthToken) {
-        write("No token provided. Skipping service installation.\n");
-        io.close?.();
-        return settings;
+  async installService(): Promise<void> {
+    this.#io.open();
+    try {
+      const installAnswer = await this.#io.ask("Install as a system service? [Y/n]: ");
+      if (installAnswer.toLowerCase() === "n" || installAnswer.toLowerCase() === "no") return;
+
+      let oauthToken: string | undefined;
+      if (this.#platform === "darwin") {
+        this.#io.write("\nmacOS requires a long-lived OAuth token for the service.\n");
+        this.#io.write("Run `claude setup-token` in another terminal, then paste the token here.\n\n");
+        oauthToken = await this.#io.ask("OAuth token: ");
+        if (!oauthToken) {
+          this.#io.write("No token provided. Skipping service installation.\n");
+          return;
+        }
+      }
+
+      try {
+        const svc = this.#serviceInstaller ?? new (await import("./service")).ServiceManager();
+        const logCmd = svc.install(oauthToken);
+        this.#io.write(`Service installed and started. Check logs:\n  ${logCmd}\n`);
+      } catch (err) {
+        this.#io.write(`Service installation failed: ${(err as Error).message}\n`);
       }
+    } finally {
+      this.#io.close();
     }
   }
-  // Release terminal control before sudo may prompt for a password
-  io.close?.();
-  if (installAnswer.toLowerCase() !== "n" && installAnswer.toLowerCase() !== "no") {
-    try {
-      const svc = opts?.serviceInstaller ?? new (await import("./service")).ServiceManager();
-      const logCmd = svc.install(oauthToken);
-      write(`Service installed and started. Check logs:\n  ${logCmd}\n`);
-    } catch (err) {
-      write(`Service installation failed: ${(err as Error).message}\n`);
+
+  async #askValidated(field: SetupField, prompt: string, fallback: string): Promise<string> {
+    const schema = settingsSchema.shape[field];
+    let value = await this.#io.ask(prompt) || fallback;
+    while (true) {
+      const result = schema.safeParse(value);
+      if (result.success) return value;
+      const issue = result.error?.issues?.[0];
+      this.#io.write(`Invalid value: ${issue?.message ?? "validation failed"}. Please try again.\n`);
+      value = await this.#io.ask(prompt) || fallback;
     }
   }
 
-  return settings;
+  async #startBot(token: string): Promise<Bot> {
+    const bot = new Bot(token);
+    bot.command("chatid", (ctx) => {
+      ctx.reply(ctx.chat.id.toString());
+    });
+    bot.catch((err) => {
+      log.debug({ err }, "Setup bot error");
+    });
+
+    await bot.init();
+    await bot.api.setMyCommands([{ command: "chatid", description: "Get your chat ID" }]);
+    // Fire-and-forget: long-polling loop, stop() aborts with "Aborted delay"
+    void bot.start().catch(() => {});
+    return bot;
+  }
+
+  async #askBotToken(): Promise<{ botToken: string; bot: Bot }> {
+    const defaultToken = this.#default("botToken");
+    const tokenPrompt = defaultToken ? `Bot token [${maskValue("botToken", defaultToken)}]: ` : "Bot token: ";
+    let botToken = await this.#askValidated("botToken", tokenPrompt, defaultToken);
+
+    // Validate token by starting a temporary bot
+    while (true) {
+      if (!botToken) {
+        botToken = await this.#askValidated("botToken", "Bot token (required): ", "");
+        continue;
+      }
+      try {
+        const bot = await this.#startBot(botToken);
+        this.#io.write(`\nBot @${bot.botInfo.username} connected.\n\n`);
+        return { botToken, bot };
+      } catch {
+        this.#io.write("Invalid bot token. Please try again.\n");
+        botToken = await this.#io.ask("Bot token: ");
+      }
+    }
+  }
 }