arisa 5.1.24 → 5.1.60

package/src/runtime/arisa-capabilities.js

@@ -1,251 +1,60 @@
-import {
-  getChatArtifactsDir,
-  getChatToolStateDir,
-  getChatToolTmpDir,
-  getToolStateDir,
-  getToolTmpDir
-} from "./paths.js";
-import { ToolResourceNoteStore } from "../core/tools/tool-resource-note-store.js";
-import { installBundledOfficialTool } from "../core/tools/official-tool-installer.js";
-
-function requireToolName(toolName) {
-  if (typeof toolName !== "string" || !toolName.trim()) {
-    throw new Error("toolName is required");
-  }
-  return toolName.trim();
-}
-
-function requireChatId(chatId, method) {
-  if (chatId == null || chatId === "") {
-    throw new Error(`${method} requires chatId`);
-  }
-  return chatId;
-}
-
-function requireString(value, fieldName) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${fieldName} is required`);
-  }
-  return value;
-}
-
-function normalizeArgs(args) {
-  if (args == null) return {};
-  if (typeof args !== "object" || Array.isArray(args)) {
-    throw new Error("args must be an object");
-  }
-  return args;
-}
-
-function normalizeLimit(limit) {
-  const value = Number(limit);
-  if (!Number.isInteger(value) || value <= 0) return 20;
-  return Math.min(value, 100);
-}
-
-function normalizeAcknowledgement(value) {
-  if (value == null || value === "") return "";
-  const acknowledgement = requireString(value, "acknowledgement").trim();
-  if (acknowledgement.length > 500) throw new Error("acknowledgement must be at most 500 characters");
-  return acknowledgement;
-}
+import { createCapabilityService } from "../core/capabilities/capability-service.js";
+
+const ipcMethods = new Set([
+  "tools.list",
+  "tools.help",
+  "tools.skills",
+  "tools.setConfig",
+  "tools.setResourceNote",
+  "tools.getResourceNote",
+  "tools.run",
+  "tools.installOfficial",
+  "artifacts.createText",
+  "artifacts.listRecent",
+  "artifacts.get",
+  "artifacts.deliver",
+  "tasks.add",
+  "tasks.list",
+  "tasks.cancel",
+  "tasks.cancelAll",
+  "agent.enqueueEvent",
+  "paths.getChatToolStateDir",
+  "paths.getToolStateDir",
+  "paths.getChatToolTmpDir",
+  "paths.getToolTmpDir",
+  "paths.getChatArtifactsDir"
+]);
 
 export function createArisaCapabilities({
+  capabilityService,
   artifactStore,
   taskStore,
   toolRegistry,
   agentManager,
-  resourceNotes = new ToolResourceNoteStore(),
-  installOfficialTool = installBundledOfficialTool
+  resourceNotes,
+  installOfficialTool,
+  logger
 } = {}) {
-  async function dispatch({ method, toolName, chatId = null, params = {} } = {}) {
-    const scopedToolName = requireToolName(toolName);
-
-    if (method === "tools.list") {
-      await toolRegistry.load();
-      return toolRegistry.listWithRuntime(chatId);
-    }
-
-    if (method === "tools.help") {
-      await toolRegistry.load();
-      return toolRegistry.help(requireString(params.name, "name"));
-    }
-
-    if (method === "tools.skills") {
-      await toolRegistry.load();
-      return toolRegistry.resolveSkills(requireString(params.name, "name"));
-    }
-
-    if (method === "tools.setConfig") {
-      await toolRegistry.load();
-      return toolRegistry.setConfig(
-        requireString(params.name, "name"),
-        requireString(params.field, "field"),
-        requireString(params.value, "value"),
-        requireChatId(chatId, method)
-      );
-    }
-
-    if (method === "tools.setResourceNote") {
-      const scopedChatId = requireChatId(chatId, method);
-      return resourceNotes.set(
-        scopedChatId,
-        scopedToolName,
-        requireString(params.resourceId, "resourceId"),
-        String(params.note ?? "")
-      );
-    }
-
-    if (method === "tools.getResourceNote") {
-      const scopedChatId = requireChatId(chatId, method);
-      return {
-        toolName: scopedToolName,
-        resourceId: requireString(params.resourceId, "resourceId"),
-        note: await resourceNotes.get(scopedChatId, scopedToolName, params.resourceId)
-      };
-    }
-
-    if (method === "tools.run") {
-      if (!agentManager?.runTool) {
-        throw new Error("tools.run requires agentManager");
-      }
-      const scopedChatId = requireChatId(chatId, method);
-      const targetToolName = requireString(params.name, "name");
-      const chatArtifactStore = artifactStore.forChat(scopedChatId);
-      const artifact = params.artifactId
-        ? await chatArtifactStore.get(requireString(params.artifactId, "artifactId"))
-        : null;
-      if (params.artifactId && !artifact) {
-        throw new Error(`Artifact not found: ${params.artifactId}`);
+  const service = capabilityService || createCapabilityService({
+    artifactStore,
+    taskStore,
+    toolRegistry,
+    toolExecutor: agentManager,
+    resourceNotes,
+    installOfficialTool,
+    logger
+  });
+
+  return {
+    dispatch: ({ method, toolName, chatId = null, params = {} } = {}) => service.execute({
+      method,
+      actorToolName: toolName,
+      chatId,
+      params,
+      context: {
+        allowedMethods: ipcMethods,
+        unknownMethodLabel: "IPC"
       }
-
-      return agentManager.runTool({
-        name: targetToolName,
-        request: {
-          artifact,
-          text: params.text,
-          resourceId: params.resourceId,
-          args: normalizeArgs(params.args)
-        },
-        chatId: scopedChatId
-      });
-    }
-
-    if (method === "tools.installOfficial") {
-      const name = requireString(params.name, "name");
-      if (params.confirmName !== name) {
-        throw new Error("tools.installOfficial requires confirmName equal to name");
-      }
-      const installed = await installOfficialTool(name);
-      await toolRegistry.load();
-      return installed;
-    }
-
-    if (method === "artifacts.createText") {
-      const scopedChatId = requireChatId(chatId, method);
-      return artifactStore.forChat(scopedChatId).createText({
-        text: requireString(params.text, "text"),
-        mimeType: params.mimeType || "text/plain",
-        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId },
-        metadata: params.metadata || {}
-      });
-    }
-
-    if (method === "artifacts.listRecent") {
-      const scopedChatId = requireChatId(chatId, method);
-      return artifactStore.forChat(scopedChatId).listRecent(normalizeLimit(params.limit));
-    }
-
-    if (method === "artifacts.get") {
-      const scopedChatId = requireChatId(chatId, method);
-      return artifactStore.forChat(scopedChatId).get(requireString(params.artifactId, "artifactId"));
-    }
-
-    if (method === "artifacts.deliver") {
-      const scopedChatId = requireChatId(chatId, method);
-      const artifactId = requireString(params.artifactId, "artifactId");
-      const artifact = await artifactStore.forChat(scopedChatId).get(artifactId);
-      if (!artifact?.path) throw new Error(`Artifact not found or has no file: ${artifactId}`);
-      if (!agentManager?.deliverArtifact) throw new Error("artifact delivery is unavailable");
-      return agentManager.deliverArtifact({
-        chatId: scopedChatId,
-        artifact,
-        caption: params.caption,
-        method: params.method
-      });
-    }
-
-    if (method === "tasks.add") {
-      const scopedChatId = requireChatId(chatId, method);
-      return taskStore.add(params.task || {}, {
-        payload: { chatId: scopedChatId },
-        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId }
-      });
-    }
-
-    if (method === "tasks.list") {
-      const scopedChatId = requireChatId(chatId, method);
-      return taskStore.list({
-        chatId: scopedChatId,
-        status: params.status || undefined,
-        kind: params.kind || undefined
-      });
-    }
-
-    if (method === "tasks.cancel") {
-      const scopedChatId = requireChatId(chatId, method);
-      const taskId = requireString(params.taskId, "taskId");
-      const task = await taskStore.get(taskId);
-      if (!task) return null;
-      if (String(task.payload?.chatId) !== String(scopedChatId)) {
-        throw new Error("task does not belong to chatId");
-      }
-      return taskStore.cancel(taskId);
-    }
-
-    if (method === "tasks.cancelAll") {
-      const scopedChatId = requireChatId(chatId, method);
-      return taskStore.cancelAll({ chatId: scopedChatId });
-    }
-
-    if (method === "agent.enqueueEvent") {
-      const scopedChatId = requireChatId(chatId, method);
-      const resourceId = String(params.resourceId || "").trim();
-      return taskStore.add({
-        kind: "agent_event",
-        payload: {
-          prompt: requireString(params.prompt, "prompt"),
-          resourceId,
-          acknowledgement: normalizeAcknowledgement(params.acknowledgement)
-        }
-      }, {
-        payload: { chatId: scopedChatId },
-        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId, resourceId }
-      });
-    }
-
-    if (method === "paths.getChatToolStateDir") {
-      return getChatToolStateDir(requireChatId(chatId, method), scopedToolName);
-    }
-
-    if (method === "paths.getToolStateDir") {
-      return getToolStateDir(scopedToolName);
-    }
-
-    if (method === "paths.getChatToolTmpDir") {
-      return getChatToolTmpDir(requireChatId(chatId, method), scopedToolName);
-    }
-
-    if (method === "paths.getToolTmpDir") {
-      return getToolTmpDir(scopedToolName);
-    }
-
-    if (method === "paths.getChatArtifactsDir") {
-      return getChatArtifactsDir(requireChatId(chatId, method));
-    }
-
-    throw new Error(`unknown IPC method: ${method}`);
-  }
-
-  return { dispatch };
+    })
+  };
 }

package/src/runtime/create-app.js

@@ -3,6 +3,7 @@ import { ArtifactStore } from "../core/artifacts/artifact-store.js";
 import { ToolRegistry } from "../core/tools/tool-registry.js";
 import { TaskStore } from "../core/tasks/task-store.js";
 import { AgentManager } from "../core/agent/agent-manager.js";
+import { createCapabilityService } from "../core/capabilities/capability-service.js";
 import { getErrorMessage, getPiAuthIssue } from "../core/agent/auth-flow.js";
 import { createTelegramBot } from "../transport/telegram/bot.js";
 import { createToolProcessSupervisor } from "./tool-process-supervisor.js";
@@ -120,7 +121,15 @@ export async function createApp({ logger, runtimeOverrides, requestRestart } = {
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
-  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, toolRegistry, agentManager });
+  const capabilityService = createCapabilityService({
+    artifactStore,
+    taskStore,
+    toolRegistry,
+    toolExecutor: agentManager,
+    logger
+  });
+  agentManager.setCapabilityService(capabilityService);
+  const arisaCapabilities = createArisaCapabilities({ capabilityService });
   const ipcServer = createIpcServer({ capabilities: arisaCapabilities, logger });
   const bot = await createTelegramBot({
     config,

package/src/runtime/create-headless-app.js

@@ -3,6 +3,7 @@ import { loadConfig } from "../core/config/config-store.js";
 import { TaskStore } from "../core/tasks/task-store.js";
 import { ToolRegistry } from "../core/tools/tool-registry.js";
 import { createDaemonRuntime } from "../core/tools/daemon-runtime.js";
+import { createCapabilityService } from "../core/capabilities/capability-service.js";
 import { createArisaCapabilities } from "./arisa-capabilities.js";
 import { createHeadlessToolExecutor } from "./headless-tool-executor.js";
 import { createIpcServer } from "./ipc/ipc-server.js";
@@ -26,12 +27,14 @@ export async function createHeadlessApp({
   await toolRegistry.load();
   const toolProcessSupervisor = supervisorFactory({ logger, policy: config.daemons, toolRegistry });
   const toolExecutor = createHeadlessToolExecutor({ artifactStore, taskStore, toolRegistry });
-  const capabilities = capabilitiesFactory({
+  const capabilityService = createCapabilityService({
     artifactStore,
     taskStore,
     toolRegistry,
-    agentManager: toolExecutor
+    toolExecutor,
+    logger
   });
+  const capabilities = capabilitiesFactory({ capabilityService, agentManager: toolExecutor });
   const ipcServer = ipcServerFactory({ capabilities, logger });
   const autoStartedDaemons = [];
 

package/src/runtime/doctor.js

@@ -193,7 +193,6 @@ export async function inspectSystemResources({ diskPath = arisaHomeDir } = {}) {
 
 function assertDoctorPolicy(policy) {
   const positiveValues = [
-    "contextInspectionTimeoutMs",
     "contextWarningPercent",
     "contextCriticalPercent",
     "contextInefficientMinTokens",
@@ -318,9 +317,7 @@ export async function runDoctor({
   inspectToolDependencies = null
 }) {
   assertDoctorPolicy(doctorPolicy);
-  const runtime = await agentManager.getRuntimeDiagnostic({
-    contextInspectionTimeoutMs: doctorPolicy.contextInspectionTimeoutMs
-  });
+  const runtime = await agentManager.getRuntimeDiagnostic();
   const report = {
     runtime,
     contexts: runtime.contexts.map((context) => evaluateContext(context, doctorPolicy)),

package/src/runtime/headless-tool-executor.js

@@ -1,5 +1,4 @@
-import path from "node:path";
-import { unlink } from "node:fs/promises";
+import { materializeToolOutput } from "../core/tools/tool-output-materializer.js";
 
 export function createHeadlessToolExecutor({ artifactStore, taskStore, toolRegistry } = {}) {
   if (!artifactStore || !taskStore || !toolRegistry) {
@@ -10,36 +9,7 @@ export function createHeadlessToolExecutor({ artifactStore, taskStore, toolRegis
     async runTool({ name, request, chatId }) {
       await toolRegistry.load();
       const result = await toolRegistry.run({ name, request, chatId });
-      const chatArtifacts = artifactStore.forChat(chatId);
-
-      if (result.output?.text) {
-        const artifact = await chatArtifacts.createText({
-          text: result.output.text,
-          source: { type: "tool", toolName: name },
-          metadata: { tool: name }
-        });
-        result.output.artifactId = artifact.id;
-      }
-      if (result.output?.filePath) {
-        const generated = await chatArtifacts.createFromFile({
-          originalPath: result.output.filePath,
-          fileName: result.output.fileName || path.basename(result.output.filePath),
-          kind: result.output.kind || "file",
-          mimeType: result.output.mimeType || "application/octet-stream",
-          source: { type: "tool", toolName: name },
-          metadata: { tool: name, delivery: result.output.delivery }
-        });
-        result.output.artifactId = generated.id;
-        await unlink(result.output.filePath).catch(() => {});
-      }
-      if (result.asyncTask || result.asyncTasks?.length) {
-        result.asyncTasks = await taskStore.addMany(result.asyncTasks || [result.asyncTask], {
-          payload: { chatId },
-          source: { type: "tool", toolName: name, chatId }
-        });
-        delete result.asyncTask;
-      }
-      return result;
+      return materializeToolOutput({ result, name, chatId, artifactStore, taskStore });
     }
   };
 }

package/src/runtime/paths.js

@@ -13,6 +13,8 @@ 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);
@@ -47,7 +49,11 @@ export function getChatArtifactsIndexFile(chatId) {
   return path.join(getChatDir(chatId), "state", "artifacts.json");
 }
 
-export function getChatConversationHistoryFile(chatId) {
+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");
 }
 

package/src/runtime/restart-receipt.js

@@ -0,0 +1,90 @@
+import crypto from "node:crypto";
+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";
+
+const execFileAsync = promisify(execFile);
+
+function normalizeDestination({ transportChatId, threadId = null }) {
+  const chatId = Number(transportChatId);
+  if (!Number.isSafeInteger(chatId)) throw new Error("Restart receipt requires a valid Telegram chat id");
+  const topic = threadId == null ? null : Number(threadId);
+  if (topic != null && (!Number.isSafeInteger(topic) || topic <= 0)) {
+    throw new Error("Restart receipt requires a valid Telegram topic id");
+  }
+  return { transportChatId: chatId, threadId: topic };
+}
+
+async function runtimeIdentity() {
+  const packageJson = JSON.parse(await readFile(path.join(arisaPackageDir, "package.json"), "utf8"));
+  let commit = null;
+  try {
+    const result = await execFileAsync("git", ["rev-parse", "--short=12", "HEAD"], { cwd: arisaPackageDir });
+    commit = String(result.stdout || "").trim() || null;
+  } catch {}
+  return { version: String(packageJson.version || "unknown"), commit };
+}
+
+export async function prepareRestartReceipt(destination, { reason = "requested restart" } = {}, {
+  receiptFile = restartReceiptFile,
+  getIdentity = runtimeIdentity
+} = {}) {
+  const target = normalizeDestination(destination);
+  const identity = await getIdentity();
+  const receipt = {
+    id: crypto.randomUUID(),
+    ...target,
+    reason: String(reason || "requested restart").slice(0, 500),
+    expectedVersion: identity.version,
+    expectedCommit: identity.commit,
+    requestedAt: new Date().toISOString()
+  };
+  await mkdir(path.dirname(receiptFile), { recursive: true, mode: 0o700 });
+  const temporaryFile = `${receiptFile}.${process.pid}.tmp`;
+  await writeFile(temporaryFile, `${JSON.stringify(receipt, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await rename(temporaryFile, receiptFile);
+  return receipt;
+}
+
+export async function cancelRestartReceipt(receiptId, { receiptFile = restartReceiptFile } = {}) {
+  try {
+    const receipt = JSON.parse(await readFile(receiptFile, "utf8"));
+    if (receipt.id !== receiptId) return false;
+    await rm(receiptFile, { force: true });
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+export async function deliverRestartReceipt(sendMessage, {
+  receiptFile = restartReceiptFile,
+  getIdentity = runtimeIdentity
+} = {}) {
+  let receipt;
+  try {
+    receipt = JSON.parse(await readFile(receiptFile, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+
+  const actual = await getIdentity();
+  const versionMatches = receipt.expectedVersion === actual.version;
+  const commitMatches = !receipt.expectedCommit || receipt.expectedCommit === actual.commit;
+  const genericReasons = new Set(["requested restart", "Agent-requested restart", "Telegram restart", "Telegram /restart", "Telegram update restart"]);
+  const resultSummary = String(receipt.reason || "").trim();
+  const lines = [
+    versionMatches && commitMatches ? "Restart completed." : "Restart completed with an unexpected runtime identity.",
+    resultSummary && !genericReasons.has(resultSummary) ? resultSummary : null,
+    `Arisa ${actual.version} is running${actual.commit ? ` at commit ${actual.commit}` : ""}.`,
+    versionMatches && commitMatches ? null : `Expected: ${receipt.expectedVersion}${receipt.expectedCommit ? ` at ${receipt.expectedCommit}` : ""}.`
+  ].filter(Boolean);
+  const options = receipt.threadId ? { message_thread_id: receipt.threadId } : {};
+  await sendMessage(receipt.transportChatId, lines.join("\n"), options);
+  await rm(receiptFile, { force: true });
+  return { receipt, actual, verified: versionMatches && commitMatches };
+}