arisa 5.1.68 → 5.2.17

package/src/runtime/doctor.js

@@ -1,86 +1,21 @@
-import { execFile } from "node:child_process";
 import { statfs } from "node:fs/promises";
 import os from "node:os";
 import process from "node:process";
-import { promisify } from "node:util";
 import { stopManagedDaemon, unregisterManagedDaemon } from "../core/tools/daemon-processes.js";
 import { getServiceStatus, serviceEntryFile } from "./service-manager.js";
-import { arisaHomeDir } from "./paths.js";
+import { arisaHomeDir } from "../platform/paths.js";
 import { renderTextReport, reportRow, wrapReportText } from "./report-format.js";
+import {
+  isArisaServiceProcess as matchesArisaServiceProcess,
+  isDaemonProcess,
+  listSystemProcesses,
+  terminateProcess
+} from "./process-inspection.js";
 
-const execFileAsync = promisify(execFile);
-
-function parsePosixProcesses(output) {
-  return String(output || "")
-    .split("\n")
-    .map((line) => /^\s*(\d+)\s+(.+)$/.exec(line))
-    .filter(Boolean)
-    .map((match) => ({ pid: Number(match[1]), command: match[2] }));
-}
-
-function parseWindowsProcesses(output) {
-  const parsed = JSON.parse(output || "[]");
-  const records = Array.isArray(parsed) ? parsed : [parsed];
-  return records
-    .filter((record) => record?.ProcessId && record?.CommandLine)
-    .map((record) => ({ pid: Number(record.ProcessId), command: String(record.CommandLine) }));
-}
-
-export async function listSystemProcesses({ timeoutMs, platform = process.platform } = {}) {
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new Error("Doctor process inspection requires a positive timeoutMs");
-  }
-  if (platform === "win32") {
-    const { stdout } = await execFileAsync("powershell.exe", [
-      "-NoProfile",
-      "-Command",
-      "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
-    ], { timeout: timeoutMs, windowsHide: true });
-    return parseWindowsProcesses(stdout);
-  }
-  const { stdout } = await execFileAsync("ps", ["-ww", "-axo", "pid=,command="], { timeout: timeoutMs });
-  return parsePosixProcesses(stdout);
-}
+export { listSystemProcesses, terminateProcess } from "./process-inspection.js";
 
 function isArisaServiceProcess(record) {
-  return record.command.includes(serviceEntryFile)
-    && /(?:^|\s)--service-runner(?:\s|$)/.test(record.command);
-}
-
-function isDaemonProcess(record, daemon) {
-  return record.command.includes(daemon.entryPath)
-    && /(?:^|\s)daemon(?:\s|$)/.test(record.command);
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function terminateProcess(pid, { forceAfterMs } = {}) {
-  if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) {
-    throw new Error(`Refusing to terminate invalid doctor target: ${pid}`);
-  }
-  if (!Number.isFinite(forceAfterMs) || forceAfterMs <= 0) {
-    throw new Error("Doctor process cleanup requires a positive forceAfterMs");
-  }
-  if (!isAlive(pid)) return false;
-  process.kill(pid, "SIGTERM");
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < forceAfterMs) {
-    if (!isAlive(pid)) return true;
-    await sleep(Math.min(100, forceAfterMs));
-  }
-  if (isAlive(pid)) process.kill(pid, "SIGKILL");
-  return true;
+  return matchesArisaServiceProcess(record, serviceEntryFile);
 }
 
 function daemonLabel(record) {
@@ -314,7 +249,8 @@ export async function runDoctor({
   unregisterDaemon = unregisterManagedDaemon,
   inspectResources = inspectSystemResources,
   inspectInfrastructure = null,
-  inspectToolDependencies = null
+  inspectToolDependencies = null,
+  supervisorPid = Number.parseInt(process.env.ARISA_SUPERVISOR_PID || "", 10)
 }) {
   assertDoctorPolicy(doctorPolicy);
   const runtime = await agentManager.getRuntimeDiagnostic();
@@ -362,7 +298,9 @@ export async function runDoctor({
 
   const processByPid = new Map(processes.map((record) => [record.pid, record]));
   const currentService = await serviceStatus();
-  if (currentService.running && currentService.pid !== process.pid) {
+  const belongsToCurrentService = currentService.pid === process.pid
+    || (Number.isSafeInteger(supervisorPid) && currentService.pid === supervisorPid);
+  if (currentService.running && !belongsToCurrentService) {
     const registered = processByPid.get(currentService.pid);
     if (registered && isArisaServiceProcess(registered)) {
       try {
@@ -383,6 +321,18 @@ export async function runDoctor({
   }
   for (const result of report.daemons) {
     const label = daemonLabel(result.record);
+    if (result.outcome === "obsolete-removed") {
+      report.repairs.push(`Removed obsolete daemon ${label}: ${result.reason}.`);
+      continue;
+    }
+    if (result.outcome === "obsolete-unverified") {
+      report.attention.push(`${label} is obsolete, but its live process identity could not be verified.`);
+      continue;
+    }
+    if (result.outcome === "obsolete-cleanup-error") {
+      report.attention.push(`${label} obsolete daemon cleanup failed: ${result.error || "unknown error"}.`);
+      continue;
+    }
     if (result.outcome === "stale-registration") {
       const pid = result.diagnostic?.pid;
       const registered = pid ? processByPid.get(pid) : null;

package/src/runtime/flush.js

@@ -1,5 +1,5 @@
 import { rm } from "node:fs/promises";
-import { arisaHomeDir } from "./paths.js";
+import { arisaHomeDir } from "../platform/paths.js";
 
 export async function flushArisaHome() {
   await rm(arisaHomeDir, { recursive: true, force: true });

package/src/runtime/ipc/ipc-server.js

@@ -1,7 +1,7 @@
 import net from "node:net";
 import path from "node:path";
 import { chmod, mkdir, unlink } from "node:fs/promises";
-import { arisaIpcSocketFile } from "../paths.js";
+import { arisaIpcSocketFile } from "../../platform/paths.js";
 
 function writeResponse(socket, response) {
   socket.write(`${JSON.stringify(response)}\n`);

package/src/runtime/log-viewer.js

@@ -1,6 +1,6 @@
 import { open, readFile, stat } from "node:fs/promises";
 import { cliLogConfig } from "../core/config/config-defaults.js";
-import { ensureArisaHome, serviceLogFile } from "./paths.js";
+import { ensureArisaHome, serviceLogFile } from "../platform/paths.js";
 
 const readChunkSize = 64 * 1024;
 

package/src/runtime/obsolete-daemon-reaper.js

@@ -0,0 +1,43 @@
+import { purgeManagedDaemon } from "../core/tools/daemon-processes.js";
+import { isDaemonProcess, listSystemProcesses, terminateProcess } from "./process-inspection.js";
+
+export async function reapObsoleteDaemon({
+  record,
+  diagnostic,
+  reason,
+  timeoutMs,
+  stopTimeoutMs,
+  inspectProcesses = listSystemProcesses,
+  stopProcess = terminateProcess,
+  purgeDaemon = purgeManagedDaemon
+} = {}) {
+  const pid = diagnostic?.pid;
+  if (pid) {
+    let processes;
+    try {
+      processes = await inspectProcesses({ timeoutMs });
+    } catch (error) {
+      return {
+        record,
+        outcome: "obsolete-unverified",
+        reason,
+        diagnostic,
+        error: `process inspection failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    const processRecord = processes.find((item) => item.pid === pid);
+    if (!processRecord || !isDaemonProcess(processRecord, record)) {
+      return { record, outcome: "obsolete-unverified", reason, diagnostic };
+    }
+    await stopProcess(pid, { forceAfterMs: stopTimeoutMs });
+  }
+
+  await purgeDaemon({ toolName: record.toolName, scope: record.scope });
+  return {
+    record,
+    outcome: "obsolete-removed",
+    reason,
+    diagnostic,
+    stoppedPid: pid || null
+  };
+}

package/src/runtime/oom-protection.js

@@ -0,0 +1,20 @@
+import { writeFile } from "node:fs/promises";
+
+const defaultCoreOomScoreAdjust = -900;
+
+export async function protectCoreFromOom({
+  platform = process.platform,
+  score = defaultCoreOomScoreAdjust,
+  writeScore = (value) => writeFile("/proc/self/oom_score_adj", `${value}\n`, "utf8"),
+  logger
+} = {}) {
+  if (platform !== "linux") return false;
+  try {
+    await writeScore(score);
+    logger?.log("service", `core OOM priority protected at ${score}`);
+    return true;
+  } catch (error) {
+    logger?.log("service", `core OOM priority could not be lowered: ${error?.code || error?.message || error}`);
+    return false;
+  }
+}

package/src/runtime/paths.js

@@ -1,151 +1,3 @@
-import { mkdir } from "node:fs/promises";
-import crypto from "node:crypto";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const arisaPackageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-export const arisaHomeDir = process.env.ARISA_HOME
-  ? path.resolve(process.env.ARISA_HOME)
-  : path.join(os.homedir(), ".arisa");
-export const stateDir = path.join(arisaHomeDir, "state");
-export const configFile = path.join(stateDir, "config.json");
-export const piAuthFile = path.join(stateDir, "pi-auth.json");
-export const servicePidFile = path.join(stateDir, "arisa.pid");
-export const serviceLogFile = path.join(stateDir, "arisa.log");
-export const restartReceiptFile = path.join(stateDir, "restart-receipt.json");
-export const sessionStartOperationalNotesFile = path.join(stateDir, "session-start-operational-notes.json");
-export function createIpcSocketPath({ homeDir = arisaHomeDir, platform = process.platform } = {}) {
-  if (platform === "win32") {
-    const suffix = crypto.createHash("sha256").update(homeDir).digest("hex").slice(0, 16);
-    return `\\\\.\\pipe\\arisa-${suffix}`;
-  }
-  return path.join(homeDir, "state", "arisa.sock");
-}
-
-export const arisaIpcSocketFile = createIpcSocketPath();
-export const tasksFile = path.join(stateDir, "tasks.json");
-export const toolsDir = path.join(arisaHomeDir, "tools");
-export const chatsDir = path.join(arisaHomeDir, "chats");
-export const toolStateDir = path.join(stateDir, "tools");
-
-export function requireToolName(toolName) {
-  const name = String(toolName ?? "");
-  if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
-    throw new Error(`Invalid tool name: ${name || "empty"}`);
-  }
-  return name;
-}
-
-export function getChatDir(chatId) {
-  return path.join(chatsDir, String(chatId));
-}
-
-export function getChatArtifactsDir(chatId) {
-  return path.join(getChatDir(chatId), "artifacts");
-}
-
-export function getChatArtifactsIndexFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "artifacts.json");
-}
-
-export function getChatSessionSeedFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "session-seed.jsonl");
-}
-
-export function getChatLegacyConversationHistoryFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "conversation.jsonl");
-}
-
-export function getChatToolUsageFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "tool-usage.json");
-}
-
-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));
-}
-
-export function normalizeDaemonScope(scope = { type: "global" }) {
-  if (!scope || scope === "global" || scope.type === "global") {
-    return { type: "global" };
-  }
-  if (scope === "chat") {
-    throw new Error("chat daemon scope requires chatId");
-  }
-  if (scope.type !== "chat") {
-    throw new Error(`Unsupported daemon scope: ${scope.type || scope}`);
-  }
-  const chatId = String(scope.chatId ?? "").trim();
-  if (!/^-?\d+$/.test(chatId)) {
-    throw new Error(`Invalid chat daemon scope: ${chatId || "missing chatId"}`);
-  }
-  return { type: "chat", chatId };
-}
-
-export function getDaemonInstanceId(scope = { type: "global" }) {
-  const normalized = normalizeDaemonScope(scope);
-  return normalized.type === "global" ? "global" : `chat:${normalized.chatId}`;
-}
-
-export function getDaemonInstanceDir(toolName, scope = { type: "global" }) {
-  const normalized = normalizeDaemonScope(scope);
-  return normalized.type === "global"
-    ? getToolStateDir(toolName)
-    : path.join(getChatToolStateDir(normalized.chatId, toolName), "daemon");
-}
-
-export function getChatPiSessionsDir(chatId, sessionRevision = 0) {
-  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
-    throw new Error(`Invalid Pi session revision: ${sessionRevision}`);
-  }
-  const sessionsDir = path.join(getChatDir(chatId), "state", "pi-sessions");
-  return sessionRevision === 0
-    ? sessionsDir
-    : path.join(sessionsDir, String(sessionRevision));
-}
-
-export function getToolDir(toolName) {
-  return path.join(toolsDir, requireToolName(toolName));
-}
-
-export function getToolConfigPath(toolName) {
-  return path.join(getToolDir(toolName), "config.js");
-}
-
-export function getChatConfigDir(chatId) {
-  return path.join(getChatDir(chatId), "config");
-}
-
-export function getChatTmpDir(chatId) {
-  return path.join(getChatDir(chatId), "tmp");
-}
-
-export function getChatToolConfigPath(chatId, toolName) {
-  return path.join(getChatConfigDir(chatId), "tools", requireToolName(toolName), "config.js");
-}
-
-export function getToolStateDir(toolName) {
-  return path.join(toolStateDir, requireToolName(toolName));
-}
-
-export function getToolTmpDir(toolName) {
-  return path.join(getToolStateDir(toolName), "tmp");
-}
-
-export function getChatToolTmpDir(chatId, toolName) {
-  return path.join(getChatTmpDir(chatId), "tools", toolName);
-}
-
-export async function ensureArisaHome() {
-  await mkdir(stateDir, { recursive: true });
-  await mkdir(toolsDir, { recursive: true });
-  await mkdir(chatsDir, { recursive: true });
-}
+// Public compatibility facade for tools and integrations.
+// Core and runtime internals import the neutral platform implementation directly.
+export * from "../platform/paths.js";

package/src/runtime/process-inspection.js

@@ -0,0 +1,78 @@
+import { execFile } from "node:child_process";
+import process from "node:process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+function parsePosixProcesses(output) {
+  return String(output || "")
+    .split("\n")
+    .map((line) => /^\s*(\d+)\s+(.+)$/.exec(line))
+    .filter(Boolean)
+    .map((match) => ({ pid: Number(match[1]), command: match[2] }));
+}
+
+function parseWindowsProcesses(output) {
+  const parsed = JSON.parse(output || "[]");
+  const records = Array.isArray(parsed) ? parsed : [parsed];
+  return records
+    .filter((record) => record?.ProcessId && record?.CommandLine)
+    .map((record) => ({ pid: Number(record.ProcessId), command: String(record.CommandLine) }));
+}
+
+export async function listSystemProcesses({ timeoutMs, platform = process.platform } = {}) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Process inspection requires a positive timeoutMs");
+  }
+  if (platform === "win32") {
+    const { stdout } = await execFileAsync("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
+    ], { timeout: timeoutMs, windowsHide: true });
+    return parseWindowsProcesses(stdout);
+  }
+  const { stdout } = await execFileAsync("ps", ["-ww", "-axo", "pid=,command="], { timeout: timeoutMs });
+  return parsePosixProcesses(stdout);
+}
+
+export function isArisaServiceProcess(record, entryFile) {
+  return record.command.includes(entryFile)
+    && /(?:^|\s)--service-runner(?:\s|$)/.test(record.command);
+}
+
+export function isDaemonProcess(record, daemon) {
+  return record.command.includes(daemon.entryPath)
+    && /(?:^|\s)daemon(?:\s|$)/.test(record.command);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function terminateProcess(pid, { forceAfterMs } = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) {
+    throw new Error(`Refusing to terminate invalid process target: ${pid}`);
+  }
+  if (!Number.isFinite(forceAfterMs) || forceAfterMs <= 0) {
+    throw new Error("Process cleanup requires a positive forceAfterMs");
+  }
+  if (!isAlive(pid)) return false;
+  process.kill(pid, "SIGTERM");
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < forceAfterMs) {
+    if (!isAlive(pid)) return true;
+    await sleep(Math.min(100, forceAfterMs));
+  }
+  if (isAlive(pid)) process.kill(pid, "SIGKILL");
+  return true;
+}

package/src/runtime/restart-receipt.js

@@ -3,7 +3,7 @@ import { execFile } from "node:child_process";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
-import { arisaPackageDir, restartReceiptFile } from "./paths.js";
+import { arisaPackageDir, restartReceiptFile } from "../platform/paths.js";
 
 const execFileAsync = promisify(execFile);
 

package/src/runtime/service-manager.js

@@ -2,7 +2,7 @@ import { open, readFile, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { ensureArisaHome, serviceLogFile, servicePidFile } from "./paths.js";
+import { ensureArisaHome, serviceLogFile, servicePidFile } from "../platform/paths.js";
 
 export const serviceEntryFile = fileURLToPath(new URL("../index.js", import.meta.url));
 

package/src/runtime/service-supervisor.js

@@ -22,6 +22,7 @@ export function createServiceSupervisor({
   restartBackoffMaxMs = 60_000,
   stableRuntimeMs = 60_000,
   logger,
+  onUnexpectedExit = null,
   spawnProcess = spawn,
   wait = sleep
 }) {
@@ -65,6 +66,19 @@ export function createServiceSupervisor({
       }
 
       const delay = Math.min(maximumBackoffMs, initialBackoffMs * (2 ** (consecutiveFailures - 1)));
+      try {
+        await onUnexpectedExit?.({
+          occurredAt: new Date().toISOString(),
+          runtimeMs,
+          restartDelayMs: delay,
+          consecutiveFailures,
+          code: outcome.code ?? null,
+          signal: outcome.signal || null,
+          detail
+        });
+      } catch (error) {
+        logger?.error("service", `worker recovery report failed: ${errorMessage(error)}`);
+      }
       logger?.log("service", `restarting worker in ${delay}ms`);
       await Promise.race([
         wait(delay),

package/src/runtime/slave-cli.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { applyConfigDefaults } from "../core/config/config-defaults.js";
 import { installLockedOfficialTool } from "../core/tools/official-tool-installer.js";
 import { createHeadlessApp } from "./create-headless-app.js";
-import { arisaPackageDir } from "./paths.js";
+import { arisaPackageDir } from "../platform/paths.js";
 import { readPackageVersion, readRecentLogLines, followLogFile } from "./log-viewer.js";
 import { parseSlaveBootstrapUrl } from "./slave-bootstrap-url.js";
 import { withSecureRequestFile } from "./secure-request-file.js";

package/src/runtime/tool-process-supervisor.js

@@ -8,7 +8,8 @@ import {
   writeDaemonStatus
 } from "../core/tools/daemon-processes.js";
 import { loadDaemonPolicy } from "../core/tools/daemon-policy.js";
-import { ensureArisaHome } from "./paths.js";
+import { ensureArisaHome } from "../platform/paths.js";
+import { reapObsoleteDaemon } from "./obsolete-daemon-reaper.js";
 
 async function fileExists(file) {
   try {
@@ -58,7 +59,12 @@ function validateRegistration(record, toolRegistry) {
   };
 }
 
-export function createToolProcessSupervisor({ logger, policy, toolRegistry } = {}) {
+export function createToolProcessSupervisor({
+  logger,
+  policy,
+  toolRegistry,
+  obsoleteDaemonReaper = reapObsoleteDaemon
+} = {}) {
   let running = false;
   let timer = null;
   let reconciliation = null;
@@ -75,13 +81,34 @@ export function createToolProcessSupervisor({ logger, policy, toolRegistry } = {
     for (const registeredRecord of await listRegisteredDaemons()) {
       const validation = validateRegistration(registeredRecord, toolRegistry);
       if (!validation.valid) {
-        logger?.log("tools", `skipping stale daemon registration ${registeredRecord.toolName} (${registeredRecord.instanceId || "global"}): ${validation.reason}`);
-        results.push({
-          record: registeredRecord,
-          outcome: "stale-registration",
-          reason: validation.reason,
-          diagnostic: await readDaemonDiagnostic(registeredRecord)
-        });
+        const diagnostic = await readDaemonDiagnostic(registeredRecord);
+        try {
+          const result = await obsoleteDaemonReaper({
+            record: registeredRecord,
+            diagnostic,
+            reason: validation.reason,
+            timeoutMs: daemonPolicy.healthTimeoutMs,
+            stopTimeoutMs: daemonPolicy.stopTimeoutMs
+          });
+          results.push(result);
+          const key = `${registeredRecord.toolName}:${registeredRecord.instanceId || "global"}`;
+          const message = result.outcome === "obsolete-removed"
+            ? `removed obsolete daemon ${registeredRecord.toolName} (${registeredRecord.instanceId || "global"}): ${validation.reason}`
+            : `left obsolete daemon ${registeredRecord.toolName} (${registeredRecord.instanceId || "global"}) untouched because process identity could not be verified`;
+          if (reportedDiagnostics.get(key) !== message) {
+            reportedDiagnostics.set(key, message);
+            logger?.log("tools", message);
+          }
+        } catch (error) {
+          logger?.error?.("tools", `obsolete daemon cleanup failed for ${registeredRecord.toolName}: ${error?.message || error}`);
+          results.push({
+            record: registeredRecord,
+            outcome: "obsolete-cleanup-error",
+            reason: validation.reason,
+            diagnostic,
+            error: error?.message || String(error)
+          });
+        }
         continue;
       }
       const record = validation.record;