arisa 4.1.8 → 4.1.12

package/test/capabilities-security.test.js

@@ -0,0 +1,249 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createArisaCapabilities } from "../src/runtime/arisa-capabilities.js";
+
+function createFakeArtifactStore() {
+  const stores = new Map();
+  return {
+    forChat(chatId) {
+      const key = String(chatId);
+      if (!stores.has(key)) {
+        const items = [];
+        stores.set(key, {
+          createText: async ({ text, mimeType, source, metadata }) => {
+            const artifact = {
+              id: `artifact-${items.length + 1}`,
+              chatId: key,
+              kind: "text",
+              mimeType,
+              text,
+              source,
+              metadata
+            };
+            items.push(artifact);
+            return artifact;
+          },
+          listRecent: async (limit) => [...items].slice(-limit).reverse(),
+          get: async (artifactId) => items.find((item) => item.id === artifactId) || null
+        });
+      }
+      return stores.get(key);
+    }
+  };
+}
+
+function createFakeTaskStore(initialTasks = []) {
+  const tasks = [...initialTasks];
+  return {
+    add: async (task, defaults = {}) => {
+      const created = {
+        id: `task-${tasks.length + 1}`,
+        ...task,
+        payload: { ...(defaults.payload || {}), ...(task.payload || {}) },
+        source: { ...(defaults.source || {}), ...(task.source || {}) }
+      };
+      tasks.push(created);
+      return created;
+    },
+    list: async (filter = {}) => tasks.filter((task) => {
+      if (filter.chatId && task.payload?.chatId !== filter.chatId) return false;
+      if (filter.status && task.status !== filter.status) return false;
+      if (filter.kind && task.kind !== filter.kind) return false;
+      return true;
+    }),
+    get: async (taskId) => tasks.find((task) => task.id === taskId) || null,
+    cancel: async (taskId) => {
+      const index = tasks.findIndex((task) => task.id === taskId);
+      if (index === -1) return null;
+      const [removed] = tasks.splice(index, 1);
+      return removed;
+    }
+  };
+}
+
+function createCapabilities(overrides = {}) {
+  return createArisaCapabilities({
+    artifactStore: overrides.artifactStore || createFakeArtifactStore(),
+    taskStore: overrides.taskStore || createFakeTaskStore(),
+    agentManager: overrides.agentManager
+  });
+}
+
+test("rejects cancellation of tasks from another chat", async () => {
+  const capabilities = createCapabilities({
+    taskStore: createFakeTaskStore([
+      { id: "task-1", status: "pending", payload: { chatId: "chat-a" } }
+    ])
+  });
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "tasks.cancel",
+      toolName: "poller",
+      chatId: "chat-b",
+      params: { taskId: "task-1" }
+    }),
+    /task does not belong to chatId/
+  );
+});
+
+test("requires a non-empty toolName for all IPC dispatches", async () => {
+  const capabilities = createCapabilities();
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "paths.getToolStateDir",
+      toolName: "  ",
+      params: {}
+    }),
+    /toolName is required/
+  );
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "paths.getToolStateDir",
+      toolName: null,
+      params: {}
+    }),
+    /toolName is required/
+  );
+});
+
+test("requires chatId for chat-scoped IPC methods", async () => {
+  const capabilities = createCapabilities({
+    agentManager: {
+      runTool: async () => ({ ok: true, status: "ok" })
+    }
+  });
+
+  for (const method of [
+    "artifacts.createText",
+    "artifacts.listRecent",
+    "artifacts.get",
+    "tasks.add",
+    "tasks.list",
+    "tasks.cancel",
+    "agent.enqueueEvent",
+    "paths.getChatToolStateDir",
+    "paths.getChatToolTmpDir",
+    "paths.getChatArtifactsDir",
+    "tools.run"
+  ]) {
+    await assert.rejects(
+      () => capabilities.dispatch({
+        method,
+        toolName: "ipc-tool",
+        params: method === "tasks.cancel" ? { taskId: "task-1" } : {}
+      }),
+      new RegExp(`${method.replace(".", "\\.")} requires chatId`)
+    );
+  }
+});
+
+test("normalizes tool run args and rejects arrays", async () => {
+  const calls = [];
+  const capabilities = createCapabilities({
+    agentManager: {
+      runTool: async (request) => {
+        calls.push(request);
+        return { ok: true, status: "ok" };
+      }
+    }
+  });
+
+  await capabilities.dispatch({
+    method: "tools.run",
+    toolName: "caller",
+    chatId: "chat-1",
+    params: { name: "worker", args: null }
+  });
+  assert.deepEqual(calls.at(-1).request.args, {});
+
+  await capabilities.dispatch({
+    method: "tools.run",
+    toolName: "caller",
+    chatId: "chat-1",
+    params: { name: "worker", args: { bpm: 128 } }
+  });
+  assert.deepEqual(calls.at(-1).request.args, { bpm: 128 });
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "tools.run",
+      toolName: "caller",
+      chatId: "chat-1",
+      params: { name: "worker", args: ["not", "an", "object"] }
+    }),
+    /args must be an object/
+  );
+});
+
+test("rejects missing artifact input before running a tool", async () => {
+  const calls = [];
+  const capabilities = createCapabilities({
+    agentManager: {
+      runTool: async (request) => {
+        calls.push(request);
+        return { ok: true, status: "ok" };
+      }
+    }
+  });
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "tools.run",
+      toolName: "caller",
+      chatId: "chat-1",
+      params: { name: "worker", artifactId: "missing" }
+    }),
+    /Artifact not found: missing/
+  );
+  assert.equal(calls.length, 0);
+});
+
+test("normalizes list limits for artifact reads", async () => {
+  const observedLimits = [];
+  const artifactStore = {
+    forChat: () => ({
+      listRecent: async (limit) => {
+        observedLimits.push(limit);
+        return [];
+      }
+    })
+  };
+  const capabilities = createCapabilities({ artifactStore });
+
+  await capabilities.dispatch({
+    method: "artifacts.listRecent",
+    toolName: "viewer",
+    chatId: "chat-1",
+    params: { limit: 0 }
+  });
+  await capabilities.dispatch({
+    method: "artifacts.listRecent",
+    toolName: "viewer",
+    chatId: "chat-1",
+    params: { limit: "not-a-number" }
+  });
+  await capabilities.dispatch({
+    method: "artifacts.listRecent",
+    toolName: "viewer",
+    chatId: "chat-1",
+    params: { limit: 1000 }
+  });
+
+  assert.deepEqual(observedLimits, [20, 20, 100]);
+});
+
+test("rejects unknown IPC methods", async () => {
+  const capabilities = createCapabilities();
+
+  await assert.rejects(
+    () => capabilities.dispatch({
+      method: "unknown.method",
+      toolName: "caller",
+      params: {}
+    }),
+    /unknown IPC method: unknown\.method/
+  );
+});

