arisa 3.1.6 → 3.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "3.1.6",
+  "version": "3.1.8",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/tools/daemon-processes.js

@@ -4,9 +4,6 @@ import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { getToolStateDir, toolStateDir } from "../../runtime/paths.js";
 
-export const OWNER_HEARTBEAT_INTERVAL_MS = 2000;
-export const OWNER_HEARTBEAT_TTL_MS = 10000;
-
 export function daemonPaths(toolName) {
   const root = getToolStateDir(toolName);
   return {
@@ -54,9 +51,11 @@ async function waitForExit(pid, timeoutMs) {
 export async function stopManagedDaemon(toolName, { signal = "SIGTERM", forceAfterMs = 3000 } = {}) {
   const paths = daemonPaths(toolName);
   const { pid } = await readJson(paths.pidFile, {});
+  let stopped = false;
   if (isProcessAlive(pid)) {
     try {
       process.kill(pid, signal);
+      stopped = true;
     } catch {}
     if (signal !== "SIGKILL" && forceAfterMs > 0 && !(await waitForExit(pid, forceAfterMs))) {
       try {
@@ -65,19 +64,24 @@ export async function stopManagedDaemon(toolName, { signal = "SIGTERM", forceAft
     }
   }
   await rm(paths.pidFile, { force: true });
+  return { toolName, pid: pid || null, stopped };
 }
 
-export async function startManagedDaemon({ toolName, entryPath, beforeStart = null, ownerEnv = {} }) {
+export async function startManagedDaemon({ toolName, entryPath, beforeStart = null, autoStart = true }) {
   const paths = daemonPaths(toolName);
   await mkdir(paths.commandsDir, { recursive: true });
 
   const current = await readJson(paths.pidFile, {});
   if (isProcessAlive(current.pid)) {
-    const sameOwner = !ownerEnv.ARISA_TOOL_OWNER_TOKEN
-      || current.ownerToken === ownerEnv.ARISA_TOOL_OWNER_TOKEN;
-    if (sameOwner) return current.pid;
-    await stopManagedDaemon(toolName);
+    await writeJson(paths.metaFile, {
+      toolName,
+      entryPath,
+      autoStart,
+      lastStartedAt: current.startedAt || new Date().toISOString()
+    });
+    return current.pid;
   }
+  await rm(paths.pidFile, { force: true });
 
   await rm(paths.commandsDir, { recursive: true, force: true });
   await mkdir(paths.commandsDir, { recursive: true });
@@ -88,26 +92,21 @@ export async function startManagedDaemon({ toolName, entryPath, beforeStart = nu
     const child = spawn(process.execPath, [entryPath, "daemon"], {
       detached: false,
       stdio: ["ignore", out, out],
-      env: { ...process.env, ...ownerEnv }
+      env: process.env
     });
     child.unref();
 
     const startedAt = new Date().toISOString();
     const record = {
       pid: child.pid,
-      startedAt,
-      ownerPid: Number.parseInt(ownerEnv.ARISA_OWNER_PID || "", 10) || null,
-      ownerToken: ownerEnv.ARISA_TOOL_OWNER_TOKEN || ""
+      startedAt
     };
     await writeJson(paths.pidFile, record);
     await writeJson(paths.metaFile, {
       toolName,
       entryPath,
-      autoStart: true,
-      lastStartedAt: startedAt,
-      ownerFile: ownerEnv.ARISA_TOOL_OWNER_FILE || "",
-      ownerPid: record.ownerPid,
-      ownerToken: record.ownerToken
+      autoStart,
+      lastStartedAt: startedAt
     });
     return child.pid;
   } finally {

package/src/core/tools/daemon-runtime.js

@@ -2,8 +2,6 @@ import crypto from "node:crypto";
 import { mkdir, readdir, rename, unlink } from "node:fs/promises";
 import path from "node:path";
 import {
-  OWNER_HEARTBEAT_INTERVAL_MS,
-  OWNER_HEARTBEAT_TTL_MS,
   daemonPaths,
   isProcessAlive,
   readJson,
@@ -40,12 +38,7 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
     return startManagedDaemon({
       toolName,
       entryPath,
-      beforeStart,
-      ownerEnv: {
-        ARISA_OWNER_PID: process.env.ARISA_OWNER_PID,
-        ARISA_TOOL_OWNER_FILE: process.env.ARISA_TOOL_OWNER_FILE,
-        ARISA_TOOL_OWNER_TOKEN: process.env.ARISA_TOOL_OWNER_TOKEN
-      }
+      beforeStart
     });
   }
 
@@ -53,39 +46,6 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
     await stopManagedDaemon(toolName);
   }
 
-  function installOwnerWatch() {
-    const ownerFile = process.env.ARISA_TOOL_OWNER_FILE;
-    const ownerToken = process.env.ARISA_TOOL_OWNER_TOKEN;
-    if (!ownerFile || !ownerToken) return;
-
-    let exiting = false;
-    async function exitIfOrphaned(message) {
-      if (exiting) return;
-      exiting = true;
-      await writeStatus({ state: "stopped", message });
-      process.exit(0);
-    }
-
-    const timer = setInterval(async () => {
-      const owner = await readJson(ownerFile, null);
-      if (!owner || owner.token !== ownerToken) {
-        await exitIfOrphaned("Arisa owner stopped");
-        return;
-      }
-
-      const heartbeatAt = Date.parse(owner.heartbeatAt || "");
-      if (!Number.isFinite(heartbeatAt) || Date.now() - heartbeatAt > OWNER_HEARTBEAT_TTL_MS) {
-        await exitIfOrphaned("Arisa owner heartbeat expired");
-        return;
-      }
-
-      if (!isProcessAlive(owner.pid)) {
-        await exitIfOrphaned("Arisa owner process exited");
-      }
-    }, OWNER_HEARTBEAT_INTERVAL_MS);
-    timer.unref();
-  }
-
   async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
@@ -143,7 +103,6 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
-    installOwnerWatch();
     let lastActivity = Date.now();
     setInterval(async () => {
       try {

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

@@ -25,9 +25,8 @@ function runProcess(command, args, options = {}) {
 }
 
 export class ToolRegistry {
-  constructor({ logger, processOwnerEnv = {} } = {}) {
+  constructor({ logger } = {}) {
     this.logger = logger;
-    this.processOwnerEnv = processOwnerEnv;
     this.tools = new Map();
     this.skillRegistry = new SkillRegistry();
   }
@@ -154,7 +153,7 @@ export class ToolRegistry {
     await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
     const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
       cwd: tool.dir,
-      env: { ...process.env, ...this.processOwnerEnv }
+      env: process.env
     });
     await unlink(requestFile).catch(() => {});
     await rmdir(tmpDir).catch(() => {});

package/src/runtime/create-app.js

@@ -53,7 +53,7 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
 
   const artifactStore = new ArtifactStore();
   const toolProcessSupervisor = createToolProcessSupervisor({ logger });
-  const toolRegistry = new ToolRegistry({ logger, processOwnerEnv: toolProcessSupervisor.env() });
+  const toolRegistry = new ToolRegistry({ logger });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);

package/src/runtime/paths.js

@@ -7,7 +7,6 @@ export const stateDir = path.join(arisaHomeDir, "state");
 export const configFile = path.join(stateDir, "config.json");
 export const servicePidFile = path.join(stateDir, "arisa.pid");
 export const serviceLogFile = path.join(stateDir, "arisa.log");
-export const toolDaemonOwnerFile = path.join(stateDir, "tool-daemon-owner.json");
 export const tasksFile = path.join(stateDir, "tasks.json");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 export const chatsDir = path.join(arisaHomeDir, "chats");

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

@@ -1,14 +1,12 @@
-import crypto from "node:crypto";
 import { access, rm } from "node:fs/promises";
 import {
   daemonPaths,
+  isProcessAlive,
   listRegisteredDaemons,
   readJson,
-  startManagedDaemon,
-  stopManagedDaemon,
-  writeJson
+  startManagedDaemon
 } from "../core/tools/daemon-processes.js";
-import { ensureArisaHome, toolDaemonOwnerFile } from "./paths.js";
+import { ensureArisaHome } from "./paths.js";
 
 async function fileExists(file) {
   try {
@@ -20,36 +18,10 @@ async function fileExists(file) {
 }
 
 export function createToolProcessSupervisor({ logger } = {}) {
-  const token = crypto.randomUUID();
-  let heartbeatTimer = null;
   let running = false;
 
-  const ownerEnv = {
-    ARISA_OWNER_PID: String(process.pid),
-    ARISA_TOOL_OWNER_FILE: toolDaemonOwnerFile,
-    ARISA_TOOL_OWNER_TOKEN: token
-  };
-
-  async function writeHeartbeat() {
-    await writeJson(toolDaemonOwnerFile, {
-      pid: process.pid,
-      token,
-      heartbeatAt: new Date().toISOString()
-    });
-  }
-
-  async function startHeartbeat() {
+  async function reconcileDaemons() {
     await ensureArisaHome();
-    await writeHeartbeat();
-    heartbeatTimer = setInterval(() => {
-      writeHeartbeat().catch((error) => {
-        logger?.error("tools", `tool daemon heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
-    }, 2000);
-    heartbeatTimer.unref();
-  }
-
-  async function restartRegisteredDaemons() {
     for (const record of await listRegisteredDaemons()) {
       if (!record.autoStart) continue;
       if (!(await fileExists(record.entryPath))) {
@@ -59,52 +31,33 @@ export function createToolProcessSupervisor({ logger } = {}) {
 
       const paths = daemonPaths(record.toolName);
       const { pid } = await readJson(paths.pidFile, {});
+      if (isProcessAlive(pid)) {
+        logger?.log("tools", `adopted managed daemon ${record.toolName} (pid ${pid})`);
+        continue;
+      }
       if (pid) {
-        await stopManagedDaemon(record.toolName);
+        await rm(paths.pidFile, { force: true });
+        logger?.log("tools", `removed stale daemon pid for ${record.toolName} (${pid})`);
       }
 
       logger?.log("tools", `starting managed daemon ${record.toolName}`);
       await startManagedDaemon({
         toolName: record.toolName,
-        entryPath: record.entryPath,
-        ownerEnv
+        entryPath: record.entryPath
       });
     }
   }
 
-  async function stopRegisteredDaemons() {
-    for (const record of await listRegisteredDaemons()) {
-      logger?.log("tools", `stopping managed daemon ${record.toolName}`);
-      await stopManagedDaemon(record.toolName);
-    }
-  }
-
-  async function removeOwnerFile() {
-    const current = await readJson(toolDaemonOwnerFile, null);
-    if (current?.token === token) {
-      await rm(toolDaemonOwnerFile, { force: true });
-    }
-  }
-
   return {
-    env() {
-      return ownerEnv;
-    },
-
     async start() {
       if (running) return;
       running = true;
-      await startHeartbeat();
-      await restartRegisteredDaemons();
+      await reconcileDaemons();
     },
 
     async stop() {
       if (!running) return;
       running = false;
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
-      await stopRegisteredDaemons();
-      await removeOwnerFile();
     }
   };
 }