arisa 5.1.49 → 5.1.60

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

@@ -0,0 +1,28 @@
+import { getErrorMessage } from "../../core/agent/auth-flow.js";
+import { formatToolUsageReport } from "../../runtime/tool-usage-report.js";
+import { renderTelegramHtml } from "./text-format.js";
+
+export function createTelegramToolsCommandHandler({
+  authorize,
+  contextRoute,
+  toolRegistry,
+  withTyping,
+  logger
+}) {
+  return async (ctx) => {
+    logger?.log("telegram", `/tools command received in chat ${ctx.chat.id}`);
+    return withTyping(ctx, async () => {
+      const auth = await authorize(ctx);
+      if (!auth.ok) return;
+      try {
+        const report = await toolRegistry.usage(contextRoute(ctx).scopeChatId);
+        await ctx.reply(renderTelegramHtml(formatToolUsageReport(report)), { parse_mode: "HTML" });
+        logger?.log("telegram", `/tools command completed in chat ${ctx.chat.id}`);
+      } catch (error) {
+        const message = getErrorMessage(error);
+        logger?.error("telegram", `/tools command failed in chat ${ctx.chat.id}: ${message}`);
+        await ctx.reply(`Tool usage report failed: ${message}`);
+      }
+    });
+  };
+}

package/src/transport/telegram/telegram-workspace-controller.js

@@ -0,0 +1,66 @@
+import { authorizeChat } from "./auth.js";
+import { resolveTelegramWorkspaceRoute } from "./workspace-group.js";
+
+function incomingChatMeta(ctx) {
+  return {
+    languageCode: ctx.from?.language_code || "",
+    username: ctx.from?.username || "",
+    firstName: ctx.from?.first_name || "",
+    lastName: ctx.from?.last_name || ""
+  };
+}
+
+export function createTelegramWorkspaceController({ config, api, saveConfig }) {
+  const routes = new WeakMap();
+  const gateStates = new Map();
+
+  async function authorizeContext(ctx) {
+    const route = await resolveTelegramWorkspaceRoute({ config, api: ctx.api || api, ctx });
+    if (!route.workspace) {
+      const authorization = await authorizeChat({
+        config,
+        chatId: ctx.chat.id,
+        saveConfig,
+        chatMeta: incomingChatMeta(ctx)
+      });
+      if (authorization.ok) routes.set(ctx, route);
+      return authorization;
+    }
+
+    const gateKey = String(ctx.chat.id);
+    const previous = gateStates.get(gateKey);
+    if (!route.ok) {
+      gateStates.set(gateKey, route.reason || "locked");
+      if (previous !== (route.reason || "locked")) {
+        await ctx.reply("Private workspace access is paused because this forum is no longer owner-only.").catch(() => {});
+      }
+      return { ok: false, reason: route.reason || "workspace-locked" };
+    }
+    if (!(config.telegram.authorizedChatIds || []).includes(route.ownerChatId)) {
+      return { ok: false, reason: "owner-not-authorized" };
+    }
+    routes.set(ctx, route);
+    gateStates.set(gateKey, "ready");
+    if (previous && previous !== "ready") {
+      await ctx.reply("Private workspace access restored.").catch(() => {});
+    }
+    return { ok: true, firstTime: false, workspace: true };
+  }
+
+  function contextRoute(ctx) {
+    return routes.get(ctx) || {
+      ok: true,
+      workspace: false,
+      sessionId: String(ctx.chat.id),
+      scopeChatId: ctx.chat.id,
+      transportChatId: ctx.chat.id,
+      threadId: null
+    };
+  }
+
+  return {
+    authorizeContext,
+    contextRoute,
+    registerRoute: (ctx, route) => routes.set(ctx, route)
+  };
+}

