arisa 5.1.68 → 5.2.17

package/src/core/tools/tool-registry.js

@@ -1,21 +1,25 @@
 import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { arisaIpcSocketFile, arisaPackageDir, getToolConfigPath, getToolStateDir, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
+import { getToolConfigPath, getToolStateDir, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../platform/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 import { readDaemonDiagnostic } from "./daemon-processes.js";
-import { createDaemonRuntime, DAEMON_EVENT_TYPES, DAEMON_PROTOCOL_VERSION } from "./daemon-runtime.js";
+import { createDaemonRuntime } from "./daemon-runtime.js";
 import { daemonConfigDefaults } from "../config/config-defaults.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 import { ToolUsageStore } from "./tool-usage-store.js";
 import { inspectToolDependencies, normalizeToolDependencies } from "./tool-dependencies.js";
 import { normalizeToolExecution, WeightedResourceGovernor } from "./weighted-resource-governor.js";
+import {
+  isolatedToolProcessInvocation,
+  runToolHelpProcess,
+  runToolProcess,
+  toolProcessEnv
+} from "./tool-process-runner.js";
 
-function toolEnv() {
-  return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir, ARISA_IPC_SOCKET: arisaIpcSocketFile };
-}
+export { createToolOutputParser } from "./tool-process-output.js";
+export { isolatedToolProcessInvocation } from "./tool-process-runner.js";
 
 const defaultToolHelpTimeoutMs = 10_000;
 const defaultToolRunTimeoutMs = 30 * 60_000;
@@ -38,168 +42,42 @@ function concurrentExecutionKey(name, chatId, request) {
   return createHash("sha256").update(serialized).digest("hex");
 }
 
-function waitForToolProcess(child, { timeoutMs, killGraceMs, label }) {
-  return new Promise((resolve, reject) => {
-    let timedOut = false;
-    let forceTimer = null;
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      forceTimer = setTimeout(() => child.kill("SIGKILL"), killGraceMs);
-    }, timeoutMs);
-
-    const finish = (callback, value) => {
-      clearTimeout(timeout);
-      clearTimeout(forceTimer);
-      callback(value);
-    };
-
-    child.once("error", (error) => finish(reject, error));
-    child.once("close", (code) => {
-      if (!timedOut) {
-        finish(resolve, code);
-        return;
-      }
-      const error = new Error(`${label} timed out after ${timeoutMs}ms`);
-      error.code = "TOOL_PROCESS_TIMEOUT";
-      finish(reject, error);
-    });
-  });
+export function readyDaemonAdmission(tool, diagnostic) {
+  const reusable = Boolean(tool?.daemon)
+    && diagnostic?.alive === true
+    && diagnostic?.state === "ready"
+    && diagnostic?.restart?.requested !== true;
+  return reusable ? { ignoreWorkerRss: true } : {};
 }
 
