arisa 5.1.11 → 5.1.12

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "arisa",
-  "version": "5.1.11",
+  "version": "5.1.12",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "arisa": "bin/arisa.js"
   },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap",
+    "test": "node --test"
+  },
   "keywords": [
     "telegram",
     "pi-agent",
@@ -39,15 +44,11 @@
     "url": "https://github.com/clasen/Arisa/issues"
   },
   "homepage": "https://arisa.sh",
+  "packageManager": "pnpm@11.3.0+sha512.2c403d6594527287672b1f7056343a1f7c3634036a67ffabfcc2b3d7595d843768f8787148d1b57cf7956c90606bbd192857c363af19e96d2d0ec9ec5741d215",
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.80.6",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0",
     "typebox": "1.1.38"
-  },
-  "scripts": {
-    "start": "node src/index.js",
-    "bootstrap": "node src/index.js --bootstrap",
-    "test": "node --test"
   }
-}
+}

package/src/runtime/create-app.js

@@ -11,7 +11,7 @@ import { createIpcServer } from "./ipc/ipc-server.js";
 import { getAgentConfig } from "../core/agent/model-selection.js";
 import { normalizeModelSpeed } from "../core/agent/model-speed.js";
 import { runDoctor } from "./doctor.js";
-import { checkForUpdates, formatUpdateReport } from "./update-manager.js";
+import { checkForUpdates, installCoreUpdate, updateOfficialTools } from "./update-manager.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -146,7 +146,9 @@ export async function createApp({ logger, runtimeOverrides, requestRestart } = {
       },
       logger
     }),
-    checkUpdates: async (chatId) => formatUpdateReport(await checkForUpdates({ chatId, toolRegistry })),
+    checkUpdates: async (chatId) => checkForUpdates({ chatId, toolRegistry }),
+    updateCore: async (targetVersion) => installCoreUpdate({ targetVersion }),
+    updateTools: async (chatId) => updateOfficialTools({ chatId, toolRegistry }),
     requestRestart,
     logger
   });

package/src/runtime/update-manager.js

@@ -58,6 +58,32 @@ async function fetchLatestVersion() {
   return version;
 }
 
+export async function installCoreUpdate({ targetVersion }, {
+  readVersion = readCurrentVersion,
+  fetchVersion = fetchLatestVersion,
+  execute = runCommand
+} = {}) {
+  if (!parseSemver(targetVersion)) throw new Error("Invalid Arisa update version");
+  const [currentVersion, latestVersion] = await Promise.all([readVersion(), fetchVersion()]);
+  if (targetVersion !== latestVersion) {
+    throw new Error(`Arisa ${latestVersion} is now the latest version. Run /update again.`);
+  }
+  if (compareVersions(currentVersion, latestVersion) !== -1) {
+    return { updated: false, currentVersion, latestVersion };
+  }
+
+  await execute("npm", ["install", "--global", `arisa@${latestVersion}`]);
+  const installedVersion = await readVersion();
+  if (installedVersion !== latestVersion) {
+    throw new Error(`npm completed, but Arisa is still ${installedVersion} instead of ${latestVersion}`);
+  }
+  return {
+    updated: true,
+    previousVersion: currentVersion,
+    currentVersion: installedVersion
+  };
+}
+
 async function cloneCatalog(scratchRoot) {
   const repoDir = path.join(scratchRoot, "repo");
   await runCommand("git", ["clone", "--depth", "1", "--branch", defaultBranch, "--", defaultRepoUrl, repoDir], { cwd: scratchRoot, timeoutMs: 180_000 });
@@ -156,6 +182,23 @@ export async function checkForUpdates({ chatId, toolRegistry }) {
   };
 }
 
