arisa 5.1.49 → 5.1.64

package/test/telegram-tools-command.test.js

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTelegramToolsCommandHandler } from "../src/transport/telegram/telegram-tools-command.js";
+
+test("/tools shows typing and sends the scoped usage report", async () => {
+  const events = [];
+  const handler = createTelegramToolsCommandHandler({
+    authorize: async () => ({ ok: true }),
+    contextRoute: () => ({ scopeChatId: 879964957 }),
+    toolRegistry: {
+      usage: async (chatId) => {
+        assert.equal(chatId, 879964957);
+        return [{ name: "example", count: 2, official: true }];
+      }
+    },
+    withTyping: async (_ctx, work) => {
+      events.push("typing");
+      return work();
+    },
+    logger: null
+  });
+  const ctx = {
+    chat: { id: 879964957 },
+    reply: async (text, options) => events.push({ text, options })
+  };
+
+  await handler(ctx);
+
+  assert.equal(events[0], "typing");
+  assert.match(events[1].text, /example/);
+  assert.deepEqual(events[1].options, { parse_mode: "HTML" });
+});
+
+test("/tools reports failures instead of disappearing", async () => {
+  const replies = [];
+  const handler = createTelegramToolsCommandHandler({
+    authorize: async () => ({ ok: true }),
+    contextRoute: () => ({ scopeChatId: 1 }),
+    toolRegistry: { usage: async () => { throw new Error("store unavailable"); } },
+    withTyping: async (_ctx, work) => work(),
+    logger: null
+  });
+
+  await handler({ chat: { id: 1 }, reply: async (text) => replies.push(text) });
+
+  assert.deepEqual(replies, ["Tool usage report failed: store unavailable"]);
+});

package/test/telegram-workspace-topic-store.test.js

