arisa 3.1.2 → 3.1.6

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

@@ -1,34 +1,16 @@
 import crypto from "node:crypto";
-import { spawn } from "node:child_process";
-import { openSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, rename, unlink } from "node:fs/promises";
 import path from "node:path";
-import { stateDir } from "../../runtime/paths.js";
-
-export function daemonPaths(toolName) {
-  const root = path.join(stateDir, toolName);
-  return {
-    root,
-    commandsDir: path.join(root, "commands"),
-    pidFile: path.join(root, "daemon.pid"),
-    statusFile: path.join(root, "status.json"),
-    logFile: path.join(root, "daemon.log")
-  };
-}
-
-export async function readJson(file, fallback = {}) {
-  try { return JSON.parse(await readFile(file, "utf8")); } catch { return fallback; }
-}
-
-export async function writeJson(file, value) {
-  await mkdir(path.dirname(file), { recursive: true });
-  await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-export function isProcessAlive(pid) {
-  if (!pid) return false;
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
+import {
+  OWNER_HEARTBEAT_INTERVAL_MS,
+  OWNER_HEARTBEAT_TTL_MS,
+  daemonPaths,
+  isProcessAlive,
+  readJson,
+  startManagedDaemon,
+  stopManagedDaemon,
+  writeJson
+} from "./daemon-processes.js";
 
 export function createDaemonRuntime({ toolName, entryPath, beforeStart = null }) {
   const paths = daemonPaths(toolName);
@@ -54,33 +36,54 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
     await writeJson(paths.statusFile, { ...current, ...patch, updatedAt: new Date().toISOString() });
   }
 
-  async function clearJobs() {
-    await rm(paths.commandsDir, { recursive: true, force: true });
-    await mkdir(paths.commandsDir, { recursive: true });
-  }
-
   async function start() {
-    await ensure();
-    const pid = await getPid();
-    if (isProcessAlive(pid)) return pid;
-
-    await clearJobs();
-    if (beforeStart) await beforeStart();
-    const out = openSync(paths.logFile, "a");
-    const child = spawn(process.execPath, [entryPath, "daemon"], {
-      detached: true,
-      stdio: ["ignore", out, out],
-      env: process.env
+    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
+      }
     });
-    child.unref();
-    await writeJson(paths.pidFile, { pid: child.pid, startedAt: new Date().toISOString() });
-    return child.pid;
   }
 
   async function stop() {
-    const pid = await getPid();
-    if (isProcessAlive(pid)) process.kill(pid, "SIGTERM");
-    await rm(paths.pidFile, { force: true });
+    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"] } = {}) {
@@ -140,6 +143,7 @@ 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

@@ -1,10 +1,11 @@
-import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
+import { SkillRegistry } from "../skills/skill-registry.js";
 
 const bundledToolsRoot = fileURLToPath(new URL("../../../tools", import.meta.url));
 const toolRoots = [
@@ -24,9 +25,11 @@ function runProcess(command, args, options = {}) {
 }
 
 export class ToolRegistry {
-  constructor({ logger } = {}) {
+  constructor({ logger, processOwnerEnv = {} } = {}) {
     this.logger = logger;
+    this.processOwnerEnv = processOwnerEnv;
     this.tools = new Map();
+    this.skillRegistry = new SkillRegistry();
   }
 
   async load() {
@@ -52,8 +55,10 @@ export class ToolRegistry {
           const configSource = await readFile(configPath, "utf8");
           const defaults = parseConfigModule(configSource);
           const config = await loadToolConfig(manifest.name, defaults);
+          const skillHints = this.skillRegistry.normalizeHints(manifest);
           this.tools.set(manifest.name, {
             ...manifest,
+            skillHints,
             dir: toolDir,
             entry: path.join(toolDir, manifest.entry || "index.js"),
             localConfigPath: configPath,
@@ -77,7 +82,8 @@ export class ToolRegistry {
       description: tool.description,
       input: tool.input,
       output: tool.output,
-      configSchema: tool.configSchema || {}
+      configSchema: tool.configSchema || {},
+      skillHints: tool.skillHints || []
     }));
   }
 
@@ -89,7 +95,29 @@ export class ToolRegistry {
     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: process.env });
-    return result.stdout || result.stderr;
+    const help = result.stdout || result.stderr;
+    const skills = await this.resolveSkills(name);
+    if (!skills.length) return help;
+    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");
+    return `${help}\n\nAssigned skills:\n${skillHelp}\n`;
+  }
+
+  async resolveSkills(name) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    const hints = await this.skillRegistry.resolveHints(tool.skillHints || []);
+    return hints.map((hint) => ({
+      name: hint.name,
+      when: hint.when,
+      found: hint.found,
+      description: hint.skill?.description || "",
+      path: hint.skill?.path || "",
+      content: hint.skill?.content || ""
+    }));
   }
 
   async resolveConfigForChat(name, chatId) {
@@ -121,12 +149,19 @@ export class ToolRegistry {
     const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
     await mkdir(tmpDir, { recursive: true });
     const requestFile = path.join(tmpDir, `.request-${Date.now()}.json`);
-    await writeFile(requestFile, `${JSON.stringify(request, null, 2)}\n`, "utf8");
+    const skills = await this.resolveSkills(name);
+    const enrichedRequest = { ...request, chatId, skills };
+    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
+      env: { ...process.env, ...this.processOwnerEnv }
     });
     await unlink(requestFile).catch(() => {});
+    await rmdir(tmpDir).catch(() => {});
+    if (chatId != null) {
+      await rmdir(path.dirname(tmpDir)).catch(() => {});
+      await rmdir(path.dirname(path.dirname(tmpDir))).catch(() => {});
+    }
     try {
       const parsed = JSON.parse(result.stdout || result.stderr);
       const normalized = normalizeToolResult(name, parsed);

package/src/index.js

@@ -4,7 +4,7 @@ import { createServer } from "node:http";
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
-import { getServiceStatus, registerServiceProcess, startService, stopService } from "./runtime/service-manager.js";
+import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
 import { installPiPackage, removePiPackage } from "./runtime/pi-package-manager.js";
 
@@ -17,6 +17,8 @@ const serviceRunner = Boolean(cli.flags["service-runner"]);
 const bootstrapOverrides = toBootstrapOverrides(cli.nestedFlags);
 const runtimeOverrides = toRuntimeOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
+let activeApp = null;
+let shuttingDown = false;
 
 const httpPort = Number(process.env.PORT);
 let httpRequestHandler = null;
@@ -97,6 +99,35 @@ const bootstrapHttpOptions = httpPort ? { httpPort, setHttpRequestHandler } : {}
 const webhookUrl = bootstrapOverrides.webhook?.url || "";
 const appHttpOptions = httpPort ? { webhookUrl, setHttpRequestHandler } : {};
 
+async function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  try {
+    await activeApp?.stop?.();
+  } catch (error) {
+    logger.error("app", `shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
+    exitCode = exitCode || 1;
+  }
+  if (serviceRunner) {
+    await unregisterServiceProcess();
+  }
+  process.exit(exitCode);
+}
+
+process.once("SIGTERM", () => {
+  shutdown(0);
+});
+
+process.once("SIGINT", () => {
+  shutdown(0);
+});
+
+async function startRuntimeApp() {
+  const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
+  activeApp = app;
+  await app.start();
+}
+
 async function runForeground() {
   const hasRuntimePiOverrides = Boolean(
     runtimeOverrides?.pi?.model
@@ -106,11 +137,12 @@ async function runForeground() {
   logger.log("app", `starting${verbose ? " in verbose mode" : ""}`);
   await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
   try {
-    const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
-    await app.start();
+    await startRuntimeApp();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("No auth found")) {
+      await activeApp?.stop?.();
+      activeApp = null;
       console.log(`\n${message}\n`);
       if (hasRuntimePiOverrides) {
         console.log("Skipping automatic bootstrap because Pi runtime overrides were provided.");
@@ -119,8 +151,7 @@ async function runForeground() {
       }
       console.log("Reopening bootstrap so you can provide a Pi API key or switch to a provider you already authenticated with.\n");
       await bootstrapIfNeeded({ force: true, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
-      const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
-      await app.start();
+      await startRuntimeApp();
       return;
     }
     throw error;
@@ -202,4 +233,9 @@ async function main() {
   await runForeground();
 }
 
-await main();
+try {
+  await main();
+} catch (error) {
+  logger.error("app", error instanceof Error ? error.message : String(error));
+  await shutdown(1);
+}

package/src/runtime/bootstrap.js

@@ -90,7 +90,7 @@ function sortBootstrapProviders(providers) {
 
 function sortBootstrapModels(provider, models) {
   const preferred = {
-    "openai-codex": ["gpt-5.4"]
+    "openai-codex": ["gpt-5.5"]
   };
 
   const priority = preferred[provider] || [];

package/src/runtime/create-app.js

@@ -4,6 +4,7 @@ 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 { createTelegramBot } from "../transport/telegram/bot.js";
+import { createToolProcessSupervisor } from "./tool-process-supervisor.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -51,7 +52,8 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
   }
 
   const artifactStore = new ArtifactStore();
-  const toolRegistry = new ToolRegistry({ logger });
+  const toolProcessSupervisor = createToolProcessSupervisor({ logger });
+  const toolRegistry = new ToolRegistry({ logger, processOwnerEnv: toolProcessSupervisor.env() });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
@@ -63,8 +65,19 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
     async start() {
       logger?.log("app", `validating Pi model ${config.pi.provider}/${config.pi.model}`);
       await agentManager.validatePiAgent();
+      await toolProcessSupervisor.start();
       logger?.log("app", "starting Telegram bot");
-      await bot.start();
+      try {
+        await bot.start();
+      } catch (error) {
+        await toolProcessSupervisor.stop();
+        throw error;
+      }
+    },
+
+    async stop() {
+      await bot.stop?.();
+      await toolProcessSupervisor.stop();
     }
   };
 }

package/src/runtime/paths.js

@@ -7,9 +7,11 @@ 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");
+export const toolStateDir = path.join(stateDir, "tools");
 
 export function getChatDir(chatId) {
   return path.join(chatsDir, String(chatId));
@@ -23,6 +25,10 @@ export function getChatArtifactsIndexFile(chatId) {
   return path.join(getChatDir(chatId), "state", "artifacts.json");
 }
 
+export function getChatToolStateDir(chatId, toolName) {
+  return path.join(getChatDir(chatId), "state", "tools", toolName);
+}
+
 export function getChatPiSessionsDir(chatId) {
   return path.join(getChatDir(chatId), "state", "pi-sessions");
 }
@@ -35,24 +41,28 @@ export function getToolConfigPath(toolName) {
   return path.join(getToolDir(toolName), "config.js");
 }
 
-export function getChatToolConfigPath(chatId, toolName) {
-  return path.join(getChatDir(chatId), "tools", toolName, "config.js");
+export function getChatConfigDir(chatId) {
+  return path.join(getChatDir(chatId), "config");
 }
 
-export function getToolRuntimeDir(toolName) {
-  return getToolDir(toolName);
+export function getChatTmpDir(chatId) {
+  return path.join(getChatDir(chatId), "tmp");
+}
+
+export function getChatToolConfigPath(chatId, toolName) {
+  return path.join(getChatConfigDir(chatId), "tools", toolName, "config.js");
 }
 
-export function getToolOutDir(toolName) {
-  return path.join(getToolRuntimeDir(toolName), "out");
+export function getToolStateDir(toolName) {
+  return path.join(toolStateDir, toolName);
 }
 
 export function getToolTmpDir(toolName) {
-  return path.join(getToolRuntimeDir(toolName), "tmp");
+  return path.join(getToolStateDir(toolName), "tmp");
 }
 
 export function getChatToolTmpDir(chatId, toolName) {
-  return path.join(getChatDir(chatId), "tools", toolName, "tmp");
+  return path.join(getChatTmpDir(chatId), "tools", toolName);
 }
 
 export async function ensureArisaHome() {

package/src/runtime/service-manager.js

@@ -74,24 +74,14 @@ export async function stopService() {
   return { ok: true, pid: status.pid };
 }
 
+export async function unregisterServiceProcess() {
+  await rm(servicePidFile, { force: true }).catch(() => {});
+}
+
 export async function registerServiceProcess() {
   await ensureArisaHome();
   await writeFile(servicePidFile, `${process.pid}\n`, "utf8");
 
-  const cleanup = async () => {
-    await rm(servicePidFile, { force: true }).catch(() => {});
-  };
-
-  process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-
-  process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-
   process.on("exit", () => {
     rm(servicePidFile, { force: true }).catch(() => {});
   });

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

@@ -0,0 +1,110 @@
+import crypto from "node:crypto";
+import { access, rm } from "node:fs/promises";
+import {
+  daemonPaths,
+  listRegisteredDaemons,
+  readJson,
+  startManagedDaemon,
+  stopManagedDaemon,
+  writeJson
+} from "../core/tools/daemon-processes.js";
+import { ensureArisaHome, toolDaemonOwnerFile } from "./paths.js";
+
+async function fileExists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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() {
+    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))) {
+        logger?.log("tools", `skipping daemon ${record.toolName}: missing entry ${record.entryPath}`);
+        continue;
+      }
+
+      const paths = daemonPaths(record.toolName);
+      const { pid } = await readJson(paths.pidFile, {});
+      if (pid) {
+        await stopManagedDaemon(record.toolName);
+      }
+
+      logger?.log("tools", `starting managed daemon ${record.toolName}`);
+      await startManagedDaemon({
+        toolName: record.toolName,
+        entryPath: record.entryPath,
+        ownerEnv
+      });
+    }
+  }
+
+  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();
+    },
+
+    async stop() {
+      if (!running) return;
+      running = false;
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+      await stopRegisteredDaemons();
+      await removeOwnerFile();
+    }
+  };
+}