+export async function updateOfficialTools({ chatId, toolRegistry }) {
+  try {
+    const result = await toolRegistry.run({
+      name: "official-tool-sync",
+      chatId,
+      request: { args: { action: "update-safe" } }
+    });
+    const sync = parseToolSyncOutput(result);
+    return {
+      updated: (sync.updates || []).filter((item) => item.action === "updated").map((item) => item.name),
+      skipped: (sync.skipped || []).map(({ name, status }) => ({ name, status }))
+    };
+  } finally {
+    await toolRegistry.load();
+  }
+}
+
 function shortToolStatus(status) {
   return ({
     "locally-modified": "local",

package/src/transport/telegram/bot.js

@@ -16,6 +16,8 @@ import { ConversationHistoryStore } from "../../core/conversation/conversation-h
 import { formatDoctorReport } from "../../runtime/doctor.js";
 import { formatToolUsageReport } from "../../runtime/tool-usage-report.js";
 import { ToolResourceNoteStore } from "../../core/tools/tool-resource-note-store.js";
+import { formatUpdateReport } from "../../runtime/update-manager.js";
+import { buildUpdatePicker, createTelegramUpdateCallbackHandler } from "./update-command.js";
 
 const slowPromptNoticeMs = 300_000;
 
@@ -23,7 +25,7 @@ export const telegramCommands = Object.freeze([
   { command: "new", description: "New chat context" },
   { command: "restart", description: "Restart Arisa" },
   { command: "doctor", description: "Check runtime health" },
-  { command: "update", description: "Check for updates" },
+  { command: "update", description: "Check and apply updates" },
   { command: "tools", description: "Tool usage counts" },
   { command: "model", description: "Choose chat model" },
   { command: "effort", description: "Choose reasoning effort" },
@@ -568,7 +570,7 @@ export async function closeModelPicker(ctx, { messageText, callbackText }) {
   await ctx.answerCallbackQuery({ text: callbackText });
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, doctor, checkUpdates, requestRestart, logger }) {
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, doctor, checkUpdates, updateCore, updateTools, requestRestart, logger }) {
   const resourceNotes = new ToolResourceNoteStore();
   const bot = new Bot(config.telegram.token);
   const perChatState = createChatStateStore();
@@ -588,6 +590,18 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     requestRestart,
     logger
   });
+  const handleUpdateCallback = createTelegramUpdateCallbackHandler({
+    authorize: (ctx) => authorizeChat({
+      config,
+      chatId: ctx.chat.id,
+      saveConfig,
+      chatMeta: getIncomingChatMeta(ctx)
+    }),
+    updateCore,
+    updateTools,
+    requestRestart,
+    logger
+  });
 
   function chatKey(chatId) {
     return String(chatId);
@@ -1272,11 +1286,13 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (!auth.ok) return;
     const pending = await ctx.reply(renderTelegramHtml("```text\nChecking Arisa and official tool updates…\n```"), { parse_mode: "HTML" });
     try {
+      const report = await checkUpdates(ctx.chat.id);
+      const picker = buildUpdatePicker(report);
       await ctx.api.editMessageText(
         ctx.chat.id,
         pending.message_id,
-        renderTelegramHtml(await checkUpdates(ctx.chat.id)),
-        { parse_mode: "HTML" }
+        renderTelegramHtml(formatUpdateReport(report)),
+        { parse_mode: "HTML", reply_markup: picker.replyMarkup }
       );
     } catch (error) {
       logger?.error("update", `update check failed: ${getErrorMessage(error)}`);
@@ -1342,6 +1358,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   });
 
   bot.on("callback_query:data", async (ctx, next) => {
+    if (await handleUpdateCallback(ctx)) return;
     const modelAction = parseModelPickerAction(ctx.callbackQuery.data);
     const effortAction = modelAction ? null : parseEffortPickerAction(ctx.callbackQuery.data);
     const speedAction = modelAction || effortAction ? null : parseSpeedPickerAction(ctx.callbackQuery.data);

package/src/transport/telegram/update-command.js

@@ -0,0 +1,122 @@
+const callbackPrefix = "arisa-update:";
+
+function callbackMessage(ctx) {
+  return {
+    chatId: ctx.chat.id,
+    messageId: ctx.callbackQuery.message.message_id
+  };
+}
+
+async function editCallbackMessage(ctx, text, extra) {
+  const { chatId, messageId } = callbackMessage(ctx);
+  return extra
+    ? ctx.api.editMessageText(chatId, messageId, text, extra)
+    : ctx.api.editMessageText(chatId, messageId, text);
+}
+
+export function buildUpdatePicker(report) {
+  const rows = [];
+  if (report.core.updateAvailable) {
+    rows.push([{
+      text: `Update Arisa → ${report.core.latestVersion}`,
+      callback_data: `${callbackPrefix}core:${report.core.latestVersion}`
+    }]);
+  }
+  if (report.tools.updateable.length) {
+    rows.push([{
+      text: `Update safe tools (${report.tools.updateable.length})`,
+      callback_data: `${callbackPrefix}tools`
+    }]);
+  }
+  rows.push(rows.length
+    ? [{ text: "Not now", callback_data: `${callbackPrefix}close` }]
+    : [{ text: "Up to date", callback_data: `${callbackPrefix}noop` }]);
+  return { replyMarkup: { inline_keyboard: rows } };
+}
+
+export function parseUpdateAction(data) {
+  if (data === `${callbackPrefix}tools`) return { type: "tools" };
+  if (data === `${callbackPrefix}close`) return { type: "close" };
+  if (data === `${callbackPrefix}noop`) return { type: "noop" };
+  const core = String(data || "").match(/^arisa-update:core:(\d+\.\d+\.\d+)$/);
+  return core ? { type: "core", targetVersion: core[1] } : null;
+}
+
+export function formatOfficialToolUpdateResult(result) {
+  const lines = result.updated.length
+    ? ["Updated official tools:", ...result.updated.map((name) => `- ${name}`)]
+    : ["Official tools were already up to date."];
+  if (result.skipped.length) {
+    lines.push("", "Not changed (needs review):");
+    for (const item of result.skipped) lines.push(`- ${item.name} [${item.status}]`);
+  }
+  return lines.join("\n");
+}
+
+export function createTelegramUpdateCallbackHandler({ authorize, updateCore, updateTools, requestRestart, logger }) {
+  let updateInProgress = false;
+
+  return async function handleTelegramUpdateCallback(ctx) {
+    const action = parseUpdateAction(ctx.callbackQuery.data);
+    if (!action) return false;
+
+    const auth = await authorize(ctx);
+    if (!auth.ok) {
+      await ctx.answerCallbackQuery({ text: "This chat is not authorized.", show_alert: true });
+      return true;
+    }
+    if (action.type === "noop") {
+      await ctx.answerCallbackQuery({ text: "Arisa and official tools are up to date." });
+      return true;
+    }
+    if (action.type === "close") {
+      await ctx.answerCallbackQuery();
+      await editCallbackMessage(ctx, "Update cancelled.");
+      return true;
+    }
+    if (updateInProgress) {
+      await ctx.answerCallbackQuery({ text: "An update is already in progress.", show_alert: true });
+      return true;
+    }
+
+    updateInProgress = true;
+    const coreUpdate = action.type === "core";
+    try {
+      await ctx.answerCallbackQuery({ text: coreUpdate ? "Updating Arisa…" : "Updating safe tools…" });
+      if (coreUpdate) {
+        await editCallbackMessage(ctx, `Updating Arisa to ${action.targetVersion}…`);
+        const result = await updateCore(action.targetVersion);
+        if (!result.updated) {
+          await editCallbackMessage(ctx, `Arisa ${result.currentVersion} is already up to date.`);
+          return true;
+        }
+        await editCallbackMessage(
+          ctx,
+          `Arisa updated from ${result.previousVersion} to ${result.currentVersion}. Restarting…`
+        );
+        try {
+          await requestRestart();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger?.error("update", `restart after update failed: ${message}`);
+          await editCallbackMessage(
+            ctx,
+            `Arisa updated to ${result.currentVersion}, but restart failed: ${message}\nRun /restart to activate it.`
+          );
+        }
+        return true;
+      }
+
+      await editCallbackMessage(ctx, "Updating safe official tools…");
+      await editCallbackMessage(ctx, formatOfficialToolUpdateResult(await updateTools(ctx.chat.id)));
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger?.error("update", `update action failed: ${message}`);
+      await editCallbackMessage(ctx, `Arisa update failed: ${message}`).catch(() => {});
+      return true;
+    } finally {
+      updateInProgress = false;
+    }
+  };
+}

package/test/update-command.test.js

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildUpdatePicker,
+  createTelegramUpdateCallbackHandler,
+  parseUpdateAction
+} from "../src/transport/telegram/update-command.js";
+
+function report(overrides = {}) {
+  return {
+    core: { currentVersion: "5.0.2", latestVersion: "5.1.0", updateAvailable: true },
+    bootstrapInstalled: [],
+    tools: {
+      installedOfficial: 2,
+      official: [],
+      nonOfficial: [],
+      counts: {},
+      updateable: ["context-vault", "gmail-workspace"],
+      blocked: []
+    },
+    ...overrides
+  };
+}
+
+test("offers only available update actions", () => {
+  assert.deepEqual(buildUpdatePicker(report()).replyMarkup.inline_keyboard, [
+    [{ text: "Update Arisa → 5.1.0", callback_data: "arisa-update:core:5.1.0" }],
+    [{ text: "Update safe tools (2)", callback_data: "arisa-update:tools" }],
+    [{ text: "Not now", callback_data: "arisa-update:close" }]
+  ]);
+
+  assert.deepEqual(buildUpdatePicker(report({
+    core: { currentVersion: "5.1.0", latestVersion: "5.1.0", updateAvailable: false },
+    tools: { ...report().tools, updateable: [] }
+  })).replyMarkup.inline_keyboard, [
+    [{ text: "Up to date", callback_data: "arisa-update:noop" }]
+  ]);
+});
+
+test("parses only valid update callback data", () => {
+  assert.deepEqual(parseUpdateAction("arisa-update:core:5.1.0"), { type: "core", targetVersion: "5.1.0" });
+  assert.deepEqual(parseUpdateAction("arisa-update:tools"), { type: "tools" });
+  assert.deepEqual(parseUpdateAction("arisa-update:close"), { type: "close" });
+  assert.deepEqual(parseUpdateAction("arisa-update:noop"), { type: "noop" });
+  assert.equal(parseUpdateAction("arisa-update:core:latest"), null);
+  assert.equal(parseUpdateAction("model:1"), null);
+});
+
+test("applies a confirmed core update and then requests restart", async () => {
+  const calls = [];
+  const handler = createTelegramUpdateCallbackHandler({
+    authorize: async () => ({ ok: true }),
+    updateCore: async (targetVersion) => {
+      calls.push(["updateCore", targetVersion]);
+      return { updated: true, previousVersion: "5.0.2", currentVersion: targetVersion };
+    },
+    updateTools: async () => assert.fail("must not update tools"),
+    requestRestart: async () => { calls.push("restart"); }
+  });
+  const ctx = {
+    chat: { id: 42 },
+    callbackQuery: { data: "arisa-update:core:5.1.0", message: { message_id: 7 } },
+    answerCallbackQuery: async (payload) => { calls.push(["answer", payload]); },
+    api: {
+      editMessageText: async (...args) => { calls.push(["edit", ...args]); }
+    }
+  };
+
+  assert.equal(await handler(ctx), true);
+  assert.deepEqual(calls, [
+    ["answer", { text: "Updating Arisa…" }],
+    ["edit", 42, 7, "Updating Arisa to 5.1.0…"],
+    ["updateCore", "5.1.0"],
+    ["edit", 42, 7, "Arisa updated from 5.0.2 to 5.1.0. Restarting…"],
+    "restart"
+  ]);
+});
+
+test("uses official-tool-sync for the confirmed safe tool action", async () => {
+  const calls = [];
+  const handler = createTelegramUpdateCallbackHandler({
+    authorize: async () => ({ ok: true }),
+    updateCore: async () => assert.fail("must not update core"),
+    updateTools: async (chatId) => {
+      calls.push(["updateTools", chatId]);
+      return {
+        updated: ["context-vault"],
+        skipped: [{ name: "customized", status: "locally-modified" }]
+      };
+    },
+    requestRestart: async () => assert.fail("tool updates do not restart Arisa")
+  });
+  const ctx = {
+    chat: { id: 42 },
+    callbackQuery: { data: "arisa-update:tools", message: { message_id: 7 } },
+    answerCallbackQuery: async (payload) => { calls.push(["answer", payload]); },
+    api: {
+      editMessageText: async (...args) => { calls.push(["edit", ...args]); }
+    }
+  };
+
+  assert.equal(await handler(ctx), true);
+  assert.deepEqual(calls, [
+    ["answer", { text: "Updating safe tools…" }],
+    ["edit", 42, 7, "Updating safe official tools…"],
+    ["updateTools", 42],
+    ["edit", 42, 7, [
+      "Updated official tools:",
+      "- context-vault",
+      "",
+      "Not changed (needs review):",
+      "- customized [locally-modified]"
+    ].join("\n")]
+  ]);
+});
+
+test("reports restart failure separately after a successful core update", async () => {
+  const edits = [];
+  const handler = createTelegramUpdateCallbackHandler({
+    authorize: async () => ({ ok: true }),
+    updateCore: async () => ({ updated: true, previousVersion: "5.0.2", currentVersion: "5.1.0" }),
+    updateTools: async () => assert.fail("must not update tools"),
+    requestRestart: async () => { throw new Error("not running as a service"); }
+  });
+  const ctx = {
+    chat: { id: 42 },
+    callbackQuery: { data: "arisa-update:core:5.1.0", message: { message_id: 7 } },
+    answerCallbackQuery: async () => {},
+    api: {
+      editMessageText: async (_chatId, _messageId, text) => { edits.push(text); }
+    }
+  };
+
+  assert.equal(await handler(ctx), true);
+  assert.equal(edits.at(-1), [
+    "Arisa updated to 5.1.0, but restart failed: not running as a service",
+    "Run /restart to activate it."
+  ].join("\n"));
+});

package/test/update-manager.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { compareVersions, formatUpdateReport } from "../src/runtime/update-manager.js";
+import { compareVersions, formatUpdateReport, installCoreUpdate, updateOfficialTools } from "../src/runtime/update-manager.js";
 
 test("compares semantic versions", () => {
   assert.equal(compareVersions("5.0.2", "5.0.3"), -1);
@@ -85,3 +85,59 @@ test("shortens long review status labels", () => {
   assert.match(report, /campaign-draft-runner\n    \[untracked\]/);
   assert.ok(report.split("\n").every((line) => [...line].length <= 35));
 });
+
+test("installs only the currently published core update and verifies it", async () => {
+  const calls = [];
+  const versions = ["5.0.2", "5.1.0"];
+  const result = await installCoreUpdate({ targetVersion: "5.1.0" }, {
+    readVersion: async () => versions.shift(),
+    fetchVersion: async () => "5.1.0",
+    execute: async (...args) => { calls.push(args); }
+  });
+
+  assert.deepEqual(calls, [["npm", ["install", "--global", "arisa@5.1.0"]]]);
+  assert.deepEqual(result, {
+    updated: true,
+    previousVersion: "5.0.2",
+    currentVersion: "5.1.0"
+  });
+});
+
+test("refuses a stale core update button", async () => {
+  await assert.rejects(
+    installCoreUpdate({ targetVersion: "5.1.0" }, {
+      readVersion: async () => "5.0.2",
+      fetchVersion: async () => "5.1.1",
+      execute: async () => assert.fail("must not install a stale target")
+    }),
+    /Run \/update again/
+  );
+});
+
+test("updates only safe official tools and reloads the registry", async () => {
+  const calls = [];
+  const toolRegistry = {
+    async run(request) {
+      calls.push(request);
+      return {
+        ok: true,
+        output: {
+          json: {
+            updates: [{ name: "context-vault", action: "updated" }],
+            skipped: [{ name: "customized", status: "locally-modified" }]
+          }
+        }
+      };
+    },
+    async load() { calls.push("load"); }
+  };
+
+  assert.deepEqual(await updateOfficialTools({ chatId: 42, toolRegistry }), {
+    updated: ["context-vault"],
+    skipped: [{ name: "customized", status: "locally-modified" }]
+  });
+  assert.deepEqual(calls, [
+    { name: "official-tool-sync", chatId: 42, request: { args: { action: "update-safe" } } },
+    "load"
+  ]);
+});