arisa 4.3.5 → 5.1.2

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 });
     }
   };
 }

package/src/runtime/tool-usage-report.js

@@ -0,0 +1,10 @@
+import { renderTextReport, reportRow } from "./report-format.js";
+
+export function formatToolUsageReport(tools) {
+  const lines = ["Arisa tools", "===========", "Usage count"];
+  if (!tools.length) lines.push("  (none installed)");
+  for (const tool of tools) {
+    lines.push(...reportRow(tool.name, tool.count, { labelWidth: 24 }));
+  }
+  return renderTextReport(lines);
+}

package/src/runtime/update-manager.js

@@ -0,0 +1,206 @@
+import { spawn } from "node:child_process";
+import { access, cp, mkdir, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { arisaPackageDir, getToolDir } from "./paths.js";
+import { renderTextReport, reportRow, wrapReportText } from "./report-format.js";
+
+const defaultRepoUrl = "https://github.com/clasen/Arisa.git";
+const defaultBranch = "main";
+const bootstrapToolNames = ["trash", "official-tool-sync"];
+
+function exists(target) {
+  return access(target).then(() => true, () => false);
+}
+
+function runCommand(command, args, { cwd, timeoutMs = 300_000, env = process.env } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
+    child.once("error", (error) => { clearTimeout(timer); reject(error); });
+    child.once("close", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(`${command} ${args.join(" ")} failed (${signal || code}): ${(stderr || stdout).trim().slice(-2000)}`));
+    });
+  });
+}
+
+function parseSemver(value) {
+  const match = String(value || "").trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  return match ? match.slice(1).map(Number) : null;
+}
+
+export function compareVersions(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (!a || !b) return null;
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  }
+  return 0;
+}
+
+async function readCurrentVersion() {
+  const packageJson = JSON.parse(await readFile(path.join(arisaPackageDir, "package.json"), "utf8"));
+  return packageJson.version;
+}
+
+async function fetchLatestVersion() {
+  const { stdout } = await runCommand("npm", ["view", "arisa", "version", "--json"], { timeoutMs: 60_000 });
+  const parsed = JSON.parse(stdout);
+  const version = Array.isArray(parsed) ? parsed.at(-1) : parsed;
+  if (!parseSemver(version)) throw new Error(`npm returned an invalid Arisa version: ${version}`);
+  return version;
+}
+
+async function cloneCatalog(scratchRoot) {
+  const repoDir = path.join(scratchRoot, "repo");
+  await runCommand("git", ["clone", "--depth", "1", "--branch", defaultBranch, "--", defaultRepoUrl, repoDir], { cwd: scratchRoot, timeoutMs: 180_000 });
+  return repoDir;
+}
+
+async function installDependencies(toolDir) {
+  if (!(await exists(path.join(toolDir, "package.json")))) return null;
+  try {
+    await runCommand("pnpm", ["install", "--lockfile=false"], { cwd: toolDir, timeoutMs: 300_000 });
+    return "pnpm";
+  } catch {
+    await runCommand("npm", ["install", "--no-package-lock"], { cwd: toolDir, timeoutMs: 300_000 });
+    return "npm";
+  }
+}
+
+async function validateTool(toolDir, expectedName) {
+  const manifest = JSON.parse(await readFile(path.join(toolDir, "tool.manifest.json"), "utf8"));
+  if (manifest.name !== expectedName) throw new Error(`Bootstrap manifest mismatch for ${expectedName}`);
+  const entry = manifest.entry || "index.js";
+  const env = { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir };
+  await runCommand(process.execPath, ["--check", entry], { cwd: toolDir, timeoutMs: 30_000, env });
+  await runCommand(process.execPath, [entry, "--help"], { cwd: toolDir, timeoutMs: 30_000, env });
+}
+
+async function stageBootstrapTool(repoDir, scratchRoot, name) {
+  const sourceDir = path.join(repoDir, "tools", name);
+  const stageDir = path.join(scratchRoot, `stage-${name}`);
+  if (!(await exists(path.join(sourceDir, "tool.manifest.json")))) throw new Error(`Official catalog is missing required bootstrap tool: ${name}`);
+  await cp(sourceDir, stageDir, { recursive: true });
+  await installDependencies(stageDir);
+  await validateTool(stageDir, name);
+  return { name, stageDir, destination: getToolDir(name) };
+}
+
+export async function ensureOfficialUpdateTools({ toolRegistry }) {
+  const missing = bootstrapToolNames.filter((name) => !toolRegistry.get(name));
+  if (!missing.length) return { installed: [] };
+  const scratchRoot = path.join(os.tmpdir(), `arisa-update-${process.pid}-${Date.now()}`);
+  await mkdir(scratchRoot, { recursive: true });
+  const deployed = [];
+  try {
+    const repoDir = await cloneCatalog(scratchRoot);
+    const staged = [];
+    for (const name of missing) staged.push(await stageBootstrapTool(repoDir, scratchRoot, name));
+    for (const item of staged) {
+      await mkdir(path.dirname(item.destination), { recursive: true });
+      await cp(item.stageDir, item.destination, { recursive: true, errorOnExist: true, force: false });
+      deployed.push(item.destination);
+    }
+    await toolRegistry.load();
+    return { installed: staged.map((item) => item.name) };
+  } catch (error) {
+    for (const destination of deployed.reverse()) await rm(destination, { recursive: true, force: true }).catch(() => {});
+    await toolRegistry.load().catch(() => {});
+    throw error;
+  } finally {
+    await rm(scratchRoot, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+function parseToolSyncOutput(result) {
+  if (!result?.ok) throw new Error(result?.error || "official-tool-sync failed");
+  const text = result.output?.text;
+  if (typeof text !== "string") return result.output?.json || {};
+  return JSON.parse(text);
+}
+
+function summarizeTools(sync, installedTools) {
+  const tools = sync.tools || [];
+  const officialNames = new Set(tools.map((tool) => tool.name));
+  const counts = {};
+  for (const tool of tools) counts[tool.status] = (counts[tool.status] || 0) + 1;
+  const updateable = tools.filter((tool) => tool.safeToUpdate && !["up-to-date", "baseline-refresh"].includes(tool.status));
+  const blocked = tools.filter((tool) => !tool.safeToUpdate && !["up-to-date", "baseline-refresh"].includes(tool.status));
+  return {
+    installedOfficial: sync.installedOfficialCount || tools.length,
+    official: tools.map(({ name, status }) => ({ name, status })).sort((left, right) => left.name.localeCompare(right.name)),
+    nonOfficial: installedTools.map((tool) => tool.name).filter((name) => !officialNames.has(name)).sort(),
+    counts,
+    updateable: updateable.map((tool) => tool.name),
+    blocked: blocked.map((tool) => ({ name: tool.name, status: tool.status }))
+  };
+}
+
+export async function checkForUpdates({ chatId, toolRegistry }) {
+  const [currentVersion, latestVersion] = await Promise.all([readCurrentVersion(), fetchLatestVersion()]);
+  const bootstrapped = await ensureOfficialUpdateTools({ toolRegistry });
+  const result = await toolRegistry.run({ name: "official-tool-sync", chatId, request: { args: { action: "check" } } });
+  const sync = parseToolSyncOutput(result);
+  return {
+    core: { currentVersion, latestVersion, updateAvailable: compareVersions(currentVersion, latestVersion) === -1 },
+    bootstrapInstalled: bootstrapped.installed,
+    tools: summarizeTools(sync, toolRegistry.list())
+  };
+}
+
+function shortToolStatus(status) {
+  return ({
+    "locally-modified": "local",
+    "untracked-difference": "untracked",
+    "update-available": "update",
+    "baseline-refresh": "refresh",
+    "up-to-date": "current"
+  })[status] || status;
+}
+
+export function formatUpdateReport(report) {
+  const lines = ["Arisa update", "============", "Core"];
+  lines.push(...reportRow("Current", report.core.currentVersion));
+  lines.push(...reportRow("Latest", report.core.latestVersion));
+  lines.push(...reportRow("Status", report.core.updateAvailable ? "update available" : "up to date"));
+  lines.push("", "Official tools");
+  lines.push(...reportRow("Installed", report.tools.installedOfficial));
+  for (const [status, count] of Object.entries(report.tools.counts)) {
+    lines.push(...reportRow(status, count, { labelWidth: 20 }));
+  }
+  lines.push("", `Official (${report.tools.official.length})`);
+  for (const item of report.tools.official) {
+    const status = shortToolStatus(item.status);
+    const suffix = status === "current" ? "" : ` [${status}]`;
+    lines.push(...wrapReportText(`${item.name}${suffix}`, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  lines.push("", `Non-official (${report.tools.nonOfficial.length})`);
+  if (!report.tools.nonOfficial.length) lines.push("  (none)");
+  for (const name of report.tools.nonOfficial) {
+    lines.push(...wrapReportText(name, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  if (report.tools.updateable.length) {
+    lines.push("", "Safe updates");
+    for (const name of report.tools.updateable) lines.push(...wrapReportText(name, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  if (report.tools.blocked.length) {
+    lines.push("", "Needs review");
+    for (const item of report.tools.blocked) {
+      lines.push(...wrapReportText(item.name, { firstPrefix: "  - ", nextPrefix: "    " }));
+      lines.push(...wrapReportText(`[${shortToolStatus(item.status)}]`, { firstPrefix: "    ", nextPrefix: "    " }));
+    }
+  }
+  if (report.bootstrapInstalled.length) {
+    lines.push("", "Update support installed");
+    for (const name of report.bootstrapInstalled) lines.push(...wrapReportText(name, { firstPrefix: "  - ", nextPrefix: "    " }));
+  }
+  return renderTextReport(lines);
+}