arisa 5.1.2 → 5.1.8

package/src/core/tools/official-tool-installer.js

@@ -0,0 +1,183 @@
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import {
+  access,
+  cp,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  rename,
+  rm
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { getToolDir } from "../../runtime/paths.js";
+
+const bundledLockFile = new URL("../../official-tools.lock.json", import.meta.url);
+
+const TOOL_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const COMMIT_PATTERN = /^[a-f0-9]{40}$/;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+
+function exists(target) {
+  return access(target).then(() => true, () => false);
+}
+
+function assertRelativeFilePath(file) {
+  if (typeof file !== "string" || !file || file.includes("\\")) {
+    throw new Error(`Invalid official tool file path: ${file || "empty"}`);
+  }
+  const normalized = path.posix.normalize(file);
+  if (normalized !== file || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+    throw new Error(`Invalid official tool file path: ${file}`);
+  }
+}
+
+export function validateOfficialToolLock(lock, toolName) {
+  if (!TOOL_NAME_PATTERN.test(String(toolName || ""))) {
+    throw new Error(`Invalid official tool name: ${toolName || "empty"}`);
+  }
+  if (lock?.version !== 1) throw new Error("Unsupported official tool lock version");
+  if (typeof lock.repository !== "string" || !lock.repository.startsWith("https://")) {
+    throw new Error("Official tool lock requires an HTTPS repository");
+  }
+  if (!COMMIT_PATTERN.test(String(lock.commit || ""))) {
+    throw new Error("Official tool lock requires an immutable 40-character commit");
+  }
+  const files = lock.tools?.[toolName]?.files;
+  if (!files || typeof files !== "object" || Array.isArray(files) || !Object.keys(files).length) {
+    throw new Error(`Official tool lock has no files for ${toolName}`);
+  }
+  for (const [file, digest] of Object.entries(files)) {
+    assertRelativeFilePath(file);
+    if (!SHA256_PATTERN.test(String(digest || ""))) {
+      throw new Error(`Invalid SHA-256 digest for ${toolName}/${file}`);
+    }
+  }
+  return { repository: lock.repository, commit: lock.commit, files };
+}
+
+async function walkFiles(root, relative = "") {
+  const directory = path.join(root, relative);
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const childRelative = relative ? `${relative}/${entry.name}` : entry.name;
+    const childPath = path.join(root, ...childRelative.split("/"));
+    const metadata = await lstat(childPath);
+    if (metadata.isSymbolicLink()) {
+      throw new Error(`Official tool contains a symbolic link: ${childRelative}`);
+    }
+    if (metadata.isDirectory()) {
+      files.push(...await walkFiles(root, childRelative));
+      continue;
+    }
+    if (!metadata.isFile()) {
+      throw new Error(`Official tool contains an unsupported entry: ${childRelative}`);
+    }
+    files.push(childRelative);
+  }
+  return files;
+}
+
+async function sha256(file) {
+  return crypto.createHash("sha256").update(await readFile(file)).digest("hex");
+}
+
+export async function verifyOfficialToolTree(toolDir, expectedFiles) {
+  const actualFiles = (await walkFiles(toolDir)).sort();
+  const lockedFiles = Object.keys(expectedFiles).sort();
+  if (actualFiles.length !== lockedFiles.length || actualFiles.some((file, index) => file !== lockedFiles[index])) {
+    const missing = lockedFiles.filter((file) => !actualFiles.includes(file));
+    const unexpected = actualFiles.filter((file) => !lockedFiles.includes(file));
+    throw new Error(`Official tool file set mismatch; missing=${missing.join(",") || "none"}; unexpected=${unexpected.join(",") || "none"}`);
+  }
+  for (const file of lockedFiles) {
+    const digest = await sha256(path.join(toolDir, ...file.split("/")));
+    if (!crypto.timingSafeEqual(Buffer.from(digest, "hex"), Buffer.from(expectedFiles[file], "hex"))) {
+      throw new Error(`Official tool integrity check failed: ${file}`);
+    }
+  }
+  return { files: lockedFiles.length };
+}
+
+function runCommand(command, args, { cwd, timeoutMs = 180_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(`${command} failed (${signal || code}): ${(stderr || stdout).trim().slice(-2000)}`));
+    });
+  });
+}
+
+async function checkoutRepository({ repository, commit, checkoutDir }) {
+  await mkdir(checkoutDir, { recursive: true });
+  await runCommand("git", ["init", "--quiet"], { cwd: checkoutDir });
+  await runCommand("git", ["remote", "add", "origin", repository], { cwd: checkoutDir });
+  await runCommand("git", ["fetch", "--quiet", "--depth", "1", "origin", commit], { cwd: checkoutDir });
+  await runCommand("git", ["checkout", "--quiet", "--detach", "FETCH_HEAD"], { cwd: checkoutDir });
+  const resolved = (await runCommand("git", ["rev-parse", "HEAD"], { cwd: checkoutDir })).stdout.trim();
+  if (resolved !== commit) throw new Error(`Official tool checkout resolved ${resolved}, expected ${commit}`);
+}
+
+async function validateEntrypoint(toolDir, toolName) {
+  const manifest = JSON.parse(await readFile(path.join(toolDir, "tool.manifest.json"), "utf8"));
+  if (manifest.name !== toolName) {
+    throw new Error(`Official tool manifest mismatch: expected ${toolName}, got ${manifest.name || "missing"}`);
+  }
+  const entry = manifest.entry || "index.js";
+  const entryPath = path.join(toolDir, entry);
+  if (!(await exists(entryPath))) throw new Error(`Official tool entry does not exist: ${entry}`);
+  await runCommand(process.execPath, ["--check", entry], { cwd: toolDir, timeoutMs: 30_000 });
+  await runCommand(process.execPath, [entry, "--help"], { cwd: toolDir, timeoutMs: 30_000 });
+}
+
+export async function installLockedOfficialTool({
+  toolName,
+  lock,
+  destination,
+  scratchRoot = os.tmpdir(),
+  checkout = checkoutRepository,
+  validate = validateEntrypoint
+}) {
+  const locked = validateOfficialToolLock(lock, toolName);
+  if (await exists(destination)) {
+    throw new Error(`Refusing to overwrite installed tool: ${destination}`);
+  }
+  const scratch = await mkdtemp(path.join(scratchRoot, `arisa-${toolName}-`));
+  const checkoutDir = path.join(scratch, "repository");
+  const stageDir = path.join(scratch, "stage");
+  try {
+    await checkout({ repository: locked.repository, commit: locked.commit, checkoutDir });
+    const sourceDir = path.join(checkoutDir, "tools", toolName);
+    await verifyOfficialToolTree(sourceDir, locked.files);
+    await cp(sourceDir, stageDir, { recursive: true, errorOnExist: true, force: false });
+    await validate(stageDir, toolName);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await rename(stageDir, destination);
+    return { toolName, destination, commit: locked.commit, files: Object.keys(locked.files).length };
+  } finally {
+    await rm(scratch, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+export async function installBundledOfficialTool(toolName, {
+  lockFile = bundledLockFile,
+  install = installLockedOfficialTool
+} = {}) {
+  const lock = JSON.parse(await readFile(lockFile, "utf8"));
+  return install({ toolName, lock, destination: getToolDir(toolName) });
+}

package/src/core/tools/tool-registry.js

@@ -6,6 +6,8 @@ import { arisaIpcSocketFile, arisaPackageDir, getToolConfigPath, getToolTmpDir,
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 import { readDaemonDiagnostic } from "./daemon-processes.js";
+import { createDaemonRuntime, DAEMON_EVENT_TYPES, DAEMON_PROTOCOL_VERSION } from "./daemon-runtime.js";
+import { daemonConfigDefaults } from "../config/config-defaults.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 import { ToolUsageStore } from "./tool-usage-store.js";
 
@@ -24,6 +26,129 @@ function runProcess(command, args, options = {}) {
   });
 }
 
+function requirementNames(requirements) {
+  if (Array.isArray(requirements)) {
+    return requirements.map((item) => typeof item === "string" ? item : item?.name).filter(Boolean);
+  }
+  if (requirements && typeof requirements === "object") return Object.keys(requirements);
+  return [];
+}
+
+export function createToolOutputParser(name, { onEvent, maxFrameBytes = 1_048_576 } = {}) {
+  let buffer = "";
+  let mode = "unknown";
+  let rawOutput = "";
+  let terminalResult = null;
+  let activeJobId = null;
+  let sequence = 0;
+  let terminalSeen = false;
+
+  async function parseEvent(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      throw new Error(`Invalid NDJSON from ${name}`);
+    }
+    if (event?.version !== DAEMON_PROTOCOL_VERSION || !DAEMON_EVENT_TYPES.includes(event?.type)) {
+      throw new Error(`Invalid versioned tool event from ${name}`);
+    }
+    if (typeof event.jobId !== "string" || !event.jobId) throw new Error(`Tool event from ${name} is missing jobId`);
+    if (activeJobId == null) activeJobId = event.jobId;
+    if (event.jobId !== activeJobId) throw new Error(`Tool ${name} multiplexed an unexpected jobId`);
+    if (!Number.isSafeInteger(event.sequence) || event.sequence !== sequence + 1) {
+      throw new Error(`Invalid tool event sequence from ${name}: ${event.sequence}`);
+    }
+    if (terminalSeen) throw new Error(`Tool ${name} emitted more than one terminal event`);
+    sequence = event.sequence;
+    terminalSeen = event.type === "completed" || event.type === "failed";
+    await onEvent?.(event);
+    if (terminalSeen) {
+      terminalResult = event.type === "completed"
+        ? event.payload?.result ?? event.payload?.output ?? event.payload
+        : { ok: false, error: event.payload?.error || `Tool failed: ${name}`, ...(event.payload?.code ? { code: event.payload.code } : {}) };
+    }
+  }
+
+  async function consumeLine(line) {
+    if (Buffer.byteLength(line, "utf8") > maxFrameBytes) throw new Error(`Tool event from ${name} exceeds ${maxFrameBytes} bytes`);
+    if (mode === "unknown") {
+      let candidate;
+      try {
+        candidate = JSON.parse(line);
+      } catch {
+        mode = "legacy";
+        return;
+      }
+      if (candidate?.version === DAEMON_PROTOCOL_VERSION && DAEMON_EVENT_TYPES.includes(candidate?.type)) {
+        mode = "ndjson";
+        rawOutput = "";
+        return parseEvent(line);
+      }
+      mode = "legacy";
+      return;
+    }
+    if (mode === "legacy") return;
+    return parseEvent(line);
+  }
+
+  return {
+    async push(chunk) {
+      const text = chunk.toString("utf8");
+      if (mode !== "ndjson") rawOutput += text;
+      if (mode === "legacy") return;
+      buffer += text;
+      if (Buffer.byteLength(buffer, "utf8") > maxFrameBytes && !buffer.includes("\n")) {
+        throw new Error(`Tool event from ${name} exceeds ${maxFrameBytes} bytes`);
+      }
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) await consumeLine(line);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    },
+    async finish() {
+      const tail = buffer.trim();
+      buffer = "";
+      if (tail) await consumeLine(tail);
+      if (mode !== "ndjson") return { mode: "legacy", output: rawOutput };
+      if (!terminalSeen) throw new Error(`Tool ${name} ended without a terminal event`);
+      return { mode: "ndjson", result: terminalResult };
+    }
+  };
+}
+
+async function runToolProcess(command, args, { onEvent, maxFrameBytes, ...options } = {}) {
+  const child = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
+  const parser = createToolOutputParser(path.basename(args[0] || command), { onEvent, maxFrameBytes });
+  const stderrChunks = [];
+  let stderrBytes = 0;
+  const stdoutTask = (async () => {
+    for await (const chunk of child.stdout) await parser.push(chunk);
+    return parser.finish();
+  })();
+  const stderrTask = (async () => {
+    for await (const chunk of child.stderr) {
+      if (stderrBytes >= maxFrameBytes) continue;
+      const accepted = chunk.subarray(0, maxFrameBytes - stderrBytes);
+      stderrChunks.push(accepted);
+      stderrBytes += accepted.length;
+    }
+    return Buffer.concat(stderrChunks).toString("utf8");
+  })();
+  const exitPromise = new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", resolve);
+  });
+  child.stdout.resume();
+  child.stderr.resume();
+  const code = await exitPromise;
+  const [parsed, stderr] = await Promise.all([stdoutTask, stderrTask]);
+  return { code, parsed, stderr };
+}
+
 function normalizeCategory(category) {
   if (typeof category !== "string") return null;
   const trimmed = category.trim();
@@ -38,6 +163,38 @@ function normalizeKeywords(keywords) {
     .filter(Boolean))];
 }
 
