arisa 4.3.5 → 5.1.2

package/src/runtime/doctor.js

@@ -0,0 +1,365 @@
+import { execFile } from "node:child_process";
+import { statfs } from "node:fs/promises";
+import os from "node:os";
+import process from "node:process";
+import { promisify } from "node:util";
+import { stopManagedDaemon, unregisterManagedDaemon } from "../core/tools/daemon-processes.js";
+import { getServiceStatus, serviceEntryFile } from "./service-manager.js";
+import { arisaHomeDir } from "./paths.js";
+import { renderTextReport, reportRow, wrapReportText } from "./report-format.js";
+
+const execFileAsync = promisify(execFile);
+
+function parsePosixProcesses(output) {
+  return String(output || "")
+    .split("\n")
+    .map((line) => /^\s*(\d+)\s+(.+)$/.exec(line))
+    .filter(Boolean)
+    .map((match) => ({ pid: Number(match[1]), command: match[2] }));
+}
+
+function parseWindowsProcesses(output) {
+  const parsed = JSON.parse(output || "[]");
+  const records = Array.isArray(parsed) ? parsed : [parsed];
+  return records
+    .filter((record) => record?.ProcessId && record?.CommandLine)
+    .map((record) => ({ pid: Number(record.ProcessId), command: String(record.CommandLine) }));
+}
+
+export async function listSystemProcesses({ timeoutMs, platform = process.platform } = {}) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Doctor process inspection requires a positive timeoutMs");
+  }
+  if (platform === "win32") {
+    const { stdout } = await execFileAsync("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
+    ], { timeout: timeoutMs, windowsHide: true });
+    return parseWindowsProcesses(stdout);
+  }
+  const { stdout } = await execFileAsync("ps", ["-ww", "-axo", "pid=,command="], { timeout: timeoutMs });
+  return parsePosixProcesses(stdout);
+}
+
+function isArisaServiceProcess(record) {
+  return record.command.includes(serviceEntryFile)
+    && /(?:^|\s)--service-runner(?:\s|$)/.test(record.command);
+}
+
+function isDaemonProcess(record, daemon) {
+  return record.command.includes(daemon.entryPath)
+    && /(?:^|\s)daemon(?:\s|$)/.test(record.command);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function terminateProcess(pid, { forceAfterMs } = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) {
+    throw new Error(`Refusing to terminate invalid doctor target: ${pid}`);
+  }
+  if (!Number.isFinite(forceAfterMs) || forceAfterMs <= 0) {
+    throw new Error("Doctor process cleanup requires a positive forceAfterMs");
+  }
+  if (!isAlive(pid)) return false;
+  process.kill(pid, "SIGTERM");
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < forceAfterMs) {
+    if (!isAlive(pid)) return true;
+    await sleep(Math.min(100, forceAfterMs));
+  }
+  if (isAlive(pid)) process.kill(pid, "SIGKILL");
+  return true;
+}
+
+function daemonLabel(record) {
+  return `${record.toolName} (${record.instanceId || "global"})`;
+}
+
+function daemonResultSummary(results) {
+  const states = new Map();
+  for (const result of results) {
+    const state = result.diagnostic?.state || result.outcome;
+    states.set(state, (states.get(state) || 0) + 1);
+  }
+  return [...states.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([state, count]) => `${count} ${state}`)
+    .join(", ");
+}
+
+function formatTokenCount(tokens) {
+  return new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 }).format(tokens);
+}
+
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "unknown";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1024 && index < units.length - 1) {
+    value /= 1024;
+    index += 1;
+  }
+  return `${value.toFixed(index < 2 ? 0 : 1)} ${units[index]}`;
+}
+
+function formatUptime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "unknown";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  return [days ? `${days}d` : "", hours ? `${hours}h` : "", `${minutes}m`].filter(Boolean).join(" ");
+}
+
+export async function inspectSystemResources({ diskPath = arisaHomeDir } = {}) {
+  const [load1, load5, load15] = os.loadavg();
+  const memoryTotal = os.totalmem();
+  const memoryFree = os.freemem();
+  const filesystem = await statfs(diskPath);
+  const blockSize = Number(filesystem.bsize);
+  const diskTotal = Number(filesystem.blocks) * blockSize;
+  const diskFree = Number(filesystem.bavail) * blockSize;
+  return {
+    platform: `${os.platform()} ${os.arch()}`,
+    cpuCores: os.cpus().length,
+    loadAverage: [load1, load5, load15],
+    memoryTotal,
+    memoryFree,
+    memoryUsed: memoryTotal - memoryFree,
+    diskTotal,
+    diskFree,
+    diskUsed: diskTotal - diskFree,
+    uptimeSeconds: os.uptime(),
+    processRss: process.memoryUsage().rss
+  };
+}
+
+function assertDoctorPolicy(policy) {
+  const positiveValues = [
+    "contextInspectionTimeoutMs",
+    "contextWarningPercent",
+    "contextCriticalPercent",
+    "contextInefficientMinTokens",
+    "contextToolResultWarningPercent",
+    "contextSingleMessageWarningPercent"
+  ];
+  for (const name of positiveValues) {
+    if (!Number.isFinite(policy?.[name]) || policy[name] <= 0) {
+      throw new Error(`Doctor configuration requires a positive ${name}`);
+    }
+  }
+  if (policy.contextCriticalPercent <= policy.contextWarningPercent) {
+    throw new Error("Doctor contextCriticalPercent must be greater than contextWarningPercent");
+  }
+}
+
+function evaluateContext(context, policy) {
+  if (context.error) return { ...context, level: "unknown", inefficiencies: [] };
+  const percent = context.percent;
+  const level = !Number.isFinite(percent)
+    ? "unknown"
+    : percent >= policy.contextCriticalPercent
+      ? "critical"
+      : percent >= policy.contextWarningPercent ? "warning" : "healthy";
+  const inefficiencies = [];
+  if (context.estimatedTokens >= policy.contextInefficientMinTokens) {
+    if (context.toolResultPercent >= policy.contextToolResultWarningPercent) {
+      inefficiencies.push(`tool results occupy ${context.toolResultPercent.toFixed(1)}% of retained content`);
+    }
+    if (context.largestMessagePercent >= policy.contextSingleMessageWarningPercent) {
+      inefficiencies.push(`one message occupies ${context.largestMessagePercent.toFixed(1)}% of retained content`);
+    }
+  }
+  return { ...context, level, inefficiencies };
+}
+
+function addContextAttention(report) {
+  for (const context of report.contexts) {
+    const label = `Chat ${context.chatId}`;
+    if (context.error) {
+      report.attention.push(`${label} context inspection failed: ${context.error}`);
+      continue;
+    }
+    if (context.level === "warning" || context.level === "critical") {
+      const size = context.tokens == null || context.contextWindow == null
+        ? `${context.percent.toFixed(1)}% of its context window`
+        : `${formatTokenCount(context.tokens)}/${formatTokenCount(context.contextWindow)} tokens (${context.percent.toFixed(1)}%)`;
+      const severity = context.level === "critical" ? "critically large" : "large";
+      report.attention.push(`${label} context is ${severity}: ${size}. Use /new to carry durable context into a fresh session.`);
+    }
+    if (context.inefficiencies.length) {
+      report.attention.push(`${label} context may be inefficient: ${formatTokenCount(context.estimatedTokens)} estimated retained tokens; ${context.inefficiencies.join("; ")}.`);
+    }
+  }
+}
+
+export function formatDoctorReport(report) {
+  const status = report.attention.length
+    ? "attention needed"
+    : report.repairs.length ? "repaired" : "healthy";
+  const measured = report.contexts.filter((context) => Number.isFinite(context.percent));
+  const large = report.contexts.filter((context) => context.level === "warning" || context.level === "critical").length;
+  const inefficient = report.contexts.filter((context) => context.inefficiencies.length).length;
+  const lines = ["Arisa Doctor", "============"];
+  lines.push(...reportRow("Status", status));
+  lines.push("", "Core");
+  lines.push(...reportRow("Runtime", "Pi"));
+  lines.push(...reportRow("Sessions", `${report.runtime.sessions} active / ${report.runtime.closingSessions} closing`));
+  lines.push(...reportRow("Contexts", `${report.contexts.length} active / ${measured.length} measured`));
+  lines.push(...reportRow("Large", large));
+  lines.push(...reportRow("Ineff.", inefficient));
+  if (measured.length) lines.push(...reportRow("Max", `${Math.max(...measured.map((context) => context.percent)).toFixed(1)}%`));
+  lines.push("", "Daemons");
+  lines.push(...reportRow("Checked", report.daemons.length));
+  if (report.daemons.length) lines.push(...reportRow("Status", daemonResultSummary(report.daemons)));
+  if (report.system) {
+    const memoryPercent = report.system.memoryTotal ? (report.system.memoryUsed / report.system.memoryTotal) * 100 : 0;
+    const diskPercent = report.system.diskTotal ? (report.system.diskUsed / report.system.diskTotal) * 100 : 0;
+    lines.push("", "System");
+    lines.push(...reportRow("Host", report.system.platform));
+    lines.push(...reportRow("Uptime", formatUptime(report.system.uptimeSeconds)));
+    lines.push(...reportRow("CPU", `${report.system.cpuCores} cores`));
+    lines.push(...reportRow("Load", report.system.loadAverage.map((value) => value.toFixed(2)).join(" / ")));
+    lines.push(...reportRow("Memory", `${memoryPercent.toFixed(1)}% / ${formatBytes(report.system.memoryFree)} free`));
+    lines.push(...reportRow("Disk", `${diskPercent.toFixed(1)}% / ${formatBytes(report.system.diskFree)} free`));
+    lines.push(...reportRow("Arisa RSS", formatBytes(report.system.processRss)));
+  } else if (report.systemError) {
+    lines.push("", "System");
+    lines.push(...reportRow("Status", `unavailable: ${report.systemError}`));
+  }
+  lines.push("", `Repairs (${report.repairs.length})`);
+  for (const item of report.repairs) lines.push(...wrapReportText(item, { firstPrefix: "  - ", nextPrefix: "    " }));
+  lines.push("", `Attention (${report.attention.length})`);
+  for (const item of report.attention) lines.push(...wrapReportText(item, { firstPrefix: "  - ", nextPrefix: "    " }));
+  return renderTextReport(lines);
+}
+
+export async function runDoctor({
+  agentManager,
+  toolProcessSupervisor,
+  daemonPolicy,
+  doctorPolicy,
+  logger,
+  listProcesses = listSystemProcesses,
+  stopProcess = terminateProcess,
+  serviceStatus = getServiceStatus,
+  stopDaemon = stopManagedDaemon,
+  unregisterDaemon = unregisterManagedDaemon,
+  inspectResources = inspectSystemResources
+}) {
+  assertDoctorPolicy(doctorPolicy);
+  const runtime = await agentManager.getRuntimeDiagnostic({
+    contextInspectionTimeoutMs: doctorPolicy.contextInspectionTimeoutMs
+  });
+  const report = {
+    runtime,
+    contexts: runtime.contexts.map((context) => evaluateContext(context, doctorPolicy)),
+    daemons: [],
+    repairs: [],
+    attention: [],
+    system: null,
+    systemError: null
+  };
+  addContextAttention(report);
+  try {
+    report.system = await inspectResources();
+  } catch (error) {
+    report.systemError = error?.message || String(error);
+    report.attention.push(`System resource inspection failed: ${report.systemError}`);
+  }
+  let processes = [];
+  try {
+    processes = await listProcesses({ timeoutMs: daemonPolicy.healthTimeoutMs });
+  } catch (error) {
+    report.attention.push(`Process inspection failed: ${error?.message || error}`);
+  }
+
+  const processByPid = new Map(processes.map((record) => [record.pid, record]));
+  const currentService = await serviceStatus();
+  if (currentService.running && currentService.pid !== process.pid) {
+    const registered = processByPid.get(currentService.pid);
+    if (registered && isArisaServiceProcess(registered)) {
+      try {
+        await stopProcess(currentService.pid, { forceAfterMs: daemonPolicy.stopTimeoutMs });
+        report.repairs.push(`Stopped duplicate Arisa service process ${currentService.pid}.`);
+      } catch (error) {
+        report.attention.push(`Duplicate Arisa service process ${currentService.pid} could not be stopped: ${error?.message || error}`);
+      }
+    } else {
+      report.attention.push(`Registered service process ${currentService.pid} could not be verified and was left running.`);
+    }
+  }
+
+  try {
+    report.daemons = await toolProcessSupervisor.repair();
+  } catch (error) {
+    report.attention.push(`Daemon reconciliation failed: ${error?.message || error}`);
+  }
+  for (const result of report.daemons) {
+    const label = daemonLabel(result.record);
+    if (result.outcome === "stale-registration") {
+      const pid = result.diagnostic?.pid;
+      const registered = pid ? processByPid.get(pid) : null;
+      if (pid && (!registered || !isDaemonProcess(registered, result.record))) {
+        report.attention.push(`${label} has a stale registration, but its live process identity could not be verified.`);
+        continue;
+      }
+      try {
+        if (pid) {
+          await stopProcess(pid, { forceAfterMs: daemonPolicy.stopTimeoutMs });
+          await stopDaemon(
+            { toolName: result.record.toolName, scope: result.record.scope },
+            { state: null }
+          );
+        }
+        await unregisterDaemon({ toolName: result.record.toolName, scope: result.record.scope });
+        report.repairs.push(`Removed stale daemon registration ${label}: ${result.reason}.`);
+      } catch (error) {
+        report.attention.push(`${label} stale registration could not be removed: ${error?.message || error}`);
+      }
+      continue;
+    }
+    if (result.outcome === "missing-entry") {
+      const pid = result.diagnostic?.pid;
+      const registered = pid ? processByPid.get(pid) : null;
+      if (registered && isDaemonProcess(registered, result.record)) {
+        try {
+          await stopProcess(pid, { forceAfterMs: daemonPolicy.stopTimeoutMs });
+          await stopDaemon(
+            { toolName: result.record.toolName, scope: result.record.scope },
+            { state: "failed", message: "Orphaned daemon stopped because its tool entry is missing" }
+          );
+          report.repairs.push(`Stopped orphaned daemon ${label}.`);
+        } catch (error) {
+          report.attention.push(`${label} could not be stopped: ${error?.message || error}`);
+        }
+      } else {
+        report.attention.push(`${label} has a missing entry${pid ? "; its process identity could not be verified" : ""}.`);
+      }
+      continue;
+    }
+    if (["started", "recovered", "restart-scheduled"].includes(result.outcome)) {
+      report.repairs.push(`${label}: ${result.outcome}.`);
+    }
+    if (result.outcome === "error") {
+      report.attention.push(`${label}: daemon reconciliation failed.`);
+    } else if (result.diagnostic?.disposition === "requires-attention") {
+      report.attention.push(`${label}: ${result.diagnostic.message || result.diagnostic.state}.`);
+    }
+  }
+
+  logger?.log("doctor", `completed with ${report.repairs.length} repair(s) and ${report.attention.length} attention item(s)`);
+  return report;
+}

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,14 @@ 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 getChatToolUsageFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "tool-usage.json");
+}
+
 export function getChatToolStateDir(chatId, toolName) {
   return path.join(getChatDir(chatId), "state", "tools", toolName);
 }
