arisa 4.3.4 → 5.0.2

package/src/runtime/log-viewer.js

@@ -0,0 +1,165 @@
+import { open, readFile, stat } from "node:fs/promises";
+import { cliLogConfig } from "../core/config/config-defaults.js";
+import { ensureArisaHome, serviceLogFile } from "./paths.js";
+
+const readChunkSize = 64 * 1024;
+
+async function getFileState(logFile) {
+  try {
+    const details = await stat(logFile);
+    return { size: details.size, ino: details.ino };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { size: 0, ino: null };
+    throw error;
+  }
+}
+
+export async function readRecentLogLines(logFile, lineCount) {
+  if (!Number.isSafeInteger(lineCount) || lineCount < 1) {
+    throw new Error("Log line count must be a positive integer");
+  }
+
+  const state = await getFileState(logFile);
+  if (state.size === 0) return { text: "", endsWithNewline: false, ...state };
+
+  const handle = await open(logFile, "r");
+  const chunks = [];
+  let position = state.size;
+  let newlineCount = 0;
+
+  try {
+    while (position > 0 && newlineCount <= lineCount) {
+      const length = Math.min(readChunkSize, position);
+      position -= length;
+      const chunk = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(chunk, 0, length, position);
+      const content = chunk.subarray(0, bytesRead);
+      chunks.unshift(content);
+      for (const byte of content) {
+        if (byte === 0x0a) newlineCount += 1;
+      }
+    }
+  } finally {
+    await handle.close();
+  }
+
+  const content = Buffer.concat(chunks).toString("utf8");
+  const endsWithNewline = content.endsWith("\n");
+  const lines = content.split("\n");
+  if (endsWithNewline) lines.pop();
+  return {
+    text: lines.slice(-lineCount).join("\n"),
+    endsWithNewline,
+    ...state
+  };
+}
+
+async function readAppendedBytes(logFile, position, size) {
+  if (size <= position) return "";
+  const handle = await open(logFile, "r");
+  const chunks = [];
+  let cursor = position;
+
+  try {
+    while (cursor < size) {
+      const length = Math.min(readChunkSize, size - cursor);
+      const chunk = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(chunk, 0, length, cursor);
+      if (bytesRead === 0) break;
+      chunks.push(chunk.subarray(0, bytesRead));
+      cursor += bytesRead;
+    }
+  } finally {
+    await handle.close();
+  }
+
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+function waitForNextPoll(intervalMs, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const finish = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, intervalMs);
+    signal?.addEventListener("abort", finish, { once: true });
+  });
+}
+
+export async function followLogFile({
+  logFile,
+  initialSize,
+  initialIno,
+  write,
+  signal,
+  pollIntervalMs = cliLogConfig.followPollIntervalMs
+}) {
+  let position = initialSize;
+  let ino = initialIno;
+
+  while (!signal?.aborted) {
+    await waitForNextPoll(pollIntervalMs, signal);
+    if (signal?.aborted) break;
+
+    const state = await getFileState(logFile);
+    if (state.ino !== ino || state.size < position) {
+      position = 0;
+      ino = state.ino;
+    }
+    if (state.size === position) continue;
+
+    try {
+      const appended = await readAppendedBytes(logFile, position, state.size);
+      if (appended) write(appended);
+      position = state.size;
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+      position = 0;
+      ino = null;
+    }
+  }
+}
+
+export async function showServiceLogs({
+  version,
+  follow = true,
+  output = process.stdout,
+  signal
+} = {}) {
+  if (!version) throw new Error("Arisa version is required");
+  await ensureArisaHome();
+
+  const snapshot = await readRecentLogLines(serviceLogFile, cliLogConfig.recentLines);
+  output.write(`Arisa v${version} | Recent logs\n`);
+  output.write(`${follow ? "Following new logs; press Ctrl+C to exit." : "Log follow disabled."}\n\n`);
+  if (snapshot.text) {
+    output.write(snapshot.text);
+    if (snapshot.endsWithNewline) output.write("\n");
+  } else {
+    output.write("No logs yet.\n");
+  }
+
+  if (!follow) return;
+  await followLogFile({
+    logFile: serviceLogFile,
+    initialSize: snapshot.size,
+    initialIno: snapshot.ino,
+    write: (content) => output.write(content),
+    signal
+  });
+}
+
+export async function readPackageVersion() {
+  const packageFile = new URL("../../package.json", import.meta.url);
+  const packageJson = JSON.parse(await readFile(packageFile, "utf8"));
+  if (typeof packageJson.version !== "string" || !packageJson.version) {
+    throw new Error("Arisa package version is missing");
+  }
+  return packageJson.version;
+}

