arisa 4.0.14 → 4.0.18

package/test/ipc-server.test.js

@@ -0,0 +1,154 @@
+import assert from "node:assert/strict";
+import net from "node:net";
+import { mkdtemp } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { createArisaClient } from "../src/core/tools/ipc-client.js";
+import { createArisaCapabilities } from "../src/runtime/arisa-capabilities.js";
+import { createIpcServer } from "../src/runtime/ipc/ipc-server.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, source, metadata }) => {
+            const artifact = { id: `artifact-${items.length + 1}`, chatId: key, text, source, metadata };
+            items.push(artifact);
+            return artifact;
+          },
+          listRecent: async () => [...items].reverse(),
+          get: async (artifactId) => items.find((item) => item.id === artifactId) || null
+        });
+      }
+      return stores.get(key);
+    }
+  };
+}
+
+function createFakeTaskStore() {
+  const tasks = [];
+  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 && String(task.payload?.chatId) !== String(filter.chatId)) return false;
+      if (filter.kind && task.kind !== filter.kind) return false;
+      if (filter.status && task.status !== filter.status) 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() {
+  return createArisaCapabilities({
+    artifactStore: createFakeArtifactStore(),
+    taskStore: createFakeTaskStore()
+  });
+}
+
+async function createTempSocketPath() {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-ipc-"));
+  return path.join(root, "arisa.sock");
+}
+
+async function sendRaw(socketPath, request) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.once("connect", () => {
+      socket.write(`${JSON.stringify(request)}\n`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) return;
+      socket.end();
+      resolve(JSON.parse(buffer.slice(0, newlineIndex)));
+    });
+    socket.once("error", reject);
+  });
+}
+
+test("dispatches explicit capabilities over local IPC", async () => {
+  const socketPath = await createTempSocketPath();
+  const ipcServer = createIpcServer({ capabilities: createCapabilities(), socketPath });
+  await ipcServer.start();
+
+  try {
+    const client = createArisaClient({ toolName: "ipc-tool", chatId: 123, socketPath });
+    const artifact = await client.artifacts.createText({ text: "hello" });
+    assert.equal(artifact.text, "hello");
+    assert.equal(artifact.source.toolName, "ipc-tool");
+    assert.equal(artifact.source.chatId, 123);
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
+test("rejects unknown IPC methods", async () => {
+  const socketPath = await createTempSocketPath();
+  const ipcServer = createIpcServer({ capabilities: createCapabilities(), socketPath });
+  await ipcServer.start();
+
+  try {
+    const response = await sendRaw(socketPath, {
+      id: "one",
+      method: "unknown.method",
+      toolName: "ipc-tool",
+      params: {}
+    });
+    assert.equal(response.ok, false);
+    assert.match(response.error, /unknown IPC method/);
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
+test("requires chatId for chat-scoped capabilities", async () => {
+  const socketPath = await createTempSocketPath();
+  const ipcServer = createIpcServer({ capabilities: createCapabilities(), socketPath });
+  await ipcServer.start();
+
+  try {
+    const client = createArisaClient({ toolName: "ipc-tool", socketPath });
+    await assert.rejects(
+      () => client.artifacts.listRecent(),
+      /artifacts\.listRecent requires chatId/
+    );
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
+test("listens on a local socket, not a TCP port", async () => {
+  const socketPath = await createTempSocketPath();
+  const ipcServer = createIpcServer({ capabilities: createCapabilities(), socketPath });
+  await ipcServer.start();
+
+  try {
+    assert.equal(ipcServer.address(), socketPath);
+  } finally {
+    await ipcServer.stop();
+  }
+});

package/test/process-ids.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseProcessIds } from "../src/runtime/process-ids.js";
+
+test("ignores empty PID command output", () => {
+  assert.deepEqual(parseProcessIds(""), []);
+  assert.deepEqual(parseProcessIds("   \n\t"), []);
+});
+
+test("parses only positive integer PID tokens", () => {
+  assert.deepEqual(parseProcessIds("123\n456"), [123, 456]);
+  assert.deepEqual(parseProcessIds("11970/tcp: 1234"), [1234]);
+  assert.deepEqual(parseProcessIds("0 nope -12 42"), [42]);
+});

package/src/runtime/web/route-validation.js

@@ -1,115 +0,0 @@
-import path from "node:path";
-
-export const RESERVED_EXACT = ["/"];
-export const RESERVED_PATHS = ["/health"];
-export const RESERVED_PREFIXES = ["/telegram-", "/api", "/auth"];
-
-const DEFAULT_METHODS = ["GET"];
-
-function isObject(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-
-function normalizeMethods(methods, isPublic) {
-  const requested = methods == null ? DEFAULT_METHODS : methods;
-  if (!Array.isArray(requested) || requested.length === 0) {
-    throw new Error("methods must be a non-empty array");
-  }
-
-  const normalized = requested.map((method) => {
-    if (typeof method !== "string" || !method.trim()) {
-      throw new Error("methods must contain only non-empty strings");
-    }
-    return method.trim().toUpperCase();
-  });
-
-  if (!isPublic && methods == null) return normalized;
-  return [...new Set(normalized)];
-}
-
-export function isReservedPath(routePath) {
-  return RESERVED_EXACT.includes(routePath)
-    || RESERVED_PATHS.includes(routePath)
-    || RESERVED_PREFIXES.some((prefix) => routePath === prefix || routePath.startsWith(prefix));
-}
-
-export function validateRoutePath(routePath) {
-  if (typeof routePath !== "string" || !routePath.startsWith("/")) {
-    throw new Error("path must be a string that starts with /");
-  }
-  if (routePath.includes("..")) {
-    throw new Error("path must not contain ..");
-  }
-  if (isReservedPath(routePath)) {
-    throw new Error(`path is reserved: ${routePath}`);
-  }
-  return routePath;
-}
-
-export function resolveHandlerWithinTool(toolDir, handlerRel) {
-  if (typeof handlerRel !== "string" || !handlerRel.trim()) {
-    throw new Error("handler must be a non-empty string");
-  }
-  if (path.isAbsolute(handlerRel)) {
-    throw new Error("handler must be relative to the tool directory");
-  }
-  if (handlerRel.includes("..")) {
-    throw new Error("handler must not contain ..");
-  }
-
-  const root = path.resolve(toolDir);
-  const handlerPath = path.resolve(root, handlerRel);
-  const relative = path.relative(root, handlerPath);
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error("handler must resolve inside the tool directory");
-  }
-  return handlerPath;
-}
-
-export function validateToolWebRoutes(manifest, toolDir, claimedPaths = new Map()) {
-  const routes = [];
-  const errors = [];
-  const toolName = manifest?.name;
-  const manifestRoutes = manifest?.web?.routes;
-
-  if (manifestRoutes == null) return { routes, errors };
-  if (!Array.isArray(manifestRoutes)) {
-    return { routes, errors: [{ toolName, error: "web.routes must be an array" }] };
-  }
-
-  for (const [index, route] of manifestRoutes.entries()) {
-    try {
-      if (!isObject(route)) {
-        throw new Error("route must be an object");
-      }
-
-      const routePath = validateRoutePath(route.path);
-      const previousTool = claimedPaths.get(routePath);
-      if (previousTool && previousTool !== toolName) {
-        throw new Error(`path collides with tool ${previousTool}: ${routePath}`);
-      }
-
-      const isPublic = route.public === true;
-      const methods = normalizeMethods(route.methods, isPublic);
-      const handlerPath = resolveHandlerWithinTool(toolDir, route.handler);
-
-      claimedPaths.set(routePath, toolName);
-      routes.push({
-        toolName,
-        path: routePath,
-        methods,
-        public: isPublic,
-        handlerPath
-      });
-    } catch (error) {
-      errors.push({
-        toolName,
-        index,
-        path: route?.path,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-
-  return { routes, errors };
-}

package/src/runtime/web/web-router.js

@@ -1,167 +0,0 @@
-import crypto from "node:crypto";
-import { pathToFileURL } from "node:url";
-
-const DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-function sendText(res, statusCode, text, headers = {}) {
-  if (res.headersSent || res.writableEnded) return;
-  res.writeHead(statusCode, {
-    "Content-Type": "text/plain; charset=utf-8",
-    ...headers
-  });
-  res.end(text);
-}
-
-function safePathname(req) {
-  try {
-    return new URL(req.url || "/", "http://localhost").pathname;
-  } catch {
-    return "/";
-  }
-}
-
-function methodKey(method, routePath) {
-  return `${String(method || "GET").toUpperCase()} ${routePath}`;
-}
-
-function extractBearerToken(req, parsedUrl) {
-  const authorization = req.headers.authorization || "";
-  const match = authorization.match(/^Bearer\s+(.+)$/i);
-  if (match) return match[1].trim();
-  return parsedUrl.searchParams.get("token") || "";
-}
-
-function timingSafeEqualString(actual, expected) {
-  if (!actual || !expected) return false;
-  const actualBuffer = Buffer.from(actual);
-  const expectedBuffer = Buffer.from(expected);
-  if (actualBuffer.length !== expectedBuffer.length) return false;
-  return crypto.timingSafeEqual(actualBuffer, expectedBuffer);
-}
-
-function installBodyLimit(req, res, limitBytes) {
-  const contentLength = Number(req.headers["content-length"] || 0);
-  if (Number.isFinite(contentLength) && contentLength > limitBytes) {
-    sendText(res, 413, "request body too large\n");
-    req.destroy();
-    return false;
-  }
-
-  let total = 0;
-  const originalEmit = req.emit;
-  req.emit = function emitWithBodyLimit(eventName, ...args) {
-    if (eventName === "data" && !res.writableEnded) {
-      const chunk = args[0];
-      total += Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk || ""));
-      if (total > limitBytes) {
-        sendText(res, 413, "request body too large\n");
-        req.destroy();
-        return false;
-      }
-    }
-    return originalEmit.call(this, eventName, ...args);
-  };
-  return true;
-}
-
-function parseChatId(parsedUrl) {
-  const raw = parsedUrl.searchParams.get("chatId");
-  if (raw == null || raw.trim() === "") return null;
-  const numberValue = Number(raw);
-  return Number.isSafeInteger(numberValue) ? numberValue : raw;
-}
-
-export function createWebRouter({
-  getRoutes,
-  buildContext,
-  getToken,
-  logger,
-  limits = {}
-} = {}) {
-  const coreRoutes = new Map();
-  const handlerCache = new Map();
-  const bodyLimitBytes = limits.bodyLimitBytes || DEFAULT_BODY_LIMIT_BYTES;
-  const timeoutMs = limits.timeoutMs || DEFAULT_TIMEOUT_MS;
-
-  async function loadHandler(route) {
-    if (!handlerCache.has(route.handlerPath)) {
-      handlerCache.set(route.handlerPath, import(pathToFileURL(route.handlerPath).href));
-    }
-    const module = await handlerCache.get(route.handlerPath);
-    if (typeof module.handleWebRequest !== "function") {
-      throw new Error(`handler does not export handleWebRequest: ${route.handlerPath}`);
-    }
-    return module.handleWebRequest;
-  }
-
-  function registerCoreRoute({ method, path, handler }) {
-    if (typeof method !== "string" || typeof path !== "string" || typeof handler !== "function") {
-      throw new Error("core route requires method, path, and handler");
-    }
-    coreRoutes.set(methodKey(method, path), handler);
-  }
-
-  async function dispatch(req, res) {
-    const parsedUrl = new URL(req.url || "/", "http://localhost");
-    const pathname = parsedUrl.pathname;
-    const method = String(req.method || "GET").toUpperCase();
-    const coreHandler = coreRoutes.get(methodKey(method, pathname));
-    if (coreHandler) {
-      return coreHandler(req, res);
-    }
-
-    const route = (getRoutes?.() || []).find((item) => item.path === pathname);
-    if (!route) {
-      sendText(res, 200, "ok");
-      return undefined;
-    }
-
-    const timeout = setTimeout(() => {
-      sendText(res, 504, "request timed out\n");
-      req.destroy();
-    }, timeoutMs);
-    timeout.unref?.();
-
-    try {
-      if (!installBodyLimit(req, res, bodyLimitBytes)) return undefined;
-
-      const token = getToken?.() || "";
-      if (!route.public && !timingSafeEqualString(extractBearerToken(req, parsedUrl), token)) {
-        sendText(res, 401, "unauthorized\n", { "WWW-Authenticate": "Bearer" });
-        return undefined;
-      }
-
-      const methods = route.methods || ["GET"];
-      if (!methods.includes(method)) {
-        sendText(res, 405, "method not allowed\n", { Allow: methods.join(", ") });
-        return undefined;
-      }
-
-      logger?.log?.("web", `${route.toolName} ${method} ${pathname}`);
-      const handleWebRequest = await loadHandler(route);
-      const context = buildContext?.({
-        toolName: route.toolName,
-        route,
-        req,
-        res,
-        parsedUrl,
-        chatId: parseChatId(parsedUrl)
-      }) || { toolName: route.toolName, chatId: parseChatId(parsedUrl) };
-      await handleWebRequest(req, res, context);
-      return undefined;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger?.error?.("web", `${route.toolName} ${safePathname(req)}: ${message}`);
-      sendText(res, 500, "internal server error\n");
-      return undefined;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  return {
-    dispatch,
-    registerCoreRoute
-  };
-}

package/test/route-validation.test.js

@@ -1,88 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import {
-  isReservedPath,
-  validateToolWebRoutes
-} from "../src/runtime/web/route-validation.js";
-
-async function tempToolDir(name) {
-  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-route-validation-"));
-  return path.join(root, name);
-}
-
-test("loads valid tool web routes", async () => {
-  const toolDir = await tempToolDir("alpha");
-  const claimedPaths = new Map();
-  const manifest = {
-    name: "alpha",
-    web: {
-      routes: [
-        { path: "/alpha", handler: "web/index.js" }
-      ]
-    }
-  };
-
-  const { routes, errors } = validateToolWebRoutes(manifest, toolDir, claimedPaths);
-
-  assert.deepEqual(errors, []);
-  assert.equal(routes.length, 1);
-  assert.equal(routes[0].toolName, "alpha");
-  assert.equal(routes[0].path, "/alpha");
-  assert.deepEqual(routes[0].methods, ["GET"]);
-  assert.equal(routes[0].public, false);
-  assert.equal(routes[0].handlerPath, path.join(toolDir, "web", "index.js"));
-});
-
-test("rejects invalid and reserved route paths", async () => {
-  const toolDir = await tempToolDir("bad");
-  const invalidPaths = ["/", "/health", "/api", "/api/tools", "/telegram-secret", "/has/../dotdot", "relative"];
-
-  for (const routePath of invalidPaths) {
-    const { routes, errors } = validateToolWebRoutes({
-      name: "bad",
-      web: { routes: [{ path: routePath, handler: "web/index.js" }] }
-    }, toolDir, new Map());
-
-    assert.equal(routes.length, 0, routePath);
-    assert.equal(errors.length, 1, routePath);
-  }
-
-  assert.equal(isReservedPath("/telegram-token"), true);
-  assert.equal(isReservedPath("/custom"), false);
-});
-
-test("rejects route collisions between tools", async () => {
-  const firstToolDir = await tempToolDir("first");
-  const secondToolDir = await tempToolDir("second");
-  const claimedPaths = new Map();
-
-  const first = validateToolWebRoutes({
-    name: "first",
-    web: { routes: [{ path: "/shared", handler: "web/index.js" }] }
-  }, firstToolDir, claimedPaths);
-
-  const second = validateToolWebRoutes({
-    name: "second",
-    web: { routes: [{ path: "/shared", handler: "web/index.js" }] }
-  }, secondToolDir, claimedPaths);
-
-  assert.equal(first.routes.length, 1);
-  assert.equal(second.routes.length, 0);
-  assert.match(second.errors[0].error, /collides with tool first/);
-});
-
-test("rejects handlers outside the tool directory", async () => {
-  const toolDir = await tempToolDir("escape");
-
-  const { routes, errors } = validateToolWebRoutes({
-    name: "escape",
-    web: { routes: [{ path: "/escape", handler: "../outside.js" }] }
-  }, toolDir, new Map());
-
-  assert.equal(routes.length, 0);
-  assert.equal(errors.length, 1);
-  assert.match(errors[0].error, /handler must not contain \.\./);
-});