-async function runProcess(command, args, { timeoutMs, killGraceMs, label, ...options } = {}) {
-  const child = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
-  let stdout = "";
-  let stderr = "";
-  child.stdout.on("data", (d) => { stdout += d.toString(); });
-  child.stderr.on("data", (d) => { stderr += d.toString(); });
-  const code = await waitForToolProcess(child, { timeoutMs, killGraceMs, label });
-  return { code, stdout, stderr };
+function declaredDaemonScope(tool, chatId) {
+  if (!tool?.daemon) return null;
+  return tool.daemon.scope === "chat"
+    ? { type: "chat", chatId }
+    : { type: "global" };
 }
 
-function requirementNames(requirements) {
-  if (Array.isArray(requirements)) {
-    return requirements.map((item) => typeof item === "string" ? item : item?.name).filter(Boolean);
-  }
-  if (requirements && typeof requirements === "object") return Object.keys(requirements);
-  return [];
+function nativeDaemonScope(tool, chatId) {
+  return tool?.daemon?.protocol === "arisa-daemon-v1" ? declaredDaemonScope(tool, chatId) : null;
 }
 
-export function createToolOutputParser(name, { onEvent, maxFrameBytes = 1_048_576 } = {}) {
-  let buffer = "";
-  let mode = "unknown";
-  let rawOutput = "";
-  let terminalResult = null;
-  let activeJobId = null;
-  let sequence = 0;
-  let terminalSeen = false;
-
-  async function parseEvent(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      throw new Error(`Invalid NDJSON from ${name}`);
-    }
-    if (event?.version !== DAEMON_PROTOCOL_VERSION || !DAEMON_EVENT_TYPES.includes(event?.type)) {
-      throw new Error(`Invalid versioned tool event from ${name}`);
-    }
-    if (typeof event.jobId !== "string" || !event.jobId) throw new Error(`Tool event from ${name} is missing jobId`);
-    if (activeJobId == null) activeJobId = event.jobId;
-    if (event.jobId !== activeJobId) throw new Error(`Tool ${name} multiplexed an unexpected jobId`);
-    if (!Number.isSafeInteger(event.sequence) || event.sequence !== sequence + 1) {
-      throw new Error(`Invalid tool event sequence from ${name}: ${event.sequence}`);
-    }
-    if (terminalSeen) throw new Error(`Tool ${name} emitted more than one terminal event`);
-    sequence = event.sequence;
-    terminalSeen = event.type === "completed" || event.type === "failed";
-    await onEvent?.(event);
-    if (terminalSeen) {
-      terminalResult = event.type === "completed"
-        ? event.payload?.result ?? event.payload?.output ?? event.payload
-        : { ok: false, error: event.payload?.error || `Tool failed: ${name}`, ...(event.payload?.code ? { code: event.payload.code } : {}) };
-    }
-  }
-
-  async function consumeLine(line) {
-    if (Buffer.byteLength(line, "utf8") > maxFrameBytes) throw new Error(`Tool event from ${name} exceeds ${maxFrameBytes} bytes`);
-    if (mode === "unknown") {
-      let candidate;
-      try {
-        candidate = JSON.parse(line);
-      } catch {
-        mode = "legacy";
-        return;
-      }
-      if (candidate?.version === DAEMON_PROTOCOL_VERSION && DAEMON_EVENT_TYPES.includes(candidate?.type)) {
-        mode = "ndjson";
-        rawOutput = "";
-        return parseEvent(line);
-      }
-      mode = "legacy";
-      return;
-    }
-    if (mode === "legacy") return;
-    return parseEvent(line);
-  }
-
+function executionForLease(execution, lease) {
+  if (!execution) return null;
   return {
-    async push(chunk) {
-      const text = chunk.toString("utf8");
-      if (mode !== "ndjson") rawOutput += text;
-      if (mode === "legacy") return;
-      buffer += text;
-      if (Buffer.byteLength(buffer, "utf8") > maxFrameBytes && !buffer.includes("\n")) {
-        throw new Error(`Tool event from ${name} exceeds ${maxFrameBytes} bytes`);
-      }
-      let newlineIndex = buffer.indexOf("\n");
-      while (newlineIndex !== -1) {
-        const line = buffer.slice(0, newlineIndex).trim();
-        buffer = buffer.slice(newlineIndex + 1);
-        if (line) await consumeLine(line);
-        newlineIndex = buffer.indexOf("\n");
-      }
-    },
-    async finish() {
-      const tail = buffer.trim();
-      buffer = "";
-      if (tail) await consumeLine(tail);
-      if (mode !== "ndjson") return { mode: "legacy", output: rawOutput };
-      if (!terminalSeen) throw new Error(`Tool ${name} ended without a terminal event`);
-      return { mode: "ndjson", result: terminalResult };
-    }
+    ...execution,
+    maxHeapMb: lease.heapLimitMb || execution.maxHeapMb,
+    maxMemoryMb: lease.memoryLimitMb || execution.maxMemoryMb,
+    memoryHighPercent: lease.memoryHighPercent,
+    swapMaxMb: lease.swapMaxMb
   };
 }
 
-async function runToolProcess(command, args, { onEvent, maxFrameBytes, timeoutMs, killGraceMs, label, ...options } = {}) {
-  const child = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
-  const parser = createToolOutputParser(path.basename(args[0] || command), { onEvent, maxFrameBytes });
-  const stderrChunks = [];
-  let stderrBytes = 0;
-  const stdoutTask = (async () => {
-    for await (const chunk of child.stdout) await parser.push(chunk);
-    return parser.finish();
-  })();
-  const stderrTask = (async () => {
-    for await (const chunk of child.stderr) {
-      if (stderrBytes >= maxFrameBytes) continue;
-      const accepted = chunk.subarray(0, maxFrameBytes - stderrBytes);
-      stderrChunks.push(accepted);
-      stderrBytes += accepted.length;
-    }
-    return Buffer.concat(stderrChunks).toString("utf8");
-  })();
-  child.stdout.resume();
-  child.stderr.resume();
-  let code;
-  try {
-    code = await waitForToolProcess(child, { timeoutMs, killGraceMs, label });
-  } catch (error) {
-    await Promise.allSettled([stdoutTask, stderrTask]);
-    throw error;
+function requirementNames(requirements) {
+  if (Array.isArray(requirements)) {
+    return requirements.map((item) => typeof item === "string" ? item : item?.name).filter(Boolean);
   }
-  const [parsed, stderr] = await Promise.all([stdoutTask, stderrTask]);
-  return { code, parsed, stderr };
+  if (requirements && typeof requirements === "object") return Object.keys(requirements);
+  return [];
 }
 
 function normalizeCategory(category) {
@@ -407,29 +285,44 @@ export class ToolRegistry {
   async help(name) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
-    const result = await runProcess("node", [tool.entry, "--help"], {
-      cwd: tool.dir,
-      env: toolEnv(),
-      timeoutMs: this.helpTimeoutMs,
-      killGraceMs: this.killGraceMs,
-      label: `Tool help for ${name}`
-    });
-    const help = result.stdout || result.stderr;
-    const skills = await this.resolveSkills(name);
-    const sections = [
-      help.trimEnd(),
-      formatSemanticMetadata(tool),
-      formatToolDependencies(tool, this.tools)
-    ];
-    if (skills.length) {
-      const skillHelp = skills.map((item) => [
-        `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
-        item.description ? `  ${item.description}` : null,
-        item.found ? `  path: ${item.path}` : "  warning: skill not found"
-      ].filter(Boolean).join("\n")).join("\n");
-      sections.push(`Assigned skills:\n${skillHelp}`);
+    const lease = await this.executionGovernor.acquire(tool.execution, `${name}:help`);
+    try {
+      const execution = executionForLease(tool.execution, lease);
+      const nodeArgs = [
+        ...(execution?.maxHeapMb ? [`--max-old-space-size=${execution.maxHeapMb}`] : []),
+        tool.entry,
+        "--help"
+      ];
+      const invocation = isolatedToolProcessInvocation(nodeArgs, execution);
+      const result = await runToolHelpProcess(invocation.command, invocation.args, {
+        cwd: tool.dir,
+        env: toolProcessEnv(),
+        timeoutMs: this.helpTimeoutMs,
+        killGraceMs: this.killGraceMs,
+        maxOutputBytes: execution?.maxOutputBytes || daemonConfigDefaults.ipcFrameBytes,
+        label: `Tool help for ${name}`
+      });
+      const help = result.stdout || result.stderr;
+      const skills = await this.resolveSkills(name);
+      const sections = [
+        help.trimEnd(),
+        formatSemanticMetadata(tool),
+        formatToolDependencies(tool, this.tools)
+      ];
+      if (skills.length) {
+        const skillHelp = skills.map((item) => [
+          `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
+          item.description ? `  ${item.description}` : null,
+          item.found ? `  path: ${item.path}` : "  warning: skill not found"
+        ].filter(Boolean).join("\n")).join("\n");
+        sections.push(`Assigned skills:\n${skillHelp}`);
+      }
+      lease.release({ success: result.code === 0 });
+      return `${sections.filter(Boolean).join("\n\n")}\n`;
+    } catch (error) {
+      lease.release({ memoryLimited: error?.code === "TOOL_PROCESS_MEMORY_LIMIT" });
+      throw error;
     }
-    return `${sections.filter(Boolean).join("\n\n")}\n`;
   }
 
   async resolveSkills(name) {
@@ -522,32 +415,56 @@ export class ToolRegistry {
     const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
     const requestFile = path.join(tmpDir, `.request-${Date.now()}-${randomUUID()}.json`);
     let lease = null;
+    let leaseOutcome = {};
     let result;
     try {
-      lease = await this.executionGovernor.acquire(tool.execution, name);
+      const admissionScope = declaredDaemonScope(tool, chatId);
+      let admission = {};
+      if (admissionScope) {
+        const diagnostic = await readDaemonDiagnostic({
+          toolName: name,
+          scope: admissionScope,
+          autoStart: Boolean(tool.daemon.autoStart)
+        }).catch(() => null);
+        admission = readyDaemonAdmission(tool, diagnostic);
+        if (admission.ignoreWorkerRss) this.logger?.log("tools", `reusing ready ${name} daemon without worker RSS spawn admission`);
+      }
+      lease = await this.executionGovernor.acquire(tool.execution, name, admission);
       this.logger?.log("tools", `running ${name}`);
       await mkdir(tmpDir, { recursive: true });
       const skills = await this.resolveSkills(name);
       const enrichedRequest = { ...request, chatId, skills };
-      if (tool.daemon?.protocol === "arisa-daemon-v1") {
-        const scope = tool.daemon.scope === "chat"
-          ? { type: "chat", chatId }
-          : { type: "global" };
+      const runtimeScope = nativeDaemonScope(tool, chatId);
+      if (runtimeScope) {
         const runtime = createDaemonRuntime({
           toolName: name,
           entryPath: tool.entry,
-          scope,
-          startupContext: scope.type === "chat" ? { chatId: String(chatId) } : {},
+          scope: runtimeScope,
+          startupContext: runtimeScope.type === "chat" ? { chatId: String(chatId) } : {},
           autoStart: Boolean(tool.daemon.autoStart)
         });
         result = await runtime.submit(enrichedRequest, { onEvent });
       } else {
         await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
-        const processResult = await runToolProcess("node", [tool.entry, "run", "--request-file", requestFile], {
+        const execution = executionForLease(tool.execution, lease);
+        const nodeArgs = [
+          ...(execution?.maxHeapMb ? [`--max-old-space-size=${execution.maxHeapMb}`] : []),
+          tool.entry,
+          "run",
+          "--request-file",
+          requestFile
+        ];
+        const processInvocation = isolatedToolProcessInvocation(nodeArgs, execution);
+        if (processInvocation.isolated) {
+          this.logger?.log("tools", `${name} isolated at ${execution.maxMemoryMb} MiB total memory (${execution.maxHeapMb} MiB heap)`);
+        }
+        const processResult = await runToolProcess(processInvocation.command, processInvocation.args, {
           cwd: tool.dir,
-          env: toolEnv(),
+          env: toolProcessEnv(),
           onEvent,
+          parserName: name,
           maxFrameBytes: daemonConfigDefaults.ipcFrameBytes,
+          maxOutputBytes: tool.execution?.maxOutputBytes || daemonConfigDefaults.ipcFrameBytes,
           timeoutMs: this.runTimeoutMs,
           killGraceMs: this.killGraceMs,
           label: `Tool run for ${name}`
@@ -555,11 +472,21 @@ export class ToolRegistry {
         if (processResult.stderr.trim()) {
           this.logger?.log("tools", `${name} stderr: ${processResult.stderr.trim()}`);
         }
+        if (processResult.code !== 0) {
+          const memoryLimited = /heap limit|heap out of memory|allocation failed.*memory|memory cgroup out of memory|\bkilled\b/i.test(processResult.stderr)
+            || (processInvocation.isolated && [9, 134, 137].includes(processResult.code));
+          const error = new Error(memoryLimited
+            ? `Tool ${name} exceeded its isolated memory limit`
+            : `Tool ${name} exited with code ${processResult.code}`);
+          error.code = memoryLimited ? "TOOL_PROCESS_MEMORY_LIMIT" : "TOOL_PROCESS_EXIT";
+          throw error;
+        }
         result = processResult.parsed.mode === "ndjson"
           ? processResult.parsed.result
           : JSON.parse(processResult.parsed.output);
       }
       const normalized = normalizeToolResult(name, result);
+      leaseOutcome = { success: normalized.ok !== false };
       if (normalized.ok === false) {
         this.logger?.log("tools", `${name} -> ${normalized.status || "error"}: ${normalized.error || "unknown error"}`);
       } else {
@@ -567,7 +494,20 @@ export class ToolRegistry {
       }
       return normalized;
     } catch (error) {
-      if (error?.code === "TOOL_PROCESS_TIMEOUT") {
+      leaseOutcome = { memoryLimited: error?.code === "TOOL_PROCESS_MEMORY_LIMIT" };
+      if (error?.code === "TOOL_RESOURCE_PRESSURE") {
+        return normalizeToolResult(name, {
+          ok: false,
+          status: "retryable",
+          error: error.message,
+          resolution: {
+            type: "retry_later",
+            retry: true,
+            message: "The tool was not started. Retry after host memory pressure falls."
+          }
+        });
+      }
+      if (["TOOL_PROCESS_TIMEOUT", "TOOL_OUTPUT_LIMIT", "TOOL_PROCESS_MEMORY_LIMIT", "TOOL_PROCESS_EXIT"].includes(error?.code)) {
         return normalizeToolResult(name, {
           ok: false,
           status: "outcome_uncertain",
@@ -575,7 +515,7 @@ export class ToolRegistry {
           resolution: {
             type: "status_check_required",
             retry: false,
-            message: "The tool process was terminated after timing out. Check external state before retrying."
+            message: "The isolated tool process ended without a confirmed result. Check external state before retrying."
           }
         });
       }
@@ -584,7 +524,7 @@ export class ToolRegistry {
         error: error?.message || `Invalid tool response for ${name}`
       });
     } finally {
-      lease?.release();
+      lease?.release(leaseOutcome);
       await unlink(requestFile).catch(() => {});
       await rmdir(tmpDir).catch(() => {});
       if (chatId != null) {

package/src/core/tools/tool-resource-note-store.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getChatToolResourceNotesFile } from "../../runtime/paths.js";
+import { getChatToolResourceNotesFile } from "../../platform/paths.js";
 
 export const maxToolResourceNoteCharacters = 200;
 

package/src/core/tools/tool-usage-store.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getChatToolUsageFile } from "../../runtime/paths.js";
+import { getChatToolUsageFile } from "../../platform/paths.js";
 
 function emptyUsage() {
   return { version: 1, tools: {} };