volute 0.24.0 → 0.26.0

package/templates/pi/src/lib/subagents.ts

@@ -0,0 +1,150 @@
+import type { Model } from "@mariozechner/pi-ai";
+import {
+  type AuthStorage,
+  bashTool,
+  codingTools,
+  createAgentSession,
+  DefaultResourceLoader,
+  type ExtensionFactory,
+  editTool,
+  type ModelRegistry,
+  readTool,
+  SessionManager,
+  SettingsManager,
+  writeTool,
+} from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { log } from "./logger.js";
+
+export type SubagentDefinition = {
+  description: string;
+  prompt: string;
+  tools?: string[]; // e.g. ["Read", "Write", "Bash"] — defaults to all coding tools
+  maxTurns?: number;
+};
+
+export function createSubagentExtension(
+  agents: Record<string, SubagentDefinition>,
+  context: {
+    cwd: string;
+    model: Model<any>;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+  },
+): ExtensionFactory {
+  return (pi) => {
+    for (const [name, def] of Object.entries(agents)) {
+      pi.registerTool({
+        name,
+        label: name.charAt(0).toUpperCase() + name.slice(1),
+        description: def.description,
+        parameters: Type.Object({
+          prompt: Type.String({ description: "The prompt for the subagent" }),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+          try {
+            const tools = resolveTools(def.tools);
+
+            const loader = new DefaultResourceLoader({
+              cwd: context.cwd,
+              systemPromptOverride: () => def.prompt,
+              settingsManager: SettingsManager.inMemory({}),
+            });
+            await loader.reload();
+
+            const { session } = await createAgentSession({
+              cwd: context.cwd,
+              model: context.model,
+              tools,
+              resourceLoader: loader,
+              sessionManager: SessionManager.inMemory(),
+              settingsManager: SettingsManager.inMemory({}),
+              authStorage: context.authStorage,
+              modelRegistry: context.modelRegistry,
+            });
+
+            const textParts: string[] = [];
+            let turnCount = 0;
+
+            const done = new Promise<void>((resolve, reject) => {
+              const timeout = setTimeout(() => {
+                session.abort();
+                reject(new Error(`Subagent "${name}" timed out after 5 minutes`));
+              }, 300_000);
+
+              session.subscribe((event: any) => {
+                if (event.type === "agent_error") {
+                  clearTimeout(timeout);
+                  reject(
+                    new Error(`Subagent "${name}" error: ${event.error?.message ?? "unknown"}`),
+                  );
+                  return;
+                }
+                if (event.type === "turn_end") {
+                  turnCount++;
+                  if (def.maxTurns && turnCount >= def.maxTurns) {
+                    session.abort();
+                  }
+                }
+                if (event.type === "agent_end") {
+                  clearTimeout(timeout);
+                  for (const msg of event.messages ?? []) {
+                    if (msg.role === "assistant" && msg.content) {
+                      for (const block of msg.content) {
+                        if (block.type === "text") textParts.push(block.text);
+                      }
+                    }
+                  }
+                  resolve();
+                }
+              });
+            });
+
+            await session.prompt(params.prompt);
+            await done;
+
+            log("mind", `subagent "${name}": completed after ${turnCount} turns`);
+
+            return {
+              content: [{ type: "text" as const, text: textParts.join("\n") || "(no output)" }],
+              details: {},
+            };
+          } catch (err: any) {
+            log("mind", `subagent "${name}" failed: ${err.message}`);
+            return {
+              content: [{ type: "text" as const, text: `[subagent error] ${err.message}` }],
+              details: {},
+            };
+          }
+        },
+      });
+    }
+  };
+}
+
+const TOOL_MAP: Record<string, any> = {
+  Read: readTool,
+  Write: writeTool,
+  Bash: bashTool,
+  Edit: editTool,
+};
+
+function resolveTools(names: string[] | undefined) {
+  if (!names) return codingTools;
+  const resolved = names
+    .map((n) => {
+      if (!TOOL_MAP[n]) {
+        log(
+          "mind",
+          `unknown subagent tool "${n}" — available: ${Object.keys(TOOL_MAP).join(", ")}`,
+        );
+      }
+      return TOOL_MAP[n];
+    })
+    .filter(Boolean);
+  if (resolved.length === 0) {
+    log("mind", "no valid tools resolved for subagent, falling back to all coding tools");
+    return codingTools;
+  }
+  return resolved;
+}

package/templates/pi/src/server.ts

@@ -31,6 +31,7 @@ const mind = createMind({
   thinkingLevel: config.thinkingLevel,
   compactionMessage: config.compactionMessage,
   maxContextTokens: config.compaction?.maxContextTokens,
+  subagents: config.subagents,
 });
 
 const router = createRouter({

package/dist/chunk-NWPT4ASZ.js

@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-import {
-  validateMindName
-} from "./chunk-B2CPS4QU.js";
-
-// src/lib/isolation.ts
-import { execFileSync } from "child_process";
-function isIsolationEnabled() {
-  return process.env.VOLUTE_ISOLATION === "user";
-}
-function mindUserName(mindName) {
-  const err = validateMindName(mindName);
-  if (err) throw new Error(`Invalid mind name for isolation: ${err}`);
-  const prefix = process.env.VOLUTE_USER_PREFIX ?? "mind-";
-  return `${prefix}${mindName}`;
-}
-function ensureVoluteGroup(opts) {
-  if (!opts?.force && !isIsolationEnabled()) return;
-  try {
-    execFileSync("getent", ["group", "volute"], { stdio: "ignore" });
-  } catch {
-    try {
-      execFileSync("groupadd", ["volute"], { stdio: ["ignore", "ignore", "pipe"] });
-    } catch (err) {
-      const stderr = err?.stderr?.toString().trim();
-      throw new Error(`Failed to create volute group${stderr ? `: ${stderr}` : ""}`);
-    }
-  }
-}
-function createMindUser(name, homeDir) {
-  if (!isIsolationEnabled()) return;
-  const user = mindUserName(name);
-  try {
-    execFileSync("id", [user], { stdio: "ignore" });
-    return;
-  } catch {
-  }
-  try {
-    const args = ["-r", "-M", "-G", "volute", "-s", "/usr/sbin/nologin"];
-    if (homeDir) args.push("-d", homeDir);
-    args.push(user);
-    execFileSync("useradd", args, {
-      stdio: ["ignore", "ignore", "pipe"]
-    });
-  } catch (err) {
-    const stderr = err?.stderr?.toString().trim();
-    throw new Error(`Failed to create user ${user}${stderr ? `: ${stderr}` : ""}`);
-  }
-}
-function deleteMindUser(name) {
-  if (!isIsolationEnabled()) return;
-  const user = mindUserName(name);
-  try {
-    execFileSync("userdel", [user], { stdio: "ignore" });
-  } catch {
-  }
-}
-function wrapForIsolation(cmd, args, mindName) {
-  if (!isIsolationEnabled()) return [cmd, args];
-  const baseName = mindName.split("@", 2)[0];
-  const user = mindUserName(baseName);
-  return ["runuser", ["-u", user, "--", cmd, ...args]];
-}
-function chownMindDir(dir, name) {
-  if (!isIsolationEnabled()) return;
-  const user = mindUserName(name);
-  try {
-    execFileSync("chown", ["-R", `${user}:${user}`, dir], { stdio: ["ignore", "ignore", "pipe"] });
-  } catch (err) {
-    const stderr = err?.stderr?.toString().trim();
-    throw new Error(`Failed to chown ${dir} to ${user}${stderr ? `: ${stderr}` : ""}`);
-  }
-  try {
-    execFileSync("chmod", ["700", dir], { stdio: ["ignore", "ignore", "pipe"] });
-  } catch (err) {
-    const stderr = err?.stderr?.toString().trim();
-    throw new Error(`Failed to chmod ${dir}${stderr ? `: ${stderr}` : ""}`);
-  }
-}
-
-export {
-  isIsolationEnabled,
-  mindUserName,
-  ensureVoluteGroup,
-  createMindUser,
-  deleteMindUser,
-  wrapForIsolation,
-  chownMindDir
-};

package/dist/service-FASYWLTC.js

@@ -1,247 +0,0 @@
-#!/usr/bin/env node
-import {
-  LAUNCHD_PLIST_LABEL,
-  LAUNCHD_PLIST_PATH,
-  SYSTEM_SERVICE_PATH,
-  USER_SYSTEMD_UNIT
-} from "./chunk-3AIBT4TW.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import {
-  resolveVoluteBin
-} from "./chunk-JTDFJWI2.js";
-import "./chunk-NWPT4ASZ.js";
-import "./chunk-B2CPS4QU.js";
-import "./chunk-K3NQKI34.js";
-
-// src/commands/service.ts
-import { execFile } from "child_process";
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { resolve } from "path";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var HOST_RE = /^[a-zA-Z0-9.:_-]+$/;
-function validateHost(host) {
-  if (!HOST_RE.test(host)) {
-    throw new Error(`Invalid host: ${host}`);
-  }
-}
-function escapeXml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function generatePlist(voluteBin, port, host) {
-  const args = ["up", "--foreground"];
-  if (port != null) args.push("--port", String(port));
-  if (host) args.push("--host", host);
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${LAUNCHD_PLIST_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    ${[voluteBin, ...args].map((a) => `<string>${escapeXml(a)}</string>`).join("\n    ")}
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${resolve(homedir(), ".volute", "daemon.log")}</string>
-  <key>StandardErrorPath</key>
-  <string>${resolve(homedir(), ".volute", "daemon.log")}</string>
-</dict>
-</plist>`;
-}
-function generateUnit(voluteBin, port, host) {
-  const args = ["up", "--foreground"];
-  if (port != null) args.push("--port", String(port));
-  if (host) args.push("--host", host);
-  return `[Unit]
-Description=Volute Daemon
-After=network.target
-
-[Service]
-Type=exec
-ExecStart=${voluteBin} ${args.join(" ")}
-Restart=on-failure
-RestartSec=5
-
-[Install]
-WantedBy=default.target
-`;
-}
-async function install(port, host) {
-  if (host) validateHost(host);
-  const voluteBin = resolveVoluteBin();
-  const platform = process.platform;
-  if (platform === "darwin") {
-    const path = LAUNCHD_PLIST_PATH;
-    mkdirSync(resolve(homedir(), "Library", "LaunchAgents"), { recursive: true });
-    writeFileSync(path, generatePlist(voluteBin, port, host));
-    console.log(`Wrote ${path}`);
-    await execFileAsync("launchctl", ["load", path]);
-    console.log("Service installed and loaded. Volute daemon will start on login.");
-  } else if (platform === "linux") {
-    if (existsSync(SYSTEM_SERVICE_PATH)) {
-      console.error(
-        "A system-level Volute service is already installed (via `volute service install --system`)."
-      );
-      console.error("Use `systemctl status volute` to check its status.");
-      console.error("To remove it first: sudo volute service uninstall --system");
-      process.exit(1);
-    }
-    if (process.getuid?.() === 0) {
-      console.error(
-        "Error: `volute service install` uses systemd user services, which don't work as root."
-      );
-      console.error(
-        "Use `volute service install --system` instead to install a system-level service."
-      );
-      process.exit(1);
-    }
-    const path = USER_SYSTEMD_UNIT;
-    mkdirSync(resolve(homedir(), ".config", "systemd", "user"), { recursive: true });
-    writeFileSync(path, generateUnit(voluteBin, port, host));
-    console.log(`Wrote ${path}`);
-    await execFileAsync("systemctl", ["--user", "enable", "--now", "volute"]);
-    console.log("Service installed and enabled. Volute daemon will start on login.");
-  } else {
-    console.error(`Unsupported platform: ${platform}. Only macOS and Linux are supported.`);
-    process.exit(1);
-  }
-}
-async function uninstall() {
-  const platform = process.platform;
-  if (platform === "darwin") {
-    const path = LAUNCHD_PLIST_PATH;
-    if (existsSync(path)) {
-      try {
-        await execFileAsync("launchctl", ["unload", path]);
-      } catch {
-        console.warn("Warning: failed to unload service (may already be unloaded)");
-      }
-      unlinkSync(path);
-      console.log("Service uninstalled.");
-    } else {
-      console.log("Service not installed.");
-    }
-  } else if (platform === "linux") {
-    const path = USER_SYSTEMD_UNIT;
-    if (existsSync(path)) {
-      try {
-        await execFileAsync("systemctl", ["--user", "disable", "--now", "volute"]);
-      } catch {
-        console.warn("Warning: failed to disable service (may already be stopped)");
-      }
-      unlinkSync(path);
-      console.log("Service uninstalled.");
-    } else {
-      console.log("Service not installed.");
-    }
-  } else {
-    console.error(`Unsupported platform: ${platform}`);
-    process.exit(1);
-  }
-}
-async function status() {
-  const platform = process.platform;
-  if (platform === "darwin") {
-    if (!existsSync(LAUNCHD_PLIST_PATH)) {
-      console.log("Service not installed.");
-      return;
-    }
-    try {
-      const { stdout } = await execFileAsync("launchctl", ["list", LAUNCHD_PLIST_LABEL]);
-      console.log(stdout);
-    } catch {
-      console.log("Service installed but not currently loaded.");
-    }
-  } else if (platform === "linux") {
-    if (existsSync(SYSTEM_SERVICE_PATH)) {
-      try {
-        const { stdout } = await execFileAsync("systemctl", ["status", "volute", "--no-pager"]);
-        console.log(stdout);
-      } catch (err) {
-        const e = err;
-        if (e.stdout) {
-          console.log(e.stdout);
-        } else {
-          console.error("System service installed but could not retrieve status.");
-          if (e.stderr) console.error(e.stderr);
-          else if (e.message) console.error(e.message);
-          console.error("Try running: systemctl status volute");
-        }
-      }
-      return;
-    }
-    if (!existsSync(USER_SYSTEMD_UNIT)) {
-      console.log("Service not installed.");
-      return;
-    }
-    try {
-      const { stdout } = await execFileAsync("systemctl", [
-        "--user",
-        "status",
-        "volute",
-        "--no-pager"
-      ]);
-      console.log(stdout);
-    } catch (err) {
-      const e = err;
-      if (e.stdout) console.log(e.stdout);
-      else console.log("Service installed but status unknown.");
-    }
-  } else {
-    console.error(`Unsupported platform: ${platform}`);
-    process.exit(1);
-  }
-}
-async function run(args) {
-  const { positional, flags } = parseArgs(args, {
-    port: { type: "number" },
-    host: { type: "string" },
-    system: { type: "boolean" },
-    force: { type: "boolean" }
-  });
-  const subcommand = positional[0];
-  switch (subcommand) {
-    case "install":
-      if (flags.system) {
-        const setup = await import("./setup-BMLM2UTK.js");
-        setup.install(flags.port, flags.host);
-      } else {
-        await install(flags.port, flags.host);
-      }
-      break;
-    case "uninstall":
-      if (flags.system) {
-        const setup = await import("./setup-BMLM2UTK.js");
-        setup.uninstall(!!flags.force);
-      } else {
-        await uninstall();
-      }
-      break;
-    case "status":
-      await status();
-      break;
-    default:
-      console.log(`Usage:
-  volute service install [--port N] [--host H]          Install as user-level service
-  volute service install --system [--port N] [--host H] Install system service with user isolation
-  volute service uninstall                               Remove user-level service
-  volute service uninstall --system [--force]            Remove system service (--force removes data + users)
-  volute service status                                  Check service status`);
-      if (subcommand) {
-        console.error(`
-Unknown subcommand: ${subcommand}`);
-        process.exit(1);
-      }
-  }
-}
-export {
-  run
-};