package/test/media-caption.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resolveMediaCaption } from "../src/core/agent/agent-manager.js";
+
+test("does not turn a domain-like filename into a caption", () => {
+  assert.equal(resolveMediaCaption(undefined), undefined);
+});
+
+test("keeps an explicit caption that is not a local path", () => {
+  assert.equal(resolveMediaCaption("Here is the report"), "Here is the report");
+});
+
+test("drops an explicit caption that leaks an absolute path", () => {
+  assert.equal(resolveMediaCaption("/Users/me/.arisa/artifacts/report.md"), undefined);
+});

package/test/normalize-for-reasoning.test.js

@@ -0,0 +1,173 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  normalizeArtifactForReasoning,
+  selectPipeTool,
+  shouldNormalizeArtifactToText
+} from "../src/core/artifacts/normalize-for-reasoning.js";
+
+function createToolRegistry(tools, run = async () => ({ ok: true, output: { text: "transcript" } })) {
+  return {
+    list: () => tools,
+    run
+  };
+}
+
+test("normalizes only audio and video artifacts to text", () => {
+  assert.equal(shouldNormalizeArtifactToText({ mimeType: "audio/ogg; codecs=opus" }), true);
+  assert.equal(shouldNormalizeArtifactToText({ mimeType: "video/mp4" }), true);
+  assert.equal(shouldNormalizeArtifactToText({ mimeType: "text/plain" }), false);
+  assert.equal(shouldNormalizeArtifactToText({ mimeType: "image/png" }), false);
+  assert.equal(shouldNormalizeArtifactToText({ mimeType: "audio/ogg" }, "application/json"), false);
+});
+
+test("selects an audio transcription pipe by MIME input/output and tool description", () => {
+  const toolRegistry = createToolRegistry([
+    {
+      name: "generic-converter",
+      description: "Converts things",
+      input: ["audio/*"],
+      output: ["text/plain"]
+    },
+    {
+      name: "whisper-transcribe",
+      description: "Speech to text for voice notes",
+      input: ["audio/*"],
+      output: ["text/plain"]
+    }
+  ]);
+
+  const tool = selectPipeTool({
+    toolRegistry,
+    artifact: { mimeType: "audio/ogg; codecs=opus" },
+    desiredMimeType: "text/plain"
+  });
+
+  assert.equal(tool.name, "whisper-transcribe");
+});
+
+test("returns no pipe when no transcription-like tool can produce the desired output", () => {
+  const toolRegistry = createToolRegistry([
+    {
+      name: "generic-converter",
+      description: "Converts audio",
+      input: ["audio/*"],
+      output: ["application/json"]
+    },
+    {
+      name: "text-maker",
+      description: "Writes text",
+      input: ["text/plain"],
+      output: ["text/plain"]
+    }
+  ]);
+
+  const tool = selectPipeTool({
+    toolRegistry,
+    artifact: { mimeType: "audio/ogg" },
+    desiredMimeType: "text/plain"
+  });
+
+  assert.equal(tool, null);
+});
+
+test("does not run tools for artifacts that do not need normalization", async () => {
+  let runCount = 0;
+  const result = await normalizeArtifactForReasoning({
+    artifact: { id: "artifact-1", mimeType: "text/plain", text: "hello" },
+    toolRegistry: createToolRegistry([], async () => {
+      runCount += 1;
+      return { ok: true, output: { text: "unused" } };
+    }),
+    chatArtifactStore: {},
+    chatId: "chat-1"
+  });
+
+  assert.deepEqual(result, { normalizedArtifact: null, toolResult: null, toolName: "" });
+  assert.equal(runCount, 0);
+});
+
+test("returns a failed normalization result when no pipe is registered", async () => {
+  const result = await normalizeArtifactForReasoning({
+    artifact: { id: "artifact-1", mimeType: "audio/ogg" },
+    toolRegistry: createToolRegistry([]),
+    chatArtifactStore: {},
+    chatId: "chat-1"
+  });
+
+  assert.equal(result.normalizedArtifact, null);
+  assert.equal(result.toolName, "");
+  assert.equal(result.toolResult.ok, false);
+  assert.match(result.toolResult.error, /No registered tool can normalize audio\/ogg to text\/plain/);
+});
+
+test("creates a text artifact from successful normalization output", async () => {
+  const calls = [];
+  const createdArtifacts = [];
+  const artifact = { id: "voice-1", mimeType: "audio/ogg" };
+  const toolRegistry = createToolRegistry([
+    {
+      name: "openai-transcribe",
+      description: "Transcription for audio",
+      input: ["audio/*"],
+      output: ["text/plain"]
+    }
+  ], async (request) => {
+    calls.push(request);
+    return { ok: true, output: { text: "hello from voice" } };
+  });
+  const chatArtifactStore = {
+    createText: async (request) => {
+      const created = { id: "text-1", ...request };
+      createdArtifacts.push(created);
+      return created;
+    }
+  };
+
+  const result = await normalizeArtifactForReasoning({
+    artifact,
+    toolRegistry,
+    chatArtifactStore,
+    chatId: "chat-1"
+  });
+
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0], {
+    name: "openai-transcribe",
+    request: { artifact, args: {} },
+    chatId: "chat-1"
+  });
+  assert.deepEqual(result.normalizedArtifact, createdArtifacts[0]);
+  assert.equal(result.toolName, "openai-transcribe");
+  assert.deepEqual(createdArtifacts[0], {
+    id: "text-1",
+    text: "hello from voice",
+    mimeType: "text/plain",
+    source: { type: "tool", toolName: "openai-transcribe" },
+    metadata: { fromArtifactId: "voice-1", tool: "openai-transcribe", normalization: true }
+  });
+});
+
+test("fails normalization when the selected tool returns no text", async () => {
+  const result = await normalizeArtifactForReasoning({
+    artifact: { id: "voice-1", mimeType: "audio/ogg" },
+    toolRegistry: createToolRegistry([
+      {
+        name: "openai-transcribe",
+        description: "Transcription for audio",
+        input: ["audio/*"],
+        output: ["text/plain"]
+      }
+    ], async () => ({ ok: true, output: {} })),
+    chatArtifactStore: {},
+    chatId: "chat-1"
+  });
+
+  assert.equal(result.normalizedArtifact, null);
+  assert.equal(result.toolName, "openai-transcribe");
+  assert.deepEqual(result.toolResult, {
+    ok: false,
+    status: "failed",
+    error: "Normalization returned no text."
+  });
+});

