arisa 5.1.49 → 5.1.64

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";
@@ -113,14 +114,22 @@ export async function createApp({ logger, runtimeOverrides, requestRestart } = {
   }
 
   const artifactStore = new ArtifactStore();
-  const toolRegistry = new ToolRegistry({ logger });
+  const toolRegistry = new ToolRegistry({ logger, executionPolicy: config.toolExecution });
   const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons, toolRegistry });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   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";
@@ -13,7 +14,7 @@ export async function createHeadlessApp({
   configLoader = loadConfig,
   artifactStoreFactory = () => new ArtifactStore(),
   taskStoreFactory = () => new TaskStore(),
-  toolRegistryFactory = () => new ToolRegistry({ logger }),
+  toolRegistryFactory = (options) => new ToolRegistry(options),
   supervisorFactory = (options) => createToolProcessSupervisor(options),
   capabilitiesFactory = (options) => createArisaCapabilities(options),
   ipcServerFactory = (options) => createIpcServer(options)
@@ -22,16 +23,18 @@ export async function createHeadlessApp({
   const config = await configLoader();
   const artifactStore = artifactStoreFactory();
   const taskStore = taskStoreFactory();
-  const toolRegistry = toolRegistryFactory();
+  const toolRegistry = toolRegistryFactory({ logger, executionPolicy: config.toolExecution });
   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 = [];
 

package/src/runtime/paths.js

@@ -65,6 +65,10 @@ export function getChatToolResourceNotesFile(chatId) {
   return path.join(getChatDir(chatId), "state", "tool-resource-notes.json");
 }
 
+export function getChatTelegramWorkspacesFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "telegram-workspaces.json");
+}
+
 export function getChatToolStateDir(chatId, toolName) {
   return path.join(getChatDir(chatId), "state", "tools", requireToolName(toolName));
 }

package/src/runtime/service-manager.js

@@ -78,7 +78,9 @@ export async function handoffServiceRestart({ verbose = true, cliArgs = [] } = {
 } = {}) {
   await ensureHome();
   const status = await getStatus();
-  if (!status.running || status.pid !== currentPid) {
+  const supervisorPid = Number.parseInt(environment.ARISA_SUPERVISOR_PID || "", 10);
+  const isActiveWorker = Number.isSafeInteger(supervisorPid) && supervisorPid === status.pid;
+  if (!status.running || (status.pid !== currentPid && !isActiveWorker)) {
     throw new Error("Service restart handoff requires the active background service process");
   }
   const logHandle = await openLog(serviceLogFile, "a");

package/src/runtime/service-supervisor.js

@@ -0,0 +1,98 @@
+import { spawn } from "node:child_process";
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function boundedInteger(value, fallback, minimum, maximum) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= minimum ? Math.min(parsed, maximum) : fallback;
+}
+
+export function createServiceSupervisor({
+  command,
+  args,
+  env = process.env,
+  restartLimit = 3,
+  restartBackoffMs = 2_000,
+  restartBackoffMaxMs = 60_000,
+  stableRuntimeMs = 60_000,
+  logger,
+  spawnProcess = spawn,
+  wait = sleep
+}) {
+  const maximumRestarts = boundedInteger(restartLimit, 3, 0, 10);
+  const initialBackoffMs = boundedInteger(restartBackoffMs, 2_000, 1, 60_000);
+  const maximumBackoffMs = boundedInteger(restartBackoffMaxMs, 60_000, initialBackoffMs, 5 * 60_000);
+  const stableAfterMs = boundedInteger(stableRuntimeMs, 60_000, 1_000, 60 * 60_000);
+  let child = null;
+  let stopping = false;
+  let wakeBackoff = null;
+  let resolveDone;
+  const done = new Promise((resolve) => { resolveDone = resolve; });
+
+  async function run() {
+    let consecutiveFailures = 0;
+    while (!stopping) {
+      const startedAt = Date.now();
+      child = spawnProcess(command, args, {
+        stdio: "inherit",
+        env: { ...env, ARISA_SUPERVISOR_PID: String(process.pid) }
+      });
+      logger?.log("service", `worker started (pid ${child.pid})`);
+
+      const outcome = await new Promise((resolve) => {
+        child.once("error", (error) => resolve({ error }));
+        child.once("exit", (code, signal) => resolve({ code, signal }));
+      });
+      child = null;
+      if (stopping) break;
+
+      const runtimeMs = Date.now() - startedAt;
+      if (runtimeMs >= stableAfterMs) consecutiveFailures = 0;
+      consecutiveFailures += 1;
+      const detail = outcome.error
+        ? errorMessage(outcome.error)
+        : `code=${outcome.code ?? "null"} signal=${outcome.signal || "none"}`;
+      logger?.error("service", `worker exited unexpectedly (${detail})`);
+      if (consecutiveFailures > maximumRestarts) {
+        logger?.error("service", `worker restart limit reached after ${consecutiveFailures} consecutive exits`);
+        break;
+      }
+
+      const delay = Math.min(maximumBackoffMs, initialBackoffMs * (2 ** (consecutiveFailures - 1)));
+      logger?.log("service", `restarting worker in ${delay}ms`);
+      await Promise.race([
+        wait(delay),
+        new Promise((resolve) => { wakeBackoff = resolve; })
+      ]);
+      wakeBackoff = null;
+    }
+    resolveDone();
+  }
+
+  return {
+    async start() {
+      run().catch((error) => {
+        logger?.error("service", `supervisor failed: ${errorMessage(error)}`);
+        resolveDone();
+      });
+      return done;
+    },
+    async stop() {
+      stopping = true;
+      wakeBackoff?.();
+      if (child) {
+        const activeChild = child;
+        const exited = new Promise((resolve) => activeChild.once("exit", resolve));
+        activeChild.kill("SIGTERM");
+        await exited;
+      }
+      resolveDone();
+    }
+  };
+}