@@ -119,4 +127,3 @@ export async function ensureArisaHome() {
   await mkdir(toolsDir, { recursive: true });
   await mkdir(chatsDir, { recursive: true });
 }
-

package/src/runtime/report-format.js

@@ -0,0 +1,51 @@
+export const reportWidth = 35;
+
+function splitLongWord(word, width) {
+  const parts = [];
+  for (let index = 0; index < word.length; index += width) parts.push(word.slice(index, index + width));
+  return parts;
+}
+
+export function wrapReportText(text, { firstPrefix = "", nextPrefix = firstPrefix } = {}) {
+  const words = String(text ?? "").trim().split(/\s+/).filter(Boolean);
+  if (!words.length) return [firstPrefix.trimEnd()];
+  const lines = [];
+  let prefix = firstPrefix;
+  let content = "";
+  for (const originalWord of words) {
+    const width = Math.max(1, reportWidth - prefix.length);
+    const parts = originalWord.length > width ? splitLongWord(originalWord, width) : [originalWord];
+    for (const word of parts) {
+      if (content && content.length + 1 + word.length > width) {
+        lines.push(prefix + content);
+        prefix = nextPrefix;
+        content = "";
+      }
+      if (!content && word.length > Math.max(1, reportWidth - prefix.length)) {
+        const fragments = splitLongWord(word, Math.max(1, reportWidth - prefix.length));
+        lines.push(prefix + fragments.shift());
+        prefix = nextPrefix;
+        content = fragments.join("");
+      } else {
+        content += `${content ? " " : ""}${word}`;
+      }
+    }
+  }
+  if (content) lines.push(prefix + content);
+  return lines;
+}
+
+export function reportRow(label, value, { indent = "  ", labelWidth = 10 } = {}) {
+  const firstPrefix = `${indent}${String(label).padEnd(labelWidth)} `;
+  return wrapReportText(value, {
+    firstPrefix,
+    nextPrefix: " ".repeat(firstPrefix.length)
+  });
+}
+
+export function renderTextReport(lines) {
+  for (const line of lines) {
+    if ([...line].length > reportWidth) throw new Error(`Report line exceeds ${reportWidth} characters: ${line}`);
+  }
+  return `\`\`\`text\n${lines.join("\n")}\n\`\`\``;
+}