arisa 4.2.6 → 4.3.0

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

@@ -7,22 +7,106 @@ import {
   readJson,
   startManagedDaemon,
   stopManagedDaemon,
+  writeDaemonStatus,
   writeJson
 } from "./daemon-processes.js";
+import { loadDaemonPolicy } from "./daemon-policy.js";
 
-export function createDaemonRuntime({ toolName, entryPath, beforeStart = null }) {
-  const paths = daemonPaths(toolName);
+const CONTROL_FIELD = "__daemon";
 
-  async function ensure() {
-    await mkdir(paths.commandsDir, { recursive: true });
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function withTimeout(work, timeoutMs, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(work),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          const error = new Error(message);
+          error.code = "DAEMON_OPERATION_TIMEOUT";
+          reject(error);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
   }
+}
 
-  function jobPaths(id) {
-    return {
-      request: path.join(paths.commandsDir, `${id}.request.json`),
-      processing: path.join(paths.commandsDir, `${id}.processing.json`),
-      result: path.join(paths.commandsDir, `${id}.result.json`)
-    };
+function jobPaths(paths, id) {
+  return {
+    request: path.join(paths.commandsDir, `${id}.request.json`),
+    processing: path.join(paths.commandsDir, `${id}.processing.json`),
+    result: path.join(paths.commandsDir, `${id}.result.json`)
+  };
+}
+
+async function waitForResult(paths, id, { timeoutMs, intervalMs }) {
+  const files = jobPaths(paths, id);
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const result = await readJson(files.result, null);
+    if (result) {
+      await unlink(files.result).catch(() => {});
+      if (!result.ok) {
+        const error = new Error(result.error || `${paths.toolName} daemon job failed`);
+        if (result.code) error.code = result.code;
+        throw error;
+      }
+      return result.output || {};
+    }
+    await sleep(intervalMs);
+  }
+  const error = new Error(`${paths.toolName} daemon job timed out after ${timeoutMs}ms`);
+  error.code = "DAEMON_JOB_TIMEOUT";
+  throw error;
+}
+
+async function enqueue(paths, payload, { control = false, timeoutMs, intervalMs }) {
+  await mkdir(paths.commandsDir, { recursive: true });
+  const id = `${control ? "control" : "job"}-${crypto.randomUUID()}`;
+  await writeJson(jobPaths(paths, id).request, { id, ...payload });
+  return waitForResult(paths, id, { timeoutMs, intervalMs });
+}
+
+export async function submitDaemonControl(record, operation, { timeoutMs } = {}) {
+  const paths = daemonPaths({ toolName: record.toolName, scope: record.scope });
+  const policy = await loadDaemonPolicy();
+  return enqueue(paths, {
+    [CONTROL_FIELD]: { operation }
+  }, {
+    control: true,
+    timeoutMs: timeoutMs ?? policy.healthTimeoutMs,
+    intervalMs: policy.queuePollIntervalMs
+  });
+}
+
+export function isDaemonReady(status, pid, policy, now = Date.now()) {
+  if (status.state !== "ready" || !isProcessAlive(pid)) return false;
+  const heartbeatAt = new Date(status.heartbeatAt || 0).getTime();
+  const healthAt = new Date(status.lastHealthSuccessAt || 0).getTime();
+  if (!heartbeatAt || now - heartbeatAt > policy.heartbeatStaleMs) return false;
+  if (!healthAt || now - healthAt > policy.healthIntervalMs + policy.healthTimeoutMs) return false;
+  return true;
+}
+
+export function createDaemonRuntime({
+  toolName,
+  entryPath,
+  scope = { type: "global" },
+  startupContext = {},
+  beforeStart = null,
+  autoStart = true
+}) {
+  const paths = daemonPaths({ toolName, scope });
+  const registration = { toolName, entryPath, scope: paths.scope, startupContext, autoStart };
+  let statusWrite = Promise.resolve();
+
+  async function ensure() {
+    await mkdir(paths.commandsDir, { recursive: true });
   }
 
   async function getPid() {
@@ -30,60 +114,72 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function writeStatus(patch) {
-    const current = await readJson(paths.statusFile, {});
-    await writeJson(paths.statusFile, { ...current, ...patch, updatedAt: new Date().toISOString() });
+    statusWrite = statusWrite.catch(() => {}).then(() => writeDaemonStatus(paths, patch));
+    return statusWrite;
   }
 
   async function start() {
     return startManagedDaemon({
-      toolName,
-      entryPath,
+      ...registration,
       beforeStart
     });
   }
 
   async function stop() {
-    await stopManagedDaemon(toolName);
+    await stopManagedDaemon({ toolName, scope: paths.scope });
   }
 
-  async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
+  async function waitReady({ timeoutMs } = {}) {
+    const policy = await loadDaemonPolicy();
+    const effectiveTimeoutMs = timeoutMs ?? policy.startupTimeoutMs;
     const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
+    while (Date.now() - startTime < effectiveTimeoutMs) {
       const status = await readJson(paths.statusFile, {});
       const pid = await getPid();
-      if (readyStates.includes(status.state) && isProcessAlive(pid)) return status;
-      if (status.state === "error") throw new Error(status.message || `${toolName} daemon failed`);
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (isDaemonReady(status, pid, policy)) return status;
+      if (status.state === "failed") throw new Error(status.message || `${toolName} daemon failed`);
+      await sleep(policy.queuePollIntervalMs);
     }
-    throw new Error(`${toolName} daemon was not ready after ${timeoutMs}ms`);
+    throw new Error(`${toolName} daemon was not ready after ${effectiveTimeoutMs}ms`);
   }
 
-  async function submit(payload, { timeoutMs = 180000, readyTimeoutMs = 120000 } = {}) {
-    await start();
-    await waitReady({ timeoutMs: readyTimeoutMs });
-    const id = crypto.randomUUID();
-    const files = jobPaths(id);
-    await writeJson(files.request, { id, ...payload });
+  async function ensureReady({ timeoutMs } = {}) {
+    const policy = await loadDaemonPolicy();
+    const status = await readJson(paths.statusFile, {});
+    const pid = await getPid();
+    if (isDaemonReady(status, pid, policy)) return status;
+    await submitDaemonControl(registration, "health", {
+      timeoutMs: timeoutMs ?? policy.healthTimeoutMs
+    });
+    return waitReady({ timeoutMs: timeoutMs ?? policy.startupTimeoutMs });
+  }
 
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const result = await readJson(files.result, null);
-      if (result) {
-        await unlink(files.result).catch(() => {});
-        if (!result.ok) throw new Error(result.error || `${toolName} job failed`);
-        return result.output || {};
-      }
-      await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    throw new Error(`${toolName} job timed out after ${timeoutMs}ms`);
+  async function submit(payload, {
+    timeoutMs,
+    readyTimeoutMs,
+    requireReady = true
+  } = {}) {
+    const policy = await loadDaemonPolicy();
+    await start();
+    if (requireReady) await ensureReady({ timeoutMs: readyTimeoutMs });
+    return enqueue(paths, payload, {
+      timeoutMs: timeoutMs ?? policy.startupTimeoutMs,
+      intervalMs: policy.queuePollIntervalMs
+    });
   }
 
   async function claimNext() {
     await ensure();
-    const files = (await readdir(paths.commandsDir)).filter((file) => file.endsWith(".request.json"));
+    const files = (await readdir(paths.commandsDir))
+      .filter((file) => file.endsWith(".request.json"))
+      .sort((a, b) => {
+        const aControl = a.startsWith("control-") ? 0 : 1;
+        const bControl = b.startsWith("control-") ? 0 : 1;
+        return aControl - bControl || a.localeCompare(b);
+      });
     for (const file of files) {
       const id = file.replace(/\.request\.json$/, "");
-      const item = jobPaths(id);
+      const item = jobPaths(paths, id);
       try {
         await rename(item.request, item.processing);
         return { id, ...item, payload: await readJson(item.processing, null) };
@@ -98,33 +194,152 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function fail(job, error) {
-    await writeJson(job.result, { ok: false, error: error?.message || String(error) });
+    await writeJson(job.result, {
+      ok: false,
+      error: error?.message || String(error),
+      code: error?.code || null
+    });
     await unlink(job.processing).catch(() => {});
   }
 
-  async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
+  async function workLoop({
+    processJob,
+    healthCheck,
+    recover = null,
+    beforeExit = null,
+    idleTimeoutMs = 0
+  }) {
+    if (typeof healthCheck !== "function") {
+      throw new Error(`${toolName} daemon must declare healthCheck`);
+    }
+    const policy = await loadDaemonPolicy();
+    const intervalMs = policy.queuePollIntervalMs;
     let lastActivity = Date.now();
-    setInterval(async () => {
+    let processing = false;
+    let exiting = false;
+    let acceptingWork = true;
+
+    await ensure();
+    await writeStatus({
+      state: "starting",
+      pid: process.pid,
+      heartbeatAt: new Date().toISOString(),
+      supportsRecovery: typeof recover === "function",
+      message: "Daemon work loop started; waiting for health check"
+    });
+
+    const heartbeatTimer = setInterval(() => {
+      writeStatus({ heartbeatAt: new Date().toISOString() }).catch(() => {});
+    }, policy.heartbeatIntervalMs);
+
+    const workTimer = setInterval(async () => {
+      if (processing || exiting || !acceptingWork) return;
+      processing = true;
       try {
         const job = await claimNext();
         if (job) {
-          lastActivity = Date.now();
+          const operation = job.payload?.[CONTROL_FIELD]?.operation;
           try {
-            await complete(job, await processJob(job.payload));
+            if (operation === "health") {
+              const checkedAt = new Date().toISOString();
+              await writeStatus({ lastHealthCheckAt: checkedAt });
+              const output = await withTimeout(
+                healthCheck,
+                policy.healthTimeoutMs,
+                `${toolName} health check timed out after ${policy.healthTimeoutMs}ms`
+              );
+              await writeStatus({
+                state: "ready",
+                lastHealthSuccessAt: new Date().toISOString(),
+                consecutiveHealthFailures: 0,
+                restartAttempts: 0,
+                restartRequested: false,
+                nextRestartAt: null,
+                message: output?.message || "Daemon health check passed"
+              });
+              await complete(job, output || { ok: true });
+            } else if (operation === "recover") {
+              const recovered = typeof recover === "function"
+                ? await withTimeout(
+                    recover,
+                    policy.healthTimeoutMs,
+                    `${toolName} recovery timed out after ${policy.healthTimeoutMs}ms`
+                  )
+                : false;
+              await complete(job, { recovered: recovered !== false });
+            } else {
+              lastActivity = Date.now();
+              const output = await processJob(job.payload);
+              await writeStatus({ lastSuccessfulJobAt: new Date().toISOString() });
+              await complete(job, output);
+              lastActivity = Date.now();
+            }
           } catch (error) {
+            if (error?.code === "DAEMON_OPERATION_TIMEOUT") {
+              acceptingWork = false;
+            }
+            const current = await readJson(paths.statusFile, {});
+            await writeStatus({
+              ...(operation === "health"
+                ? {
+                    state: error?.code === "DAEMON_OPERATION_TIMEOUT" ? "unhealthy" : "degraded",
+                    consecutiveHealthFailures: Number(current.consecutiveHealthFailures || 0) + 1
+                  }
+                : {}),
+              lastError: {
+                at: new Date().toISOString(),
+                phase: operation || "job",
+                message: error?.message || String(error)
+              },
+              message: error?.message || String(error)
+            });
             await fail(job, error);
           }
-          lastActivity = Date.now();
         }
         if (idleTimeoutMs > 0 && Date.now() - lastActivity > idleTimeoutMs) {
-          await writeStatus({ state: "stopped", message: "Idle timeout reached" });
+          exiting = true;
+          clearInterval(heartbeatTimer);
+          clearInterval(workTimer);
+          if (beforeExit) await beforeExit();
+          await writeStatus({
+            state: "stopped",
+            restartRequested: false,
+            nextRestartAt: null,
+            message: "Idle timeout reached"
+          });
           process.exit(0);
         }
       } catch (error) {
-        await writeStatus({ state: "error", message: error?.message || String(error) });
+        await writeStatus({
+          state: "degraded",
+          lastError: {
+            at: new Date().toISOString(),
+            phase: "work-loop",
+            message: error?.message || String(error)
+          },
+          message: error?.message || String(error)
+        });
+      } finally {
+        processing = false;
       }
     }, intervalMs);
+
+    submitDaemonControl(registration, "health", {
+      timeoutMs: policy.healthTimeoutMs
+    }).catch(() => {});
   }
 
-  return { paths, ensure, getPid, writeStatus, start, stop, waitReady, submit, workLoop };
+  return {
+    paths,
+    registration,
+    ensure,
+    getPid,
+    writeStatus,
+    start,
+    stop,
+    waitReady,
+    ensureReady,
+    submit,
+    workLoop
+  };
 }

package/src/runtime/bootstrap.js

@@ -6,6 +6,7 @@ import { spawn } from "node:child_process";
 import { Bot } from "grammy";
 import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
 import { createPiRuntime, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
+import { applyConfigDefaults } from "../core/config/config-defaults.js";
 import { buildDeviceCodeTelegramMessage } from "../transport/telegram/device-code-message.js";
 import { configFile, ensureArisaHome } from "./paths.js";
 
@@ -28,7 +29,7 @@ async function exists(file) {
 }
 
 function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [], chatMeta = {}, provider, model, piApiKey }) {
-  return {
+  return applyConfigDefaults({
     telegram: {
       token: telegramApiKey,
       maxChatIds: telegramMaxChatIds,
@@ -41,7 +42,7 @@ function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [
       apiKey: piApiKey
     },
     createdAt: new Date().toISOString()
-  };
+  });
 }
 
 function sortBootstrapProviders(providers) {

package/src/runtime/create-app.js

@@ -98,7 +98,7 @@ export async function createApp({ logger, runtimeOverrides } = {}) {
   }
 
   const artifactStore = new ArtifactStore();
-  const toolProcessSupervisor = createToolProcessSupervisor({ logger });
+  const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons });
   const toolRegistry = new ToolRegistry({ logger });
   const taskStore = new TaskStore();
   await toolRegistry.load();

package/src/runtime/paths.js

@@ -43,6 +43,35 @@ export function getChatToolStateDir(chatId, toolName) {
   return path.join(getChatDir(chatId), "state", "tools", 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) {
   return path.join(getChatDir(chatId), "state", "pi-sessions");
 }

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

@@ -1,11 +1,7 @@
-import { access, rm } from "node:fs/promises";
-import {
-  daemonPaths,
-  isProcessAlive,
-  listRegisteredDaemons,
-  readJson,
-  startManagedDaemon
-} from "../core/tools/daemon-processes.js";
+import { access } from "node:fs/promises";
+import { superviseDaemon } from "../core/tools/daemon-health.js";
+import { listRegisteredDaemons } from "../core/tools/daemon-processes.js";
+import { loadDaemonPolicy } from "../core/tools/daemon-policy.js";
 import { ensureArisaHome } from "./paths.js";
 
 async function fileExists(file) {
@@ -17,47 +13,63 @@ async function fileExists(file) {
   }
 }
 
-export function createToolProcessSupervisor({ logger } = {}) {
+export function createToolProcessSupervisor({ logger, policy } = {}) {
   let running = false;
+  let timer = null;
+  let reconciliation = null;
+  let daemonPolicy = policy;
+
+  function reportLoopError(error) {
+    logger?.error?.("tools", `daemon supervisor loop failed: ${error?.message || error}`);
+  }
 
   async function reconcileDaemons() {
     await ensureArisaHome();
     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 (isProcessAlive(pid)) {
-        logger?.log("tools", `adopted managed daemon ${record.toolName} (pid ${pid})`);
-        continue;
-      }
-      if (pid) {
-        await rm(paths.pidFile, { force: true });
-        logger?.log("tools", `removed stale daemon pid for ${record.toolName} (${pid})`);
+      try {
+        const outcome = await superviseDaemon(record, daemonPolicy);
+        if (outcome !== "healthy") {
+          logger?.log("tools", `${record.toolName} (${record.instanceId || "global"}): ${outcome}`);
+        }
+      } catch (error) {
+        logger?.error?.("tools", `daemon supervision failed for ${record.toolName}: ${error?.message || error}`);
       }
+    }
+  }
 
-      logger?.log("tools", `starting managed daemon ${record.toolName}`);
-      await startManagedDaemon({
-        toolName: record.toolName,
-        entryPath: record.entryPath
-      });
+  async function runLoop() {
+    if (!running || reconciliation) return;
+    reconciliation = reconcileDaemons();
+    try {
+      await reconciliation;
+    } finally {
+      reconciliation = null;
+      if (running) {
+        timer = setTimeout(() => {
+          runLoop().catch(reportLoopError);
+        }, daemonPolicy.supervisorIntervalMs);
+      }
     }
   }
 
   return {
     async start() {
       if (running) return;
+      daemonPolicy ||= await loadDaemonPolicy();
       running = true;
-      await reconcileDaemons();
+      runLoop().catch(reportLoopError);
     },
 
     async stop() {
       if (!running) return;
       running = false;
+      clearTimeout(timer);
+      timer = null;
+      await reconciliation?.catch(() => {});
     }
   };
 }

package/test/artifact-store.test.js

@@ -78,12 +78,12 @@ test("creates generated file artifacts", async () => {
     source: { type: "assistant" }
   });
 
-  assert.equal(await readFile(artifact.path, "utf8"), "# Hello\n");
+  assert.equal(await readFile(artifact.path, "utf8"), "\ufeff# Hello\n");
   assert.equal(artifact.kind, "document");
   assert.equal(artifact.mimeType, "text/markdown");
 });
 
-test("writes generated text file artifacts as UTF-8", async () => {
+test("writes generated text file artifacts as BOM UTF-8", async () => {
   await resetHome();
   const content = "# Español\nÑandú\n";
   const artifact = await new ArtifactStore().forChat("chat-1").createGeneratedFile({
@@ -94,6 +94,43 @@ test("writes generated text file artifacts as UTF-8", async () => {
     source: { type: "assistant" }
   });
 
+  assert.deepEqual(await readFile(artifact.path), Buffer.from(`\ufeff${content}`, "utf8"));
+});
+
+test("normalizes copied generated text files to BOM UTF-8", async () => {
+  await resetHome();
+  const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));
+  const originalPath = path.join(originalDir, "report.json");
+  const content = "{\"message\":\"Español\"}\n";
+  await writeFile(originalPath, content, "utf8");
+
+  const artifact = await new ArtifactStore().forChat("chat-1").createFromFile({
+    originalPath,
+    fileName: "report.json",
+    kind: "document",
+    mimeType: "application/json",
+    source: { type: "tool", toolName: "reporter" }
+  });
+
+  assert.deepEqual(await readFile(artifact.path), Buffer.from(`\ufeff${content}`, "utf8"));
+  assert.equal(await readFile(originalPath, "utf8"), content);
+});
+
+test("does not duplicate an existing UTF-8 BOM", async () => {
+  await resetHome();
+  const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));
+  const originalPath = path.join(originalDir, "report.txt");
+  const content = "\ufeffAlready marked\n";
+  await writeFile(originalPath, content, "utf8");
+
+  const artifact = await new ArtifactStore().forChat("chat-1").createFromFile({
+    originalPath,
+    fileName: "report.txt",
+    kind: "document",
+    mimeType: "text/plain",
+    source: { type: "tool", toolName: "reporter" }
+  });
+
   assert.deepEqual(await readFile(artifact.path), Buffer.from(content, "utf8"));
 });
 

package/test/daemon-catalog-conformance.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const expected = {
+  "whispermix-transcribe": { scope: "global", autoStart: false },
+  "whatsapp-web": { scope: "chat", autoStart: false },
+  "roster-sites": { scope: "global", autoStart: true },
+  "turn-server": { scope: "global", autoStart: true },
+  "signaling-server": { scope: "global", autoStart: true }
+};
+
+for (const [toolName, daemon] of Object.entries(expected)) {
+  test(`${toolName} declares the managed daemon contract`, async () => {
+    const toolDir = path.join(repositoryRoot, "tools", toolName);
+    const manifest = JSON.parse(await readFile(path.join(toolDir, "tool.manifest.json"), "utf8"));
+    const source = await readFile(path.join(toolDir, manifest.entry), "utf8");
+
+    assert.equal(manifest.daemon.scope, daemon.scope);
+    assert.equal(manifest.daemon.autoStart, daemon.autoStart);
+    assert.equal(manifest.daemon.health, "internal");
+    assert.match(source, /createDaemonRuntime/);
+    assert.match(source, /healthCheck/);
+  });
+}