@@ -0,0 +1,124 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import {
+  migrateLegacyReplyTopics,
+  WorkspaceTopicStore
+} from "../src/transport/telegram/workspace-topic-store.js";
+
+async function fixture(now = Date.parse("2026-08-24T12:00:00.000Z")) {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-workspace-topics-"));
+  const file = path.join(directory, "topics.json");
+  return {
+    file,
+    store: new WorkspaceTopicStore({ resolveFile: () => file, now: () => now }),
+    cleanup: () => rm(directory, { recursive: true, force: true })
+  };
+}
+
+test("workspace topics are learned, renamed, closed, and reopened dynamically", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    const route = {
+      workspace: true,
+      ownerChatId: 42,
+      transportChatId: -100123,
+      topicThreadId: 25,
+      generalTopicId: 1
+    };
+    await store.observeMessage(route, { forum_topic_created: { name: "Research" } });
+    assert.equal((await store.listTopics(42, -100123))[0].name, "Research");
+
+    await store.observeMessage(route, { forum_topic_edited: { name: "Research Lab" } });
+    assert.equal((await store.listTopics(42, -100123))[0].name, "Research Lab");
+
+    await store.observeMessage(route, { forum_topic_closed: {} });
+    assert.deepEqual(await store.listTopics(42, -100123), []);
+    assert.equal((await store.listTopics(42, -100123, { includeClosed: true }))[0].status, "closed");
+
+    await store.observeMessage(route, { forum_topic_reopened: {} });
+    assert.equal((await store.listTopics(42, -100123))[0].status, "open");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("Arisa topic initialization persists semantic context", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    await store.upsertTopic(42, -100123, {
+      threadId: 114,
+      name: "CORE",
+      description: "Arisa runtime and Telegram engineering",
+      source: "arisa-initialized"
+    });
+    assert.deepEqual((await store.listTopics(42, -100123)).map(({ threadId, name, description, source }) => ({
+      threadId,
+      name,
+      description,
+      source
+    })), [{
+      threadId: 114,
+      name: "CORE",
+      description: "Arisa runtime and Telegram engineering",
+      source: "arisa-initialized"
+    }]);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("concurrent topic updates preserve every workspace entry", async () => {
+  const { store, file, cleanup } = await fixture();
+  try {
+    await Promise.all(Array.from({ length: 30 }, (_, index) => store.upsertTopic(42, -100123, {
+      threadId: index + 2,
+      name: `Topic ${index + 2}`
+    })));
+    assert.equal((await store.listTopics(42, -100123)).length, 30);
+    assert.equal(JSON.parse(await readFile(file, "utf8")).version, 1);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("legacy configured topics migrate once into dynamic state", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    const config = {
+      telegram: {
+        ownerWorkspaceGroups: {
+          "-100123": {
+            ownerChatId: 42,
+            generalTopicId: 1,
+            replyTopics: {
+              "1": { name: "General" },
+              "23": { name: "Stories", description: "Editorial work" }
+            }
+          }
+        }
+      }
+    };
+    assert.equal(await migrateLegacyReplyTopics(config, store), 1);
+    assert.equal(config.telegram.ownerWorkspaceGroups["-100123"].replyTopics, undefined);
+    assert.deepEqual((await store.listTopics(42, -100123)).map((topic) => topic.name), ["Stories"]);
+    assert.equal(await migrateLegacyReplyTopics(config, store), 0);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("recent proposals are deduplicated and scoped by supergroup", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    await store.recordProposal(42, -100123, "Research Lab");
+    await store.recordProposal(42, -100123, "research lab");
+    await store.recordProposal(42, -100999, "Another Group");
+    assert.deepEqual((await store.listRecentProposals(42, -100123)).map((item) => item.name), ["research lab"]);
+    assert.deepEqual((await store.listRecentProposals(42, -100999)).map((item) => item.name), ["Another Group"]);
+  } finally {
+    await cleanup();
+  }
+});

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

@@ -157,6 +157,22 @@ test("lists optional semantic metadata with stable defaults", async () => {
 
   assert.equal(registry.list()[0].category, null);
   assert.deepEqual(registry.list()[0].keywords, []);
+  assert.equal(registry.get("fake-tool").execution, null);
+});
+
+test("loads weighted execution metadata from the tool manifest", async () => {
+  await resetHome();
+  await createFakeTool("heavy-tool", {
+    execution: { resourceClass: "browser", weight: 2 }
+  });
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  assert.deepEqual(registry.get("heavy-tool").execution, {
+    resourceClass: "browser",
+    weight: 2
+  });
 });
 
 test("shows semantic metadata in tool help", async () => {
@@ -193,6 +209,31 @@ test("reports dependency status in help and blocks a tool with a missing depende
   );
 });
 
+test("wraps declared tool runs in the shared execution governor", async () => {
+  await resetHome();
+  await createFakeTool("heavy-tool", {
+    execution: { resourceClass: "browser", weight: 1 }
+  });
+  const calls = [];
+  const executionGovernor = {
+    acquire: async (execution, label) => {
+      calls.push({ type: "acquire", execution, label });
+      return { release: () => calls.push({ type: "release", label }) };
+    },
+    snapshot: () => ({ resources: {} })
+  };
+  const registry = new ToolRegistry({ executionGovernor });
+  await registry.load();
+
+  const result = await registry.run({ name: "heavy-tool", request: { args: {} } });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(calls, [
+    { type: "acquire", execution: { resourceClass: "browser", weight: 1 }, label: "heavy-tool" },
+    { type: "release", label: "heavy-tool" }
+  ]);
+});
+
 test("runs a registered tool process with an enriched request and cleans up request files", async () => {
   await resetHome();
   await createFakeTool("fake-tool");

package/test/weighted-resource-governor.test.js

@@ -0,0 +1,95 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  normalizeToolExecution,
+  normalizeToolExecutionPolicy,
+  WeightedResourceGovernor
+} from "../src/core/tools/weighted-resource-governor.js";
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => { resolve = done; });
+  return { promise, resolve };
+}
+
+test("normalizes manifest weights and configurable class capacities", () => {
+  assert.deepEqual(normalizeToolExecution({ resourceClass: "browser", weight: 2 }), {
+    resourceClass: "browser",
+    weight: 2
+  });
+  assert.equal(normalizeToolExecution(undefined), null);
+  assert.throws(() => normalizeToolExecution({ resourceClass: "Browser!", weight: 1 }), /Invalid tool execution resource class/);
+  assert.throws(() => normalizeToolExecution({ resourceClass: "browser", weight: 0 }), /positive integer/);
+  assert.deepEqual(normalizeToolExecutionPolicy({
+    defaultCapacity: 3,
+    maxQueuedPerClass: 12,
+    capacities: { browser: 4 }
+  }), {
+    defaultCapacity: 3,
+    maxQueuedPerClass: 12,
+    capacities: { browser: 4 }
+  });
+});
+
+test("queues weighted work fairly within one resource class", async () => {
+  let time = 100;
+  const governor = new WeightedResourceGovernor({
+    policy: { defaultCapacity: 2 },
+    now: () => time,
+    memoryUsage: () => ({ rss: 100 * 1024 * 1024 })
+  });
+  const execution = { resourceClass: "browser", weight: 1 };
+  const first = await governor.acquire(execution, "first");
+  const second = await governor.acquire(execution, "second");
+  const thirdLease = governor.acquire(execution, "third");
+  const fourthLease = governor.acquire(execution, "fourth");
+
+  assert.deepEqual(governor.snapshot().resources.browser, {
+    capacity: 2,
+    activeWeight: 2,
+    queued: 2
+  });
+
+  const thirdGranted = deferred();
+  thirdLease.then((lease) => thirdGranted.resolve(lease));
+  time = 140;
+  first.release();
+  const third = await thirdGranted.promise;
+  assert.equal(third.waitedMs, 40);
+  assert.equal(governor.snapshot().resources.browser.queued, 1);
+
+  second.release();
+  const fourth = await fourthLease;
+  assert.equal(fourth.waitedMs, 40);
+  third.release();
+  fourth.release();
+  assert.equal(governor.snapshot().resources.browser.activeWeight, 0);
+});
+
+test("undeclared lightweight work bypasses constrained resource queues", async () => {
+  const governor = new WeightedResourceGovernor({ policy: { defaultCapacity: 1 } });
+  const heavy = await governor.acquire({ resourceClass: "browser", weight: 1 }, "heavy");
+  const queued = governor.acquire({ resourceClass: "browser", weight: 1 }, "queued");
+  const light = await governor.acquire(null, "light");
+  assert.equal(light.waitedMs, 0);
+  assert.equal(governor.snapshot().resources.browser.queued, 1);
+  light.release();
+  heavy.release();
+  (await queued).release();
+});
+
+test("larger weights consume shared capacity and worker RSS peaks are retained", async () => {
+  let rss = 120 * 1024 * 1024;
+  const governor = new WeightedResourceGovernor({
+    policy: { defaultCapacity: 3 },
+    memoryUsage: () => ({ rss })
+  });
+  const large = await governor.acquire({ resourceClass: "browser", weight: 2 }, "large");
+  const waiting = governor.acquire({ resourceClass: "browser", weight: 2 }, "waiting");
+  assert.equal(governor.snapshot().resources.browser.queued, 1);
+  rss = 180 * 1024 * 1024;
+  large.release();
+  const next = await waiting;
+  assert.equal(governor.snapshot().peakRssBytes, rss);
+  next.release();
+});