volute 0.6.0 → 0.8.0

package/dist/{chunk-G6ZNGLUX.js → chunk-W6TMWYU3.js}

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-H7AMDUIA.js";
+} from "./chunk-QF22MYDJ.js";
 import {
   applyIsolation
-} from "./chunk-W76KWE23.js";
+} from "./chunk-IQXBMFZG.js";
 import {
   agentDir,
   findAgent,
   findVariant,
   setAgentRunning,
   setVariantRunning,
-  validateBranchName,
+  stateDir,
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 
 // src/lib/agent-manager.ts
 import { execFile, spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 import { promisify } from "util";
 
@@ -59,14 +59,21 @@ function clearJsonMap(path, map) {
 }
 
 // src/lib/rotating-log.ts
-import { createWriteStream, existsSync as existsSync2, renameSync, statSync } from "fs";
+import {
+  createWriteStream,
+  existsSync as existsSync2,
+  renameSync,
+  rmSync,
+  statSync
+} from "fs";
 import { Writable } from "stream";
 var MAX_SIZE = 10 * 1024 * 1024;
 var RotatingLog = class extends Writable {
-  constructor(path, maxSize = MAX_SIZE) {
+  constructor(path, maxSize = MAX_SIZE, maxFiles = 5) {
     super();
     this.path = path;
     this.maxSize = maxSize;
+    this.maxFiles = maxFiles;
     this.on("error", () => {
     });
     try {
@@ -82,6 +89,13 @@ var RotatingLog = class extends Writable {
     this.size += chunk.length;
     if (this.size > this.maxSize) {
       try {
+        const oldest = `${this.path}.${this.maxFiles}`;
+        if (existsSync2(oldest)) rmSync(oldest);
+        for (let i = this.maxFiles - 1; i >= 1; i--) {
+          const from = `${this.path}.${i}`;
+          const to = `${this.path}.${i + 1}`;
+          if (existsSync2(from)) renameSync(from, to);
+        }
         renameSync(this.path, `${this.path}.1`);
         const oldStream = this.stream;
         this.stream = createWriteStream(this.path);
@@ -99,6 +113,9 @@ var RotatingLog = class extends Writable {
 
 // src/lib/agent-manager.ts
 var execFileAsync = promisify(execFile);
+function agentPidPath(name) {
+  return resolve(stateDir(name), "agent.pid");
+}
 var MAX_RESTART_ATTEMPTS = 5;
 var BASE_RESTART_DELAY = 3e3;
 var MAX_RESTART_DELAY = 6e4;
@@ -107,6 +124,7 @@ var AgentManager = class {
   stopping = /* @__PURE__ */ new Set();
   shuttingDown = false;
   restartAttempts = /* @__PURE__ */ new Map();
+  pendingContext = /* @__PURE__ */ new Map();
   resolveTarget(name) {
     const [baseName, variantName] = name.split("@", 2);
     const entry = findAgent(baseName);
@@ -127,6 +145,34 @@ var AgentManager = class {
     const target = this.resolveTarget(name);
     const { dir, isVariant, baseName, variantName } = target;
     const port = target.port;
+    const pidFile = agentPidPath(name);
+    try {
+      if (existsSync3(pidFile)) {
+        const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
+        if (stalePid > 0) {
+          try {
+            process.kill(stalePid, 0);
+            const { stdout } = await execFileAsync("ps", ["-p", String(stalePid), "-o", "args="]);
+            if (stdout.includes("server.ts")) {
+              console.error(`[daemon] killing stale agent process ${stalePid} for ${name}`);
+              process.kill(-stalePid, "SIGTERM");
+              await new Promise((r) => setTimeout(r, 500));
+            } else {
+              console.error(
+                `[daemon] stale PID ${stalePid} for ${name} is not an agent process, skipping`
+              );
+            }
+          } catch (err) {
+            if (err.code !== "ESRCH") {
+              console.error(`[daemon] failed to check/kill stale process for ${name}:`, err);
+            }
+          }
+        }
+        rmSync2(pidFile, { force: true });
+      }
+    } catch (err) {
+      console.error(`[daemon] failed to read PID file for ${name}:`, err);
+    }
     try {
       const res = await fetch(`http://127.0.0.1:${port}/health`);
       if (res.ok) {
@@ -136,13 +182,18 @@ var AgentManager = class {
       }
     } catch {
     }
-    const voluteDir = resolve(dir, ".volute");
-    const logsDir = resolve(voluteDir, "logs");
+    const logsDir = resolve(stateDir(name), "logs");
     mkdirSync(logsDir, { recursive: true });
     const logStream = new RotatingLog(resolve(logsDir, "agent.log"));
-    const agentEnv = loadMergedEnv(dir);
-    const { VOLUTE_DAEMON_TOKEN: _, ...parentEnv } = process.env;
-    const env = { ...parentEnv, ...agentEnv, VOLUTE_AGENT: name };
+    const agentEnv = loadMergedEnv(name);
+    const env = {
+      ...process.env,
+      ...agentEnv,
+      VOLUTE_AGENT: name,
+      VOLUTE_STATE_DIR: stateDir(name),
+      VOLUTE_AGENT_DIR: dir,
+      VOLUTE_AGENT_PORT: String(port)
+    };
     const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
     const spawnOpts = {
       cwd: dir,
@@ -185,82 +236,83 @@ var AgentManager = class {
       }
       throw err;
     }
+    if (child.pid) {
+      try {
+        writeFileSync2(pidFile, String(child.pid));
+      } catch (err) {
+        console.error(`[daemon] failed to write PID file for ${name}:`, err);
+      }
+    }
     if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    this.setupCrashRecovery(name, child, dir, isVariant);
+    this.setupCrashRecovery(name, child);
     if (isVariant) {
       setVariantRunning(baseName, variantName, true);
     } else {
       setAgentRunning(name, true);
     }
     console.error(`[daemon] started agent ${name} on port ${port}`);
+    await this.deliverPendingContext(name);
+  }
+  setPendingContext(name, context) {
+    this.pendingContext.set(name, context);
   }
-  setupCrashRecovery(name, child, dir, isVariant) {
+  async deliverPendingContext(name) {
+    const context = this.pendingContext.get(name);
+    if (!context) return;
+    const tracked = this.agents.get(name);
+    if (!tracked) return;
+    this.pendingContext.delete(name);
+    const parts = [];
+    if (context.type === "merge" || context.type === "merged") {
+      parts.push(`[system] Variant "${context.name}" has been merged and you have been restarted.`);
+    } else {
+      parts.push("[system] You have been restarted.");
+    }
+    if (context.summary) parts.push(`Changes: ${context.summary}`);
+    if (context.justification) parts.push(`Why: ${context.justification}`);
+    if (context.memory) parts.push(`Context: ${context.memory}`);
+    try {
+      await fetch(`http://127.0.0.1:${tracked.port}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          content: [{ type: "text", text: parts.join("\n") }],
+          channel: "system"
+        })
+      });
+    } catch (err) {
+      console.error(`[daemon] failed to deliver pending context to ${name}:`, err);
+    }
+  }
+  setupCrashRecovery(name, child) {
     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`);
-        if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-        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 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);
         }
-        const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
-        this.restartAttempts.set(name, attempts + 1);
-        this.saveCrashAttempts();
-        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);
+        return;
       }
-    });
-  }
-  async handleRestart(name, dir) {
-    const restartPath = resolve(dir, ".volute", "restart.json");
-    if (!existsSync3(restartPath)) return false;
-    try {
-      const signal = JSON.parse(readFileSync2(restartPath, "utf-8"));
-      unlinkSync2(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" }
+      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
+      this.restartAttempts.set(name, attempts + 1);
+      this.saveCrashAttempts();
+      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);
         });
-      }
-      return true;
-    } catch (e) {
-      console.error(`[daemon] failed to handle restart for ${name}:`, e);
-      return false;
-    }
+      }, delay);
+    });
   }
   async stopAgent(name) {
     const tracked = this.agents.get(name);
@@ -285,11 +337,14 @@ var AgentManager = class {
     });
     this.stopping.delete(name);
     if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    const [baseName, variantName] = name.split("@", 2);
-    if (variantName) {
-      setVariantRunning(baseName, variantName, false);
-    } else {
-      setAgentRunning(name, false);
+    rmSync2(agentPidPath(name), { force: true });
+    if (!this.shuttingDown) {
+      const [baseName, variantName] = name.split("@", 2);
+      if (variantName) {
+        setVariantRunning(baseName, variantName, false);
+      } else {
+        setAgentRunning(name, false);
+      }
     }
     console.error(`[daemon] stopped agent ${name}`);
   }

package/dist/{up-CSX3ZUIU.js → chunk-XSJ27WEM.js}

@@ -4,8 +4,7 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   voluteHome
-} from "./chunk-UWHWAPGO.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-DP2DX4WV.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";
@@ -103,6 +102,7 @@ async function run(args) {
   console.error(`Check logs: ${logFile}`);
   process.exit(1);
 }
+
 export {
   readGlobalConfig,
   run

package/dist/cli.js

@@ -9,46 +9,52 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-4DP4Y4UO.js");
+  const { default: pkg } = await import("./package-5UCKNK6J.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-X7GJLBLW.js").then((m) => m.run(args));
+    await import("./agent-YORVRB6I.js").then((m) => m.run(args));
     break;
-  case "message":
-    await import("./message-SCOQDR3P.js").then((m) => m.run(args));
+  case "send":
+    await import("./send-BNC2S5BY.js").then((m) => m.run(args));
+    break;
+  case "history":
+    await import("./history-PXJVYLVY.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-4Z6W3PP6.js").then((m) => m.run(args));
+    await import("./variant-RKXPN5DH.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-Y7JPNROO.js").then((m) => m.run(args));
+    await import("./connector-ZP6MEFF4.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-SMCNOIVQ.js").then((m) => m.run(args));
+    await import("./channel-RDGHBFSI.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-S6QVC5ON.js").then((m) => m.run(args));
+    await import("./schedule-HCUCBNQI.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-7GLUJCWS.js").then((m) => m.run(args));
+    await import("./env-KMNYGVZ2.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-CSX3ZUIU.js").then((m) => m.run(args));
+    await import("./up-V6EAA7OZ.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-FXWAN66A.js").then((m) => m.run(args));
+    await import("./down-O4EWZTVA.js").then((m) => m.run(args));
+    break;
+  case "restart":
+    await import("./daemon-restart-CPBLMMRI.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-F4TCWVSP.js").then((m) => m.run(args));
+    await import("./setup-JXDCJX7W.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-HZNIDNJF.js").then((m) => m.run(args));
+    await import("./service-R4MCNBOA.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-XSIX3GGP.js").then((m) => m.run(args));
+    await import("./update-EUCZ7XGG.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -67,8 +73,8 @@ Commands:
   volute agent upgrade <name>             Upgrade agent to latest template
   volute agent import <path>              Import an OpenClaw workspace
 
-  volute message send <name> "<msg>"      Send a message to an agent
-  volute message history [--agent <name>] View message history
+  volute send <target> "<msg>"             Send a message (agent DM, channel, etc.)
+  volute history [--agent <name>]          View message history
 
   volute variant create <name>            Create a variant (worktree + server)
   volute variant list                     List variants for an agent
@@ -79,7 +85,6 @@ Commands:
   volute connector disconnect <type>      Disable a connector for an agent
 
   volute channel read <uri>               Read recent messages from a channel
-  volute channel send <uri> "<msg>"       Send a message to a channel
   volute channel list [<platform>]        List conversations on a platform
   volute channel users <platform>         List users on a platform
   volute channel create <platform> ...    Create a conversation on a platform
@@ -92,6 +97,7 @@ Commands:
 
   volute up [--port N]                    Start the daemon (default: 4200)
   volute down                             Stop the daemon
+  volute restart [--port N]               Restart the daemon
 
   volute service install [--port N]       Install as system service (auto-start)
   volute service uninstall                Remove system service
@@ -105,7 +111,7 @@ Options:
   --version, -v                           Show version number
   --help, -h                              Show this help message
 
-Agent-scoped commands (variant, connector, schedule, channel, message history)
+Agent-scoped commands (send, history, variant, connector, schedule, channel)
 use --agent <name> or VOLUTE_AGENT env var to identify the agent.`);
     break;
   default:
@@ -114,7 +120,7 @@ Run 'volute --help' for usage.`);
     process.exit(1);
 }
 if (command !== "update") {
-  import("./update-check-5ZADDHCK.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-SM4244SU.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);

package/dist/{connector-Y7JPNROO.js → connector-ZP6MEFF4.js}

@@ -6,16 +6,16 @@ import {
   agentEnvPath,
   readEnv,
   writeEnv
-} from "./chunk-H7AMDUIA.js";
+} from "./chunk-QF22MYDJ.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-JR4UXCTO.js";
+} from "./chunk-23L3MKEV.js";
 import {
   agentDir
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/connector.ts

package/dist/connectors/discord.js

@@ -1,27 +1,18 @@
 #!/usr/bin/env node
 import {
   buildChannelSlug,
-  fireAndForget,
-  handleAgentMessage,
   loadEnv,
   loadFollowedChannels,
   reportTyping,
+  sendToAgent,
   slugify,
-  splitMessage,
   writeChannelEntry
-} from "../chunk-BX7KI4S3.js";
+} from "../chunk-N6MLQ26B.js";
+import "../chunk-DP2DX4WV.js";
 import "../chunk-K3NQKI34.js";
 
 // src/connectors/discord.ts
-import {
-  AttachmentBuilder,
-  ChannelType,
-  Client,
-  Events,
-  GatewayIntentBits,
-  Partials
-} from "discord.js";
-var DISCORD_MAX_LENGTH = 2e3;
+import { ChannelType, Client, Events, GatewayIntentBits, Partials } from "discord.js";
 var TYPING_INTERVAL_MS = 8e3;
 var env = loadEnv();
 var token = process.env.DISCORD_TOKEN;
@@ -102,14 +93,16 @@ client.on(Events.MessageCreate, async (message) => {
     channelName: channelName ?? message.channelId,
     serverName: message.guild?.name
   });
-  if (env.agentDir) {
-    writeChannelEntry(env.agentDir, channelKey, {
+  try {
+    writeChannelEntry(env.agentName, channelKey, {
       platformId: message.channelId,
       platform: "discord",
       name: channelName ? `#${channelName}` : void 0,
       server: message.guild?.name,
       type: isDM ? "dm" : "channel"
     });
+  } catch (err) {
+    console.error(`[discord] failed to write channel entry for ${channelKey}:`, err);
   }
   const participantCount = isDM ? 2 : message.guild?.memberCount;
   const payload = {
@@ -122,15 +115,20 @@ client.on(Events.MessageCreate, async (message) => {
     ...message.guild?.name ? { serverName: message.guild.name } : {},
     ...participantCount ? { participantCount } : {}
   };
+  reportTyping(env, channelKey, senderName, false);
   if (isFollowedChannel && !isMentioned) {
-    await fireAndForget(env, payload);
+    const result = await sendToAgent(env, payload);
+    if (!result.ok)
+      message.reply(result.error ?? "Failed to process message").catch((err) => {
+        console.warn(`[discord] failed to send error reply: ${err}`);
+      });
     return;
   }
   await handleDiscordMessage(message, payload);
 });
 client.on(Events.TypingStart, (typing) => {
   if (typing.user.bot) return;
-  const sender = typing.member?.displayName ?? typing.user.username ?? typing.user.id ?? "unknown";
+  const sender = typing.user.displayName || typing.user.username || typing.user.id || "unknown";
   const typingChannel = typing.guild ? `discord:${slugify(typing.guild.name)}/${slugify("name" in typing.channel ? String(typing.channel.name) : typing.channel.id)}` : `discord:@${slugify(typing.user.username ?? typing.user.id)}`;
   reportTyping(env, typingChannel, sender, true);
 });
@@ -138,54 +136,19 @@ async function handleDiscordMessage(message, payload) {
   const channel = message.channel;
   if (!("sendTyping" in channel)) return;
   const typingInterval = setInterval(() => {
-    channel.sendTyping().catch(() => {
+    channel.sendTyping().catch((err) => {
+      console.warn(`[discord] sendTyping failed: ${err}`);
     });
   }, TYPING_INTERVAL_MS);
-  channel.sendTyping().catch(() => {
+  channel.sendTyping().catch((err) => {
+    console.warn(`[discord] sendTyping failed: ${err}`);
   });
-  let replied = false;
   try {
-    await handleAgentMessage(env, payload, {
-      onFlush: async (text, images) => {
-        if (!text && images.length === 0) return;
-        const chunks = text ? splitMessage(text, DISCORD_MAX_LENGTH) : [];
-        const imageFiles = images.map((img, i) => {
-          const ext = img.media_type.split("/")[1] || "png";
-          return new AttachmentBuilder(Buffer.from(img.data, "base64"), {
-            name: `image-${i}.${ext}`
-          });
-        });
-        if (chunks.length === 0 && imageFiles.length > 0) {
-          const sendFn = replied ? channel.send.bind(channel) : message.reply.bind(message);
-          await sendFn({ content: "\u200B", files: imageFiles }).catch((err) => {
-            console.error(`Failed to send message: ${err}`);
-          });
-          replied = true;
-          return;
-        }
-        for (let i = 0; i < chunks.length; i++) {
-          const isLast = i === chunks.length - 1;
-          const opts = {
-            content: chunks[i]
-          };
-          if (isLast && imageFiles.length > 0) opts.files = imageFiles;
-          try {
-            if (!replied) {
-              await message.reply(opts);
-              replied = true;
-            } else {
-              await channel.send(opts);
-            }
-          } catch (err) {
-            console.error(`Failed to send message: ${err}`);
-          }
-        }
-      },
-      onError: async (msg) => {
-        await message.reply(msg).catch(() => {
-        });
-      }
-    });
+    const result = await sendToAgent(env, payload);
+    if (!result.ok)
+      message.reply(result.error ?? "Failed to process message").catch((err) => {
+        console.warn(`[discord] failed to send error reply: ${err}`);
+      });
   } finally {
     clearInterval(typingInterval);
   }