arisa 4.3.5 → 5.1.2

package/test/service-manager.test.js

@@ -0,0 +1,237 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTelegramRestartHandler, telegramCommands } from "../src/transport/telegram/bot.js";
+import { handoffServiceRestart, restartService, serviceEntryFile, waitForServiceStop } from "../src/runtime/service-manager.js";
+
+test("registers maintenance as native Telegram commands", () => {
+  assert.equal(
+    telegramCommands.some((command) => command.command === "restart"),
+    true
+  );
+  assert.equal(telegramCommands.some((command) => command.command === "update"), true);
+  assert.equal(telegramCommands.some((command) => command.command === "tools"), true);
+  assert.ok(telegramCommands.every((command) => command.description.length <= 24));
+  assert.equal(telegramCommands.some((command) => command.command === "harness"), false);
+  assert.equal(telegramCommands.some((command) => command.command === "login"), false);
+});
+
+test("replies before handing restart to a detached CLI process", async () => {
+  const calls = [];
+  let unreferenced = false;
+  let logClosed = false;
+  const environment = { ARISA_TEST: "restart" };
+
+  const result = await handoffServiceRestart({
+    verbose: false,
+    cliArgs: ["--pi.model", "example/model"]
+  }, {
+    ensureHome: async () => { calls.push("ensure-home"); },
+    getStatus: async () => {
+      calls.push("get-status");
+      return { running: true, pid: 41 };
+    },
+    openLog: async (file, mode) => {
+      calls.push(["open-log", file, mode]);
+      return {
+        fd: 17,
+        close: async () => { logClosed = true; }
+      };
+    },
+    spawnProcess: (command, args, options) => {
+      calls.push(["spawn", command, args, options]);
+      return {
+        pid: 84,
+        unref: () => { unreferenced = true; }
+      };
+    },
+    environment,
+    currentPid: 41
+  });
+
+  assert.equal(calls[0], "ensure-home");
+  assert.equal(calls[1], "get-status");
+  assert.equal(calls[2][0], "open-log");
+  assert.equal(calls[2][2], "a");
+  assert.equal(calls[3][0], "spawn");
+  assert.equal(calls[3][1], process.execPath);
+  assert.deepEqual(calls[3][2], [
+    serviceEntryFile,
+    "restart",
+    "--pi.model",
+    "example/model",
+    "--silent"
+  ]);
+  assert.deepEqual(calls[3][3], {
+    detached: true,
+    stdio: ["ignore", 17, 17],
+    env: environment
+  });
+  assert.equal(unreferenced, true);
+  assert.equal(logClosed, true);
+  assert.equal(result.pid, 84);
+
+  const handlerCalls = [];
+  const handler = createTelegramRestartHandler({
+    authorize: async () => ({ ok: true }),
+    requestRestart: async () => {
+      handlerCalls.push("handoff");
+      return result;
+    }
+  });
+  const ctx = {
+    reply: async (text) => { handlerCalls.push(["reply", text]); }
+  };
+
+  await handler(ctx);
+  await handler(ctx);
+
+  assert.deepEqual(handlerCalls, [
+    ["reply", "Arisa is restarting. I'll be back shortly."],
+    "handoff",
+    ["reply", "An Arisa restart is already in progress."]
+  ]);
+});
+
+test("refuses Telegram restart handoff outside the active background service", async () => {
+  let spawned = false;
+
+  await assert.rejects(
+    handoffServiceRestart({}, {
+      ensureHome: async () => {},
+      getStatus: async () => ({ running: true, pid: 99 }),
+      spawnProcess: () => {
+        spawned = true;
+      },
+      currentPid: 41
+    }),
+    /requires the active background service process/
+  );
+
+  assert.equal(spawned, false);
+});
+
+test("reports a failed Telegram restart handoff and permits retry", async () => {
+  const replies = [];
+  let attempts = 0;
+  const handler = createTelegramRestartHandler({
+    authorize: async () => ({ ok: true }),
+    requestRestart: async () => {
+      attempts += 1;
+      if (attempts === 1) throw new Error("synthetic handoff failure");
+      return { pid: 84 };
+    }
+  });
+  const ctx = { reply: async (text) => { replies.push(text); } };
+
+  await handler(ctx);
+  await handler(ctx);
+
+  assert.equal(attempts, 2);
+  assert.deepEqual(replies, [
+    "Arisa is restarting. I'll be back shortly.",
+    "Arisa could not be restarted: synthetic handoff failure",
+    "Arisa is restarting. I'll be back shortly."
+  ]);
+});
+
+test("waits until the stopped service releases its PID before restarting", async () => {
+  const calls = [];
+  const statuses = [
+    { running: true, pid: 41 },
+    { running: true, pid: 41 },
+    { running: false, pid: null }
+  ];
+
+  const result = await restartService({
+    verbose: false,
+    cliArgs: ["--pi.model", "example/model"],
+    shutdownTimeoutMs: 1_000,
+    shutdownPollIntervalMs: 1
+  }, {
+    stop: async () => {
+      calls.push("stop");
+      return { ok: true, pid: 41 };
+    },
+    getStatus: async () => {
+      calls.push("status");
+      return statuses.shift();
+    },
+    start: async (options) => {
+      calls.push("start");
+      assert.deepEqual(options, {
+        verbose: false,
+        cliArgs: ["--pi.model", "example/model"]
+      });
+      return { ok: true, pid: 84, logFile: "/tmp/arisa.log" };
+    },
+    sleep: async () => {
+      calls.push("sleep");
+    }
+  });
+
+  assert.deepEqual(calls, ["stop", "status", "sleep", "status", "sleep", "status", "start"]);
+  assert.deepEqual(result, {
+    ok: true,
+    pid: 84,
+    previousPid: 41,
+    wasRunning: true,
+    logFile: "/tmp/arisa.log"
+  });
+});
+
+test("restart starts Arisa when it is not running", async () => {
+  let statusChecks = 0;
+  const result = await restartService({
+    shutdownTimeoutMs: 1_000,
+    shutdownPollIntervalMs: 1
+  }, {
+    stop: async () => ({ ok: false, reason: "not-running", pid: null }),
+    getStatus: async () => {
+      statusChecks += 1;
+      return { running: false, pid: null };
+    },
+    start: async () => ({ ok: true, pid: 84, logFile: "/tmp/arisa.log" })
+  });
+
+  assert.equal(statusChecks, 0);
+  assert.deepEqual(result, {
+    ok: true,
+    pid: 84,
+    previousPid: null,
+    wasRunning: false,
+    logFile: "/tmp/arisa.log"
+  });
+});
+
+test("restart does not start a second service when shutdown times out", async () => {
+  let started = false;
+
+  await assert.rejects(
+    restartService({
+      shutdownTimeoutMs: 2,
+      shutdownPollIntervalMs: 1
+    }, {
+      stop: async () => ({ ok: true, pid: 41 }),
+      getStatus: async () => ({ running: true, pid: 41 }),
+      start: async () => {
+        started = true;
+        return { ok: true, pid: 84 };
+      },
+      sleep: async () => {}
+    }),
+    /did not stop within 2ms/
+  );
+
+  assert.equal(started, false);
+});
+
+test("requires explicit positive shutdown timing policy", async () => {
+  await assert.rejects(
+    waitForServiceStop({ timeoutMs: 0, pollIntervalMs: 1 }),
+    /positive shutdownTimeoutMs/
+  );
+  await assert.rejects(
+    waitForServiceStop({ timeoutMs: 1, pollIntervalMs: 0 }),
+    /positive shutdownPollIntervalMs/
+  );
+});

