arisa 5.1.68 → 5.2.7

package/src/runtime/paths.js

@@ -1,151 +1,3 @@
-import { mkdir } from "node:fs/promises";
-import crypto from "node:crypto";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const arisaPackageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-export const arisaHomeDir = process.env.ARISA_HOME
-  ? path.resolve(process.env.ARISA_HOME)
-  : path.join(os.homedir(), ".arisa");
-export const stateDir = path.join(arisaHomeDir, "state");
-export const configFile = path.join(stateDir, "config.json");
-export const piAuthFile = path.join(stateDir, "pi-auth.json");
-export const servicePidFile = path.join(stateDir, "arisa.pid");
-export const serviceLogFile = path.join(stateDir, "arisa.log");
-export const restartReceiptFile = path.join(stateDir, "restart-receipt.json");
-export const sessionStartOperationalNotesFile = path.join(stateDir, "session-start-operational-notes.json");
-export function createIpcSocketPath({ homeDir = arisaHomeDir, platform = process.platform } = {}) {
-  if (platform === "win32") {
-    const suffix = crypto.createHash("sha256").update(homeDir).digest("hex").slice(0, 16);
-    return `\\\\.\\pipe\\arisa-${suffix}`;
-  }
-  return path.join(homeDir, "state", "arisa.sock");
-}
-
-export const arisaIpcSocketFile = createIpcSocketPath();
-export const tasksFile = path.join(stateDir, "tasks.json");
-export const toolsDir = path.join(arisaHomeDir, "tools");
-export const chatsDir = path.join(arisaHomeDir, "chats");
-export const toolStateDir = path.join(stateDir, "tools");
-
-export function requireToolName(toolName) {
-  const name = String(toolName ?? "");
-  if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
-    throw new Error(`Invalid tool name: ${name || "empty"}`);
-  }
-  return name;
-}
-
-export function getChatDir(chatId) {
-  return path.join(chatsDir, String(chatId));
-}
-
-export function getChatArtifactsDir(chatId) {
-  return path.join(getChatDir(chatId), "artifacts");
-}
-
-export function getChatArtifactsIndexFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "artifacts.json");
-}
-
-export function getChatSessionSeedFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "session-seed.jsonl");
-}
-
-export function getChatLegacyConversationHistoryFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "conversation.jsonl");
-}
-
-export function getChatToolUsageFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "tool-usage.json");
-}
-
-export function getChatToolResourceNotesFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "tool-resource-notes.json");
-}
-
-export function getChatTelegramWorkspacesFile(chatId) {
-  return path.join(getChatDir(chatId), "state", "telegram-workspaces.json");
-}
-
-export function getChatToolStateDir(chatId, toolName) {
-  return path.join(getChatDir(chatId), "state", "tools", requireToolName(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, sessionRevision = 0) {
-  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
-    throw new Error(`Invalid Pi session revision: ${sessionRevision}`);
-  }
-  const sessionsDir = path.join(getChatDir(chatId), "state", "pi-sessions");
-  return sessionRevision === 0
-    ? sessionsDir
-    : path.join(sessionsDir, String(sessionRevision));
-}
-
-export function getToolDir(toolName) {
-  return path.join(toolsDir, requireToolName(toolName));
-}
-
-export function getToolConfigPath(toolName) {
-  return path.join(getToolDir(toolName), "config.js");
-}
-
-export function getChatConfigDir(chatId) {
-  return path.join(getChatDir(chatId), "config");
-}
-
-export function getChatTmpDir(chatId) {
-  return path.join(getChatDir(chatId), "tmp");
-}
-
-export function getChatToolConfigPath(chatId, toolName) {
-  return path.join(getChatConfigDir(chatId), "tools", requireToolName(toolName), "config.js");
-}
-
-export function getToolStateDir(toolName) {
-  return path.join(toolStateDir, requireToolName(toolName));
-}
-
-export function getToolTmpDir(toolName) {
-  return path.join(getToolStateDir(toolName), "tmp");
-}
-
-export function getChatToolTmpDir(chatId, toolName) {
-  return path.join(getChatTmpDir(chatId), "tools", toolName);
-}
-
-export async function ensureArisaHome() {
-  await mkdir(stateDir, { recursive: true });
-  await mkdir(toolsDir, { recursive: true });
-  await mkdir(chatsDir, { recursive: true });
-}
+// Public compatibility facade for tools and integrations.
+// Core and runtime internals import the neutral platform implementation directly.
+export * from "../platform/paths.js";

package/src/runtime/restart-receipt.js

@@ -3,7 +3,7 @@ import { execFile } from "node:child_process";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
-import { arisaPackageDir, restartReceiptFile } from "./paths.js";
+import { arisaPackageDir, restartReceiptFile } from "../platform/paths.js";
 
 const execFileAsync = promisify(execFile);
 

package/src/runtime/service-manager.js

@@ -2,7 +2,7 @@ import { open, readFile, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { ensureArisaHome, serviceLogFile, servicePidFile } from "./paths.js";
+import { ensureArisaHome, serviceLogFile, servicePidFile } from "../platform/paths.js";
 
 export const serviceEntryFile = fileURLToPath(new URL("../index.js", import.meta.url));
 

package/src/runtime/service-supervisor.js

@@ -22,6 +22,7 @@ export function createServiceSupervisor({
   restartBackoffMaxMs = 60_000,
   stableRuntimeMs = 60_000,
   logger,
+  onUnexpectedExit = null,
   spawnProcess = spawn,
   wait = sleep
 }) {
@@ -65,6 +66,19 @@ export function createServiceSupervisor({
       }
 
       const delay = Math.min(maximumBackoffMs, initialBackoffMs * (2 ** (consecutiveFailures - 1)));
+      try {
+        await onUnexpectedExit?.({
+          occurredAt: new Date().toISOString(),
+          runtimeMs,
+          restartDelayMs: delay,
+          consecutiveFailures,
+          code: outcome.code ?? null,
+          signal: outcome.signal || null,
+          detail
+        });
+      } catch (error) {
+        logger?.error("service", `worker recovery report failed: ${errorMessage(error)}`);
+      }
       logger?.log("service", `restarting worker in ${delay}ms`);
       await Promise.race([
         wait(delay),

package/src/runtime/slave-cli.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { applyConfigDefaults } from "../core/config/config-defaults.js";
 import { installLockedOfficialTool } from "../core/tools/official-tool-installer.js";
 import { createHeadlessApp } from "./create-headless-app.js";
-import { arisaPackageDir } from "./paths.js";
+import { arisaPackageDir } from "../platform/paths.js";
 import { readPackageVersion, readRecentLogLines, followLogFile } from "./log-viewer.js";
 import { parseSlaveBootstrapUrl } from "./slave-bootstrap-url.js";
 import { withSecureRequestFile } from "./secure-request-file.js";

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

@@ -8,7 +8,7 @@ import {
   writeDaemonStatus
 } from "../core/tools/daemon-processes.js";
 import { loadDaemonPolicy } from "../core/tools/daemon-policy.js";
-import { ensureArisaHome } from "./paths.js";
+import { ensureArisaHome } from "../platform/paths.js";
 
 async function fileExists(file) {
   try {

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 pending or running owner-scoped Arisa 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;
+  }
+}