talon-agent 3.33.4 → 3.34.0

package/src/cli/setup.ts

@@ -7,67 +7,88 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { printBanner, loadConfig, saveConfig, type Config } from "./config.js";
 
+/** Strip spaces, "+", brackets and dashes from a phone number. */
+const bareDigits = (raw: string) => raw.replace(/[\s+()-]/g, "");
+
 /** "353871234567, +44 7700 900000" → ["353871234567", "447700900000"]. */
 function parseNumberList(raw: string): string[] {
   return raw
     .split(",")
-    .map((entry) => entry.replace(/[\s+()-]/g, ""))
+    .map(bareDigits)
     .filter((entry) => entry.length > 0);
 }
 
-export async function runSetup(): Promise<void> {
-  printBanner();
-  p.intro(pc.inverse(" Setup Wizard "));
+/** Empty answers mean "unset"; everything else is trimmed. */
+const trimmedOrUndefined = (raw: string) => raw.trim() || undefined;
 
-  const config = loadConfig();
+/**
+ * Await a clack prompt; on Esc/Ctrl-C say so and leave the wizard.
+ *
+ * Every prompt used to be followed by the same four-line `isCancel` guard,
+ * and because `@clack/core` narrows `isCancel` to its own unique symbol
+ * the unguarded remainder still needed an `as string` cast. clack only
+ * ever resolves a symbol to mean "cancelled", so narrowing on `typeof`
+ * here removes both.
+ */
+async function askOrExit<T>(prompt: Promise<T | symbol>): Promise<T> {
+  const value = await prompt;
+  if (typeof value === "symbol") {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+
+// ── Steps: each prompts for one section and returns its slice of the answers ──
+
+async function askFrontends(config: Config): Promise<string[]> {
   const existingFrontends = Array.isArray(config.frontend)
     ? config.frontend
     : [config.frontend || "telegram"];
 
-  const frontendSelection = await p.multiselect({
-    message: "Frontend platforms (space to toggle, enter to confirm)",
-    initialValues: existingFrontends,
-    options: [
-      {
-        value: "telegram",
-        label: `Telegram  ${pc.dim("— bot via @BotFather")}`,
-      },
-      {
-        value: "whatsapp",
-        label: `WhatsApp  ${pc.dim("— a real account via Baileys multi-device")}`,
-      },
-      {
-        value: "discord",
-        label: `Discord   ${pc.dim("— bot via Developer Portal (discord.js v14)")}`,
-      },
-      {
-        value: "teams",
-        label: `Teams     ${pc.dim("— Microsoft Teams via Power Automate")}`,
-      },
-      {
-        value: "terminal",
-        label: `Terminal  ${pc.dim("— local CLI chat")}`,
-      },
-      {
-        value: "native",
-        label: `Native    ${pc.dim("— HTTP+SSE bridge for the companion app")}`,
-      },
-    ],
-    required: true,
-  });
-  if (p.isCancel(frontendSelection)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const selectedFrontends = frontendSelection as string[];
+  return askOrExit(
+    p.multiselect({
+      message: "Frontend platforms (space to toggle, enter to confirm)",
+      initialValues: existingFrontends,
+      options: [
+        {
+          value: "telegram",
+          label: `Telegram  ${pc.dim("— bot via @BotFather")}`,
+        },
+        {
+          value: "whatsapp",
+          label: `WhatsApp  ${pc.dim("— a real account via Baileys multi-device")}`,
+        },
+        {
+          value: "discord",
+          label: `Discord   ${pc.dim("— bot via Developer Portal (discord.js v14)")}`,
+        },
+        {
+          value: "teams",
+          label: `Teams     ${pc.dim("— Microsoft Teams via Power Automate")}`,
+        },
+        {
+          value: "terminal",
+          label: `Terminal  ${pc.dim("— local CLI chat")}`,
+        },
+        {
+          value: "native",
+          label: `Native    ${pc.dim("— HTTP+SSE bridge for the companion app")}`,
+        },
+      ],
+      required: true,
+    }),
+  );
+}
 
-  let botToken: string | undefined;
-  let adminId: string | undefined;
-  let apiId: number | undefined;
-  let apiHash: string | undefined;
+type TelegramAnswers = Pick<
+  SetupAnswers,
+  "botToken" | "adminId" | "apiId" | "apiHash"
+>;
 
-  if (selectedFrontends.includes("telegram")) {
-    const token = await p.text({
+async function askTelegram(config: Config): Promise<TelegramAnswers> {
+  const botToken = await askOrExit(
+    p.text({
       message: "Bot token",
       placeholder: "Paste your token from @BotFather",
       initialValue: config.botToken || undefined,
@@ -75,76 +96,71 @@ export async function runSetup(): Promise<void> {
         if (!v) return "Token is required";
         if (!v.includes(":")) return "Invalid format";
       },
-    });
-    if (p.isCancel(token)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    botToken = token;
+    }),
+  );
 
-    adminId = (await p.text({
+  const adminId = await askOrExit(
+    p.text({
       message: "Your Telegram user ID",
       placeholder: "optional — message @userinfobot to find yours",
       initialValue: config.adminUserId ? String(config.adminUserId) : "",
-    })) as string;
-    if (p.isCancel(adminId)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
+    }),
+  );
 
-    const wantUserbot = await p.confirm({
+  const wantUserbot = await askOrExit(
+    p.confirm({
       message: "Set up userbot for full history access?",
       initialValue: !!(config.apiId && config.apiHash),
-    });
-    if (p.isCancel(wantUserbot)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-
-    if (wantUserbot) {
-      p.note(
-        "Get these from https://my.telegram.org → API development tools",
-        "Telegram API credentials",
-      );
-      const id = await p.text({
-        message: "API ID",
-        placeholder: "12345678",
-        initialValue: config.apiId ? String(config.apiId) : "",
-        validate: (v) => {
-          if (v && isNaN(parseInt(v, 10))) return "Must be a number";
-        },
-      });
-      if (p.isCancel(id)) {
-        p.cancel("Cancelled.");
-        process.exit(0);
-      }
-      const hash = await p.text({
-        message: "API Hash",
-        initialValue: config.apiHash || "",
-      });
-      if (p.isCancel(hash)) {
-        p.cancel("Cancelled.");
-        process.exit(0);
-      }
-      if (id) apiId = parseInt(id, 10);
-      if (hash) apiHash = hash as string;
-    }
-  }
-
-  let teamsWebhookUrl: string | undefined;
-  let teamsWebhookSecret: string | undefined;
-  let teamsWebhookPort: number | undefined;
-  let teamsBotDisplayName: string | undefined;
-
-  if (selectedFrontends.includes("teams")) {
-    p.note(
-      "Set up two Power Automate workflows in Teams:\n" +
-        "1. Send: 'Post to a channel when a webhook request is received' — copy the URL below\n" +
-        "2. Receive: 'When a new channel message is added' → HTTP POST to your Talon endpoint",
-      "Teams Setup",
-    );
+    }),
+  );
+  if (!wantUserbot) return { botToken, adminId };
+
+  p.note(
+    "Get these from https://my.telegram.org → API development tools",
+    "Telegram API credentials",
+  );
+  const id = await askOrExit(
+    p.text({
+      message: "API ID",
+      placeholder: "12345678",
+      initialValue: config.apiId ? String(config.apiId) : "",
+      validate: (v) => {
+        if (v && isNaN(parseInt(v, 10))) return "Must be a number";
+      },
+    }),
+  );
+  const hash = await askOrExit(
+    p.text({
+      message: "API Hash",
+      initialValue: config.apiHash || "",
+    }),
+  );
+  return {
+    botToken,
+    adminId,
+    ...(id ? { apiId: parseInt(id, 10) } : {}),
+    ...(hash ? { apiHash: hash } : {}),
+  };
+}
 
-    const url = await p.text({
+type TeamsAnswers = Pick<
+  SetupAnswers,
+  | "teamsWebhookUrl"
+  | "teamsWebhookSecret"
+  | "teamsWebhookPort"
+  | "teamsBotDisplayName"
+>;
+
+async function askTeams(config: Config): Promise<TeamsAnswers> {
+  p.note(
+    "Set up two Power Automate workflows in Teams:\n" +
+      "1. Send: 'Post to a channel when a webhook request is received' — copy the URL below\n" +
+      "2. Receive: 'When a new channel message is added' → HTTP POST to your Talon endpoint",
+    "Teams Setup",
+  );
+
+  const teamsWebhookUrl = await askOrExit(
+    p.text({
       message: "Power Automate webhook URL (for sending to Teams)",
       placeholder: "https://prod-XX.westus.logic.azure.com/workflows/...",
       initialValue: config.teamsWebhookUrl || undefined,
@@ -156,25 +172,19 @@ export async function runSetup(): Promise<void> {
           return "Must be a valid URL";
         }
       },
-    });
-    if (p.isCancel(url)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    teamsWebhookUrl = url;
+    }),
+  );
 
-    const secret = (await p.text({
+  const secret = await askOrExit(
+    p.text({
       message: "Webhook secret for inbound verification",
       placeholder: "optional — shared secret to verify incoming webhooks",
       initialValue: config.teamsWebhookSecret || "",
-    })) as string;
-    if (p.isCancel(secret)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    if (secret) teamsWebhookSecret = secret;
-
-    const port = await p.text({
+    }),
+  );
+
+  const port = await askOrExit(
+    p.text({
       message: "Webhook receiver port",
       placeholder: "19878",
       initialValue: config.teamsWebhookPort
@@ -185,99 +195,92 @@ export async function runSetup(): Promise<void> {
         const n = parseInt(v, 10);
         if (isNaN(n) || n < 1024 || n > 65535) return "Port must be 1024-65535";
       },
-    });
-    if (p.isCancel(port)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    teamsWebhookPort = parseInt(port as string, 10);
+    }),
+  );
 
-    const botName = (await p.text({
+  const botName = await askOrExit(
+    p.text({
       message: "Bot display name in Teams (for echo loop prevention)",
       placeholder: "optional — e.g. 'Talon Bot'",
       initialValue: config.teamsBotDisplayName || "",
-    })) as string;
-    if (p.isCancel(botName)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    if (botName) teamsBotDisplayName = botName;
-  }
+    }),
+  );
 
-  let discordBotToken: string | undefined;
-  let discordApplicationId: string | undefined;
+  return {
+    teamsWebhookUrl,
+    teamsWebhookPort: parseInt(port, 10),
+    ...(secret ? { teamsWebhookSecret: secret } : {}),
+    ...(botName ? { teamsBotDisplayName: botName } : {}),
+  };
+}
 
-  if (selectedFrontends.includes("discord")) {
-    p.note(
-      "Get bot token + application ID from\n" +
-        "https://discord.com/developers/applications → your app → Bot",
-      "Discord Setup",
-    );
+type DiscordAnswers = Pick<
+  SetupAnswers,
+  "discordBotToken" | "discordApplicationId"
+>;
+
+async function askDiscord(config: Config): Promise<DiscordAnswers> {
+  p.note(
+    "Get bot token + application ID from\n" +
+      "https://discord.com/developers/applications → your app → Bot",
+    "Discord Setup",
+  );
 
-    const token = await p.text({
+  const discordBotToken = await askOrExit(
+    p.text({
       message: "Discord bot token",
       placeholder: "MTxxxxxxxxxxxxxxxxxxxxxxxxxxx",
       initialValue: config.discord?.botToken || undefined,
       validate: (v) => {
         if (!v) return "Bot token is required";
       },
-    });
-    if (p.isCancel(token)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    discordBotToken = token as string;
+    }),
+  );
 
-    const appId = await p.text({
+  const discordApplicationId = await askOrExit(
+    p.text({
       message: "Discord application ID",
       placeholder: "1234567890123456789",
       initialValue: config.discord?.applicationId || undefined,
       validate: (v) => {
         if (!v) return "Application ID is required";
       },
-    });
-    if (p.isCancel(appId)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    discordApplicationId = appId as string;
-  }
+    }),
+  );
 
-  let whatsapp: Config["whatsapp"] | undefined;
+  return { discordBotToken, discordApplicationId };
+}
 
-  if (selectedFrontends.includes("whatsapp")) {
-    p.note(
-      "Talon drives a real WhatsApp account over Baileys multi-device —\n" +
-        "the same mechanism as WhatsApp Web. On first start you'll pair it\n" +
-        "under WhatsApp → Linked devices.",
-      "WhatsApp Setup",
-    );
+async function askWhatsApp(config: Config): Promise<Config["whatsapp"]> {
+  p.note(
+    "Talon drives a real WhatsApp account over Baileys multi-device —\n" +
+      "the same mechanism as WhatsApp Web. On first start you'll pair it\n" +
+      "under WhatsApp → Linked devices.",
+    "WhatsApp Setup",
+  );
 
-    const pairing = (await p.text({
+  const pairing = await askOrExit(
+    p.text({
       message: "The bot account's own number (E.164 digits, no +)",
       placeholder: "leave blank to pair by QR code instead",
       initialValue: config.whatsapp?.pairingNumber || "",
       validate: (v) => {
-        if (v && !/^\d{7,15}$/.test(v.replace(/[\s+()-]/g, "")))
+        if (v && !/^\d{7,15}$/.test(bareDigits(v)))
           return "Digits only, country code included — e.g. 353871234567";
       },
-    })) as string;
-    if (p.isCancel(pairing)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
+    }),
+  );
 
-    const allowed = (await p.text({
+  const allowed = await askOrExit(
+    p.text({
       message: "Numbers allowed to DM the bot (comma-separated)",
       placeholder: "353871234567, 447700900000 — blank disables DMs",
       initialValue: (config.whatsapp?.allowedJids ?? []).join(", "),
-    })) as string;
-    if (p.isCancel(allowed)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
+    }),
+  );
 
-    const groupPolicy = await p.select({
+  const groupPolicy = await askOrExit(
+    p.select<"listed" | "with-allowed-user" | "all">({
       message: "Which groups should the bot serve?",
       initialValue: config.whatsapp?.groupPolicy ?? "listed",
       options: [
@@ -294,25 +297,22 @@ export async function runSetup(): Promise<void> {
           label: `All             ${pc.dim("— every group the account belongs to")}`,
         },
       ],
-    });
-    if (p.isCancel(groupPolicy)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-
-    whatsapp = {
-      // Preserve allowedGroups / respondMode / sendReadReceipts — the
-      // wizard doesn't prompt for them but must not drop them.
-      ...config.whatsapp,
-      allowedJids: parseNumberList(allowed),
-      groupPolicy: groupPolicy as "listed" | "with-allowed-user" | "all",
-      ...(pairing.replace(/[\s+()-]/g, "")
-        ? { pairingNumber: pairing.replace(/[\s+()-]/g, "") }
-        : {}),
-    };
-  }
+    }),
+  );
 
-  // Discover models from SDK; fall back to static list if SDK isn't available
+  const pairingNumber = bareDigits(pairing);
+  return {
+    // Preserve allowedGroups / respondMode / sendReadReceipts — the
+    // wizard doesn't prompt for them but must not drop them.
+    ...config.whatsapp,
+    allowedJids: parseNumberList(allowed),
+    groupPolicy,
+    ...(pairingNumber ? { pairingNumber } : {}),
+  };
+}
+
+/** Discover models from the SDK; fall back to the static list if it isn't installed. */
+async function discoverModels(config: Config) {
   const {
     registerClaudeModels,
     registerClaudeModelsStatic,
@@ -334,171 +334,197 @@ export async function runSetup(): Promise<void> {
     registerClaudeModelsStatic(CLAUDE_MODELS_STATIC);
   }
   const { getModels } = await import("../core/models/catalog.js");
-  const registeredModels = getModels();
-
-  const model = await p.select({
-    message: "Default model",
-    initialValue: config.model,
-    options: registeredModels.map((m) => ({
-      value: m.id,
-      label: `${m.displayName.padEnd(12)}${m.description ? pc.dim(`— ${m.description}`) : ""}`,
-    })),
-  });
-  if (p.isCancel(model)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
+  return getModels();
+}
 
-  const pulse = !selectedFrontends.every((f) => f === "terminal")
-    ? await p.confirm({
-        message: "Enable pulse? (periodic group engagement)",
-        initialValue: config.pulse,
-      })
-    : false;
-  if (p.isCancel(pulse)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
+async function askModel(config: Config): Promise<string> {
+  const registeredModels = await discoverModels(config);
+  return askOrExit(
+    p.select({
+      message: "Default model",
+      initialValue: config.model,
+      options: registeredModels.map((m) => ({
+        value: m.id,
+        label: `${m.displayName.padEnd(12)}${m.description ? pc.dim(`— ${m.description}`) : ""}`,
+      })),
+    }),
+  );
+}
 
-  // ── Backend selection ──
-  const backendSelection = await p.select({
-    message: "AI backend",
-    initialValue: config.backend ?? "claude",
-    options: [
-      {
-        value: "claude",
-        label: `Claude    ${pc.dim("— Anthropic Claude Agent SDK")}`,
-      },
-      {
-        value: "kilo",
-        label: `Kilo      ${pc.dim("— @kilocode/sdk (multi-provider routing)")}`,
-      },
-      {
-        value: "opencode",
-        label: `OpenCode  ${pc.dim("— @opencode-ai/sdk")}`,
-      },
-      {
-        value: "codex",
-        label: `Codex     ${pc.dim("— OpenAI Codex CLI (@openai/codex)")}`,
-      },
-      {
-        value: "openai-agents",
-        label: `OpenAI Agents ${pc.dim("— @openai/agents (OpenAI or any OpenAI-compatible endpoint)")}`,
-      },
-    ],
-  });
-  if (p.isCancel(backendSelection)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const backend = backendSelection as Config["backend"];
+/** Pulse only makes sense with a chat platform — terminal-only installs skip it. */
+async function askPulse(
+  config: Config,
+  selectedFrontends: string[],
+): Promise<boolean> {
+  if (selectedFrontends.every((f) => f === "terminal")) return false;
+  return askOrExit(
+    p.confirm({
+      message: "Enable pulse? (periodic group engagement)",
+      initialValue: config.pulse,
+    }),
+  );
+}
 
-  // ── Backend-specific config ──
-  let claudeBinary: string | undefined;
-  let codexApiKey: string | undefined;
-  let openaiApiKey: string | undefined;
-  let openaiBaseUrl: string | undefined;
-  let openaiApiMode: "responses" | "chat_completions" | undefined;
+async function askBackend(config: Config): Promise<Config["backend"]> {
+  return askOrExit(
+    p.select({
+      message: "AI backend",
+      initialValue: config.backend ?? "claude",
+      options: [
+        {
+          value: "claude",
+          label: `Claude    ${pc.dim("— Anthropic Claude Agent SDK")}`,
+        },
+        {
+          value: "kilo",
+          label: `Kilo      ${pc.dim("— @kilocode/sdk (multi-provider routing)")}`,
+        },
+        {
+          value: "opencode",
+          label: `OpenCode  ${pc.dim("— @opencode-ai/sdk")}`,
+        },
+        {
+          value: "codex",
+          label: `Codex     ${pc.dim("— OpenAI Codex CLI (@openai/codex)")}`,
+        },
+        {
+          value: "openai-agents",
+          label: `OpenAI Agents ${pc.dim("— @openai/agents (OpenAI or any OpenAI-compatible endpoint)")}`,
+        },
+      ],
+    }),
+  );
+}
 
-  if (backend === "claude") {
-    const claudeBinaryInput = await p.text({
+type BackendAnswers = Pick<
+  SetupAnswers,
+  | "claudeBinary"
+  | "codexApiKey"
+  | "openaiApiKey"
+  | "openaiBaseUrl"
+  | "openaiApiMode"
+>;
+
+async function askClaudeBackend(config: Config): Promise<BackendAnswers> {
+  const claudeBinary = await askOrExit(
+    p.text({
       message: "Claude Code binary path",
       placeholder: "leave empty for default (claude)",
       initialValue: config.claudeBinary || "",
-    });
-    if (p.isCancel(claudeBinaryInput)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    claudeBinary = (claudeBinaryInput as string).trim() || undefined;
-  } else if (backend === "codex") {
-    const keyInput = await p.text({
+    }),
+  );
+  return { claudeBinary: trimmedOrUndefined(claudeBinary) };
+}
+
+async function askCodexBackend(config: Config): Promise<BackendAnswers> {
+  const codexApiKey = await askOrExit(
+    p.text({
       message: "Codex OpenAI API key",
       placeholder:
         "leave empty to use CODEX_API_KEY / TALON_CODEX_KEY env or `codex login` auth",
       initialValue: config.codexApiKey || "",
-    });
-    if (p.isCancel(keyInput)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    codexApiKey = (keyInput as string).trim() || undefined;
-  } else if (backend === "openai-agents") {
-    const keyInput = await p.text({
-      message:
-        "API key (OpenAI, OpenRouter, Azure, or whatever your endpoint requires)",
-      placeholder: "leave empty to use OPENAI_API_KEY env",
-      initialValue: config.openaiApiKey || "",
-    });
-    if (p.isCancel(keyInput)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    openaiApiKey = (keyInput as string).trim() || undefined;
-
-    const baseUrlInput = await p.text({
-      message:
-        "Base URL " +
-        pc.dim(
-          "(leave empty for OpenAI direct; e.g. https://openrouter.ai/api/v1)",
-        ),
-      placeholder: "https://openrouter.ai/api/v1",
-      initialValue: config.openaiBaseUrl || "",
-    });
-    if (p.isCancel(baseUrlInput)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    openaiBaseUrl = (baseUrlInput as string).trim() || undefined;
-
-    if (openaiBaseUrl) {
-      const modeSelection = await p.select({
-        message: "OpenAI API surface",
-        options: [
-          {
-            value: "chat_completions",
-            label: `Chat Completions ${pc.dim("— most third parties (OpenRouter, Ollama, LiteLLM, most Azure)")}`,
-          },
-          {
-            value: "responses",
-            label: `Responses ${pc.dim("— OpenAI native, requires proxy support")}`,
-          },
-        ],
-        initialValue: config.openaiApiMode ?? "chat_completions",
-      });
-      if (p.isCancel(modeSelection)) {
-        p.cancel("Cancelled.");
-        process.exit(0);
-      }
-      openaiApiMode = modeSelection as "responses" | "chat_completions";
-    }
+    }),
+  );
+  return { codexApiKey: trimmedOrUndefined(codexApiKey) };
+}
+
+async function askOpenAiAgentsBackend(config: Config): Promise<BackendAnswers> {
+  const openaiApiKey = trimmedOrUndefined(
+    await askOrExit(
+      p.text({
+        message:
+          "API key (OpenAI, OpenRouter, Azure, or whatever your endpoint requires)",
+        placeholder: "leave empty to use OPENAI_API_KEY env",
+        initialValue: config.openaiApiKey || "",
+      }),
+    ),
+  );
+
+  const openaiBaseUrl = trimmedOrUndefined(
+    await askOrExit(
+      p.text({
+        message:
+          "Base URL " +
+          pc.dim(
+            "(leave empty for OpenAI direct; e.g. https://openrouter.ai/api/v1)",
+          ),
+        placeholder: "https://openrouter.ai/api/v1",
+        initialValue: config.openaiBaseUrl || "",
+      }),
+    ),
+  );
+  if (!openaiBaseUrl) return { openaiApiKey, openaiBaseUrl };
+
+  const openaiApiMode = await askOrExit(
+    p.select<NonNullable<Config["openaiApiMode"]>>({
+      message: "OpenAI API surface",
+      options: [
+        {
+          value: "chat_completions",
+          label: `Chat Completions ${pc.dim("— most third parties (OpenRouter, Ollama, LiteLLM, most Azure)")}`,
+        },
+        {
+          value: "responses",
+          label: `Responses ${pc.dim("— OpenAI native, requires proxy support")}`,
+        },
+      ],
+      initialValue: config.openaiApiMode ?? "chat_completions",
+    }),
+  );
+  return { openaiApiKey, openaiBaseUrl, openaiApiMode };
+}
+
+/**
+ * kilo / opencode need no extra prompts — bundled SDK + per-provider creds
+ * configured separately (kilo via `kilo login`, opencode via its own auth
+ * flow).
+ */
+async function askBackendCredentials(
+  config: Config,
+  backend: Config["backend"],
+): Promise<BackendAnswers> {
+  switch (backend) {
+    case "claude":
+      return askClaudeBackend(config);
+    case "codex":
+      return askCodexBackend(config);
+    case "openai-agents":
+      return askOpenAiAgentsBackend(config);
+    default:
+      return {};
   }
+}
 
-  // kilo / opencode need no extra prompts — bundled SDK + per-provider
-  // creds configured separately (kilo via `kilo login`, opencode via
-  // its own auth flow).
+// ── The wizard: the steps above, in order ──
+
+export async function runSetup(): Promise<void> {
+  printBanner();
+  p.intro(pc.inverse(" Setup Wizard "));
+
+  const config = loadConfig();
+  const selectedFrontends = await askFrontends(config);
+  const on = (id: string) => selectedFrontends.includes(id);
+
+  const telegram = on("telegram") ? await askTelegram(config) : {};
+  const teams = on("teams") ? await askTeams(config) : {};
+  const discord = on("discord") ? await askDiscord(config) : {};
+  const whatsapp = on("whatsapp") ? await askWhatsApp(config) : undefined;
+
+  const model = await askModel(config);
+  const pulse = await askPulse(config, selectedFrontends);
+  const backend = await askBackend(config);
+  const credentials = await askBackendCredentials(config, backend);
 
   const newConfig = buildSetupConfig(config, {
     selectedFrontends,
     backend,
-    botToken,
-    claudeBinary,
-    codexApiKey,
-    openaiApiKey,
-    openaiBaseUrl,
-    openaiApiMode,
-    model: model as string,
-    pulse: pulse as boolean,
-    adminId,
-    apiId,
-    apiHash,
-    teamsWebhookUrl,
-    teamsWebhookSecret,
-    teamsWebhookPort,
-    teamsBotDisplayName,
-    discordBotToken,
-    discordApplicationId,
+    model,
+    pulse,
     whatsapp,
+    ...telegram,
+    ...teams,
+    ...discord,
+    ...credentials,
   });
 
   const s = p.spinner();
@@ -508,7 +534,7 @@ export async function runSetup(): Promise<void> {
 
   p.outro(`Run ${pc.cyan(pc.bold("talon start"))} to launch Talon`);
 
-  if (selectedFrontends.includes("telegram") && apiId && apiHash) {
+  if (on("telegram") && telegram.apiId && telegram.apiHash) {
     console.log(
       `  ${pc.yellow("!")} Run ${pc.cyan("npx tsx src/login.ts")} to authenticate the userbot first.\n`,
     );