arisa 5.1.68 → 5.2.7

package/src/platform/paths.js

@@ -0,0 +1,152 @@
+import { mkdir } from "node:fs/promises";
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const arisaPackageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+export const arisaHomeDir = process.env.ARISA_HOME
+  ? path.resolve(process.env.ARISA_HOME)
+  : path.join(os.homedir(), ".arisa");
+export const stateDir = path.join(arisaHomeDir, "state");
+export const tuiSessionsDir = path.join(stateDir, "pi-tui-sessions");
+export const configFile = path.join(stateDir, "config.json");
+export const piAuthFile = path.join(stateDir, "pi-auth.json");
+export const servicePidFile = path.join(stateDir, "arisa.pid");
+export const serviceLogFile = path.join(stateDir, "arisa.log");
+export const restartReceiptFile = path.join(stateDir, "restart-receipt.json");
+export const sessionStartOperationalNotesFile = path.join(stateDir, "session-start-operational-notes.json");
+export function createIpcSocketPath({ homeDir = arisaHomeDir, platform = process.platform } = {}) {
+  if (platform === "win32") {
+    const suffix = crypto.createHash("sha256").update(homeDir).digest("hex").slice(0, 16);
+    return `\\\\.\\pipe\\arisa-${suffix}`;
+  }
+  return path.join(homeDir, "state", "arisa.sock");
+}
+
+export const arisaIpcSocketFile = createIpcSocketPath();
+export const tasksFile = path.join(stateDir, "tasks.json");
+export const toolsDir = path.join(arisaHomeDir, "tools");
+export const chatsDir = path.join(arisaHomeDir, "chats");
+export const toolStateDir = path.join(stateDir, "tools");
+
+export function requireToolName(toolName) {
+  const name = String(toolName ?? "");
+  if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
+    throw new Error(`Invalid tool name: ${name || "empty"}`);
+  }
+  return name;
+}
+
+export function getChatDir(chatId) {
+  return path.join(chatsDir, String(chatId));
+}
+
+export function getChatArtifactsDir(chatId) {
+  return path.join(getChatDir(chatId), "artifacts");
+}
+
+export function getChatArtifactsIndexFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "artifacts.json");
+}
+
+export function getChatSessionSeedFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "session-seed.jsonl");
+}
+
+export function getChatLegacyConversationHistoryFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "conversation.jsonl");
+}
+
+export function getChatToolUsageFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "tool-usage.json");
+}
+
+export function getChatToolResourceNotesFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "tool-resource-notes.json");
+}
+
+export function getChatTelegramWorkspacesFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "telegram-workspaces.json");
+}
+
+export function getChatToolStateDir(chatId, toolName) {
+  return path.join(getChatDir(chatId), "state", "tools", requireToolName(toolName));
+}
+
+export function normalizeDaemonScope(scope = { type: "global" }) {
+  if (!scope || scope === "global" || scope.type === "global") {
+    return { type: "global" };
+  }
+  if (scope === "chat") {
+    throw new Error("chat daemon scope requires chatId");
+  }
+  if (scope.type !== "chat") {
+    throw new Error(`Unsupported daemon scope: ${scope.type || scope}`);
+  }
+  const chatId = String(scope.chatId ?? "").trim();
+  if (!/^-?\d+$/.test(chatId)) {
+    throw new Error(`Invalid chat daemon scope: ${chatId || "missing chatId"}`);
+  }
+  return { type: "chat", chatId };
+}
+
+export function getDaemonInstanceId(scope = { type: "global" }) {
+  const normalized = normalizeDaemonScope(scope);
+  return normalized.type === "global" ? "global" : `chat:${normalized.chatId}`;
+}
+
+export function getDaemonInstanceDir(toolName, scope = { type: "global" }) {
+  const normalized = normalizeDaemonScope(scope);
+  return normalized.type === "global"
+    ? getToolStateDir(toolName)
+    : path.join(getChatToolStateDir(normalized.chatId, toolName), "daemon");
+}
+
+export function getChatPiSessionsDir(chatId, sessionRevision = 0) {
+  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
+    throw new Error(`Invalid Pi session revision: ${sessionRevision}`);
+  }
+  const sessionsDir = path.join(getChatDir(chatId), "state", "pi-sessions");
+  return sessionRevision === 0
+    ? sessionsDir
+    : path.join(sessionsDir, String(sessionRevision));
+}
+
+export function getToolDir(toolName) {
+  return path.join(toolsDir, requireToolName(toolName));
+}
+
+export function getToolConfigPath(toolName) {
+  return path.join(getToolDir(toolName), "config.js");
+}
+
+export function getChatConfigDir(chatId) {
+  return path.join(getChatDir(chatId), "config");
+}
+
+export function getChatTmpDir(chatId) {
+  return path.join(getChatDir(chatId), "tmp");
+}
+
+export function getChatToolConfigPath(chatId, toolName) {
+  return path.join(getChatConfigDir(chatId), "tools", requireToolName(toolName), "config.js");
+}
+
+export function getToolStateDir(toolName) {
+  return path.join(toolStateDir, requireToolName(toolName));
+}
+
+export function getToolTmpDir(toolName) {
+  return path.join(getToolStateDir(toolName), "tmp");
+}
+
+export function getChatToolTmpDir(chatId, toolName) {
+  return path.join(getChatTmpDir(chatId), "tools", toolName);
+}
+
+export async function ensureArisaHome() {
+  await mkdir(stateDir, { recursive: true });
+  await mkdir(toolsDir, { recursive: true });
+  await mkdir(chatsDir, { recursive: true });
+}

