arisa 4.1.10 → 4.1.14

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

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import { access, mkdir, mkdtemp, rm, writeFile } 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-registry-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const { ToolRegistry } = await import("../src/core/tools/tool-registry.js");
+const {
+  arisaHomeDir,
+  arisaPackageDir,
+  arisaIpcSocketFile,
+  toolsDir
+} = await import("../src/runtime/paths.js");
+
+async function resetHome() {
+  await rm(arisaHomeDir, { recursive: true, force: true });
+}
+
+async function createFakeTool(name = "fake-tool") {
+  const dir = path.join(toolsDir, name);
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, "tool.manifest.json"), `${JSON.stringify({
+    name,
+    description: "Fake test tool",
+    entry: "index.js",
+    input: ["text/plain"],
+    output: ["text/plain"],
+    configSchema: {
+      apiKey: { type: "string", required: false }
+    },
+    skillHints: [{ name: "missing-skill", when: "testing" }]
+  }, null, 2)}\n`, "utf8");
+  await writeFile(path.join(dir, "config.js"), "export default {\n  apiKey: \"default-key\"\n};\n", "utf8");
+  await writeFile(path.join(dir, "index.js"), `import { readFile } from "node:fs/promises";
+
+const requestFileIndex = process.argv.indexOf("--request-file");
+if (process.argv.includes("--help")) {
+  process.stdout.write("Fake test tool help\\n");
+  process.exit(0);
+}
+if (requestFileIndex === -1) {
+  process.stdout.write(JSON.stringify({ ok: false, error: "missing request file" }));
+  process.exit(0);
+}
+
+const requestFile = process.argv[requestFileIndex + 1];
+const request = JSON.parse(await readFile(requestFile, "utf8"));
+process.stdout.write(JSON.stringify({
+  ok: true,
+  output: {
+    text: "tool completed",
+    request,
+    requestFile,
+    env: {
+      ARISA_PACKAGE_DIR: process.env.ARISA_PACKAGE_DIR,
+      ARISA_IPC_SOCKET: process.env.ARISA_IPC_SOCKET
+    }
+  }
+}));
+`, "utf8");
+  return dir;
+}
+
+test("loads and lists installed tools from the user tools directory", async () => {
+  await resetHome();
+  await createFakeTool("fake-tool");
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  assert.deepEqual(registry.list(), [{
+    name: "fake-tool",
+    description: "Fake test tool",
+    input: ["text/plain"],
+    output: ["text/plain"],
+    configSchema: {
+      apiKey: { type: "string", required: false }
+    },
+    skillHints: [{ name: "missing-skill", when: "testing" }]
+  }]);
+});
+
+test("runs a registered tool process with an enriched request and cleans up request files", async () => {
+  await resetHome();
+  await createFakeTool("fake-tool");
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  const result = await registry.run({
+    name: "fake-tool",
+    chatId: "chat-1",
+    request: {
+      text: "hello",
+      args: { count: 2 }
+    }
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.status, "ok");
+  assert.equal(result.output.text, "tool completed");
+  assert.deepEqual(result.output.request, {
+    text: "hello",
+    args: { count: 2 },
+    chatId: "chat-1",
+    skills: [{
+      name: "missing-skill",
+      when: "testing",
+      found: false,
+      description: "",
+      path: "",
+      content: ""
+    }]
+  });
+  assert.equal(result.output.env.ARISA_PACKAGE_DIR, arisaPackageDir);
+  assert.equal(result.output.env.ARISA_IPC_SOCKET, arisaIpcSocketFile);
+
+  const requestFile = result.output.requestFile;
+  await assert.rejects(() => access(requestFile), { code: "ENOENT" });
+  await assert.rejects(() => access(path.dirname(requestFile)), { code: "ENOENT" });
+});
+
+test("rejects unknown tools", async () => {
+  await resetHome();
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  await assert.rejects(
+    () => registry.run({ name: "missing-tool", request: {}, chatId: "chat-1" }),
+    /Tool not found: missing-tool/
+  );
+});

package/test/tool-result.test.js

@@ -0,0 +1,127 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  normalizeToolResult,
+  toolError,
+  toolNeedsConfig,
+  toolOk
+} from "../src/core/tools/tool-result.js";
+
+test("builds standard successful tool responses", () => {
+  assert.deepEqual(
+    toolOk({ text: "done" }, { asyncTasks: [{ id: "task-1" }] }),
+    { ok: true, output: { text: "done" }, asyncTasks: [{ id: "task-1" }] }
+  );
+});
+
+test("builds standard failed tool responses", () => {
+  assert.deepEqual(
+    toolError("boom", { status: "bad_request", details: { field: "name" } }),
+    {
+      ok: false,
+      status: "bad_request",
+      error: "boom",
+      details: { field: "name" }
+    }
+  );
+});
+
+test("builds missing-config tool responses", () => {
+  assert.deepEqual(
+    toolNeedsConfig({
+      tool: "demo",
+      missingConfig: ["apiKey"],
+      configPath: "/tmp/config.js"
+    }),
+    {
+      ok: false,
+      status: "needs_config",
+      error: "Missing tool configuration for demo.",
+      missingConfig: ["apiKey"],
+      configPath: "/tmp/config.js",
+      resolution: {
+        type: "user_config_required",
+        tool: "demo",
+        missingConfig: ["apiKey"],
+        configPath: "/tmp/config.js"
+      }
+    }
+  );
+});
+
+test("normalizes non-object responses into failed results", () => {
+  const result = normalizeToolResult("demo", "not-json");
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "Invalid tool response for demo");
+});
+
+test("normalizes missing-config failures", () => {
+  const result = normalizeToolResult("demo", {
+    ok: false,
+    error: "Need API key",
+    missingConfig: ["apiKey"],
+    configPath: "/tmp/config.js"
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "needs_config");
+  assert.equal(result.error, "Need API key");
+  assert.deepEqual(result.resolution, {
+    type: "user_config_required",
+    tool: "demo",
+    missingConfig: ["apiKey"],
+    configPath: "/tmp/config.js"
+  });
+});
+
+test("preserves explicit missing-config status and resolution", () => {
+  const result = normalizeToolResult("demo", {
+    ok: false,
+    status: "blocked",
+    error: "Need consent",
+    missingConfig: ["consent"],
+    resolution: { type: "manual", url: "https://example.com" }
+  });
+
+  assert.equal(result.status, "blocked");
+  assert.deepEqual(result.resolution, { type: "manual", url: "https://example.com" });
+});
+
+test("normalizes regular failures", () => {
+  const result = normalizeToolResult("demo", {
+    ok: false,
+    error: "Tool exploded",
+    stdout: "",
+    stderr: "stack"
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "Tool exploded");
+  assert.equal(result.stderr, "stack");
+});
+
+test("normalizes successful responses", () => {
+  const result = normalizeToolResult("demo", {
+    ok: true,
+    output: { text: "hello" },
+    delivery: { method: "document" }
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.status, "ok");
+  assert.deepEqual(result.output, { text: "hello" });
+  assert.deepEqual(result.delivery, { method: "document" });
+});
+
+test("rejects object responses without an ok contract", () => {
+  const rawResult = { output: { text: "hello" } };
+  const result = normalizeToolResult("demo", rawResult);
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "Invalid tool response for demo");
+  assert.deepEqual(result.rawResult, rawResult);
+});