package/src/runtime/paths.js

@@ -39,6 +39,10 @@ export function getChatArtifactsIndexFile(chatId) {
   return path.join(getChatDir(chatId), "state", "artifacts.json");
 }
 
+export function getChatConversationHistoryFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "conversation.jsonl");
+}
+
 export function getChatToolStateDir(chatId, toolName) {
   return path.join(getChatDir(chatId), "state", "tools", toolName);
 }
@@ -119,4 +123,3 @@ export async function ensureArisaHome() {
   await mkdir(toolsDir, { recursive: true });
   await mkdir(chatsDir, { recursive: true });
 }
-

package/src/runtime/service-manager.js

@@ -4,14 +4,24 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { ensureArisaHome, serviceLogFile, servicePidFile } from "./paths.js";
 
-const entryFile = fileURLToPath(new URL("../index.js", import.meta.url));
+export const serviceEntryFile = fileURLToPath(new URL("../index.js", import.meta.url));
 
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
-    return false;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function requirePositiveTiming(value, name) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`Service restart requires a positive ${name}`);
   }
 }
 
@@ -19,7 +29,7 @@ async function readPid() {
   try {
     const raw = await readFile(servicePidFile, "utf8");
     const pid = Number.parseInt(raw.trim(), 10);
-    return Number.isFinite(pid) ? pid : null;
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
   }
@@ -44,7 +54,7 @@ export async function startService({ verbose = true, cliArgs = [] } = {}) {
   }
 
   const logHandle = await open(serviceLogFile, "a");
-  const args = [entryFile, "--service-runner", ...cliArgs];
+  const args = [serviceEntryFile, "--service-runner", ...cliArgs];
   if (!verbose) args.push("--silent");
 
   const child = spawn(process.execPath, args, {
@@ -58,6 +68,36 @@ export async function startService({ verbose = true, cliArgs = [] } = {}) {
   return { ok: true, pid: child.pid, logFile: serviceLogFile };
 }
 
+export async function handoffServiceRestart({ verbose = true, cliArgs = [] } = {}, {
+  ensureHome = ensureArisaHome,
+  getStatus = getServiceStatus,
+  openLog = open,
+  spawnProcess = spawn,
+  environment = process.env,
+  currentPid = process.pid
+} = {}) {
+  await ensureHome();
+  const status = await getStatus();
+  if (!status.running || status.pid !== currentPid) {
+    throw new Error("Service restart handoff requires the active background service process");
+  }
+  const logHandle = await openLog(serviceLogFile, "a");
+  const args = [serviceEntryFile, "restart", ...cliArgs];
+  if (!verbose) args.push("--silent");
+
+  try {
+    const child = spawnProcess(process.execPath, args, {
+      detached: true,
+      stdio: ["ignore", logHandle.fd, logHandle.fd],
+      env: environment
+    });
+    child.unref();
+    return { ok: true, pid: child.pid, logFile: serviceLogFile };
+  } finally {
+    await logHandle.close();
+  }
+}
+
 export async function stopService() {
   const status = await getServiceStatus();
   if (!status.running) {
@@ -66,14 +106,72 @@ export async function stopService() {
 
   try {
     process.kill(status.pid, "SIGTERM");
-  } catch {
-    await rm(servicePidFile, { force: true }).catch(() => {});
-    return { ok: false, reason: "not-running", pid: status.pid };
+  } catch (error) {
+    if (error?.code === "ESRCH") {
+      await rm(servicePidFile, { force: true }).catch(() => {});
+      return { ok: false, reason: "not-running", pid: status.pid };
+    }
+    throw error;
   }
 
   return { ok: true, pid: status.pid };
 }
 
+export async function waitForServiceStop({
+  pid,
+  timeoutMs,
+  pollIntervalMs,
+  getStatus = getServiceStatus,
+  wait = sleep
+}) {
+  requirePositiveTiming(timeoutMs, "shutdownTimeoutMs");
+  requirePositiveTiming(pollIntervalMs, "shutdownPollIntervalMs");
+
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const status = await getStatus();
+    if (!status.running || status.pid !== pid) return;
+    await wait(pollIntervalMs);
+  }
+
+  throw new Error(`Arisa process ${pid} did not stop within ${timeoutMs}ms`);
+}
+
+export async function restartService({
+  verbose = true,
+  cliArgs = [],
+  shutdownTimeoutMs,
+  shutdownPollIntervalMs
+} = {}, {
+  stop = stopService,
+  getStatus = getServiceStatus,
+  start = startService,
+  sleep: wait = sleep
+} = {}) {
+  requirePositiveTiming(shutdownTimeoutMs, "shutdownTimeoutMs");
+  requirePositiveTiming(shutdownPollIntervalMs, "shutdownPollIntervalMs");
+
+  const stopped = await stop();
+  if (!stopped.ok && stopped.reason !== "not-running") return stopped;
+
+  if (stopped.ok) {
+    await waitForServiceStop({
+      pid: stopped.pid,
+      timeoutMs: shutdownTimeoutMs,
+      pollIntervalMs: shutdownPollIntervalMs,
+      getStatus,
+      wait
+    });
+  }
+
+  const started = await start({ verbose, cliArgs });
+  return {
+    ...started,
+    previousPid: stopped.ok ? stopped.pid : null,
+    wasRunning: stopped.ok
+  };
+}
+
 export async function unregisterServiceProcess() {
   await rm(servicePidFile, { force: true }).catch(() => {});
 }

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

@@ -1,6 +1,12 @@
 import { access } from "node:fs/promises";
+import path from "node:path";
 import { superviseDaemon } from "../core/tools/daemon-health.js";
-import { listRegisteredDaemons } from "../core/tools/daemon-processes.js";
+import {
+  daemonPaths,
+  listRegisteredDaemons,
+  readDaemonDiagnostic,
+  writeDaemonStatus
+} from "../core/tools/daemon-processes.js";
 import { loadDaemonPolicy } from "../core/tools/daemon-policy.js";
 import { ensureArisaHome } from "./paths.js";
 
@@ -13,41 +19,127 @@ async function fileExists(file) {
   }
 }
 
-export function createToolProcessSupervisor({ logger, policy } = {}) {
+function oneLine(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+export function formatDaemonOutcome(record, outcome, diagnostic, policy) {
+  const details = [`${record.toolName} (${record.instanceId || "global"}): ${outcome}`];
+  if (diagnostic.lastError?.message) {
+    details.push(`error[${diagnostic.lastError.phase || "unknown"}]=${oneLine(diagnostic.lastError.message)}`);
+    if (diagnostic.lastError.code) details.push(`code=${diagnostic.lastError.code}`);
+  } else if (diagnostic.message) {
+    details.push(`message=${oneLine(diagnostic.message)}`);
+  }
+  if (diagnostic.restart.attempts > 0) {
+    details.push(`restarts=${diagnostic.restart.attempts}/${policy.restartLimit}`);
+  }
+  if (diagnostic.restart.nextAt) details.push(`next=${diagnostic.restart.nextAt}`);
+  details.push(`action=${diagnostic.disposition}`);
+  if (diagnostic.disposition === "requires-attention") details.push(`log=${diagnostic.logFile}`);
+  return details.join(" | ");
+}
+
+function validateRegistration(record, toolRegistry) {
+  if (!toolRegistry) return { valid: true, record };
+  const tool = toolRegistry.get(record.toolName);
+  if (!tool) return { valid: false, reason: "tool is no longer installed" };
+  if (!tool.daemon) return { valid: false, reason: "tool no longer declares a daemon" };
+  const expectedScope = tool.daemon.scope === "chat" ? "chat" : "global";
+  if (record.scope?.type !== expectedScope) {
+    return { valid: false, reason: `registered ${record.scope?.type || "unknown"} scope does not match manifest ${expectedScope} scope` };
+  }
+  if (path.resolve(record.entryPath) !== path.resolve(tool.entry)) {
+    return { valid: false, reason: "registered entry does not match the installed tool" };
+  }
+  return {
+    valid: true,
+    record: { ...record, autoStart: Boolean(tool.daemon.autoStart) }
+  };
+}
+
+export function createToolProcessSupervisor({ logger, policy, toolRegistry } = {}) {
   let running = false;
   let timer = null;
   let reconciliation = null;
   let daemonPolicy = policy;
+  const reportedDiagnostics = new Map();
 
   function reportLoopError(error) {
     logger?.error?.("tools", `daemon supervisor loop failed: ${error?.message || error}`);
   }
 
-  async function reconcileDaemons() {
+  async function reconcileDaemons({ repairFailed = false } = {}) {
     await ensureArisaHome();
-    for (const record of await listRegisteredDaemons()) {
+    const results = [];
+    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)
+        });
+        continue;
+      }
+      const record = validation.record;
       if (!(await fileExists(record.entryPath))) {
         logger?.log("tools", `skipping daemon ${record.toolName}: missing entry ${record.entryPath}`);
+        results.push({ record, outcome: "missing-entry", diagnostic: await readDaemonDiagnostic(record) });
         continue;
       }
       try {
+        const current = await readDaemonDiagnostic(record);
+        if (repairFailed && current.state === "failed") {
+          await writeDaemonStatus(daemonPaths(record), {
+            state: "restarting",
+            pid: null,
+            heartbeatAt: null,
+            restartAttempts: 0,
+            restartRequested: true,
+            nextRestartAt: null,
+            message: "Manual repair requested by /doctor"
+          });
+        }
         const outcome = await superviseDaemon(record, daemonPolicy);
-        if (outcome !== "healthy") {
-          logger?.log("tools", `${record.toolName} (${record.instanceId || "global"}): ${outcome}`);
+        const key = `${record.toolName}:${record.instanceId || "global"}`;
+        if (outcome === "healthy") {
+          reportedDiagnostics.delete(key);
+          results.push({ record, outcome, diagnostic: await readDaemonDiagnostic(record) });
+          continue;
         }
+        const diagnostic = await readDaemonDiagnostic(record);
+        results.push({ record, outcome, diagnostic });
+        const message = formatDaemonOutcome(record, outcome, diagnostic, daemonPolicy);
+        if (reportedDiagnostics.get(key) === message) continue;
+        reportedDiagnostics.set(key, message);
+        logger?.log("tools", message);
       } catch (error) {
         logger?.error?.("tools", `daemon supervision failed for ${record.toolName}: ${error?.message || error}`);
+        results.push({ record, outcome: "error", error: error?.message || String(error) });
       }
     }
+    return results;
+  }
+
+  async function runReconciliation(options) {
+    while (reconciliation) await reconciliation.catch(() => {});
+    const current = reconcileDaemons(options);
+    reconciliation = current;
+    try {
+      return await current;
+    } finally {
+      if (reconciliation === current) reconciliation = null;
+    }
   }
 
   async function runLoop() {
-    if (!running || reconciliation) return;
-    reconciliation = reconcileDaemons();
+    if (!running) return;
     try {
-      await reconciliation;
+      await runReconciliation();
     } finally {
-      reconciliation = null;
       if (running) {
         timer = setTimeout(() => {
           runLoop().catch(reportLoopError);
@@ -70,6 +162,11 @@ export function createToolProcessSupervisor({ logger, policy } = {}) {
       clearTimeout(timer);
       timer = null;
       await reconciliation?.catch(() => {});
+    },
+
+    async repair() {
+      daemonPolicy ||= await loadDaemonPolicy();
+      return runReconciliation({ repairFailed: true });
     }
   };
 }