+function searchableToolText(tool) {
+  return [
+    tool.name,
+    tool.description,
+    tool.category,
+    ...(tool.keywords || []),
+    ...(tool.input || []),
+    ...(tool.output || [])
+  ].filter(Boolean).join(" ").toLowerCase();
+}
+
+export function rankToolMatches(tools, query) {
+  const terms = String(query || "").toLowerCase().match(/[\p{L}\p{N}_-]+/gu) || [];
+  if (!terms.length) return [];
+  return tools.map((tool) => {
+    const name = String(tool.name || "").toLowerCase();
+    const category = String(tool.category || "").toLowerCase();
+    const keywords = (tool.keywords || []).map((keyword) => String(keyword).toLowerCase());
+    const haystack = searchableToolText(tool);
+    let score = 0;
+    for (const term of terms) {
+      if (keywords.includes(term)) score += 12;
+      else if (name === term) score += 10;
+      else if (name.includes(term)) score += 7;
+      else if (category === term) score += 6;
+      else if (haystack.includes(term)) score += 2;
+    }
+    return { tool, score };
+  }).filter((match) => match.score > 0)
+    .sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name));
+}
+
 function formatSemanticMetadata(tool) {
   return [
     "Semantic metadata:",
@@ -99,6 +256,9 @@ export class ToolRegistry {
   list() {
     return [...this.tools.values()].map((tool) => ({
       name: tool.name,
+      version: typeof tool.version === "string" ? tool.version : null,
+      packageDigest: typeof tool.packageDigest === "string" ? tool.packageDigest : null,
+      requirements: requirementNames(tool.requirements),
       description: tool.description,
       input: tool.input,
       output: tool.output,
@@ -109,6 +269,10 @@ export class ToolRegistry {
     }));
   }
 
+  search(query) {
+    return rankToolMatches(this.list(), query).map(({ tool, score }) => ({ ...tool, score }));
+  }
+
   async listWithRuntime(chatId = null) {
     return Promise.all(this.list().map(async (listedTool) => {
       const daemon = this.get(listedTool.name)?.daemon;
@@ -203,7 +367,7 @@ export class ToolRegistry {
       .sort((left, right) => left.name.localeCompare(right.name));
   }
 
-  async run({ name, request, chatId = null }) {
+  async run({ name, request, chatId = null, onEvent = null }) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
     await this.usageStore.record(chatId, name).catch((error) => {
@@ -215,33 +379,54 @@ export class ToolRegistry {
     const requestFile = path.join(tmpDir, `.request-${Date.now()}-${randomUUID()}.json`);
     const skills = await this.resolveSkills(name);
     const enrichedRequest = { ...request, chatId, skills };
-    await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
-    const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
-      cwd: tool.dir,
-      env: toolEnv()
-    });
-    await unlink(requestFile).catch(() => {});
-    await rmdir(tmpDir).catch(() => {});
-    if (chatId != null) {
-      await rmdir(path.dirname(tmpDir)).catch(() => {});
-      await rmdir(path.dirname(path.dirname(tmpDir))).catch(() => {});
-    }
+    let result;
     try {
-      const parsed = JSON.parse(result.stdout || result.stderr);
-      const normalized = normalizeToolResult(name, parsed);
+      if (tool.daemon?.protocol === "arisa-daemon-v1") {
+        const scope = tool.daemon.scope === "chat"
+          ? { type: "chat", chatId }
+          : { type: "global" };
+        const runtime = createDaemonRuntime({
+          toolName: name,
+          entryPath: tool.entry,
+          scope,
+          startupContext: scope.type === "chat" ? { chatId: String(chatId) } : {},
+          autoStart: Boolean(tool.daemon.autoStart)
+        });
+        result = await runtime.submit(enrichedRequest, { onEvent });
+      } else {
+        await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
+        const processResult = await runToolProcess("node", [tool.entry, "run", "--request-file", requestFile], {
+          cwd: tool.dir,
+          env: toolEnv(),
+          onEvent,
+          maxFrameBytes: daemonConfigDefaults.ipcFrameBytes
+        });
+        if (processResult.stderr.trim()) {
+          this.logger?.log("tools", `${name} stderr: ${processResult.stderr.trim()}`);
+        }
+        result = processResult.parsed.mode === "ndjson"
+          ? processResult.parsed.result
+          : JSON.parse(processResult.parsed.output);
+      }
+      const normalized = normalizeToolResult(name, result);
       if (normalized.ok === false) {
         this.logger?.log("tools", `${name} -> ${normalized.status || "error"}: ${normalized.error || "unknown error"}`);
       } else {
         this.logger?.log("tools", `${name} -> ok`);
       }
       return normalized;
-    } catch {
+    } catch (error) {
       return normalizeToolResult(name, {
         ok: false,
-        error: `Invalid tool response for ${name}`,
-        stdout: result.stdout,
-        stderr: result.stderr
+        error: error?.message || `Invalid tool response for ${name}`
       });
+    } finally {
+      await unlink(requestFile).catch(() => {});
+      await rmdir(tmpDir).catch(() => {});
+      if (chatId != null) {
+        await rmdir(path.dirname(tmpDir)).catch(() => {});
+        await rmdir(path.dirname(path.dirname(tmpDir))).catch(() => {});
+      }
     }
   }
 }

package/src/core/tools/tool-resource-note-store.js

@@ -0,0 +1,78 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getChatToolResourceNotesFile } from "../../runtime/paths.js";
+
+export const maxToolResourceNoteCharacters = 200;
+
+function emptyNotes() {
+  return { version: 1, tools: {} };
+}
+
+function requiredText(value, name) {
+  const text = String(value ?? "").trim();
+  if (!text) throw new Error(`${name} is required`);
+  return text;
+}
+
+async function readNotes(file) {
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return parsed?.version === 1 && parsed.tools && typeof parsed.tools === "object"
+      ? parsed
+      : emptyNotes();
+  } catch (error) {
+    if (error?.code === "ENOENT") return emptyNotes();
+    throw error;
+  }
+}
+
+async function writeNotes(file, notes) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(notes, null, 2)}\n`, "utf8");
+  await rename(temporary, file);
+}
+
+export class ToolResourceNoteStore {
+  constructor({ resolveFile = getChatToolResourceNotesFile } = {}) {
+    this.resolveFile = resolveFile;
+    this.queues = new Map();
+  }
+
+  async get(chatId, toolName, resourceId) {
+    if (chatId == null || !resourceId) return "";
+    await (this.queues.get(String(chatId)) || Promise.resolve()).catch(() => {});
+    const notes = await readNotes(this.resolveFile(chatId));
+    return notes.tools?.[String(toolName)]?.[String(resourceId)]?.note || "";
+  }
+
+  async set(chatId, toolName, resourceId, note) {
+    const scopedToolName = requiredText(toolName, "toolName");
+    const scopedResourceId = requiredText(resourceId, "resourceId");
+    const scopedNote = String(note ?? "").trim();
+    if ([...scopedNote].length > maxToolResourceNoteCharacters) {
+      throw new Error(`note must be at most ${maxToolResourceNoteCharacters} characters`);
+    }
+    const key = String(chatId);
+    const previous = this.queues.get(key) || Promise.resolve();
+    const current = previous.catch(() => {}).then(async () => {
+      const file = this.resolveFile(chatId);
+      const notes = await readNotes(file);
+      notes.tools[scopedToolName] ||= {};
+      if (scopedNote) {
+        notes.tools[scopedToolName][scopedResourceId] = { note: scopedNote };
+      } else {
+        delete notes.tools[scopedToolName][scopedResourceId];
+        if (!Object.keys(notes.tools[scopedToolName]).length) delete notes.tools[scopedToolName];
+      }
+      await writeNotes(file, notes);
+    });
+    this.queues.set(key, current);
+    try {
+      await current;
+    } finally {
+      if (this.queues.get(key) === current) this.queues.delete(key);
+    }
+    return { ok: true, toolName: scopedToolName, resourceId: scopedResourceId, note: scopedNote };
+  }
+}

package/src/index.js

@@ -4,10 +4,12 @@ import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { applyRuntimeOverrides, createApp } from "./runtime/create-app.js";
 import { loadConfig } from "./core/config/config-store.js";
 import { createLogger } from "./runtime/logger.js";
-import { getServiceStatus, handoffServiceRestart, registerServiceProcess, restartService, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
+import { getServiceStatus, handoffServiceRestart, registerServiceProcess, restartService, serviceEntryFile, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
 import { readPackageVersion, showServiceLogs } from "./runtime/log-viewer.js";
 import { arisaPackageDir } from "./runtime/paths.js";
+import { runSlaveCli } from "./runtime/slave-cli.js";
+import { unregisterSlaveServiceProcess } from "./runtime/slave-service.js";
 
 process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
 
@@ -17,6 +19,8 @@ const command = cli.positionals[0] || "run";
 const forceBootstrap = Boolean(cli.flags.bootstrap);
 const verbose = !cli.flags.silent;
 const serviceRunner = Boolean(cli.flags["service-runner"]);
+const slaveCommand = command === "slave";
+const slaveServiceRunner = slaveCommand && serviceRunner;
 const runtimeOverrides = toNestedOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
 let activeApp = null;
@@ -99,7 +103,10 @@ async function shutdown(exitCode = 0) {
     logger.error("app", `shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
     exitCode = exitCode || 1;
   }
-  if (serviceRunner) {
+  if (slaveServiceRunner) {
+    const slavePaths = activeApp?.slavePaths;
+    if (slavePaths) await unregisterSlaveServiceProcess(slavePaths);
+  } else if (serviceRunner) {
     await unregisterServiceProcess();
   }
   process.exit(exitCode);
@@ -208,6 +215,22 @@ async function runForeground() {
 }
 
 async function main() {
+  if (slaveCommand) {
+    const result = await runSlaveCli({
+      positionals: cli.positionals.slice(1),
+      flags: cli.flags,
+      logger,
+      entryFile: serviceEntryFile
+    });
+    if (result?.serviceRunner) {
+      activeApp = {
+        slavePaths: result.paths,
+        stop: async () => result.app.stop()
+      };
+    }
+    return;
+  }
+
   if (serviceRunner) {
     await registerServiceProcess();
     await runForeground();

package/src/official-tools.lock.json

@@ -0,0 +1,40 @@
+{
+  "version": 1,
+  "repository": "https://github.com/clasen/Arisa.git",
+  "commit": "5959b7378c94b4d9c4864eba9e1ef9aa564f104a",
+  "tools": {
+    "master-slave": {
+      "files": {
+        "README.md": "39a546ca6046e622f92eff2d46f2c441beef43f150758799c68328bffd54efce",
+        "batch-runner.js": "be3939efe9c5800d3078c15a094f53db1094ef6e809d7826db7c47e3bec0c31b",
+        "chat-state-store.js": "50de39aa33432733bb688eb01968e314a32b169324a66d0f0089b2a19ed9c880",
+        "config.js": "ff1c1cb6701ae1da7a6eb1519ba96a416e48daa73c2155a6f93cf5d64f65cef8",
+        "index.js": "39dc9bf44f94864bc4fd09ce695cc2e084e59eea48d09764f0fb6f998faf9dd3",
+        "lib/bootstrap-url.js": "f05925cc0f0dff0882f94f9908c6f2c80aa8632cd51f63389381dcbb0f73afb3",
+        "lib/encrypted-frames.js": "47e1b11fafdbbcdfd86a0993a47a774e4f37d6386edeaf8ec1c8511b109728cf",
+        "lib/handshake-crypto.js": "9728b117aad7de53f5f0e255c0fd865ee1a19633368730a7634334d374094578",
+        "lib/ip-address.js": "3d5ab42d15fd47e79c5733114f905e995ef2d43226e29c434b250bf37878b0fa",
+        "lib/pairing-secret-store.js": "390f5d31d2a75707461147a1ec1b26de5f36da3ec4ec404b6f00a0f10c14065a",
+        "lib/profile-catalog.js": "d5cf43a564e45297d2c25642ba53a72a782ac2f3302f086658b3930236e6a154",
+        "lib/secure-store.js": "b8f365197f8e60d7f81fde6ed1cfc8851b603f6b0783e4cdc9036bb5c99726e1",
+        "master-domain.js": "10b7dfb43eb9939eb5baec54f742076cc73a2add6589a0ff57c51bc79c236faf",
+        "network-session.js": "db2d81a7ef47af29236d963b98e21414a11fef68e8b20895126eaad3f696ba3d",
+        "package.json": "8e9177238ba878dd4b51e32e0ed58a39c5789186c22b19ad7a43ab6caf9dc469",
+        "remote-runtime.js": "92c86adf575f2734c6f2f0d9004018f2019a8ac10288a1810425ce9fe0ffa129",
+        "slave-operations.js": "fec2e8addfff98f080284f24f722c1516124e5f6d12d8c03bb3c9cc0c475d1d6",
+        "state-store.js": "c56849a3f1b9c990128276e17963034a7836abacedc44f2e500d5732ebf9e451",
+        "test/batch-runner.test.js": "f14c6fddff5d6240008eef388df6a153e82490e534d06419d7bb267e4f4693a7",
+        "test/bootstrap-url.test.js": "62c112b1a38c59ea2c77f797e32873667b52db32386da661a6ae8410490126fe",
+        "test/encrypted-frames.test.js": "cfb3195d3a58df7dc570bc7840a21c1841a53e0abc8b92840e0c24ed3435bcc1",
+        "test/handshake-crypto.test.js": "f11d6e95658f2055d8256bd7dfb66b39bedf95bf62a3cec5525b109bb6f9bc95",
+        "test/master-domain.test.js": "7298766db3e6b186cca0109f352766e1bf417a8af12a58dd1c2b78fd1a61ff24",
+        "test/network-session.test.js": "2e459346cc9364be705bc5f54691245044588b2cd03ae77e2e870dee6dfbcca6",
+        "test/pairing-secret-store.test.js": "c51257365fd0b641c24768d710cdff2d1c5f8816bf90f66c2c01a226904cb43f",
+        "test/profile-catalog.test.js": "d8e297bee413d53ec13f2e1779c13f2e019cb8304976d567eab0e9f1ca36637c",
+        "test/remote-runtime.test.js": "a842c9934a3bf2e37c0a807ad2bc78f2f0d5adb38336c53369ddd92132bfb2b6",
+        "test/slave-operations.test.js": "a84526ad7554c7d03192a68655b4637bec18750559a5c3436f7471e912ca74cc",
+        "tool.manifest.json": "abf24c67b1d9ef0331ded59e04dcc092772419e74691c0d753ab51b40286d6f6"
+      }
+    }
+  }
+}