arisa 4.0.5 → 4.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.0.5",
+  "version": "4.0.6",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/auth-flow.js

@@ -82,13 +82,28 @@ export function buildPiAuthTelegramMessage({ config, issue = null, verified = fa
   } else if (status.hasApiKey) {
     lines.push("A Pi API key is configured, but the provider rejected the current request. Update the key and restart Arisa.");
   } else if (status.supportsOAuth) {
-    lines.push("For now, re-run `arisa --bootstrap` on the host and complete Pi login again.");
+    lines.push("Run `/auth` here in Telegram to renew the Pi login.");
   } else {
     lines.push("This provider needs a Pi API key. Re-run `arisa --bootstrap`, provide a key, and restart Arisa.");
   }
 
-  if (issue) {
-    lines.push("Telegram-based renewal is not wired yet, but this /auth path is ready for that flow.");
+  return lines.join("\n");
+}
+
+export function buildPiAuthRecoveryBlockedMessage({ config, issue = null, renewalActive = false }) {
+  const status = getPiAuthStatus(config);
+  const lines = [
+    `Pi authentication is not ready for ${status.provider}/${status.model}.`,
+    "I did not send your message to the agent."
+  ];
+
+  if (issue?.message) {
+    lines.push(`Details: ${issue.message}`);
   }
+
+  lines.push(renewalActive
+    ? "A Pi login is already in progress. Paste the redirect URL or code here when the provider gives it to you."
+    : "Send `/auth` to start Pi login from Telegram.");
+
   return lines.join("\n");
 }

package/src/core/agent/pi-auth-login.js

@@ -0,0 +1,57 @@
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
+
+export function createPiOAuthLogin({ provider, onAuth, onDeviceCode, onPrompt, onProgress, onSelect } = {}) {
+  const authStorage = AuthStorage.create();
+  const oauthProvider = authStorage.getOAuthProviders().find((item) => item.id === provider);
+  if (!oauthProvider) {
+    throw new Error(`No internal OAuth login flow is available for ${provider}.`);
+  }
+
+  let resolveManualCode;
+  const manualCodePromise = new Promise((resolve) => {
+    resolveManualCode = resolve;
+  });
+
+  const controller = {
+    provider,
+    oauthProvider,
+    manualInputRequested: false,
+    submitManualCode(value) {
+      if (!resolveManualCode) return false;
+      controller.manualInputRequested = false;
+      resolveManualCode(String(value || "").trim());
+      resolveManualCode = null;
+      return true;
+    },
+    waitForManualCode() {
+      controller.manualInputRequested = true;
+      return manualCodePromise;
+    },
+    promise: null
+  };
+
+  controller.promise = authStorage.login(provider, {
+    onAuth: async (params) => {
+      await onAuth?.({ ...params, controller });
+    },
+    onDeviceCode: async (params) => {
+      await onDeviceCode?.({ ...params, controller });
+    },
+    onPrompt: async (params) => {
+      if (!onPrompt) return "";
+      return onPrompt({ ...params, controller });
+    },
+    onProgress: (message) => {
+      onProgress?.(message);
+    },
+    onSelect: async (params) => {
+      if (!onSelect) return params.options?.[0]?.id;
+      return onSelect({ ...params, controller });
+    },
+    onManualCodeInput: () => controller.waitForManualCode()
+  }).finally(() => {
+    controller.submitManualCode("");
+  });
+
+  return controller;
+}

package/src/runtime/bootstrap.js

@@ -2,7 +2,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
-import { AuthStorage } from "@mariozechner/pi-coding-agent";
+import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
 import { createPiRuntime, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
 import { configFile, ensureArisaHome } from "./paths.js";
 
@@ -194,37 +194,19 @@ function installAuthRelay(httpPort, setHttpRequestHandler) {
 }
 
 async function runInternalPiLogin(provider, { rl = null, authRelay = null } = {}) {
-  const authStorage = AuthStorage.create();
-  const selected = authStorage.getOAuthProviders().find((item) => item.id === provider);
-  if (!selected) {
-    throw new Error(`No internal OAuth login flow is available for ${provider}.`);
-  }
-
-  let manualCodeResolve;
-  let manualCodeReject;
-  const manualCodePromise = new Promise((resolve, reject) => {
-    manualCodeResolve = resolve;
-    manualCodeReject = reject;
-  });
-
-  await authStorage.login(provider, {
-    onAuth: async ({ url, instructions }) => {
+  const login = createPiOAuthLogin({
+    provider,
+    onAuth: async ({ url, instructions, controller }) => {
       console.log(`${instructions || "Open this URL to continue authentication:"}\n${url}\n`);
       await maybeOpenExternal(url);
       if (authRelay) {
         authRelay.setAuthUrl(url);
         console.log("Waiting for authentication via the web relay...");
         const redirectUrl = await authRelay.waitForRedirectUrl();
-        if (redirectUrl && manualCodeResolve) {
-          manualCodeResolve(redirectUrl);
-          manualCodeResolve = undefined;
-        }
-      } else if (selected.usesCallbackServer && rl) {
+        if (redirectUrl) controller.submitManualCode(redirectUrl);
+      } else 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 && manualCodeResolve) {
-          manualCodeResolve(pasted);
-          manualCodeResolve = undefined;
-        }
+        if (pasted) controller.submitManualCode(pasted);
       }
     },
     onDeviceCode: async ({ userCode, verificationUri }) => {
@@ -240,15 +222,9 @@ async function runInternalPiLogin(provider, { rl = null, authRelay = null } = {}
     },
     onProgress: (message) => {
       console.log(message);
-    },
-    onManualCodeInput: () => manualCodePromise,
-  }).finally(() => {
-    if (manualCodeResolve) {
-      manualCodeResolve("");
-      manualCodeResolve = undefined;
     }
-    manualCodeReject = undefined;
   });
+  await login.promise;
 }
 
 export async function bootstrapIfNeeded({ force = false, cliConfigOverrides = {}, httpPort = 0, setHttpRequestHandler } = {}) {

package/src/transport/telegram/bot.js

@@ -3,7 +3,8 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml } from "./text-format.js";
-import { buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue } from "../../core/agent/auth-flow.js";
+import { buildPiAuthRecoveryBlockedMessage, buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue, getPiAuthStatus } from "../../core/agent/auth-flow.js";
+import { createPiOAuthLogin } from "../../core/agent/pi-auth-login.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 const slowPromptNoticeMs = 300_000;
@@ -247,8 +248,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   const bot = new Bot(config.telegram.token);
   const perChatState = new Map();
   const notifiedPromptErrors = new WeakSet();
+  const authRenewals = new Map();
+  let piAuthIssue = null;
   let taskTimer = null;
 
+  function chatKey(chatId) {
+    return String(chatId);
+  }
+
   function wasPromptErrorNotified(error) {
     return error instanceof Error && notifiedPromptErrors.has(error);
   }
@@ -257,8 +264,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (error instanceof Error) notifiedPromptErrors.add(error);
   }
 
-  async function notifyPiAuthIssueIfNeeded(chatId, error) {
+  function rememberPiAuthIssue(error) {
     const issue = getPiAuthIssue(error);
+    if (issue) piAuthIssue = issue;
+    return issue;
+  }
+
+  async function notifyPiAuthIssueIfNeeded(chatId, error) {
+    const issue = rememberPiAuthIssue(error);
     if (!issue) return false;
 
     try {
@@ -271,6 +284,84 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
   }
 
+  function selectTelegramLoginOption(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;
+  }
+
+  async function finishAuthRenewal(chatId, renewal) {
+    try {
+      await renewal.promise;
+      await agentManager.validatePiAgent();
+      agentManager.clearSessionCache(chatId);
+      piAuthIssue = null;
+      logger?.log("telegram", `Pi auth renewal completed for chat ${chatId}`);
+      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, verified: true }));
+    } catch (error) {
+      const issue = rememberPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
+      piAuthIssue = issue;
+      logger?.error("telegram", `Pi auth renewal failed for chat ${chatId}: ${getErrorMessage(error)}`);
+      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, issue })).catch((notifyError) => {
+        logger?.error("telegram", `auth renewal failure notice failed for chat ${chatId}: ${getErrorMessage(notifyError)}`);
+      });
+    } finally {
+      authRenewals.delete(chatKey(chatId));
+    }
+  }
+
+  async function startAuthRenewal(chatId) {
+    const key = chatKey(chatId);
+    const existing = authRenewals.get(key);
+    if (existing) {
+      return { started: false, renewal: existing };
+    }
+
+    const renewal = createPiOAuthLogin({
+      provider: config.pi.provider,
+      onSelect: async ({ message, options }) => {
+        const selected = selectTelegramLoginOption(options);
+        if (!selected) return undefined;
+        logger?.log("telegram", `Pi auth option for chat ${chatId}: ${selected.id}`);
+        await bot.api.sendMessage(chatId, `${message}\nUsing: ${selected.label || selected.id}`);
+        return selected.id;
+      },
+      onAuth: async ({ url, instructions }) => {
+        await bot.api.sendMessage(chatId, [
+          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 expiry = expiresInSeconds ? `\nExpires in ${Math.round(expiresInSeconds / 60)} minute(s).` : "";
+        await bot.api.sendMessage(chatId, `Open this URL: ${verificationUri}\nThen enter code: ${userCode}${expiry}`);
+      },
+      onPrompt: async ({ message, controller }) => {
+        await bot.api.sendMessage(chatId, `${message}\nReply here with the value.`);
+        return controller.waitForManualCode();
+      },
+      onProgress: (message) => {
+        if (message) logger?.log("telegram", `Pi auth progress for chat ${chatId}: ${message}`);
+      }
+    });
+
+    authRenewals.set(key, renewal);
+    finishAuthRenewal(chatId, renewal);
+    return { started: true, renewal };
+  }
+
+  async function submitAuthRenewalInput(ctx) {
+    const renewal = authRenewals.get(chatKey(ctx.chat.id));
+    const text = getIncomingMessageText(ctx.message).trim();
+    if (!renewal || !renewal.manualInputRequested || !text) return false;
+
+    if (!renewal.submitManualCode(text)) return false;
+    await ctx.reply("Got it. Finishing Pi login now...");
+    return true;
+  }
+
   function getIncomingChatMeta(ctx) {
     return {
       languageCode: ctx.from?.language_code || "",
@@ -523,22 +614,48 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   bot.command("new", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
+    if (piAuthIssue) {
+      await ctx.reply(buildPiAuthRecoveryBlockedMessage({
+        config,
+        issue: piAuthIssue,
+        renewalActive: authRenewals.has(chatKey(ctx.chat.id))
+      }));
+      return;
+    }
     await handleNewCommand(ctx);
   });
 
   bot.command("auth", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
-    await withTyping(ctx, async () => {
-      try {
-        await agentManager.validatePiAgent();
-        agentManager.clearSessionCache(ctx.chat.id);
-        await ctx.reply(buildPiAuthTelegramMessage({ config, verified: true }));
-      } catch (error) {
-        const issue = getPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
-        await ctx.reply(buildPiAuthTelegramMessage({ config, issue }));
-      }
-    });
+
+    const status = getPiAuthStatus(config);
+    if (status.hasApiKey || !status.supportsOAuth) {
+      await withTyping(ctx, async () => {
+        try {
+          await agentManager.validatePiAgent();
+          agentManager.clearSessionCache(ctx.chat.id);
+          piAuthIssue = null;
+          await ctx.reply(buildPiAuthTelegramMessage({ config, verified: true }));
+        } catch (error) {
+          const issue = rememberPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
+          piAuthIssue = issue;
+          await ctx.reply(buildPiAuthTelegramMessage({ config, issue }));
+        }
+      });
+      return;
+    }
+
+    try {
+      const { started } = await startAuthRenewal(ctx.chat.id);
+      await ctx.reply(started
+        ? "Starting Pi login from Telegram..."
+        : "Pi login is already in progress. Paste the redirect URL or code here when you have it.");
+    } catch (error) {
+      const issue = rememberPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
+      piAuthIssue = issue;
+      await ctx.reply(buildPiAuthTelegramMessage({ config, issue }));
+    }
   });
 
   bot.on("message", async (ctx) => {
@@ -548,6 +665,17 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     const command = getTelegramCommand(ctx);
     if (command) return;
 
+    if (await submitAuthRenewalInput(ctx)) return;
+
+    if (piAuthIssue) {
+      await ctx.reply(buildPiAuthRecoveryBlockedMessage({
+        config,
+        issue: piAuthIssue,
+        renewalActive: authRenewals.has(chatKey(ctx.chat.id))
+      }));
+      return;
+    }
+
     try {
       await enqueueOrProcess(ctx);
     } catch (error) {