arisa 4.1.2 → 4.1.6

package/package.json

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

package/src/runtime/bootstrap.js

@@ -98,13 +98,28 @@ function parseYesNo(value, fallback = true) {
   return null;
 }
 
-function buildInlineKeyboard(action, items) {
-  return {
-    inline_keyboard: items.map((item, index) => ([{
-      text: item.text,
-      callback_data: `${action}:${index}`
-    }]))
-  };
+function buildPagedInlineKeyboard(action, items, { page = 0, pageSize = 8 } = {}) {
+  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
+  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
+  const startIndex = currentPage * pageSize;
+  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
+    text: item.text,
+    callback_data: `${action}:${startIndex + index}`
+  }]));
+
+  if (pageCount > 1) {
+    const navigation = [];
+    if (currentPage > 0) {
+      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
+    }
+    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
+    if (currentPage < pageCount - 1) {
+      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
+    }
+    rows.push(navigation);
+  }
+
+  return { inline_keyboard: rows };
 }
 
 function getIncomingChatMeta(ctx) {
@@ -275,6 +290,17 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
     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) => {
@@ -295,24 +321,26 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
     });
   };
 
-  const askProvider = async () => {
+  const askProvider = async (ctx = null, page = 0) => {
     state = "provider";
-    await sendSetupMessage("Select the Pi provider Arisa should use:", {
-      reply_markup: buildInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })))
+    await showSetupPrompt(ctx, "Select the Pi provider Arisa should use:", {
+      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), { page })
     });
   };
 