package/test/paths.test.js

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import {
+  chatsDir,
+  createIpcSocketPath,
+  getChatArtifactsDir,
+  getChatToolConfigPath,
+  getChatToolStateDir,
+  getToolStateDir,
+  stateDir
+} from "../src/runtime/paths.js";
+
+test("keeps chat artifact paths scoped below the chat directory", () => {
+  const artifactsDir = getChatArtifactsDir("chat-1");
+
+  assert.equal(artifactsDir, path.join(chatsDir, "chat-1", "artifacts"));
+});
+
+test("keeps chat tool state and config paths scoped below the chat directory for normal names", () => {
+  assert.equal(
+    getChatToolStateDir("chat-1", "strudel-agent"),
+    path.join(chatsDir, "chat-1", "state", "tools", "strudel-agent")
+  );
+  assert.equal(
+    getChatToolConfigPath("chat-1", "strudel-agent"),
+    path.join(chatsDir, "chat-1", "config", "tools", "strudel-agent", "config.js")
+  );
+});
+
+test("documents current traversal behavior for unsanitized tool names", () => {
+  const expectedRoot = path.join(chatsDir, "chat-1", "state", "tools");
+  const traversed = getChatToolStateDir("chat-1", "../../evil");
+
+  assert.equal(path.resolve(traversed), path.join(chatsDir, "chat-1", "evil"));
+  assert.equal(path.resolve(traversed).startsWith(`${expectedRoot}${path.sep}`), false);
+});
+
+test("documents current traversal behavior for global tool state paths", () => {
+  const expectedRoot = path.join(stateDir, "tools");
+  const traversed = getToolStateDir("../../evil");
+
+  assert.equal(path.resolve(traversed), path.join(path.dirname(stateDir), "evil"));
+  assert.equal(path.resolve(traversed).startsWith(`${expectedRoot}${path.sep}`), false);
+});
+
+test("creates POSIX IPC socket paths under the state directory", () => {
+  const socketPath = createIpcSocketPath({
+    homeDir: "/tmp/arisa-home",
+    platform: "darwin"
+  });
+
+  assert.equal(socketPath, path.join("/tmp/arisa-home", "state", "arisa.sock"));
+});