package/test/agent-session-lifecycle.test.js

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AgentSessionLifecycle } from "../src/core/agent/agent-session-lifecycle.js";
+
+test("session lifecycle owns cache closure and pending handoffs", async () => {
+  let closes = 0;
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({ messages: 0, estimatedTokens: 0 })
+  });
+  lifecycle.sessions.set("chat", {
+    session: {
+      async close() { closes += 1; }
+    }
+  });
+
+  lifecycle.resetSession("chat", { handoff: "continue here", parentSession: "parent.jsonl" });
+  await lifecycle.waitForClose("chat");
+
+  assert.equal(closes, 1);
+  assert.equal(lifecycle.sessions.has("chat"), false);
+  assert.equal(lifecycle.pendingNewSessions.has("chat"), true);
+  assert.deepEqual(lifecycle.pendingSessionHandoffs.get("chat"), {
+    text: "continue here",
+    parentSession: "parent.jsonl"
+  });
+
+  lifecycle.completeNewSession("chat");
+  assert.equal(lifecycle.pendingNewSessions.has("chat"), false);
+  assert.equal(lifecycle.pendingSessionHandoffs.has("chat"), false);
+});
+
+test("session lifecycle diagnostics remain available after extraction", async () => {
+  const lifecycle = new AgentSessionLifecycle({
+    logger: null,
+    summarizeContext: () => ({ messages: 2, estimatedTokens: 42 })
+  });
+  lifecycle.sessions.set("123", {
+    session: {
+      messages: [{ role: "user" }, { role: "assistant" }],
+      getSessionStats: () => ({ contextUsage: { tokens: 42, contextWindow: 1000, percent: 4.2 } })
+    }
+  });
+
+  assert.deepEqual(await lifecycle.getDiagnostic(), {
+    harness: "pi",
+    sessions: 1,
+    closingSessions: 0,
+    contexts: [{
+      chatId: "123",
+      messages: 2,
+      estimatedTokens: 42,
+      tokens: 42,
+      contextWindow: 1000,
+      percent: 4.2
+    }]
+  });
+});

package/test/artifact-store.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -9,7 +9,7 @@ process.env.HOME = homeDir;
 process.env.USERPROFILE = homeDir;
 
 const { ArtifactStore } = await import("../src/core/artifacts/artifact-store.js");
-const { arisaHomeDir } = await import("../src/runtime/paths.js");
+const { arisaHomeDir, getChatArtifactsIndexFile } = await import("../src/runtime/paths.js");
 
 async function resetHome() {
   await rm(arisaHomeDir, { recursive: true, force: true });
@@ -46,6 +46,42 @@ test("creates, persists, reads, and lists text artifacts by recency", async () =
   assert.deepEqual(await reloadedStore.get(first.id), first);
 });
 
+test("serializes 100 concurrent artifact writes across store instances", async () => {
+  await resetHome();
+  const chatId = "concurrent-chat";
+  const stores = Array.from({ length: 5 }, () => new ArtifactStore().forChat(chatId));
+  const artifacts = await Promise.all(Array.from({ length: 100 }, (_, index) => (
+    stores[index % stores.length].createText({
+      text: `message ${index}`,
+      source: { type: "test", index }
+    })
+  )));
+
+  const persisted = JSON.parse(await readFile(getChatArtifactsIndexFile(chatId), "utf8"));
+  assert.equal(persisted.length, 100);
+  assert.equal(new Set(persisted.map((artifact) => artifact.id)).size, 100);
+  assert.deepEqual(
+    new Set(persisted.map((artifact) => artifact.id)),
+    new Set(artifacts.map((artifact) => artifact.id))
+  );
+  const stateFiles = await readdir(path.dirname(getChatArtifactsIndexFile(chatId)));
+  assert.equal(stateFiles.some((name) => name.endsWith(".tmp")), false);
+});
+
+test("refuses to overwrite a corrupt artifact index", async () => {
+  await resetHome();
+  const chatId = "corrupt-chat";
+  const indexFile = getChatArtifactsIndexFile(chatId);
+  await new ArtifactStore().forChat(chatId).createText({ text: "safe", source: { type: "test" } });
+  await writeFile(indexFile, "{truncated", "utf8");
+
+  await assert.rejects(
+    new ArtifactStore().forChat(chatId).createText({ text: "must not replace", source: { type: "test" } }),
+    /Artifact index is unreadable/
+  );
+  assert.equal(await readFile(indexFile, "utf8"), "{truncated");
+});
+
 test("copies file artifacts into the chat artifact directory", async () => {
   await resetHome();
   const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));

package/test/capabilities-security.test.js

@@ -142,6 +142,64 @@ test("requires chatId for chat-scoped IPC methods", async () => {
   }
 });
 
