arisa 5.1.49 → 5.1.60

package/src/runtime/arisa-capabilities.js

@@ -1,251 +1,60 @@
-import {
-  getChatArtifactsDir,
-  getChatToolStateDir,
-  getChatToolTmpDir,
-  getToolStateDir,
-  getToolTmpDir
-} from "./paths.js";
-import { ToolResourceNoteStore } from "../core/tools/tool-resource-note-store.js";
-import { installBundledOfficialTool } from "../core/tools/official-tool-installer.js";
-
-function requireToolName(toolName) {
-  if (typeof toolName !== "string" || !toolName.trim()) {
-    throw new Error("toolName is required");
-  }
-  return toolName.trim();
-}
-
-function requireChatId(chatId, method) {
-  if (chatId == null || chatId === "") {
-    throw new Error(`${method} requires chatId`);
-  }
-  return chatId;
-}
-
-function requireString(value, fieldName) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${fieldName} is required`);
-  }
-  return value;
-}
-
-function normalizeArgs(args) {
-  if (args == null) return {};
-  if (typeof args !== "object" || Array.isArray(args)) {
-    throw new Error("args must be an object");
-  }
-  return args;
-}
-
-function normalizeLimit(limit) {
-  const value = Number(limit);
-  if (!Number.isInteger(value) || value <= 0) return 20;
-  return Math.min(value, 100);
-}
-
-function normalizeAcknowledgement(value) {
-  if (value == null || value === "") return "";
-  const acknowledgement = requireString(value, "acknowledgement").trim();
-  if (acknowledgement.length > 500) throw new Error("acknowledgement must be at most 500 characters");
-  return acknowledgement;
-}
+import { createCapabilityService } from "../core/capabilities/capability-service.js";
+
+const ipcMethods = new Set([
+  "tools.list",
+  "tools.help",
+  "tools.skills",
+  "tools.setConfig",
+  "tools.setResourceNote",
+  "tools.getResourceNote",
+  "tools.run",
+  "tools.installOfficial",
+  "artifacts.createText",
+  "artifacts.listRecent",
+  "artifacts.get",
+  "artifacts.deliver",
+  "tasks.add",
+  "tasks.list",
+  "tasks.cancel",
+  "tasks.cancelAll",
+  "agent.enqueueEvent",
+  "paths.getChatToolStateDir",
+  "paths.getToolStateDir",
+  "paths.getChatToolTmpDir",
+  "paths.getToolTmpDir",
+  "paths.getChatArtifactsDir"
+]);
 
 export function createArisaCapabilities({
+  capabilityService,
   artifactStore,
   taskStore,
   toolRegistry,
   agentManager,
-  resourceNotes = new ToolResourceNoteStore(),
-  installOfficialTool = installBundledOfficialTool
+  resourceNotes,
+  installOfficialTool,
+  logger
 } = {}) {
-  async function dispatch({ method, toolName, chatId = null, params = {} } = {}) {
-    const scopedToolName = requireToolName(toolName);
-
-    if (method === "tools.list") {
-      await toolRegistry.load();
-      return toolRegistry.listWithRuntime(chatId);
-    }
-
-    if (method === "tools.help") {
-      await toolRegistry.load();
-      return toolRegistry.help(requireString(params.name, "name"));
-    }
-
-    if (method === "tools.skills") {
-      await toolRegistry.load();
-      return toolRegistry.resolveSkills(requireString(params.name, "name"));
-    }
-
-    if (method === "tools.setConfig") {
-      await toolRegistry.load();
-      return toolRegistry.setConfig(
-        requireString(params.name, "name"),
-        requireString(params.field, "field"),
-        requireString(params.value, "value"),
-        requireChatId(chatId, method)
-      );
-    }
-
-    if (method === "tools.setResourceNote") {
-      const scopedChatId = requireChatId(chatId, method);
-      return resourceNotes.set(
-        scopedChatId,
-        scopedToolName,
-        requireString(params.resourceId, "resourceId"),
-        String(params.note ?? "")
-      );
-    }
-
-    if (method === "tools.getResourceNote") {
-      const scopedChatId = requireChatId(chatId, method);
-      return {
-        toolName: scopedToolName,
-        resourceId: requireString(params.resourceId, "resourceId"),
-        note: await resourceNotes.get(scopedChatId, scopedToolName, params.resourceId)
-      };
-    }
-
-    if (method === "tools.run") {
-      if (!agentManager?.runTool) {
-        throw new Error("tools.run requires agentManager");
-      }
-      const scopedChatId = requireChatId(chatId, method);
-      const targetToolName = requireString(params.name, "name");
-      const chatArtifactStore = artifactStore.forChat(scopedChatId);
-      const artifact = params.artifactId
-        ? await chatArtifactStore.get(requireString(params.artifactId, "artifactId"))
-        : null;
-      if (params.artifactId && !artifact) {
-        throw new Error(`Artifact not found: ${params.artifactId}`);
+  const service = capabilityService || createCapabilityService({
+    artifactStore,
+    taskStore,
+    toolRegistry,
+    toolExecutor: agentManager,
+    resourceNotes,
+    installOfficialTool,
+    logger
+  });
+
+  return {
+    dispatch: ({ method, toolName, chatId = null, params = {} } = {}) => service.execute({
+      method,
+      actorToolName: toolName,
+      chatId,
+      params,
+      context: {
+        allowedMethods: ipcMethods,
+        unknownMethodLabel: "IPC"
       }
-
-      return agentManager.runTool({
-        name: targetToolName,
-        request: {
-          artifact,
-          text: params.text,
-          resourceId: params.resourceId,
-          args: normalizeArgs(params.args)
-        },
-        chatId: scopedChatId
-      });
-    }
-
-    if (method === "tools.installOfficial") {
-      const name = requireString(params.name, "name");
-      if (params.confirmName !== name) {
-        throw new Error("tools.installOfficial requires confirmName equal to name");
-      }
-      const installed = await installOfficialTool(name);
-      await toolRegistry.load();
-      return installed;
-    }
-
-    if (method === "artifacts.createText") {
-      const scopedChatId = requireChatId(chatId, method);
-      return artifactStore.forChat(scopedChatId).createText({
-        text: requireString(params.text, "text"),
-        mimeType: params.mimeType || "text/plain",
-        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId },
-        metadata: params.metadata || {}
-      });
-    }
-
-    if (method === "artifacts.listRecent") {
-      const scopedChatId = requireChatId(chatId, method);
-      return artifactStore.forChat(scopedChatId).listRecent(normalizeLimit(params.limit));
-    }
-
-    if (method === "artifacts.get") {
-      const scopedChatId = requireChatId(chatId, method);
-      return artifactStore.forChat(scopedChatId).get(requireString(params.artifactId, "artifactId"));
-    }
-
-    if (method === "artifacts.deliver") {
-      const scopedChatId = requireChatId(chatId, method);
-      const artifactId = requireString(params.artifactId, "artifactId");
-      const artifact = await artifactStore.forChat(scopedChatId).get(artifactId);
-      if (!artifact?.path) throw new Error(`Artifact not found or has no file: ${artifactId}`);
-      if (!agentManager?.deliverArtifact) throw new Error("artifact delivery is unavailable");
-      return agentManager.deliverArtifact({
-        chatId: scopedChatId,
-        artifact,
-        caption: params.caption,
-        method: params.method
-      });
-    }
-
-    if (method === "tasks.add") {
-      const scopedChatId = requireChatId(chatId, method);
-      return taskStore.add(params.task || {}, {
-        payload: { chatId: scopedChatId },
-        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId }
-      });
-    }
-
-    if (method === "tasks.list") {
-      const scopedChatId = requireChatId(chatId, method);
-      return taskStore.list({
-        chatId: scopedChatId,
-        status: params.status || undefined,
-        kind: params.kind || undefined
-      });
-    }
-
-    if (method === "tasks.cancel") {
-      const scopedChatId = requireChatId(chatId, method);
-      const taskId = requireString(params.taskId, "taskId");
-      const task = await taskStore.get(taskId);
-      if (!task) return null;
-      if (String(task.payload?.chatId) !== String(scopedChatId)) {
-        throw new Error("task does not belong to chatId");
-      }
-      return taskStore.cancel(taskId);
-    }
-
-    if (method === "tasks.cancelAll") {
-      const scopedChatId = requireChatId(chatId, method);
-      return taskStore.cancelAll({ chatId: scopedChatId });
-    }
-
-    if (method === "agent.enqueueEvent") {
-      const scopedChatId = requireChatId(chatId, method);
-      const resourceId = String(params.resourceId || "").trim();
-      return taskStore.add({
-        kind: "agent_event",
-        payload: {
-          prompt: requireString(params.prompt, "prompt"),
-          resourceId,
-          acknowledgement: normalizeAcknowledgement(params.acknowledgement)
-        }
-      }, {
-        payload: { chatId: scopedChatId },
-        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId, resourceId }
-      });
-    }
-
-    if (method === "paths.getChatToolStateDir") {
-      return getChatToolStateDir(requireChatId(chatId, method), scopedToolName);
-    }
-
-    if (method === "paths.getToolStateDir") {
-      return getToolStateDir(scopedToolName);
-    }
-
-    if (method === "paths.getChatToolTmpDir") {
-      return getChatToolTmpDir(requireChatId(chatId, method), scopedToolName);
-    }
-
-    if (method === "paths.getToolTmpDir") {
-      return getToolTmpDir(scopedToolName);
-    }
-
-    if (method === "paths.getChatArtifactsDir") {
-      return getChatArtifactsDir(requireChatId(chatId, method));
-    }
-
-    throw new Error(`unknown IPC method: ${method}`);
-  }
-
-  return { dispatch };
+    })
+  };
 }

package/src/runtime/create-app.js

@@ -3,6 +3,7 @@ import { ArtifactStore } from "../core/artifacts/artifact-store.js";
 import { ToolRegistry } from "../core/tools/tool-registry.js";
 import { TaskStore } from "../core/tasks/task-store.js";
 import { AgentManager } from "../core/agent/agent-manager.js";
+import { createCapabilityService } from "../core/capabilities/capability-service.js";
 import { getErrorMessage, getPiAuthIssue } from "../core/agent/auth-flow.js";
 import { createTelegramBot } from "../transport/telegram/bot.js";
 import { createToolProcessSupervisor } from "./tool-process-supervisor.js";
@@ -120,7 +121,15 @@ export async function createApp({ logger, runtimeOverrides, requestRestart } = {
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
-  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, toolRegistry, agentManager });
+  const capabilityService = createCapabilityService({
+    artifactStore,
+    taskStore,
+    toolRegistry,
+    toolExecutor: agentManager,
+    logger
+  });
+  agentManager.setCapabilityService(capabilityService);
+  const arisaCapabilities = createArisaCapabilities({ capabilityService });
   const ipcServer = createIpcServer({ capabilities: arisaCapabilities, logger });
   const bot = await createTelegramBot({
     config,

package/src/runtime/create-headless-app.js

@@ -3,6 +3,7 @@ import { loadConfig } from "../core/config/config-store.js";
 import { TaskStore } from "../core/tasks/task-store.js";
 import { ToolRegistry } from "../core/tools/tool-registry.js";
 import { createDaemonRuntime } from "../core/tools/daemon-runtime.js";
+import { createCapabilityService } from "../core/capabilities/capability-service.js";
 import { createArisaCapabilities } from "./arisa-capabilities.js";
 import { createHeadlessToolExecutor } from "./headless-tool-executor.js";
 import { createIpcServer } from "./ipc/ipc-server.js";
@@ -26,12 +27,14 @@ export async function createHeadlessApp({
   await toolRegistry.load();
   const toolProcessSupervisor = supervisorFactory({ logger, policy: config.daemons, toolRegistry });
   const toolExecutor = createHeadlessToolExecutor({ artifactStore, taskStore, toolRegistry });
-  const capabilities = capabilitiesFactory({
+  const capabilityService = createCapabilityService({
     artifactStore,
     taskStore,
     toolRegistry,
-    agentManager: toolExecutor
+    toolExecutor,
+    logger
   });
+  const capabilities = capabilitiesFactory({ capabilityService, agentManager: toolExecutor });
   const ipcServer = ipcServerFactory({ capabilities, logger });
   const autoStartedDaemons = [];