package/test/task-store.test.js

@@ -0,0 +1,119 @@
+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-store-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const { TaskStore } = await import("../src/core/tasks/task-store.js");
+const { arisaHomeDir } = await import("../src/runtime/paths.js");
+
+async function resetHome() {
+  await rm(arisaHomeDir, { recursive: true, force: true });
+}
+
+test("adds tasks and lists them by chat, status, and kind", async () => {
+  await resetHome();
+  const store = new TaskStore();
+
+  await store.add({ id: "chat-1-pending", kind: "agent_task" }, { payload: { chatId: "chat-1" } });
+  await store.add({ id: "chat-1-event", kind: "agent_event" }, { payload: { chatId: "chat-1" } });
+  await store.add({ id: "chat-2-pending", kind: "agent_task" }, { payload: { chatId: "chat-2" } });
+
+  assert.deepEqual(
+    (await store.list({ chatId: "chat-1" })).map((task) => task.id),
+    ["chat-1-pending", "chat-1-event"]
+  );
+  assert.deepEqual(
+    (await store.list({ kind: "agent_task" })).map((task) => task.id),
+    ["chat-1-pending", "chat-2-pending"]
+  );
+  assert.deepEqual(
+    (await store.list({ status: "pending" })).map((task) => task.id),
+    ["chat-1-pending", "chat-1-event", "chat-2-pending"]
+  );
+});
+
+test("claims only due pending tasks and marks them running", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const past = new Date(Date.now() - 1000).toISOString();
+  const future = new Date(Date.now() + 60_000).toISOString();
+
+  await store.add({ id: "due-1", kind: "agent_task", runAt: past });
+  await store.add({ id: "due-2", kind: "agent_task", runAt: past });
+  await store.add({ id: "future", kind: "agent_task", runAt: future });
+  await store.add({ id: "done", kind: "agent_task", runAt: past, status: "done" });
+  await store.add({ id: "invalid", kind: "agent_task", runAt: "not-a-date" });
+
+  const claimed = await store.claimDue(1);
+
+  assert.deepEqual(claimed.map((task) => task.id), ["due-1"]);
+  assert.equal(claimed[0].status, "running");
+  assert.equal((await store.get("due-1")).status, "running");
+  assert.equal((await store.get("due-2")).status, "pending");
+  assert.equal((await store.get("future")).status, "pending");
+  assert.equal((await store.get("done")).status, "done");
+});
+
+test("completes one-off tasks and re-schedules recurring interval tasks", async () => {
+  await resetHome();
+  const store = new TaskStore();
+  const past = new Date(Date.now() - 1000).toISOString();
+
+  await store.add({ id: "once", kind: "agent_task", status: "running" });
+  await store.add({
+    id: "repeat",
+    kind: "poll_tool",
+    status: "running",
+    runAt: past,
+    recurrence: { type: "interval", everySeconds: 60 }
+  });
+
+  const once = await store.complete("once");
+  const repeat = await store.complete("repeat");
+
+  assert.equal(once.status, "done");
+  assert.ok(once.completedAt);
+  assert.equal(repeat.status, "pending");
+  assert.ok(Date.parse(repeat.runAt) > Date.now());
+  assert.ok(repeat.lastRunAt);
+});
+
+test("fails and cancels tasks by id", async () => {
+  await resetHome();
+  const store = new TaskStore();
+
+  await store.add({ id: "will-fail", kind: "agent_task" });
+  await store.add({ id: "will-cancel", kind: "agent_task" });
+
+  const failed = await store.fail("will-fail", "boom");
+  const canceled = await store.cancel("will-cancel");
+
+  assert.equal(failed.status, "failed");
+  assert.equal(failed.error, "boom");
+  assert.equal(canceled.id, "will-cancel");
+  assert.equal(await store.get("will-cancel"), null);
+});
+
+test("cancelAll preserves done and failed tasks and respects chat filters", async () => {
+  await resetHome();
+  const store = new TaskStore();
+
+  await store.add({ id: "chat-1-pending", kind: "agent_task" }, { payload: { chatId: "chat-1" } });
+  await store.add({ id: "chat-2-pending", kind: "agent_task" }, { payload: { chatId: "chat-2" } });
+  await store.add({ id: "chat-1-done", kind: "agent_task", status: "done" }, { payload: { chatId: "chat-1" } });
+  await store.add({ id: "chat-1-failed", kind: "agent_task", status: "failed" }, { payload: { chatId: "chat-1" } });
+
+  const removed = await store.cancelAll({ chatId: "chat-1" });
+  const remaining = await store.list();
+
+  assert.deepEqual(removed.map((task) => task.id), ["chat-1-pending"]);
+  assert.deepEqual(
+    remaining.map((task) => task.id),
+    ["chat-2-pending", "chat-1-done", "chat-1-failed"]
+  );
+});

