volute 0.1.0 → 0.2.1

package/README.md

@@ -71,7 +71,6 @@ Responses stream back to your terminal in real time. The agent knows which chann
 │   ├── VOLUTE.md          # channel routing docs
 │   └── memory/            # daily logs (YYYY-MM-DD.md)
 ├── src/                   # agent server code
-├── volute.json            # agent config (model, etc.)
 └── .volute/               # runtime state, session, logs
 ```
 
@@ -210,7 +209,7 @@ volute create atlas --template pi
 
 ## Model configuration
 
-Set the model via `volute.json` in the agent's root directory, or the `VOLUTE_MODEL` env var.
+Set the model via `home/.config/volute.json` in the agent directory, or the `VOLUTE_MODEL` env var.
 
 ## Development
 

package/dist/agent-manager-SSJUZWOV.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  AgentManager,
+  getAgentManager,
+  initAgentManager
+} from "./chunk-L3BQEZ4Z.js";
+import "./chunk-KFNNHQK7.js";
+import "./chunk-6UCG6MIX.js";
+export {
+  AgentManager,
+  getAgentManager,
+  initAgentManager
+};

package/dist/{channel-Q642YUZE.js → channel-2WJRM7PE.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-A5ZJEMHT.js";
+} from "./chunk-KFNNHQK7.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   resolveAgent
-} from "./chunk-5YW4B7CG.js";
+} from "./chunk-6UCG6MIX.js";
 
 // src/lib/channels/discord.ts
 var API_BASE = "https://discord.com/api/v10";

package/dist/{chunk-H5XQARAP.js → chunk-4YXYAMFT.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
-  VOLUTE_HOME
-} from "./chunk-5YW4B7CG.js";
+  voluteHome
+} from "./chunk-6UCG6MIX.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
 function readDaemonConfig() {
-  const configPath = resolve(VOLUTE_HOME, "daemon.json");
+  const configPath = resolve(voluteHome(), "daemon.json");
   if (!existsSync(configPath)) {
     console.error("Volute is not running. Start with: volute up");
     process.exit(1);

package/dist/{chunk-5YW4B7CG.js → chunk-6UCG6MIX.js}

@@ -9,19 +9,24 @@ var __export = (target, all) => {
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { resolve } from "path";
-var VOLUTE_HOME = process.env.VOLUTE_HOME || resolve(homedir(), ".volute");
-var VARIANTS_PATH = resolve(VOLUTE_HOME, "variants.json");
+function voluteHome() {
+  return process.env.VOLUTE_HOME || resolve(homedir(), ".volute");
+}
+function variantsPath() {
+  return resolve(voluteHome(), "variants.json");
+}
 function readAllVariants() {
-  if (!existsSync(VARIANTS_PATH)) return {};
+  const path = variantsPath();
+  if (!existsSync(path)) return {};
   try {
-    return JSON.parse(readFileSync(VARIANTS_PATH, "utf-8"));
+    return JSON.parse(readFileSync(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeAllVariants(all) {
-  mkdirSync(VOLUTE_HOME, { recursive: true });
-  writeFileSync(VARIANTS_PATH, `${JSON.stringify(all, null, 2)}
+  mkdirSync(voluteHome(), { recursive: true });
+  writeFileSync(variantsPath(), `${JSON.stringify(all, null, 2)}
 `);
 }
 function readVariants(agentName) {
@@ -52,6 +57,28 @@ function removeVariant(agentName, name) {
 function findVariant(agentName, name) {
   return readVariants(agentName).find((v) => v.name === name);
 }
+function setVariantRunning(agentName, variantName, running) {
+  const all = readAllVariants();
+  const variants = all[agentName] ?? [];
+  const variant = variants.find((v) => v.name === variantName);
+  if (variant) {
+    variant.running = running;
+    all[agentName] = variants;
+    writeAllVariants(all);
+  }
+}
+function getAllRunningVariants() {
+  const all = readAllVariants();
+  const result = [];
+  for (const [agentName, variants] of Object.entries(all)) {
+    for (const variant of variants) {
+      if (variant.running) {
+        result.push({ agentName, variant });
+      }
+    }
+  }
+  return result;
+}
 function removeAllVariants(agentName) {
   const all = readAllVariants();
   delete all[agentName];
@@ -81,19 +108,20 @@ function validateBranchName(branch) {
 }
 
 // src/lib/registry.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve2 } from "path";
-var VOLUTE_HOME2 = process.env.VOLUTE_HOME || resolve2(homedir2(), ".volute");
-var AGENTS_DIR = resolve2(VOLUTE_HOME2, "agents");
-var REGISTRY_PATH = resolve2(VOLUTE_HOME2, "agents.json");
+function voluteHome2() {
+  return process.env.VOLUTE_HOME || resolve2(homedir2(), ".volute");
+}
 function ensureVoluteHome() {
-  mkdirSync2(AGENTS_DIR, { recursive: true });
+  mkdirSync2(resolve2(voluteHome2(), "agents"), { recursive: true });
 }
 function readRegistry() {
-  if (!existsSync2(REGISTRY_PATH)) return [];
+  const registryPath = resolve2(voluteHome2(), "agents.json");
+  if (!existsSync2(registryPath)) return [];
   try {
-    const entries = JSON.parse(readFileSync2(REGISTRY_PATH, "utf-8"));
+    const entries = JSON.parse(readFileSync2(registryPath, "utf-8"));
     return entries.map((e) => ({ ...e, running: e.running ?? false }));
   } catch {
     return [];
@@ -101,10 +129,26 @@ function readRegistry() {
 }
 function writeRegistry(entries) {
   ensureVoluteHome();
-  writeFileSync2(REGISTRY_PATH, `${JSON.stringify(entries, null, 2)}
+  const registryPath = resolve2(voluteHome2(), "agents.json");
+  const tmpPath = `${registryPath}.tmp`;
+  writeFileSync2(tmpPath, `${JSON.stringify(entries, null, 2)}
 `);
+  renameSync(tmpPath, registryPath);
+}
+var AGENT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var AGENT_NAME_MAX = 64;
+function validateAgentName(name) {
+  if (!name) return "Agent name is required";
+  if (name.length > AGENT_NAME_MAX)
+    return `Agent name must be at most ${AGENT_NAME_MAX} characters`;
+  if (!AGENT_NAME_RE.test(name)) {
+    return "Agent name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
+  }
+  return null;
 }
 function addAgent(name, port) {
+  const err = validateAgentName(name);
+  if (err) throw new Error(err);
   const entries = readRegistry();
   const filtered = entries.filter((e) => e.name !== name);
   filtered.push({ name, port, created: (/* @__PURE__ */ new Date()).toISOString(), running: false });
@@ -126,34 +170,37 @@ function findAgent(name) {
   return readRegistry().find((e) => e.name === name);
 }
 function agentDir(name) {
-  return resolve2(AGENTS_DIR, name);
+  return resolve2(voluteHome2(), "agents", name);
 }
 function nextPort() {
   const entries = readRegistry();
   const usedPorts = new Set(entries.map((e) => e.port));
+  for (const entry of entries) {
+    for (const v of readVariants(entry.name)) {
+      if (v.port) usedPorts.add(v.port);
+    }
+  }
   let port = 4100;
   while (usedPorts.has(port)) port++;
+  if (port > 65535) throw new Error("No available ports \u2014 all ports 4100-65535 are allocated");
   return port;
 }
 function resolveAgent(name) {
   const [baseName, variantName] = name.split("@", 2);
   const entry = findAgent(baseName);
   if (!entry) {
-    console.error(`Unknown agent: ${baseName}`);
-    process.exit(1);
+    throw new Error(`Unknown agent: ${baseName}`);
   }
   const dir = agentDir(baseName);
   if (!existsSync2(dir)) {
-    console.error(`Agent directory missing: ${dir}`);
-    process.exit(1);
+    throw new Error(`Agent directory missing: ${dir}`);
   }
   if (variantName) {
     const variant = findVariant(baseName, variantName);
     if (!variant) {
-      console.error(`Unknown variant: ${variantName} (agent: ${baseName})`);
-      process.exit(1);
+      throw new Error(`Unknown variant: ${variantName} (agent: ${baseName})`);
     }
-    return { entry: { ...entry, port: variant.port }, dir };
+    return { entry: { ...entry, port: variant.port }, dir: variant.path };
   }
   return { entry, dir };
 }
@@ -165,10 +212,12 @@ export {
   addVariant,
   removeVariant,
   findVariant,
+  setVariantRunning,
+  getAllRunningVariants,
   removeAllVariants,
   checkHealth,
   validateBranchName,
-  VOLUTE_HOME2 as VOLUTE_HOME,
+  voluteHome2 as voluteHome,
   ensureVoluteHome,
   readRegistry,
   addAgent,

package/dist/{chunk-A5ZJEMHT.js → chunk-KFNNHQK7.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
-  VOLUTE_HOME
-} from "./chunk-5YW4B7CG.js";
+  voluteHome
+} from "./chunk-6UCG6MIX.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 function sharedEnvPath() {
-  return resolve(VOLUTE_HOME, "env.json");
+  return resolve(voluteHome(), "env.json");
 }
 function agentEnvPath(agentDir) {
   return resolve(agentDir, ".volute", "env.json");
@@ -23,7 +23,7 @@ function readEnv(path) {
 function writeEnv(path, env) {
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(env, null, 2)}
-`);
+`, { mode: 384 });
 }
 function loadMergedEnv(agentDir) {
   const shared = readEnv(sharedEnvPath());

package/dist/chunk-L3BQEZ4Z.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+import {
+  loadMergedEnv
+} from "./chunk-KFNNHQK7.js";
+import {
+  agentDir,
+  findAgent,
+  findVariant,
+  setAgentRunning,
+  setVariantRunning,
+  validateBranchName
+} from "./chunk-6UCG6MIX.js";
+
+// src/lib/agent-manager.ts
+import { execFile, spawn } from "child_process";
+import { createWriteStream, existsSync, mkdirSync, readFileSync, unlinkSync } from "fs";
+import { resolve } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_RESTART_ATTEMPTS = 5;
+var BASE_RESTART_DELAY = 3e3;
+var MAX_RESTART_DELAY = 6e4;
+var AgentManager = class {
+  agents = /* @__PURE__ */ new Map();
+  stopping = /* @__PURE__ */ new Set();
+  shuttingDown = false;
+  restartAttempts = /* @__PURE__ */ new Map();
+  resolveTarget(name) {
+    const [baseName, variantName] = name.split("@", 2);
+    const entry = findAgent(baseName);
+    if (!entry) throw new Error(`Unknown agent: ${baseName}`);
+    if (variantName) {
+      const variant = findVariant(baseName, variantName);
+      if (!variant) throw new Error(`Unknown variant: ${variantName} (agent: ${baseName})`);
+      return { dir: variant.path, port: variant.port, isVariant: true, baseName, variantName };
+    }
+    const dir = agentDir(baseName);
+    if (!existsSync(dir)) throw new Error(`Agent directory missing: ${dir}`);
+    return { dir, port: entry.port, isVariant: false, baseName };
+  }
+  async startAgent(name) {
+    if (this.agents.has(name)) {
+      throw new Error(`Agent ${name} is already running`);
+    }
+    const target = this.resolveTarget(name);
+    const { dir, isVariant, baseName, variantName } = target;
+    const port = target.port;
+    try {
+      const res = await fetch(`http://localhost:${port}/health`);
+      if (res.ok) {
+        console.error(`[daemon] killing orphan process on port ${port}`);
+        await killProcessOnPort(port);
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    } catch {
+    }
+    const voluteDir = resolve(dir, ".volute");
+    const logsDir = resolve(voluteDir, "logs");
+    mkdirSync(logsDir, { recursive: true });
+    const logStream = createWriteStream(resolve(logsDir, "agent.log"), {
+      flags: "a"
+    });
+    const agentEnv = loadMergedEnv(dir);
+    const { VOLUTE_DAEMON_TOKEN: _, ...parentEnv } = process.env;
+    const env = { ...parentEnv, ...agentEnv, VOLUTE_AGENT: name };
+    const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
+    const child = spawn(tsxBin, ["src/server.ts", "--port", String(port)], {
+      cwd: dir,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      env
+    });
+    this.agents.set(name, { child, port });
+    child.stdout?.pipe(logStream);
+    child.stderr?.pipe(logStream);
+    try {
+      await new Promise((resolve2, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error(`Agent ${name} did not start within 30s`));
+        }, 3e4);
+        function checkOutput(data) {
+          if (data.toString().match(/listening on :\d+/)) {
+            clearTimeout(timeout);
+            resolve2();
+          }
+        }
+        child.stdout?.on("data", checkOutput);
+        child.stderr?.on("data", checkOutput);
+        child.on("error", (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+        child.on("exit", (code) => {
+          clearTimeout(timeout);
+          reject(new Error(`Agent ${name} exited with code ${code} during startup`));
+        });
+      });
+    } catch (err) {
+      this.agents.delete(name);
+      try {
+        child.kill();
+      } catch {
+      }
+      throw err;
+    }
+    this.restartAttempts.delete(name);
+    this.setupCrashRecovery(name, child, dir, isVariant);
+    if (isVariant) {
+      setVariantRunning(baseName, variantName, true);
+    } else {
+      setAgentRunning(name, true);
+    }
+    console.error(`[daemon] started agent ${name} on port ${port}`);
+  }
+  setupCrashRecovery(name, child, dir, isVariant) {
+    child.on("exit", async (code) => {
+      this.agents.delete(name);
+      if (this.shuttingDown || this.stopping.has(name)) return;
+      console.error(`[daemon] agent ${name} exited with code ${code}`);
+      const wasRestart = isVariant ? false : await this.handleRestart(name, dir);
+      if (wasRestart) {
+        console.error(`[daemon] restarting ${name} immediately after merge`);
+        this.restartAttempts.delete(name);
+        this.startAgent(name).catch((err) => {
+          console.error(`[daemon] failed to restart ${name} after merge:`, err);
+        });
+      } else {
+        const attempts = this.restartAttempts.get(name) ?? 0;
+        if (attempts >= MAX_RESTART_ATTEMPTS) {
+          console.error(`[daemon] ${name} crashed ${attempts} times \u2014 giving up on restart`);
+          const [base, variant] = name.split("@", 2);
+          if (variant) {
+            setVariantRunning(base, variant, false);
+          } else {
+            setAgentRunning(name, false);
+          }
+          return;
+        }
+        const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
+        this.restartAttempts.set(name, attempts + 1);
+        console.error(
+          `[daemon] crash recovery for ${name} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, restarting in ${delay}ms`
+        );
+        setTimeout(() => {
+          if (this.shuttingDown) return;
+          this.startAgent(name).catch((err) => {
+            console.error(`[daemon] failed to restart ${name}:`, err);
+          });
+        }, delay);
+      }
+    });
+  }
+  async handleRestart(name, dir) {
+    const restartPath = resolve(dir, ".volute", "restart.json");
+    if (!existsSync(restartPath)) return false;
+    try {
+      const signal = JSON.parse(readFileSync(restartPath, "utf-8"));
+      unlinkSync(restartPath);
+      if (signal.action === "merge" && signal.name) {
+        const err = validateBranchName(signal.name);
+        if (err) {
+          console.error(`[daemon] invalid variant name in restart.json for ${name}: ${err}`);
+          return false;
+        }
+        console.error(`[daemon] merging variant for ${name}: ${signal.name}`);
+        const mergeArgs = ["merge", name, signal.name];
+        if (signal.summary) mergeArgs.push("--summary", signal.summary);
+        if (signal.justification) mergeArgs.push("--justification", signal.justification);
+        if (signal.memory) mergeArgs.push("--memory", signal.memory);
+        const { VOLUTE_DAEMON_TOKEN: _t, ...mergeEnv } = process.env;
+        await execFileAsync("volute", mergeArgs, {
+          cwd: dir,
+          env: { ...mergeEnv, VOLUTE_SUPERVISOR: "1" }
+        });
+      }
+      return true;
+    } catch (e) {
+      console.error(`[daemon] failed to handle restart for ${name}:`, e);
+      return false;
+    }
+  }
+  async stopAgent(name) {
+    const tracked = this.agents.get(name);
+    if (!tracked) return;
+    this.stopping.add(name);
+    const { child } = tracked;
+    this.agents.delete(name);
+    await new Promise((resolve2) => {
+      child.on("exit", () => resolve2());
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        resolve2();
+      }
+      setTimeout(() => {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+        resolve2();
+      }, 5e3);
+    });
+    this.stopping.delete(name);
+    this.restartAttempts.delete(name);
+    const [baseName, variantName] = name.split("@", 2);
+    if (variantName) {
+      setVariantRunning(baseName, variantName, false);
+    } else {
+      setAgentRunning(name, false);
+    }
+    console.error(`[daemon] stopped agent ${name}`);
+  }
+  async restartAgent(name) {
+    await this.stopAgent(name);
+    await this.startAgent(name);
+  }
+  async stopAll() {
+    this.shuttingDown = true;
+    const names = [...this.agents.keys()];
+    await Promise.all(names.map((name) => this.stopAgent(name)));
+  }
+  isRunning(name) {
+    return this.agents.has(name);
+  }
+  getRunningAgents() {
+    return [...this.agents.keys()];
+  }
+};
+async function killProcessOnPort(port) {
+  try {
+    const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
+    const pids = /* @__PURE__ */ new Set();
+    for (const line of stdout.trim().split("\n").filter(Boolean)) {
+      const pid = parseInt(line, 10);
+      pids.add(pid);
+      try {
+        const { stdout: psOut } = await execFileAsync("ps", ["-p", String(pid), "-o", "pgid="]);
+        const pgid = parseInt(psOut.trim(), 10);
+        if (pgid > 1) pids.add(pgid);
+      } catch {
+      }
+    }
+    for (const pid of pids) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var instance = null;
+function initAgentManager() {
+  if (instance) throw new Error("AgentManager already initialized");
+  instance = new AgentManager();
+  return instance;
+}
+function getAgentManager() {
+  if (!instance) instance = new AgentManager();
+  return instance;
+}
+
+export {
+  AgentManager,
+  initAgentManager,
+  getAgentManager
+};

package/dist/{chunk-N4QN44LC.js → chunk-MY74SUOL.js}

@@ -2,6 +2,7 @@
 
 // src/lib/spawn-server.ts
 import { spawn } from "child_process";
+import { closeSync, mkdirSync, openSync, readFileSync } from "fs";
 import { resolve } from "path";
 function tsxBin(cwd) {
   return resolve(cwd, "node_modules", ".bin", "tsx");
@@ -39,33 +40,39 @@ function spawnAttached(cwd, port) {
   });
 }
 function spawnDetached(cwd, port) {
+  const logsDir = resolve(cwd, ".volute", "logs");
+  mkdirSync(logsDir, { recursive: true });
+  const logPath = resolve(logsDir, "agent.log");
+  const logFd = openSync(logPath, "a");
   const child = spawn(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
     cwd,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: ["ignore", logFd, logFd],
     detached: true
   });
-  return new Promise((resolve2) => {
-    const timeout = setTimeout(() => resolve2(null), 3e4);
-    function checkOutput(data) {
-      const match = data.toString().match(/listening on :(\d+)/);
-      if (match) {
-        clearTimeout(timeout);
-        child.stdout?.destroy();
-        child.stderr?.destroy();
-        child.unref();
-        resolve2({ child, actualPort: parseInt(match[1], 10) });
-      }
-    }
-    child.stdout?.on("data", checkOutput);
-    child.stderr?.on("data", checkOutput);
-    child.on("error", () => {
-      clearTimeout(timeout);
-      resolve2(null);
-    });
-    child.on("exit", () => {
+  child.unref();
+  closeSync(logFd);
+  return new Promise((res) => {
+    let done = false;
+    function finish(result) {
+      if (done) return;
+      done = true;
+      clearInterval(interval);
       clearTimeout(timeout);
-      resolve2(null);
-    });
+      res(result);
+    }
+    const interval = setInterval(() => {
+      try {
+        const content = readFileSync(logPath, "utf-8");
+        const match = content.match(/listening on :(\d+)/);
+        if (match) {
+          finish({ child, actualPort: parseInt(match[1], 10) });
+        }
+      } catch {
+      }
+    }, 100);
+    const timeout = setTimeout(() => finish(null), 3e4);
+    child.on("error", () => finish(null));
+    child.on("exit", () => finish(null));
   });
 }
 

package/dist/{chunk-KSMIWOCN.js → chunk-N4YNKR3Q.js}

@@ -45,6 +45,7 @@ var log = {
 var logger_default = log;
 
 // src/lib/ndjson.ts
+var MAX_BUFFER_SIZE = 1e6;
 async function* readNdjson(body) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
@@ -54,6 +55,11 @@ async function* readNdjson(body) {
       const { done, value } = await reader.read();
       if (done) break;
       buffer += decoder.decode(value, { stream: true });
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        logger_default.warn("ndjson: buffer exceeded 1MB, resetting");
+        buffer = "";
+        continue;
+      }
       const lines = buffer.split("\n");
       buffer = lines.pop() || "";
       for (const line of lines) {