package/test/task-store.test.js

@@ -59,6 +59,37 @@ test("claims only due pending tasks and marks them running", async () => {
   assert.equal((await store.get("done")).status, "done");
 });
 
+test("recovers interrupted running tasks for retry after restart", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const runAt = new Date(Date.now() - 1000).toISOString();
+
+  await store.add({ id: "interrupted-once", kind: "agent_task", runAt, status: "running" });
+  await store.add({
+    id: "interrupted-recurring",
+    kind: "poll_tool",
+    runAt,
+    status: "running",
+    recurrence: { type: "interval", everySeconds: 60 }
+  });
+  await store.add({ id: "still-pending", kind: "agent_task", runAt });
+  await store.add({ id: "already-done", kind: "agent_task", runAt, status: "done" });
+
+  const recovered = await store.recoverInterrupted();
+
+  assert.deepEqual(recovered.map((task) => task.id), ["interrupted-once", "interrupted-recurring"]);
+  assert.ok(recovered.every((task) => task.status === "pending"));
+  assert.ok(recovered.every((task) => task.runAt === runAt));
+  assert.equal((await store.get("still-pending")).status, "pending");
+  assert.equal((await store.get("already-done")).status, "done");
+
+  const restartedStore = new TaskStore();
+  assert.deepEqual(
+    (await restartedStore.claimDue()).map((task) => task.id),
+    ["interrupted-once", "interrupted-recurring", "still-pending"]
+  );
+});
+
 test("completes one-off tasks and re-schedules recurring interval tasks", async () => {
   await resetHome();
   const store = new TaskStore();

package/test/telegram-text-artifact.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { buildPrompt, shouldIncludeArtifactReference } from "../src/transport/telegram/bot.js";
+import { buildPrompt, buildReactionPrompt, shouldIncludeArtifactReference } from "../src/transport/telegram/bot.js";
 import { captureIncomingArtifact } from "../src/transport/telegram/media.js";
 
 function createTextContext(text = "hello") {
@@ -60,6 +60,41 @@ test("keeps distinct artifacts visible to the prompt", () => {
   );
 });
 
+test("surfaces Telegram forwarding provenance in the prompt", () => {
+  const ctx = createTextContext("forwarded text");
+  ctx.message.forward_origin = {
+    type: "user",
+    sender_user: { id: 999, username: "source_user", first_name: "Source" },
+    date: 1_786_570_000
+  };
+
+  const prompt = buildPrompt({ ctx });
+
+  assert.match(prompt, /forwarded: true/);
+  assert.match(prompt, /forwardedOriginType: user/);
+  assert.match(prompt, /forwardedFrom: @source_user/);
+  assert.match(prompt, /forwardedAt: 2026-/);
+});
+
+test("formats Telegram reaction changes as lightweight feedback", () => {
+  const prompt = buildReactionPrompt({
+    reaction: {
+      chat: { id: 123 },
+      user: { id: 456, username: "martin", first_name: "Martin" },
+      message_id: 321,
+      old_reaction: [{ type: "emoji", emoji: "👍" }],
+      new_reaction: [{ type: "emoji", emoji: "❤️" }]
+    },
+    reactedMessageText: "Updated draft intro"
+  });
+
+  assert.match(prompt, /reactedMessageId: 321/);
+  assert.match(prompt, /reactedMessageText: Updated draft intro/);
+  assert.match(prompt, /addedReactions: ❤️/);
+  assert.match(prompt, /removedReactions: 👍/);
+  assert.match(prompt, /otherwise stay silent/);
+});
+
 test("marks incoming Telegram text artifacts as internal inline messages", async () => {
   const calls = [];
   const artifactStore = {

package/test/tool-registry-run.test.js

@@ -155,12 +155,33 @@ test("runs a registered tool process with an enriched request and cleans up requ
   });
   assert.equal(result.output.env.ARISA_PACKAGE_DIR, arisaPackageDir);
   assert.equal(result.output.env.ARISA_IPC_SOCKET, arisaIpcSocketFile);
+  assert.deepEqual(await registry.usage("chat-1"), [{ name: "fake-tool", count: 1 }]);
 
   const requestFile = result.output.requestFile;
   await assert.rejects(() => access(requestFile), { code: "ENOENT" });
   await assert.rejects(() => access(path.dirname(requestFile)), { code: "ENOENT" });
 });
 
+test("keeps concurrent requests to the same tool isolated", async () => {
+  await resetHome();
+  await createFakeTool("fake-tool");
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  const results = await Promise.all(Array.from({ length: 12 }, (_, index) => registry.run({
+    name: "fake-tool",
+    chatId: "chat-1",
+    request: { text: `request-${index}`, args: { index } }
+  })));
+
+  assert.deepEqual(
+    results.map((result) => result.output.request.text).sort(),
+    Array.from({ length: 12 }, (_, index) => `request-${index}`).sort()
+  );
+  assert.equal(new Set(results.map((result) => result.output.requestFile)).size, 12);
+});
+
 test("rejects unknown tools", async () => {
   await resetHome();
   const registry = new ToolRegistry();

package/test/tool-usage.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { ToolUsageStore } from "../src/core/tools/tool-usage-store.js";
+import { formatToolUsageReport } from "../src/runtime/tool-usage-report.js";
+
+test("counts concurrent tool uses per chat", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-tool-usage-"));
+  const store = new ToolUsageStore({ resolveFile: (chatId) => path.join(root, String(chatId), "usage.json") });
+  try {
+    await Promise.all([
+      store.record("chat-1", "gmail-workspace"),
+      store.record("chat-1", "gmail-workspace"),
+      store.record("chat-1", "x-reader"),
+      store.record("chat-2", "gmail-workspace")
+    ]);
+    assert.deepEqual(await store.counts("chat-1"), {
+      "gmail-workspace": 2,
+      "x-reader": 1
+    });
+    assert.deepEqual(await store.counts("chat-2"), { "gmail-workspace": 1 });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("formats narrow tool usage counts", () => {
+  const report = formatToolUsageReport([
+    { name: "campaign-draft-runner", count: 12 },
+    { name: "gmail-workspace", count: 3 }
+  ]);
+  assert.match(report, /campaign-draft-runner\s+12/);
+  assert.match(report, /gmail-workspace\s+3/);
+  assert.ok(report.split("\n").every((line) => [...line].length <= 35));
+});

package/test/update-manager.test.js

@@ -0,0 +1,87 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { compareVersions, formatUpdateReport } from "../src/runtime/update-manager.js";
+
+test("compares semantic versions", () => {
+  assert.equal(compareVersions("5.0.2", "5.0.3"), -1);
+  assert.equal(compareVersions("5.1.0", "5.0.9"), 1);
+  assert.equal(compareVersions("5.0.2", "5.0.2"), 0);
+  assert.equal(compareVersions("invalid", "5.0.2"), null);
+});
+
+test("formats core and official tool update status", () => {
+  assert.equal(formatUpdateReport({
+    core: { currentVersion: "5.0.2", latestVersion: "5.1.0", updateAvailable: true },
+    bootstrapInstalled: ["official-tool-sync"],
+    tools: {
+      installedOfficial: 3,
+      official: [
+        { name: "context-vault", status: "up-to-date" },
+        { name: "customized", status: "diverged" },
+        { name: "gmail-workspace", status: "upstream-update" }
+      ],
+      nonOfficial: ["private-helper"],
+      counts: { "up-to-date": 1, "upstream-update": 1, diverged: 1 },
+      updateable: ["context-vault"],
+      blocked: [{ name: "customized", status: "diverged" }]
+    }
+  }), [
+    "```text",
+    "Arisa update",
+    "============",
+    "Core",
+    "  Current    5.0.2",
+    "  Latest     5.1.0",
+    "  Status     update available",
+    "",
+    "Official tools",
+    "  Installed  3",
+    "  up-to-date           1",
+    "  upstream-update      1",
+    "  diverged             1",
+    "",
+    "Official (3)",
+    "  - context-vault",
+    "  - customized [diverged]",
+    "  - gmail-workspace",
+    "    [upstream-update]",
+    "",
+    "Non-official (1)",
+    "  - private-helper",
+    "",
+    "Safe updates",
+    "  - context-vault",
+    "",
+    "Needs review",
+    "  - customized",
+    "    [diverged]",
+    "",
+    "Update support installed",
+    "  - official-tool-sync",
+    "```"
+  ].join("\n"));
+});
+
+test("shortens long review status labels", () => {
+  const report = formatUpdateReport({
+    core: { currentVersion: "5.0.2", latestVersion: "5.0.2", updateAvailable: false },
+    bootstrapInstalled: [],
+    tools: {
+      installedOfficial: 2,
+      official: [
+        { name: "audio-extractor", status: "locally-modified" },
+        { name: "campaign-draft-runner", status: "untracked-difference" }
+      ],
+      nonOfficial: [],
+      counts: {},
+      updateable: [],
+      blocked: [
+        { name: "audio-extractor", status: "locally-modified" },
+        { name: "campaign-draft-runner", status: "untracked-difference" }
+      ]
+    }
+  });
+  assert.match(report, /audio-extractor\n    \[local\]/);
+  assert.match(report, /campaign-draft-runner\n    \[untracked\]/);
+  assert.ok(report.split("\n").every((line) => [...line].length <= 35));
+});