package/test/text-format.test.js

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { renderTelegramHtml, splitTelegramText } from "../src/transport/telegram/text-format.js";
+
+test("escapes HTML-sensitive characters in inline text", () => {
+  const rendered = renderTelegramHtml("<script>alert(\"x\")</script> & done");
+
+  assert.equal(rendered, "&lt;script&gt;alert(&quot;x&quot;)&lt;/script&gt; &amp; done");
+});
+
+test("escapes inline formatting content before rendering Telegram HTML tags", () => {
+  const rendered = renderTelegramHtml("**<b>bold & safe</b>** and `<tag attr=\"x\">`");
+
+  assert.equal(
+    rendered,
+    "<b>&lt;b&gt;bold &amp; safe&lt;/b&gt;</b> and <code>&lt;tag attr=&quot;x&quot;&gt;</code>"
+  );
+});
+
+test("escapes fenced code content", () => {
+  const rendered = renderTelegramHtml("before\n```js\nconst x = \"<tag>\" && value;\n```\nafter");
+
+  assert.equal(
+    rendered,
+    "before\n<pre><code language=\"js\">const x = &quot;&lt;tag&gt;&quot; &amp;&amp; value;</code></pre>\nafter"
+  );
+});
+
+test("escapes fenced code language attributes", () => {
+  const rendered = renderTelegramHtml("```js\" onmouseover=\"alert(1)\nconsole.log(\"safe\");\n```");
+
+  assert.match(rendered, /<pre><code language="js&quot; onmouseover=&quot;alert\(1\)">/);
+  assert.doesNotMatch(rendered, /onmouseover="/);
+});
+
+test("leaves unterminated fences as escaped inline text", () => {
+  const rendered = renderTelegramHtml("```html\n<b>not code");
+
+  assert.equal(rendered, "```html\n&lt;b&gt;not code");
+});
+
+test("splits empty or whitespace-only Telegram text into no chunks", () => {
+  assert.deepEqual(splitTelegramText(""), []);
+  assert.deepEqual(splitTelegramText("   \n\t  "), []);
+});
+
+test("splits Telegram text at readable boundaries without exceeding the limit", () => {
+  const source = "alpha beta gamma delta epsilon zeta";
+  const chunks = splitTelegramText(source, 12);
+
+  assert.deepEqual(chunks, ["alpha beta", "gamma delta", "epsilon zeta"]);
+  assert.ok(chunks.every((chunk) => chunk.length <= 12));
+  assert.equal(chunks.join(" "), source);
+});
+
+test("falls back to hard splits when no readable boundary exists", () => {
+  const chunks = splitTelegramText("abcdefghijklmnop", 5);
+
+  assert.deepEqual(chunks, ["abcde", "fghij", "klmno", "p"]);
+  assert.ok(chunks.every((chunk) => chunk.length <= 5));
+});