arisa 5.1.68 → 5.2.17

package/src/runtime/tui.js

@@ -0,0 +1,200 @@
+import { mkdir, readFile } from "node:fs/promises";
+import {
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  defineTool,
+  InteractiveMode,
+  SessionManager
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { loadConfig } from "../core/config/config-store.js";
+import { buildPiToolPolicy } from "../core/agent/core-tools.js";
+import { createModelSpeedController } from "../core/agent/model-speed.js";
+import { clampModelThinkingLevel, createPiRuntime, hasProviderAuth } from "../core/agent/pi-runtime.js";
+import { appendArisaAgentsFile, arisaAgentsFile } from "../core/agent/runtime-context.js";
+import { createPiSettingsManager } from "../core/agent/agent-manager.js";
+import { createArisaClient } from "../core/tools/ipc-client.js";
+import { arisaHomeDir, tuiSessionsDir } from "../platform/paths.js";
+
+const tuiToolNames = Object.freeze([
+  "list_tools",
+  "tool_help",
+  "tool_skills",
+  "set_tool_config",
+  "run_tool",
+  "list_scheduled_tasks",
+  "cancel_scheduled_task",
+  "cancel_all_scheduled_tasks"
+]);
+
+function jsonResult(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    details: result
+  };
+}
+
+export function resolveTuiChatId(config) {
+  const chatId = config?.telegram?.authorizedChatIds?.[0];
+  if (chatId == null || !String(chatId).trim()) {
+    throw new Error("arisa tui requires at least one authorized chat for scoped tools and artifacts");
+  }
+  return chatId;
+}
+
+export function createTuiCapabilityTools(client) {
+  return [
+    defineTool({
+      name: "list_tools",
+      label: "List tools",
+      description: "List or search Arisa modular tools by capability.",
+      parameters: Type.Object({ query: Type.Optional(Type.String()) }),
+      execute: async (_id, params) => jsonResult(await client.tools.list(params))
+    }),
+    defineTool({
+      name: "tool_help",
+      label: "Tool help",
+      description: "Show the CLI help for an Arisa modular tool.",
+      parameters: Type.Object({ name: Type.String() }),
+      execute: async (_id, params) => jsonResult(await client.tools.help(params))
+    }),
+    defineTool({
+      name: "tool_skills",
+      label: "Tool skills",
+      description: "Show skill hints assigned to an Arisa modular tool.",
+      parameters: Type.Object({ name: Type.String() }),
+      execute: async (_id, params) => jsonResult(await client.tools.skills(params))
+    }),
+    defineTool({
+      name: "set_tool_config",
+      label: "Set tool config",
+      description: "Write an Arisa tool config value in the owner chat scope.",
+      parameters: Type.Object({ name: Type.String(), field: Type.String(), value: Type.String() }),
+      execute: async (_id, params) => jsonResult(await client.tools.setConfig(params))
+    }),
+    defineTool({
+      name: "run_tool",
+      label: "Run tool",
+      description: "Run an Arisa modular tool. Generated files remain owner-scoped artifacts; Telegram delivery is unavailable from TUI mode.",
+      parameters: Type.Object({
+        name: Type.String(),
+        artifactId: Type.Optional(Type.String()),
+        text: Type.Optional(Type.String()),
+        resourceId: Type.Optional(Type.String()),
+        args: Type.Optional(Type.Record(Type.String(), Type.String()))
+      }),
+      execute: async (_id, params) => jsonResult(await client.tools.run(params, { timeoutMs: 900_000 }))
+    }),
+    defineTool({
+      name: "list_scheduled_tasks",
+      label: "List scheduled tasks",
+      description: "List owner-scoped Arisa tasks.",
+      parameters: Type.Object({
+        status: Type.Optional(Type.String()),
+        limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 }))
+      }),
+      execute: async (_id, params) => jsonResult(await client.tasks.list(params))
+    }),
+    defineTool({
+      name: "cancel_scheduled_task",
+      label: "Cancel scheduled task",
+      description: "Cancel one owner-scoped Arisa task.",
+      parameters: Type.Object({ id: Type.String() }),
+      execute: async (_id, params) => jsonResult(await client.tasks.cancel(params))
+    }),
+    defineTool({
+      name: "cancel_all_scheduled_tasks",
+      label: "Cancel all scheduled tasks",
+      description: "Cancel all active owner-scoped Arisa tasks, including authentication-blocked tasks.",
+      parameters: Type.Object({}),
+      execute: async () => jsonResult(await client.tasks.cancelAll())
+    })
+  ];
+}
+
+function requiresProviderAuth(model) {
+  if (typeof model?.baseUrl !== "string") return true;
+  try {
+    const hostname = new URL(model.baseUrl).hostname;
+    return hostname !== "127.0.0.1" && hostname !== "localhost";
+  } catch {
+    return true;
+  }
+}
+
+export async function createArisaTuiRuntime({ config, client, logger } = {}) {
+  const chatId = resolveTuiChatId(config);
+  const policy = buildPiToolPolicy({ config, customToolNames: tuiToolNames });
+  const piRuntime = createPiRuntime({ provider: config.pi.provider, apiKey: config.pi.apiKey });
+  const model = piRuntime.modelRegistry.find(config.pi.provider, config.pi.model);
+  if (!model) throw new Error(`Model not found: ${config.pi.provider}/${config.pi.model}`);
+  if (requiresProviderAuth(model) && !config.pi.apiKey && !hasProviderAuth(config.pi.provider, piRuntime)) {
+    throw new Error(`No auth found for ${config.pi.provider}. Complete Arisa bootstrap first.`);
+  }
+
+  await mkdir(tuiSessionsDir, { recursive: true });
+  const arisaAgentsContent = await readFile(arisaAgentsFile, "utf8");
+  const customTools = createTuiCapabilityTools(client);
+  const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
+    const settingsManager = createPiSettingsManager(config);
+    const services = await createAgentSessionServices({
+      cwd,
+      agentDir: arisaHomeDir,
+      authStorage: piRuntime.authStorage,
+      modelRegistry: piRuntime.modelRegistry,
+      settingsManager,
+      resourceLoaderOptions: {
+        agentsFilesOverride: (current) => appendArisaAgentsFile(current, arisaAgentsContent)
+      }
+    });
+    const created = await createAgentSessionFromServices({
+      services,
+      sessionManager,
+      sessionStartEvent,
+      model,
+      thinkingLevel: clampModelThinkingLevel(model, config.pi.thinkingLevel),
+      tools: policy.tools,
+      excludeTools: policy.excludeTools,
+      customTools
+    });
+    const speedController = createModelSpeedController(created.session.agent.streamFn, config.pi.speed);
+    created.session.agent.streamFn = speedController.streamFn;
+    logger?.log("tui", `opened ${created.session.sessionFile || "in-memory session"} for owner scope ${chatId}`);
+    return { ...created, services, diagnostics: services.diagnostics };
+  };
+
+  return createAgentSessionRuntime(createRuntime, {
+    cwd: policy.workspaceDir,
+    agentDir: arisaHomeDir,
+    sessionManager: SessionManager.create(policy.workspaceDir, tuiSessionsDir)
+  });
+}
+
+export async function runTui({ logger } = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("arisa tui requires an interactive terminal");
+  }
+  const config = await loadConfig();
+  const chatId = resolveTuiChatId(config);
+  const client = createArisaClient({ toolName: "arisa-tui", chatId });
+  try {
+    await client.tools.list();
+  } catch (error) {
+    throw new Error(`arisa tui requires the Arisa background service: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  const runtime = await createArisaTuiRuntime({ config, client, logger });
+  const mode = new InteractiveMode(runtime, {
+    migratedProviders: [],
+    modelFallbackMessage: runtime.modelFallbackMessage,
+    initialImages: [],
+    initialMessages: [],
+    verbose: false
+  });
+  try {
+    await mode.run();
+  } finally {
+    await runtime.dispose();
+  }
+}

package/src/runtime/update-manager.js

@@ -2,7 +2,7 @@ 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 { arisaPackageDir, getToolDir } from "../platform/paths.js";
 import { renderTextReport, reportRow, wrapReportText } from "./report-format.js";
 
 const defaultRepoUrl = "https://github.com/clasen/Arisa.git";

package/src/runtime/worker-recovery-report.js

@@ -0,0 +1,142 @@
+import crypto from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { readRecentLogLines } from "./log-viewer.js";
+import { arisaPackageDir, serviceLogFile, stateDir, tasksFile } from "../platform/paths.js";
+
+export const workerRecoveryReportFile = path.join(stateDir, "worker-recovery-report.json");
+
+function boundedText(value, maximum = 300) {
+  return String(value || "").trim().slice(0, maximum);
+}
+
+export async function recordUnexpectedWorkerExit(input, { reportFile = workerRecoveryReportFile } = {}) {
+  const report = {
+    id: crypto.randomUUID(),
+    occurredAt: input.occurredAt || new Date().toISOString(),
+    runtimeMs: Math.max(0, Number(input.runtimeMs || 0)),
+    restartDelayMs: Math.max(0, Number(input.restartDelayMs || 0)),
+    consecutiveFailures: Math.max(1, Number(input.consecutiveFailures || 1)),
+    code: input.code == null ? null : boundedText(input.code, 40),
+    signal: input.signal == null ? null : boundedText(input.signal, 40),
+    detail: boundedText(input.detail)
+  };
+  await mkdir(path.dirname(reportFile), { recursive: true, mode: 0o700 });
+  const temporary = `${reportFile}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(report, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, reportFile);
+  return report;
+}
+
+function logTimestamp(line) {
+  const match = String(line).match(/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\]/);
+  if (!match) return null;
+  const value = new Date(match[1].replace(" ", "T")).getTime();
+  return Number.isFinite(value) ? value : null;
+}
+
+function relevantLogLines(lines, report) {
+  const occurredAt = new Date(report.occurredAt).getTime();
+  if (!Number.isFinite(occurredAt)) return lines.slice(-300);
+  const earliest = occurredAt - 2 * 60_000;
+  const latest = occurredAt + 5_000;
+  let start = -1;
+  let end = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const timestamp = logTimestamp(lines[index]);
+    if (timestamp == null) continue;
+    if (start === -1 && timestamp >= earliest) start = index;
+    if (timestamp <= latest) end = index;
+  }
+  if (start === -1 || end < start) return lines.slice(-300);
+  return lines.slice(start, end + 1);
+}
+
+export function summarizeRecoveryEvidence(lines, report) {
+  const relevant = relevantLogLines(lines, report);
+  const outOfMemory = relevant.some((line) => /heap limit|heap out of memory|allocation failed.*memory/i.test(line));
+  const tools = new Map();
+  for (const line of relevant) {
+    const match = line.match(/\[agent\] run_tool ([a-z0-9-]+)/i);
+    if (match) tools.set(match[1], (tools.get(match[1]) || 0) + 1);
+  }
+  return {
+    cause: outOfMemory
+      ? "JavaScript heap out of memory"
+      : report.signal
+        ? `worker terminated by ${report.signal}`
+        : `worker exited with code ${report.code ?? "unknown"}`,
+    tools: [...tools.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 3)
+  };
+}
+
+async function interruptedTaskCount(report, file = tasksFile) {
+  try {
+    const document = JSON.parse(await readFile(file, "utf8"));
+    const tasks = Array.isArray(document) ? document : document.tasks || [];
+    const occurredAt = new Date(report.occurredAt).getTime();
+    return tasks.filter((task) => {
+      const updatedAt = new Date(task.updatedAt || 0).getTime();
+      return task.lastOutcome === "outcome_uncertain"
+        && /interrupted before confirmation/i.test(task.lastError || "")
+        && Number.isFinite(occurredAt)
+        && Math.abs(updatedAt - occurredAt) <= 2 * 60_000;
+    }).length;
+  } catch {
+    return 0;
+  }
+}
+
+async function runtimeVersion() {
+  try {
+    return String(JSON.parse(await readFile(path.join(arisaPackageDir, "package.json"), "utf8")).version || "unknown");
+  } catch {
+    return "unknown";
+  }
+}
+
+export async function loadWorkerRecoveryReport({
+  reportFile = workerRecoveryReportFile,
+  logFile = serviceLogFile,
+  taskFile = tasksFile,
+  readLines = readRecentLogLines,
+  getVersion = runtimeVersion
+} = {}) {
+  let report;
+  try {
+    report = JSON.parse(await readFile(reportFile, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  const snapshot = await readLines(logFile, 1_000).catch(() => []);
+  const lines = Array.isArray(snapshot) ? snapshot : String(snapshot?.text || "").split(/\r?\n/);
+  const evidence = summarizeRecoveryEvidence(lines, report);
+  const uncertain = await interruptedTaskCount(report, taskFile);
+  const version = await getVersion();
+  const context = evidence.tools.length
+    ? `Recent tool activity: ${evidence.tools.map(([name, count]) => `${name} ×${count}`).join(", ")}.`
+    : null;
+  return {
+    report,
+    text: [
+      "Arisa recovered automatically after an unexpected worker exit.",
+      `Cause: ${evidence.cause}.`,
+      context,
+      uncertain ? `${uncertain} scheduled execution${uncertain === 1 ? " was" : "s were"} marked outcome-uncertain and not replayed.` : null,
+      `Recovery: worker restarted after ${Math.round(report.restartDelayMs / 100) / 10}s; Arisa ${version} is running.`
+    ].filter(Boolean).join("\n")
+  };
+}
+
+export async function consumeWorkerRecoveryReport(reportId, { reportFile = workerRecoveryReportFile } = {}) {
+  try {
+    const report = JSON.parse(await readFile(reportFile, "utf8"));
+    if (report.id !== reportId) return false;
+    await rm(reportFile, { force: true });
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}