+test("tool-emitted tasks cannot override trusted chat routing", async () => {
+  const capabilities = createCapabilities();
+  const created = await capabilities.dispatch({
+    method: "tasks.add",
+    toolName: "poller",
+    chatId: "trusted-chat",
+    params: {
+      task: {
+        kind: "agent_task",
+        route: { transport: "telegram", destination: { chatId: "attacker-chat" } },
+        payload: {
+          chatId: "attacker-chat",
+          telegramContext: { transportChatId: "attacker-chat" },
+          prompt: "Safe payload"
+        }
+      }
+    }
+  });
+
+  assert.equal(created.route, undefined);
+  assert.equal(created.payload.chatId, "trusted-chat");
+  assert.equal(created.payload.telegramContext, undefined);
+  assert.equal(created.payload.prompt, "Safe payload");
+});
+
+test("IPC resource notes remain scoped to the calling tool", async () => {
+  const calls = [];
+  const capabilities = createArisaCapabilities({
+    artifactStore: createFakeArtifactStore(),
+    taskStore: createFakeTaskStore(),
+    resourceNotes: {
+      set: async (...args) => {
+        calls.push(args);
+        return { ok: true };
+      }
+    }
+  });
+
+  await capabilities.dispatch({
+    method: "tools.setResourceNote",
+    toolName: "caller-tool",
+    chatId: "chat-1",
+    params: { name: "other-tool", resourceId: "resource-1", note: "watch" }
+  });
+
+  assert.deepEqual(calls, [["chat-1", "caller-tool", "resource-1", "watch"]]);
+});
+
+test("IPC does not expose Telegram-only capability methods", async () => {
+  const capabilities = createCapabilities();
+  await assert.rejects(() => capabilities.dispatch({
+    method: "telegram.createTopic",
+    toolName: "caller-tool",
+    chatId: "chat-1",
+    params: { name: "Unsafe", context: "No" }
+  }), /unknown IPC method: telegram\.createTopic/);
+});
+
 test("agent events preserve a bounded immediate acknowledgement", async () => {
   const capabilities = createCapabilities();
   const created = await capabilities.dispatch({

package/test/context-and-task-bounds.test.js

@@ -4,6 +4,7 @@ import {
   collectText,
   ensureQueuedTelegramTyping,
   isSilentReply,
+  resolveIncomingBusyMessageMode,
   stopQueuedTelegramTyping
 } from "../src/transport/telegram/bot.js";
 import {
@@ -13,7 +14,7 @@ import {
   resolveTelegramBusyMessageMode,
   routeBusyPrompt
 } from "../src/transport/telegram/chat-queue.js";
-import { selectScheduledTasks } from "../src/core/agent/agent-manager.js";
+import { selectScheduledTasks } from "../src/core/capabilities/capability-service.js";
 
 test("queued Telegram prompts start typing immediately and share one indicator", async () => {
   let actions = 0;
@@ -158,6 +159,8 @@ test("chat state uses one queue for numeric and string chat IDs", () => {
     processing: false,
     pendingPrompts: [],
     pendingPromptContexts: [],
+    pendingPromptReceipts: [],
+    pendingPromptCoalescible: [],
     continueAfterClose: false,
     historyRevision: 0,
     beforeNextPrompt: null,
@@ -183,6 +186,32 @@ test("queued prompts retain their message boundaries and order", async () => {
   assert.deepEqual(processed, ["first request", "second request", "third request"]);
 });
 
+test("queued execution receipts resolve only after their prompt runs", async () => {
+  const chatState = createChatStateStore().get("chat");
+  chatState.processing = true;
+  let releaseFirst;
+  const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+  const { createPromptExecutionReceipt } = await import("../src/transport/telegram/chat-queue.js");
+  const receipt = createPromptExecutionReceipt();
+  queueChatPrompt(chatState, "scheduled request", { receipt });
+  let confirmed = false;
+  receipt.promise.then(() => { confirmed = true; });
+
+  const draining = drainChatPromptQueue({
+    chatState,
+    initialPrompt: "active request",
+    processPrompt: async ({ prompt }) => {
+      if (prompt === "active request") await firstGate;
+    }
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(confirmed, false);
+  releaseFirst();
+  await receipt.promise;
+  assert.equal(confirmed, true);
+  await draining;
+});
+
 test("a queued /new continues after the active session closes", async () => {
   const chatState = createChatStateStore().get("chat");
   chatState.processing = true;
@@ -265,6 +294,20 @@ test("busy message mode supports global defaults and per-chat overrides", () =>
   assert.equal(resolveTelegramBusyMessageMode({ telegram: { busyMessageMode: "invalid" } }, 123), "queue");
 });
 
+test("forum topics queue while direct Arisa messages retain steer mode", () => {
+  const config = { telegram: { busyMessageMode: "steer", chatMeta: {} } };
+  assert.equal(resolveIncomingBusyMessageMode({
+    config,
+    route: { workspace: true, sessionId: "owner--topic-87" },
+    message: { text: "topic follow-up" }
+  }), "queue");
+  assert.equal(resolveIncomingBusyMessageMode({
+    config,
+    route: { workspace: false, sessionId: "879964957" },
+    message: { text: "direct follow-up" }
+  }), "steer");
+});
+
 test("steer mode sends text to the active Pi session", async () => {
   const received = [];
   const chatState = createChatStateStore().get("chat");
@@ -297,6 +340,38 @@ test("failed or unavailable steering falls back to the ordered queue", async ()
   assert.deepEqual(chatState.pendingPrompts, ["keep this", "and this"]);
 });
 
+test("direct steer fallback coalesces consecutive text without reordering it", async () => {
+  const steered = [];
+  const chatState = createChatStateStore().get("chat");
+
+  const unavailable = await routeBusyPrompt({
+    chatState,
+    prompt: "first direct message",
+    mode: "steer",
+    coalesceQueued: true,
+    ctx: { message: { message_id: 1 } }
+  });
+  chatState.activeSession = {
+    isStreaming: true,
+    async steer(prompt) { steered.push(prompt); }
+  };
+  const next = await routeBusyPrompt({
+    chatState,
+    prompt: "second direct message",
+    mode: "steer",
+    coalesceQueued: true,
+    ctx: { message: { message_id: 2 } }
+  });
+
+  assert.equal(unavailable.disposition, "queued");
+  assert.equal(next.disposition, "coalesced");
+  assert.deepEqual(steered, []);
+  assert.deepEqual(chatState.pendingPrompts, [
+    "first direct message\n\n--- next direct message ---\n\nsecond direct message"
+  ]);
+  assert.equal(chatState.pendingPromptContexts[0].message.message_id, 2);
+});
+
 test("a pending /new forces later text into the replacement queue", async () => {
   const steered = [];
   const chatState = createChatStateStore().get("chat");

package/test/device-code-message.test.js

@@ -1,6 +1,15 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { buildDeviceCodeTelegramMessage } from "../src/transport/telegram/device-code-message.js";
+import { selectTelegramLoginOption } from "../src/transport/telegram/telegram-auth-controller.js";
+
+test("Telegram auth prefers device login and falls back deterministically", () => {
+  const browser = { id: "oauth", label: "Browser login" };
+  const device = { id: "device-code", label: "Device code" };
+  assert.strictEqual(selectTelegramLoginOption([browser, device]), device);
+  assert.strictEqual(selectTelegramLoginOption([browser]), browser);
+  assert.equal(selectTelegramLoginOption([]), null);
+});
 
 test("builds a copyable device-code Telegram message with HTML and inline buttons", () => {
   const payload = buildDeviceCodeTelegramMessage({

package/test/media-caption.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { resolveMediaCaption } from "../src/core/agent/agent-manager.js";
+import { resolveMediaCaption } from "../src/core/capabilities/capability-service.js";
 
 test("does not turn a domain-like filename into a caption", () => {
   assert.equal(resolveMediaCaption(undefined), undefined);

package/test/pi-capability-tools.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createPiCapabilityTools } from "../src/core/agent/pi-capability-tools.js";
+
+function createHarness() {
+  const calls = [];
+  let taskContext = { transportChatId: "chat-1", messageThreadId: 10 };
+  const capabilityService = {
+    async execute(request) {
+      calls.push(request);
+      if (request.method === "tools.list") return { tools: [] };
+      if (request.method === "tools.run") return { ok: true, output: {} };
+      return { ok: true };
+    }
+  };
+  const telegram = {
+    getTaskContext: () => taskContext,
+    sendMedia: async () => {}
+  };
+  const tools = createPiCapabilityTools({
+    capabilityService,
+    telegram,
+    chatId: "session-1",
+    policy: {
+      workspaceDir: "/workspace",
+      tools: ["read"],
+      excludeTools: [],
+      shell: {}
+    }
+  });
+  return {
+    calls,
+    tools,
+    setTaskContext(value) {
+      taskContext = value;
+    }
+  };
+}
+
+test("Pi tools delegate capability policy to CapabilityService", async () => {
+  const harness = createHarness();
+  const listTools = harness.tools.find((tool) => tool.name === "list_tools");
+
+  await listTools.execute("call-1", { query: "audio" });
+
+  assert.equal(harness.calls.length, 1);
+  assert.equal(harness.calls[0].method, "tools.list");
+  assert.equal(harness.calls[0].actorToolName, "list_tools");
+  assert.equal(harness.calls[0].chatId, "session-1");
+  assert.equal(harness.calls[0].context.workspaceDir, "/workspace");
+  assert.equal(harness.calls[0].context.coreTools[0].name, "read");
+  assert.equal(harness.calls[0].context.nativeTools[0].name, "system_shell");
+});
+
+test("Pi tool execution resolves the current Telegram task context per call", async () => {
+  const harness = createHarness();
+  const runTool = harness.tools.find((tool) => tool.name === "run_tool");
+
+  await runTool.execute("call-1", { name: "worker", args: {} });
+  harness.setTaskContext({ transportChatId: "chat-1", messageThreadId: 20 });
+  await runTool.execute("call-2", { name: "worker", args: {} });
+
+  assert.equal(harness.calls[0].context.taskContext.messageThreadId, 10);
+  assert.equal(harness.calls[1].context.taskContext.messageThreadId, 20);
+});

package/test/session-start-operational-notes.test.js

@@ -16,7 +16,7 @@ async function loadNotesWithHome(homeDir, notesPayload) {
   );
 
   const script = `
-const mod = await import(${JSON.stringify(new URL("../src/core/agent/agent-manager.js", import.meta.url).href)});
+const mod = await import(${JSON.stringify(new URL("../src/core/agent/agent-session-lifecycle.js", import.meta.url).href)});
 process.stdout.write(JSON.stringify(mod.loadSessionStartOperationalNotes()));
 `;
   const { stdout } = await execFileAsync(process.execPath, ["--input-type=module", "--eval", script], {

package/test/task-idempotency.test.js

@@ -0,0 +1,40 @@
+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";
+
+const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-task-idempotency-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const { TaskStore } = await import("../src/core/tasks/task-store.js");
+const { createTaskRunner } = await import("../src/core/tasks/task-runner.js");
+const { arisaHomeDir } = await import("../src/runtime/paths.js");
+
+test("two concurrent dispatchers execute one task id exactly once", async () => {
+  await rm(arisaHomeDir, { recursive: true, force: true });
+  const seedStore = new TaskStore();
+  await seedStore.add({
+    id: "single-execution",
+    kind: "agent_task",
+    runAt: new Date(Date.now() - 1_000).toISOString()
+  });
+
+  const executions = [];
+  const dispatch = async (task) => {
+    executions.push(task.id);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  };
+  const first = createTaskRunner({ taskStore: new TaskStore(), dispatch });
+  const second = createTaskRunner({ taskStore: new TaskStore(), dispatch });
+
+  const results = (await Promise.all([
+    first.dispatchDueTasks(),
+    second.dispatchDueTasks()
+  ])).flat();
+
+  assert.deepEqual(executions, ["single-execution"]);
+  assert.deepEqual(results, [{ taskId: "single-execution", status: "completed" }]);
+  assert.equal((await new TaskStore().get("single-execution")).status, "done");
+});

package/test/task-routing.test.js

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { taskWithoutCallerRouting } from "../src/core/tasks/task-routing.js";
+import { materializeToolOutput } from "../src/core/tools/tool-output-materializer.js";
+
+test("external tasks cannot override owner scope or transport routing", () => {
+  assert.deepEqual(taskWithoutCallerRouting({
+    kind: "agent_task",
+    route: { transport: "telegram", destination: { chatId: -999, threadId: 1 } },
+    payload: {
+      chatId: "other-owner",
+      telegramContext: { transportChatId: -999, messageThreadId: 1 },
+      prompt: "safe"
+    }
+  }), {
+    kind: "agent_task",
+    payload: { prompt: "safe" }
+  });
+});
+
+test("tool output materialization stores routing outside task payloads", async () => {
+  let capturedTasks;
+  let capturedDefaults;
+  const taskStore = {
+    async addMany(tasks, defaults) {
+      capturedTasks = tasks;
+      capturedDefaults = defaults;
+      return tasks;
+    }
+  };
+  const artifactStore = {
+    forChat() {
+      return {
+        async createText() { throw new Error("unexpected text artifact"); },
+        async createFromFile() { throw new Error("unexpected file artifact"); }
+      };
+    }
+  };
+  const route = { transport: "telegram", destination: { chatId: -1001, threadId: 87 } };
+
+  await materializeToolOutput({
+    result: {
+      asyncTask: {
+        kind: "agent_task",
+        route: { transport: "telegram", destination: { chatId: -999, threadId: 1 } },
+        payload: { chatId: "other", prompt: "run" }
+      }
+    },
+    name: "scheduler",
+    chatId: "owner",
+    artifactStore,
+    taskStore,
+    taskContext: route
+  });
+
+  assert.deepEqual(capturedTasks, [{ kind: "agent_task", payload: { prompt: "run" } }]);
+  assert.deepEqual(capturedDefaults, {
+    payload: { chatId: "owner" },
+    route,
+    source: { type: "tool", toolName: "scheduler", chatId: "owner" }
+  });
+});