-  const askModel = async () => {
+  const askModel = async (ctx = null, page = 0) => {
     state = "model";
     const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
-    await sendSetupMessage(`Select the model for ${selectedProvider.provider}:`, {
-      reply_markup: buildInlineKeyboard("model", models.map((model) => ({ text: formatModelOption(model) })))
+    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatModelOption(model) })), { page });
+    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 () => {
+  const askBackground = async (ctx = null) => {
     state = "background";
-    await sendSetupMessage("Bootstrap complete. Keep Arisa running in background now?", {
+    await showSetupPrompt(ctx, "Bootstrap complete. Keep Arisa running in background now?", {
       reply_markup: {
         inline_keyboard: [
           [{ text: "Yes, start in background", callback_data: "background:yes" }],
@@ -322,12 +350,14 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
     });
   };
 
-  const askApiKey = async () => {
+  const askApiKey = async (ctx = null) => {
     state = "pi-api-key";
-    await sendSetupMessage(`Send the Pi API key for ${selectedProvider.provider}.`);
+    await showSetupPrompt(ctx, `Send the Pi API key for ${selectedProvider.provider}.`, {
+      reply_markup: { inline_keyboard: [] }
+    });
   };
 
-  const askAuthMethod = async () => {
+  const askAuthMethod = async (ctx = null) => {
     const providerRuntime = createPiRuntime();
     const selectedAuthReady = hasProviderAuth(selectedProvider.provider, providerRuntime);
     const providerSupportsOAuth = supportsProviderOAuth(selectedProvider.provider, providerRuntime);
@@ -340,9 +370,10 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
       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 sendSetupMessage([
+    await showSetupPrompt(ctx, [
       `Selected model: ${selectedProvider.provider}/${selectedModel.id}`,
       `Existing Pi auth for ${selectedProvider.provider}: ${selectedAuthReady ? "yes" : "no"}`,
       "Choose how Arisa should authenticate Pi."
@@ -440,10 +471,35 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
     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();
+      await askModel(ctx);
       return;
     }
 
@@ -451,17 +507,17 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
       const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
       selectedModel = models[Number(rawValue)];
       if (!selectedModel) return;
-      await askAuthMethod();
+      await askAuthMethod(ctx);
       return;
     }
 
     if (action === "auth" && state === "auth-method") {
       if (rawValue === "existing") {
         if (hasProviderAuth(selectedProvider.provider, createPiRuntime())) {
-          await askBackground();
+          await askBackground(ctx);
         } else {
           await sendSetupMessage(`No existing Pi auth found for ${selectedProvider.provider}.`);
-          await askAuthMethod();
+          await askAuthMethod(ctx);
         }
         return;
       }
@@ -470,7 +526,7 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
         return;
       }
       if (rawValue === "key") {
-        await askApiKey();
+        await askApiKey(ctx);
         return;
       }
     }

package/src/runtime/ipc/ipc-server.js

@@ -11,6 +11,10 @@ function isStaleSocketError(error) {
   return ["ENOENT", "ECONNREFUSED"].includes(error?.code);
 }
 
+function isNamedPipe(socketPath) {
+  return typeof socketPath === "string" && /^\\\\[.?]\\pipe\\/i.test(socketPath);
+}
+
 async function hasLiveSocket(socketPath) {
   return new Promise((resolve, reject) => {
     const client = net.createConnection(socketPath);
@@ -52,14 +56,19 @@ export function createIpcServer({ capabilities, socketPath = arisaIpcSocketFile,
 
   async function start() {
     if (server) return { socketPath };
-    await mkdir(path.dirname(socketPath), { recursive: true });
+    const namedPipe = isNamedPipe(socketPath);
+    if (!namedPipe) {
+      await mkdir(path.dirname(socketPath), { recursive: true });
+    }
 
     if (await hasLiveSocket(socketPath)) {
       throw new Error(`Arisa IPC socket already in use: ${socketPath}`);
     }
-    await unlink(socketPath).catch((error) => {
-      if (error?.code !== "ENOENT") throw error;
-    });
+    if (!namedPipe) {
+      await unlink(socketPath).catch((error) => {
+        if (error?.code !== "ENOENT") throw error;
+      });
+    }
 
     server = net.createServer((socket) => {
       socket.setEncoding("utf8");
@@ -83,7 +92,9 @@ export function createIpcServer({ capabilities, socketPath = arisaIpcSocketFile,
       server.once("error", reject);
       server.listen(socketPath, resolve);
     });
-    await chmod(socketPath, 0o600).catch(() => {});
+    if (!namedPipe) {
+      await chmod(socketPath, 0o600).catch(() => {});
+    }
     logger?.log?.("ipc", `listening on ${socketPath}`);
     return { socketPath };
   }
@@ -93,9 +104,11 @@ export function createIpcServer({ capabilities, socketPath = arisaIpcSocketFile,
     const closingServer = server;
     server = null;
     await new Promise((resolve) => closingServer.close(resolve));
-    await unlink(socketPath).catch((error) => {
-      if (error?.code !== "ENOENT") throw error;
-    });
+    if (!isNamedPipe(socketPath)) {
+      await unlink(socketPath).catch((error) => {
+        if (error?.code !== "ENOENT") throw error;
+      });
+    }
   }
 
   return {

package/src/runtime/paths.js

@@ -1,4 +1,5 @@
 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";
@@ -9,7 +10,15 @@ export const stateDir = path.join(arisaHomeDir, "state");
 export const configFile = path.join(stateDir, "config.json");
 export const servicePidFile = path.join(stateDir, "arisa.pid");
 export const serviceLogFile = path.join(stateDir, "arisa.log");
-export const arisaIpcSocketFile = path.join(stateDir, "arisa.sock");
+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");

package/test/ipc-server.test.js

@@ -7,6 +7,7 @@ import test from "node:test";
 import { createArisaClient } from "../src/core/tools/ipc-client.js";
 import { createArisaCapabilities } from "../src/runtime/arisa-capabilities.js";
 import { createIpcServer } from "../src/runtime/ipc/ipc-server.js";
+import { createIpcSocketPath } from "../src/runtime/paths.js";
 
 function createFakeArtifactStore() {
   const stores = new Map();
@@ -67,6 +68,15 @@ function createCapabilities(overrides = {}) {
   });
 }
 
+test("uses a Windows named pipe for IPC on Windows", () => {
+  const socketPath = createIpcSocketPath({
+    homeDir: "C:\\Users\\Arisa\\.arisa",
+    platform: "win32"
+  });
+
+  assert.match(socketPath, /^\\\\\.\\pipe\\arisa-[a-f0-9]{16}$/);
+});
+
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }