arisa 5.1.2 → 5.1.8

package/README.md

@@ -103,6 +103,31 @@ Per chat (`~/.arisa/chats/<chatId>/`):
 
 Managed daemons become ready only after their tool-defined health operation succeeds through the normal command queue. Arisa records heartbeats, successful jobs, errors, and standard lifecycle states, then retries recovery or recreates an unhealthy process with its persisted scope and startup context.
 
+Daemon tools may opt into the `arisa-daemon-v1` local protocol for immediate
+multiplexed jobs and incremental NDJSON events over a capability-protected local
+socket. The runtime persists request, accepted and terminal records so a restart
+can recover queued work and will not silently repeat an accepted effect. Legacy
+daemon tools continue to use the existing request-file contract.
+
+### Arisa Master and Slave
+
+The official `master-slave` daemon tool lets one normal Arisa installation act
+as Master for deterministic headless Slave hosts. Master keeps Telegram and Pi;
+Slave runs only the IPC host, daemon supervisor and installed tools. Connections
+are authenticated, encrypted, initiated by Slave and restricted by per-Slave
+roots and capability grants.
+
+Linux with systemd is the first supported Slave target. Bootstrap uses a
+single-use URL issued by Master:
+
+```bash
+npm i -g arisa && arisa slave tcp://198.51.100.12:4719/arisa_secret_v1_<secret>
+```
+
+The URL is sensitive and may remain in shell history. `arisa slave status`,
+`log`, `tools`, `start`, `stop`, `restart` and `unpair` operate the isolated
+headless service without starting Telegram or Pi Agent.
+
 Pi authentication can use either:
 - an API key entered during bootstrap
 - or Pi's existing OAuth login when supported, such as `openai-codex`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "5.1.2",
+  "version": "5.1.8",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/agent-manager.js

@@ -11,6 +11,8 @@ import { createSystemShellTool } from "./system-shell-tool.js";
 import { clampModelThinkingLevel } from "./pi-runtime.js";
 import { clampModelSpeed, createModelSpeedController } from "./model-speed.js";
 import { arisaHomeDir, getChatPiSessionsDir } from "../../runtime/paths.js";
+import { searchOfficialToolCatalog } from "../tools/official-tool-catalog.js";
+import { ToolResourceNoteStore } from "../tools/tool-resource-note-store.js";
 
 const piValidationTimeoutMs = 60_000;
 const arisaToolNames = [
@@ -18,6 +20,7 @@ const arisaToolNames = [
   "tool_help",
   "tool_skills",
   "set_tool_config",
+  "set_tool_resource_note",
   "run_tool",
   "list_scheduled_tasks",
   "cancel_scheduled_task",
@@ -221,6 +224,7 @@ export class AgentManager {
     this.toolRegistry = toolRegistry;
     this.taskStore = taskStore;
     this.logger = logger;
+    this.resourceNotes = new ToolResourceNoteStore();
     this.sessions = new Map();
     this.pendingNewSessions = new Set();
     this.pendingSessionHandoffs = new Map();
@@ -505,7 +509,12 @@ export class AgentManager {
     await this.toolRegistry.load();
     this.logger?.log("agent", `run_tool ${name}`);
     const chatArtifactStore = this.artifactStore.forChat(chatId);
-    const result = await this.toolRegistry.run({ name, request, chatId });
+    const resourceId = String(request?.resourceId || "").trim();
+    const resourceNote = resourceId
+      ? await this.resourceNotes.get(chatId, name, resourceId)
+      : "";
+    const enrichedRequest = resourceNote ? { ...request, resourceId, resourceNote } : request;
+    const result = await this.toolRegistry.run({ name, request: enrichedRequest, chatId });
 
     if (result.output?.text) {
       const outArtifact = await chatArtifactStore.createText({
@@ -551,9 +560,9 @@ export class AgentManager {
       defineTool({
         name: "list_tools",
         label: "List tools",
-        description: "List Arisa core, native shell, and modular CLI tools with their capabilities and daemon diagnostics.",
-        parameters: Type.Object({}),
-        execute: async () => {
+        description: "List Arisa tools, or search installed tool metadata by capability with automatic official-catalog fallback.",
+        parameters: Type.Object({ query: Type.Optional(Type.String()) }),
+        execute: async (_id, params) => {
           await this.toolRegistry.load();
           const coreTools = getCoreCodingTools({
             tools: policy.tools,
@@ -567,17 +576,35 @@ export class AgentManager {
             shell: policy.shell.shellPath || (process.platform === "win32" ? "powershell" : "sh"),
             enabled: !(policy.excludeTools || []).includes("system_shell")
           }];
-          const cliTools = (await this.toolRegistry.listWithRuntime(chatId)).map((tool) => ({
-            ...tool,
-            source: "arisa-modular",
-            invocation: "run_tool"
-          }));
+          const query = params.query?.trim() || "";
+          let catalogFallback = null;
+          const cliTools = query
+            ? this.toolRegistry.search(query).map((tool) => ({
+              ...tool,
+              source: "arisa-modular",
+              invocation: "run_tool"
+            }))
+            : (await this.toolRegistry.listWithRuntime(chatId)).map((tool) => ({
+              ...tool,
+              source: "arisa-modular",
+              invocation: "run_tool"
+            }));
+          if (query && cliTools.length === 0) {
+            try {
+              catalogFallback = await searchOfficialToolCatalog(query);
+            } catch (error) {
+              catalogFallback = { unavailable: true, error: error?.message || String(error), matches: [] };
+            }
+          }
           const result = {
+            query: query || null,
             workspaceDir: policy.workspaceDir,
-            coreTools,
-            nativeTools,
+            coreTools: query ? [] : coreTools,
+            nativeTools: query ? [] : nativeTools,
             cliTools,
-            tools: [...coreTools.filter((tool) => tool.enabled), ...nativeTools.filter((tool) => tool.enabled), ...cliTools]
+            officialCatalogMatches: Array.isArray(catalogFallback) ? catalogFallback : catalogFallback?.matches || [],
+            catalogFallback: catalogFallback && !Array.isArray(catalogFallback) ? catalogFallback : null,
+            tools: query ? cliTools : [...coreTools.filter((tool) => tool.enabled), ...nativeTools.filter((tool) => tool.enabled), ...cliTools]
           };
           return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
@@ -619,6 +646,20 @@ export class AgentManager {
           return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
         }
       }),
+      defineTool({
+        name: "set_tool_resource_note",
+        label: "Set tool resource note",
+        description: "Set or clear a deterministic chat-scoped note of up to 200 characters for one tool resource.",
+        parameters: Type.Object({
+          name: Type.String(),
+          resourceId: Type.String(),
+          note: Type.String()
+        }),
+        execute: async (_id, params) => {
+          const result = await this.resourceNotes.set(chatId, params.name, params.resourceId, params.note);
+          return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+        }
+      }),
       defineTool({
         name: "run_tool",
         label: "Run tool",
@@ -627,6 +668,7 @@ export class AgentManager {
           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())),
           deliver: Type.Optional(Type.Boolean())
         }),
@@ -643,6 +685,7 @@ export class AgentManager {
             request: {
               artifact,
               text: params.text,
+              resourceId: params.resourceId,
               args: params.args || {}
             },
             chatId

package/src/core/config/config-defaults.js

@@ -11,7 +11,9 @@ export const daemonConfigDefaults = Object.freeze({
   restartBackoffMaxMs: 60_000,
   startupTimeoutMs: 120_000,
   stopTimeoutMs: 3_000,
-  queuePollIntervalMs: 250
+  queuePollIntervalMs: 250,
+  streamBufferBytes: 1_048_576,
+  ipcFrameBytes: 1_048_576
 });
 
 export const telegramConfigDefaults = Object.freeze({

package/src/core/tools/daemon-processes.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import { closeSync, openSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import {
   chatsDir,
@@ -35,6 +35,7 @@ function daemonIdentity(toolNameOrOptions, scope) {
 export function daemonPaths(toolNameOrOptions, scope) {
   const identity = daemonIdentity(toolNameOrOptions, scope);
   const root = getDaemonInstanceDir(identity.toolName, identity.scope);
+  const localSocket = path.join(root, "daemon.sock");
   return {
     ...identity,
     instanceId: getDaemonInstanceId(identity.scope),
@@ -44,7 +45,13 @@ export function daemonPaths(toolNameOrOptions, scope) {
     metaFile: path.join(root, "daemon.meta.json"),
     statusFile: path.join(root, "status.json"),
     logFile: path.join(root, "daemon.log"),
-    startLockFile: path.join(root, "daemon.start.lock")
+    startLockFile: path.join(root, "daemon.start.lock"),
+    socketFile: process.platform === "win32"
+      ? `\\\\.\\pipe\\arisa-daemon-${crypto.createHash("sha256").update(root).digest("hex").slice(0, 16)}`
+      : Buffer.byteLength(localSocket) <= 96
+        ? localSocket
+        : path.join("/tmp", `arisa-daemon-${crypto.createHash("sha256").update(root).digest("hex").slice(0, 24)}.sock`),
+    capabilityFile: path.join(root, "daemon.capability")
   };
 }
 
@@ -63,6 +70,25 @@ export async function writeJson(file, value) {
   await rename(temporary, file);
 }
 
+export async function ensureDaemonCapability(pathsOrIdentity) {
+  const paths = pathsOrIdentity.capabilityFile ? pathsOrIdentity : daemonPaths(pathsOrIdentity);
+  await mkdir(paths.root, { recursive: true });
+  try {
+    const existing = (await readFile(paths.capabilityFile, "utf8")).trim();
+    if (existing) return existing;
+  } catch {}
+  const token = crypto.randomBytes(32).toString("base64url");
+  try {
+    await writeFile(paths.capabilityFile, `${token}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    return token;
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+    const existing = (await readFile(paths.capabilityFile, "utf8")).trim();
+    if (!existing) throw new Error(`Invalid daemon capability file for ${paths.toolName}`);
+    return existing;
+  }
+}
+
 export function isProcessAlive(pid) {
   if (!pid) return false;
   try {
@@ -232,6 +258,8 @@ export async function unregisterManagedDaemon(toolNameOrOptions, { scope } = {})
     rm(paths.pidFile, { force: true }),
     rm(paths.statusFile, { force: true }),
     rm(paths.startLockFile, { force: true }),
+    rm(paths.capabilityFile, { force: true }),
+    process.platform === "win32" ? Promise.resolve() : rm(paths.socketFile, { force: true }),
     rm(paths.commandsDir, { recursive: true, force: true })
   ]);
   return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
@@ -311,8 +339,9 @@ export async function startManagedDaemon({
       return current.pid;
     }
     await rm(paths.pidFile, { force: true });
-    await rm(paths.commandsDir, { recursive: true, force: true });
     await mkdir(paths.commandsDir, { recursive: true });
+    const capabilityToken = await ensureDaemonCapability(paths);
+    if (process.platform !== "win32") await chmod(paths.capabilityFile, 0o600);
     if (beforeStart) await beforeStart();
 
     const startedAt = new Date().toISOString();
@@ -344,7 +373,8 @@ export async function startManagedDaemon({
         env: {
           ...process.env,
           ARISA_DAEMON_META_FILE: paths.metaFile,
-          ARISA_DAEMON_INSTANCE_ID: paths.instanceId
+          ARISA_DAEMON_INSTANCE_ID: paths.instanceId,
+          ARISA_DAEMON_CAPABILITY: capabilityToken
         }
       });
       await new Promise((resolve, reject) => {
@@ -411,7 +441,13 @@ async function listGlobalDaemonRecords() {
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const meta = await readJson(daemonPaths(entry.name).metaFile, null);
+    let paths;
+    try {
+      paths = daemonPaths(entry.name);
+    } catch {
+      continue;
+    }
+    const meta = await readJson(paths.metaFile, null);
     if (meta?.toolName && meta?.entryPath) records.push(meta);
   }
   return records;
@@ -437,7 +473,13 @@ async function listChatDaemonRecords() {
     const toolEntries = await readdir(toolsRoot, { withFileTypes: true }).catch(() => []);
     for (const toolEntry of toolEntries) {
       if (!toolEntry.isDirectory()) continue;
-      const meta = await readJson(daemonPaths({ toolName: toolEntry.name, scope }).metaFile, null);
+      let paths;
+      try {
+        paths = daemonPaths({ toolName: toolEntry.name, scope });
+      } catch {
+        continue;
+      }
+      const meta = await readJson(paths.metaFile, null);
       if (meta?.toolName && meta?.entryPath) records.push(meta);
     }
   }