arisa 4.1.10 → 4.1.14

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/telegram-text-artifact.test.js

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildPrompt, shouldIncludeArtifactReference } from "../src/transport/telegram/bot.js";
+import { captureIncomingArtifact } from "../src/transport/telegram/media.js";
+
+function createTextContext(text = "hello") {
+  return {
+    chat: { id: 123 },
+    from: { id: 456, username: "martin" },
+    msg: { message_id: 789 },
+    message: {
+      message_id: 789,
+      text
+    }
+  };
+}
+
+test("does not expose inline message text artifacts as prompt attachments", () => {
+  const prompt = buildPrompt({
+    ctx: createTextContext("hello"),
+    artifact: {
+      id: "artifact-1",
+      kind: "text",
+      mimeType: "text/plain",
+      text: "hello"
+    }
+  });
+
+  assert.match(prompt, /text: hello/);
+  assert.doesNotMatch(prompt, /artifactId: artifact-1/);
+  assert.doesNotMatch(prompt, /mimeType: text\/plain/);
+  assert.doesNotMatch(prompt, /kind: text/);
+});
+
+test("keeps distinct artifacts visible to the prompt", () => {
+  assert.equal(
+    shouldIncludeArtifactReference({
+      artifact: {
+        id: "artifact-1",
+        kind: "document",
+        mimeType: "text/plain",
+        path: "/tmp/note.txt"
+      },
+      messageText: "see attached"
+    }),
+    true
+  );
+
+  assert.equal(
+    shouldIncludeArtifactReference({
+      artifact: {
+        id: "artifact-2",
+        kind: "text",
+        mimeType: "text/plain",
+        text: "different text"
+      },
+      messageText: "hello"
+    }),
+    true
+  );
+});
+
+test("marks incoming Telegram text artifacts as internal inline messages", async () => {
+  const calls = [];
+  const artifactStore = {
+    forChat: (chatId) => ({
+      createText: async (request) => {
+        calls.push({ chatId, ...request });
+        return { id: "artifact-1", chatId, kind: "text", mimeType: "text/plain", ...request };
+      }
+    })
+  };
+
+  const artifact = await captureIncomingArtifact(createTextContext("hello"), artifactStore);
+
+  assert.equal(artifact.text, "hello");
+  assert.deepEqual(calls[0].metadata, {
+    visibility: "internal",
+    representation: "inline-message"
+  });
+});

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));
+});

package/test/tool-config.test.js

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } 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-tool-config-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const {
+  loadToolConfig,
+  parseConfigModule,
+  serializeConfigModule,
+  writeToolConfig
+} = await import("../src/core/tools/tool-config.js");
+
+test("parses and serializes config modules", () => {
+  const config = parseConfigModule("export default {\n  apiKey: \"secret\",\n  enabled: true\n};\n");
+  const serialized = serializeConfigModule(config);
+
+  assert.deepEqual(config, { apiKey: "secret", enabled: true });
+  assert.equal(serialized, "export default {\n  apiKey: \"secret\",\n  enabled: true\n};\n");
+  assert.deepEqual(parseConfigModule(serialized), config);
+});
+
+test("loads tool config with defaults, global config, and chat config precedence", async () => {
+  await writeToolConfig("demo-tool", {
+    apiKey: "global-key",
+    mode: "global",
+    retries: 3
+  });
+  await writeToolConfig("demo-tool", {
+    mode: "chat",
+    chatOnly: true
+  }, "chat-1");
+
+  const config = await loadToolConfig("demo-tool", {
+    apiKey: "default-key",
+    mode: "default",
+    timeoutMs: 1000
+  }, "chat-1");
+
+  assert.deepEqual(config, {
+    apiKey: "global-key",
+    mode: "chat",
+    timeoutMs: 1000,
+    retries: 3,
+    chatOnly: true
+  });
+});
+
+test("writes config modules to the selected scope", async () => {
+  const { getChatToolConfigPath } = await import("../src/runtime/paths.js");
+  const configPath = await writeToolConfig("scoped-tool", { token: "chat-token" }, "chat-2");
+  const source = await readFile(configPath, "utf8");
+
+  assert.equal(configPath, getChatToolConfigPath("chat-2", "scoped-tool"));
+  assert.equal(source, "export default {\n  token: \"chat-token\"\n};\n");
+});
+
+test("documents that config parsing executes JavaScript expressions", () => {
+  delete globalThis.__arisaConfigExecuted;
+
+  const config = parseConfigModule(
+    "export default (() => { globalThis.__arisaConfigExecuted = true; return { enabled: true }; })();"
+  );
+
+  assert.deepEqual(config, { enabled: true });
+  assert.equal(globalThis.__arisaConfigExecuted, true);
+  delete globalThis.__arisaConfigExecuted;
+});