package/src/runtime/bootstrap-cli.js

@@ -0,0 +1,121 @@
+import { spawn } from "node:child_process";
+import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
+import {
+  createPiRuntime,
+  formatPiModelOption,
+  hasProviderAuth,
+  listPiProviders,
+  listProviderModels,
+  supportsProviderOAuth
+} from "../core/agent/pi-runtime.js";
+import {
+  buildBootstrapConfig,
+  formatProviderOption,
+  selectByIndex,
+  selectPiLoginOption,
+  sortBootstrapModels,
+  sortBootstrapProviders
+} from "./bootstrap-config.js";
+
+export async function openExternal(url) {
+  if (!url) return;
+  await new Promise((resolve) => {
+    let child;
+    if (process.platform === "darwin") {
+      child = spawn("open", [url], { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      child = spawn("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+    } else {
+      child = spawn("xdg-open", [url], { stdio: "ignore" });
+    }
+    child.on("exit", () => resolve());
+    child.on("error", () => resolve());
+  });
+}
+
+async function runInternalPiLogin(provider, { rl = null } = {}) {
+  const login = createPiOAuthLogin({
+    provider,
+    onSelect: async ({ message, options }) => {
+      const selected = selectPiLoginOption(options);
+      if (!selected) return undefined;
+      console.log(`${message}\nUsing: ${selected.label || selected.id}\n`);
+      return selected.id;
+    },
+    onAuth: async ({ url, instructions, controller }) => {
+      console.log(`${instructions || "Open this URL to continue authentication:"}\n${url}\n`);
+      await openExternal(url);
+      if (controller.oauthProvider.usesCallbackServer && rl) {
+        const pasted = (await rl.question("Paste the redirect URL here if the browser does not return automatically, or press Enter to keep waiting: ")).trim();
+        if (pasted) controller.submitManualCode(pasted);
+      }
+    },
+    onDeviceCode: async ({ userCode, verificationUri }) => {
+      console.log(`Open this URL: ${verificationUri}`);
+      console.log(`Then enter code: ${userCode}\n`);
+      await openExternal(verificationUri);
+    },
+    onPrompt: async ({ message }) => {
+      if (!rl) throw new Error(`Pi login for ${provider} requires interactive input: ${message}`);
+      return (await rl.question(`${message} `)).trim();
+    },
+    onProgress: (message) => console.log(message)
+  });
+  await login.promise;
+}
+
+export async function collectCliBootstrapChoices({ telegramApiKey, rl, ask }) {
+  const telegramMaxChatIds = Number(await ask("Maximum authorized chat IDs", "1"));
+  const runtime = createPiRuntime();
+  const providers = sortBootstrapProviders(listPiProviders(runtime));
+  console.log("\nAvailable Pi providers:");
+  providers.forEach((item, index) => console.log(`${index + 1}. ${formatProviderOption(item)}`));
+
+  const selectedProvider = selectByIndex(providers, await ask("Select Pi provider by number", "1"));
+  const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, runtime));
+  console.log(`\nAvailable models for ${selectedProvider.provider}:`);
+  models.forEach((model, index) => console.log(`${index + 1}. ${formatPiModelOption(model)}`));
+
+  const selectedModel = selectByIndex(models, await ask("Select Pi model by number", "1"));
+  const selectedAuthReady = hasProviderAuth(selectedProvider.provider, runtime);
+  const providerSupportsOAuth = supportsProviderOAuth(selectedProvider.provider, runtime);
+  console.log(`Selected model: ${selectedModel.provider}/${selectedModel.id}`);
+  console.log(`Existing Pi auth for ${selectedProvider.provider}: ${selectedAuthReady ? "yes" : "no"}`);
+  if (providerSupportsOAuth) {
+    console.log("Pi auth tip: leaving the API key empty will start Pi's internal login flow for this provider.");
+  }
+
+  let piApiKey = "";
+  while (true) {
+    piApiKey = (await rl.question(`Pi API key for ${selectedProvider.provider} (optional): `)).trim();
+    if (piApiKey) break;
+    if (hasProviderAuth(selectedProvider.provider, createPiRuntime())) break;
+    if (!providerSupportsOAuth) {
+      console.log(`No existing Pi auth found for ${selectedProvider.provider}. This provider requires an API key.`);
+      continue;
+    }
+    console.log(`No existing Pi auth found for ${selectedProvider.provider}. Starting internal Pi login...`);
+    try {
+      await runInternalPiLogin(selectedProvider.provider, { rl });
+    } catch (error) {
+      console.log(`Internal Pi login failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (hasProviderAuth(selectedProvider.provider, createPiRuntime())) {
+      console.log(`Detected Pi auth for ${selectedProvider.provider}. Continuing bootstrap.`);
+      break;
+    }
+    console.log(`Pi auth for ${selectedProvider.provider} is still missing after login.`);
+  }
+
+  return {
+    config: buildBootstrapConfig({
+      telegramApiKey,
+      telegramMaxChatIds,
+      provider: selectedProvider.provider,
+      model: selectedModel.id,
+      piApiKey
+    }),
+    startInBackground: false,
+    viaTelegram: false
+  };
+}

package/src/runtime/bootstrap-config.js

@@ -0,0 +1,97 @@
+import { applyConfigDefaults } from "../core/config/config-defaults.js";
+
+export function buildBootstrapConfig({
+  telegramApiKey,
+  telegramMaxChatIds,
+  authorizedChatIds = [],
+  chatMeta = {},
+  provider,
+  model,
+  piApiKey
+}) {
+  return applyConfigDefaults({
+    telegram: {
+      token: telegramApiKey,
+      maxChatIds: telegramMaxChatIds,
+      authorizedChatIds,
+      chatMeta
+    },
+    pi: {
+      provider,
+      model,
+      apiKey: piApiKey
+    },
+    createdAt: new Date().toISOString()
+  });
+}
+
+export function sortBootstrapProviders(providers) {
+  const preferredOrder = ["openai-codex"];
+  const positions = new Map(providers.map((provider, index) => [provider.provider, index]));
+
+  return [...providers].sort((a, b) => {
+    const aPref = preferredOrder.indexOf(a.provider);
+    const bPref = preferredOrder.indexOf(b.provider);
+    const aRank = aPref === -1 ? Number.MAX_SAFE_INTEGER : aPref;
+    const bRank = bPref === -1 ? Number.MAX_SAFE_INTEGER : bPref;
+    if (aRank !== bRank) return aRank - bRank;
+    return (positions.get(a.provider) || 0) - (positions.get(b.provider) || 0);
+  });
+}
+
+export function sortBootstrapModels(provider, models) {
+  const preferred = {
+    "openai-codex": ["gpt-5.5"]
+  };
+  const priority = preferred[provider] || [];
+  const positions = new Map(models.map((model, index) => [model.id, index]));
+
+  return [...models].sort((a, b) => {
+    const aIndex = priority.indexOf(a.id);
+    const bIndex = priority.indexOf(b.id);
+    const aRank = aIndex === -1 ? Number.MAX_SAFE_INTEGER : aIndex;
+    const bRank = bIndex === -1 ? Number.MAX_SAFE_INTEGER : bIndex;
+    if (aRank !== bRank) return aRank - bRank;
+    return (positions.get(b.id) || 0) - (positions.get(a.id) || 0);
+  });
+}
+
+export function parsePositiveInteger(value, fallback = null) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return fallback;
+  return Math.floor(number);
+}
+
+export function selectByIndex(items, value, fallbackIndex = 0) {
+  const index = parsePositiveInteger(value, fallbackIndex + 1) - 1;
+  return items[Math.max(0, Math.min(items.length - 1, index))];
+}
+
+export function parseYesNo(value, fallback = true) {
+  const text = String(value ?? "").trim().toLowerCase();
+  if (!text) return fallback;
+  if (["y", "yes", "s", "si", "sí"].includes(text)) return true;
+  if (["n", "no"].includes(text)) return false;
+  return null;
+}
+
+export function getIncomingChatMeta(ctx) {
+  return {
+    languageCode: ctx.from?.language_code || "",
+    username: ctx.from?.username || "",
+    firstName: ctx.from?.first_name || "",
+    lastName: ctx.from?.last_name || ""
+  };
+}
+
+export function formatProviderOption(item) {
+  const authLabel = item.authConfigured ? "auth configured" : item.supportsOAuth ? "login or API key" : "API key";
+  return `${item.provider} (${item.modelCount} models, ${authLabel})`;
+}
+
+export function selectPiLoginOption(options = []) {
+  return options.find((option) => /device/i.test(`${option.id} ${option.label}`))
+    || options.find((option) => /browser|oauth|web/i.test(`${option.id} ${option.label}`))
+    || options[0]
+    || null;
+}

package/src/runtime/bootstrap-telegram.js

@@ -0,0 +1,325 @@
+import { Bot } from "grammy";
+import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
+import {
+  createPiRuntime,
+  formatPiModelOption,
+  hasProviderAuth,
+  listPiProviders,
+  listProviderModels,
+  supportsProviderOAuth
+} from "../core/agent/pi-runtime.js";
+import { telegramConfigDefaults } from "../core/config/config-defaults.js";
+import { buildDeviceCodeTelegramMessage } from "../transport/telegram/device-code-message.js";
+import { buildPagedInlineKeyboard } from "../transport/telegram/paged-inline-keyboard.js";
+import {
+  buildBootstrapConfig,
+  formatProviderOption,
+  getIncomingChatMeta,
+  parseYesNo,
+  selectPiLoginOption,
+  sortBootstrapModels,
+  sortBootstrapProviders
+} from "./bootstrap-config.js";
+
+export async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
+  const bot = new Bot(telegramApiKey);
+  const runtime = createPiRuntime();
+  const providers = sortBootstrapProviders(listPiProviders(runtime));
+  let setupChatId = null;
+  let chatMeta = {};
+  let state = "await-start";
+  let telegramMaxChatIds = 1;
+  let selectedProvider = null;
+  let selectedModel = null;
+  let piApiKey = "";
+  let activeLogin = null;
+  let completed = false;
+  let resolveResult;
+  let rejectResult;
+
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+
+  const sendSetupMessage = async (text, extra = {}) => {
+    if (!setupChatId) return;
+    await bot.api.sendMessage(setupChatId, text, extra);
+  };
+
+  const showSetupPrompt = async (ctx, text, extra = {}) => {
+    const messageId = ctx?.callbackQuery?.message?.message_id;
+    if (messageId && ctx.chat?.id) {
+      try {
+        await ctx.api.editMessageText(ctx.chat.id, messageId, text, extra);
+        return;
+      } catch {}
+    }
+    await sendSetupMessage(text, extra);
+  };
+
+  const isSetupChat = (ctx) => setupChatId && ctx.chat?.id === setupChatId;
+
+  const complete = (startInBackground) => {
+    if (completed) return;
+    completed = true;
+    resolveResult({
+      config: buildBootstrapConfig({
+        telegramApiKey,
+        telegramMaxChatIds,
+        authorizedChatIds: [setupChatId],
+        chatMeta: { [setupChatId]: chatMeta },
+        provider: selectedProvider.provider,
+        model: selectedModel.id,
+        piApiKey
+      }),
+      startInBackground,
+      viaTelegram: true
+    });
+  };
+
+  const askProvider = async (ctx = null, page = 0) => {
+    state = "provider";
+    await showSetupPrompt(ctx, "Select the Pi provider Arisa should use:", {
+      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), {
+        page,
+        pageSize: telegramConfigDefaults.modelPickerPageSize
+      })
+    });
+  };
+
+  const askModel = async (ctx = null, page = 0) => {
+    state = "model";
+    const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
+    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatPiModelOption(model) })), {
+      page,
+      pageSize: telegramConfigDefaults.modelPickerPageSize
+    });
+    keyboard.inline_keyboard.push([{ text: "Back to providers", callback_data: "back:provider" }]);
+    await showSetupPrompt(ctx, `Select the model for ${selectedProvider.provider}:`, { reply_markup: keyboard });
+  };
+
+  const askBackground = async (ctx = null) => {
+    state = "background";
+    await showSetupPrompt(ctx, "Bootstrap complete. Keep Arisa running in background now?", {
+      reply_markup: {
+        inline_keyboard: [
+          [{ text: "Yes, start in background", callback_data: "background:yes" }],
+          [{ text: "No, continue in foreground", callback_data: "background:no" }]
+        ]
+      }
+    });
+  };
+
+  const askApiKey = async (ctx = null) => {
+    state = "pi-api-key";
+    await showSetupPrompt(ctx, `Send the Pi API key for ${selectedProvider.provider}.`, {
+      reply_markup: { inline_keyboard: [] }
+    });
+  };
+
+  const askAuthMethod = async (ctx = null) => {
+    const providerRuntime = createPiRuntime();
+    const selectedAuthReady = hasProviderAuth(selectedProvider.provider, providerRuntime);
+    const providerSupportsOAuth = supportsProviderOAuth(selectedProvider.provider, providerRuntime);
+    const buttons = [];
+    if (selectedAuthReady) buttons.push([{ text: "Use existing Pi auth", callback_data: "auth:existing" }]);
+    if (providerSupportsOAuth) {
+      buttons.push([{ text: selectedAuthReady ? "Run Pi login again" : "Start Pi login", callback_data: "auth:login" }]);
+    }
+    buttons.push([{ text: "Enter API key", callback_data: "auth:key" }]);
+    buttons.push([{ text: "Back to models", callback_data: "back:model" }]);
+
+    state = "auth-method";
+    await showSetupPrompt(ctx, [
+      `Selected model: ${selectedProvider.provider}/${selectedModel.id}`,
+      `Existing Pi auth for ${selectedProvider.provider}: ${selectedAuthReady ? "yes" : "no"}`,
+      "Choose how Arisa should authenticate Pi."
+    ].join("\n"), { reply_markup: { inline_keyboard: buttons } });
+  };
+
+  const finishPiLogin = async (login) => {
+    try {
+      await login.promise;
+      activeLogin = null;
+      if (hasProviderAuth(selectedProvider.provider, createPiRuntime())) {
+        await sendSetupMessage(`Detected Pi auth for ${selectedProvider.provider}.`);
+        await askBackground();
+        return;
+      }
+      await sendSetupMessage(`Pi auth for ${selectedProvider.provider} is still missing after login.`);
+      await askAuthMethod();
+    } catch (error) {
+      activeLogin = null;
+      await sendSetupMessage(`Pi login failed: ${error instanceof Error ? error.message : String(error)}`);
+      await askAuthMethod();
+    }
+  };
+
+  const startPiLogin = async () => {
+    if (hasProviderAuth(selectedProvider.provider, createPiRuntime())) {
+      await sendSetupMessage(`Existing Pi auth for ${selectedProvider.provider} detected.`);
+      await askBackground();
+      return;
+    }
+
+    state = "pi-login";
+    const login = createPiOAuthLogin({
+      provider: selectedProvider.provider,
+      onSelect: async ({ message, options }) => {
+        const selected = selectPiLoginOption(options);
+        if (!selected) return undefined;
+        await sendSetupMessage(`${message}\nUsing: ${selected.label || selected.id}`);
+        return selected.id;
+      },
+      onAuth: async ({ url, instructions }) => {
+        await sendSetupMessage([
+          instructions || "Open this URL to continue Pi authentication:",
+          url,
+          "After login, paste the full redirect URL back here."
+        ].join("\n"));
+      },
+      onDeviceCode: async ({ userCode, verificationUri, expiresInSeconds }) => {
+        const { text, ...options } = buildDeviceCodeTelegramMessage({ userCode, verificationUri, expiresInSeconds });
+        await sendSetupMessage(text, options);
+      },
+      onPrompt: async ({ message, controller }) => {
+        await sendSetupMessage(`${message}\nReply here with the value.`);
+        return controller.waitForManualCode();
+      },
+      onProgress: (message) => {
+        if (message) console.log(`[bootstrap] Pi auth progress: ${message}`);
+      }
+    });
+
+    activeLogin = login;
+    finishPiLogin(login);
+  };
+
+  bot.catch((error) => console.error("Telegram setup bot error:", error));
+
+  bot.command("start", async (ctx) => {
+    if (String(ctx.match || "").trim() !== setupToken) {
+      await ctx.reply("Invalid setup link. Use the link shown in the Arisa bootstrap terminal.");
+      return;
+    }
+    if (setupChatId && ctx.chat.id !== setupChatId) {
+      await ctx.reply("This setup session is already connected to another chat.");
+      return;
+    }
+    setupChatId = ctx.chat.id;
+    chatMeta = getIncomingChatMeta(ctx);
+    await ctx.reply([
+      `Connected to @${botInfo.username}.`,
+      "This chat will be the only Telegram chat authorized during setup."
+    ].join("\n"));
+    await askProvider();
+  });
+
+  bot.on("callback_query:data", async (ctx) => {
+    await ctx.answerCallbackQuery().catch(() => {});
+    if (!isSetupChat(ctx)) return;
+    const data = String(ctx.callbackQuery.data || "");
+    const [action, rawValue] = data.split(":");
+    if (action === "noop") return;
+    if (action === "back" && rawValue === "provider" && state === "model") {
+      selectedProvider = null;
+      selectedModel = null;
+      await askProvider(ctx);
+      return;
+    }
+    if (action === "back" && rawValue === "model" && state === "auth-method") {
+      selectedModel = null;
+      await askModel(ctx);
+      return;
+    }
+    if (action === "provider-page" && state === "provider") {
+      await askProvider(ctx, Number(rawValue));
+      return;
+    }
+    if (action === "model-page" && state === "model") {
+      await askModel(ctx, Number(rawValue));
+      return;
+    }
+    if (action === "provider" && state === "provider") {
+      selectedProvider = providers[Number(rawValue)];
+      if (!selectedProvider) return;
+      await askModel(ctx);
+      return;
+    }
+    if (action === "model" && state === "model") {
+      const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
+      selectedModel = models[Number(rawValue)];
+      if (!selectedModel) return;
+      await askAuthMethod(ctx);
+      return;
+    }
+    if (action === "auth" && state === "auth-method") {
+      if (rawValue === "existing") {
+        if (hasProviderAuth(selectedProvider.provider, createPiRuntime())) {
+          await askBackground(ctx);
+        } else {
+          await sendSetupMessage(`No existing Pi auth found for ${selectedProvider.provider}.`);
+          await askAuthMethod(ctx);
+        }
+        return;
+      }
+      if (rawValue === "login") {
+        await startPiLogin();
+        return;
+      }
+      if (rawValue === "key") {
+        await askApiKey(ctx);
+        return;
+      }
+    }
+    if (action === "background" && state === "background") {
+      await sendSetupMessage(rawValue === "yes"
+        ? "Saving config. Arisa will start in background now."
+        : "Saving config. Arisa will continue in foreground.");
+      complete(rawValue === "yes");
+    }
+  });
+
+  bot.on("message:text", async (ctx) => {
+    if (!isSetupChat(ctx)) return;
+    const text = String(ctx.message.text || "").trim();
+    if (!text || text.startsWith("/")) return;
+    if (state === "pi-api-key") {
+      piApiKey = text;
+      await askBackground();
+      return;
+    }
+    if (state === "pi-login" && activeLogin?.manualInputRequested) {
+      if (activeLogin.submitManualCode(text)) await ctx.reply("Got it. Finishing Pi login now...");
+      return;
+    }
+    if (state === "background") {
+      const answer = parseYesNo(text, true);
+      if (answer === null) {
+        await ctx.reply("Please answer yes or no.");
+        return;
+      }
+      await ctx.reply(answer
+        ? "Saving config. Arisa will start in background now."
+        : "Saving config. Arisa will continue in foreground.");
+      complete(answer);
+    }
+  });
+
+  await bot.api.deleteWebhook({ drop_pending_updates: true });
+  console.log("Waiting for Telegram setup to complete...");
+  const polling = bot.start().then(() => {
+    if (!completed) throw new Error("Telegram setup bot stopped before bootstrap completed.");
+  });
+
+  try {
+    return await Promise.race([resultPromise, polling]);
+  } catch (error) {
+    rejectResult(error);
+    throw error;
+  } finally {
+    bot.stop();
+    await polling.catch(() => {});
+  }
+}