volute 0.1.0 → 0.2.1

package/dist/daemon.js

@@ -1,283 +1,108 @@
 #!/usr/bin/env node
+import {
+  getAgentManager,
+  initAgentManager
+} from "./chunk-L3BQEZ4Z.js";
 import {
   logBuffer,
   logger_default,
   readNdjson
-} from "./chunk-KSMIWOCN.js";
+} from "./chunk-N4YNKR3Q.js";
 import {
   loadMergedEnv
-} from "./chunk-A5ZJEMHT.js";
+} from "./chunk-KFNNHQK7.js";
 import {
-  VOLUTE_HOME,
   __export,
   agentDir,
   checkHealth,
   findAgent,
+  findVariant,
+  getAllRunningVariants,
   readRegistry,
   readVariants,
   removeAgent,
   removeAllVariants,
-  setAgentRunning
-} from "./chunk-5YW4B7CG.js";
+  setAgentRunning,
+  setVariantRunning,
+  voluteHome
+} from "./chunk-6UCG6MIX.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve8 } from "path";
 
-// 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 AgentManager = class {
-  agents = /* @__PURE__ */ new Map();
-  stopping = /* @__PURE__ */ new Set();
-  shuttingDown = false;
-  async startAgent(name) {
-    if (this.agents.has(name)) {
-      throw new Error(`Agent ${name} is already running`);
-    }
-    const entry = findAgent(name);
-    if (!entry) throw new Error(`Unknown agent: ${name}`);
-    const dir = agentDir(name);
-    if (!existsSync(dir)) throw new Error(`Agent directory missing: ${dir}`);
-    const port = entry.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 env = { ...process.env, ...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((resolve9, 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);
-            resolve9();
-          }
-        }
-        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.setupCrashRecovery(name, child, dir);
-    setAgentRunning(name, true);
-    console.error(`[daemon] started agent ${name} on port ${port}`);
-  }
-  setupCrashRecovery(name, child, dir) {
-    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 = await this.handleRestart(name, dir);
-      if (wasRestart) {
-        console.error(`[daemon] restarting ${name} immediately after merge`);
-        this.startAgent(name).catch((err) => {
-          console.error(`[daemon] failed to restart ${name} after merge:`, err);
-        });
-      } else {
-        console.error(`[daemon] crash recovery for ${name} \u2014 restarting in 3s`);
-        setTimeout(() => {
-          if (this.shuttingDown) return;
-          this.startAgent(name).catch((err) => {
-            console.error(`[daemon] failed to restart ${name}:`, err);
-          });
-        }, 3e3);
-      }
-    });
-  }
-  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) {
-        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);
-        await execFileAsync("volute", mergeArgs, {
-          cwd: dir,
-          env: { ...process.env, 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((resolve9) => {
-      child.on("exit", () => resolve9());
-      try {
-        process.kill(-child.pid, "SIGTERM");
-      } catch {
-        resolve9();
-      }
-      setTimeout(() => {
-        try {
-          process.kill(-child.pid, "SIGKILL");
-        } catch {
-        }
-        resolve9();
-      }, 5e3);
-    });
-    this.stopping.delete(name);
-    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;
-}
-
 // src/lib/connector-manager.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import {
-  createWriteStream as createWriteStream2,
-  existsSync as existsSync3,
+  createWriteStream,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
-  unlinkSync as unlinkSync2,
+  readFileSync as readFileSync2,
+  unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { homedir } from "os";
-import { dirname, resolve as resolve3 } from "path";
+import { dirname as dirname2, resolve as resolve2 } from "path";
 
 // src/lib/volute-config.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+function configPath(agentDir2) {
+  const newPath = resolve(agentDir2, "home/.config/volute.json");
+  if (existsSync(newPath)) return newPath;
+  const oldPath = resolve(agentDir2, "volute.json");
+  if (existsSync(oldPath)) return oldPath;
+  return newPath;
+}
 function readVoluteConfig(agentDir2) {
-  const path = resolve2(agentDir2, "volute.json");
-  if (!existsSync2(path)) return {};
+  const path = configPath(agentDir2);
+  if (!existsSync(path)) return {};
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync(path, "utf-8"));
   } catch {
-    return {};
+    return null;
   }
 }
 function writeVoluteConfig(agentDir2, config) {
-  const path = resolve2(agentDir2, "volute.json");
+  const path = resolve(agentDir2, "home/.config/volute.json");
+  mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(config, null, 2)}
 `);
 }
 
 // src/lib/connector-manager.ts
+function searchUpwards(...segments) {
+  let searchDir = dirname2(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve2(searchDir, ...segments);
+    if (existsSync2(candidate)) return candidate;
+    searchDir = dirname2(searchDir);
+  }
+  return null;
+}
+var MAX_RESTART_ATTEMPTS = 5;
+var BASE_RESTART_DELAY = 3e3;
+var MAX_RESTART_DELAY = 6e4;
 var ConnectorManager = class {
   connectors = /* @__PURE__ */ new Map();
   stopping = /* @__PURE__ */ new Set();
   // "agent:type" keys currently being explicitly stopped
   shuttingDown = false;
-  async startConnectors(agentName, agentDir2, agentPort) {
-    const config = readVoluteConfig(agentDir2);
+  restartAttempts = /* @__PURE__ */ new Map();
+  // "agent:type" -> count
+  async startConnectors(agentName, agentDir2, agentPort, daemonPort) {
+    const config = readVoluteConfig(agentDir2) ?? {};
     const types = config.connectors ?? [];
     for (const type of types) {
       try {
-        await this.startConnector(agentName, agentDir2, agentPort, type);
+        await this.startConnector(agentName, agentDir2, agentPort, type, daemonPort);
       } catch (err) {
         console.error(`[daemon] failed to start connector ${type} for ${agentName}:`, err);
       }
     }
   }
-  async startConnector(agentName, agentDir2, agentPort, type) {
+  async startConnector(agentName, agentDir2, agentPort, type, daemonPort) {
     const existing = this.connectors.get(agentName)?.get(type);
     if (existing) {
       await new Promise((res) => {
@@ -298,37 +123,41 @@ var ConnectorManager = class {
       this.connectors.get(agentName)?.delete(type);
     }
     this.killOrphanConnector(agentDir2, type);
-    const agentConnector = resolve3(agentDir2, "connectors", type, "index.ts");
-    const userConnector = resolve3(homedir(), ".volute", "connectors", type, "index.ts");
+    const agentConnector = resolve2(agentDir2, "connectors", type, "index.ts");
+    const userConnector = resolve2(homedir(), ".volute", "connectors", type, "index.ts");
     const builtinConnector = this.resolveBuiltinConnector(type);
     let connectorScript;
     let runtime;
-    if (existsSync3(agentConnector)) {
+    if (existsSync2(agentConnector)) {
       connectorScript = agentConnector;
-      runtime = resolve3(agentDir2, "node_modules", ".bin", "tsx");
-    } else if (existsSync3(userConnector)) {
+      runtime = resolve2(agentDir2, "node_modules", ".bin", "tsx");
+    } else if (existsSync2(userConnector)) {
       connectorScript = userConnector;
       runtime = this.resolveVoluteTsx();
-    } else if (builtinConnector && existsSync3(builtinConnector)) {
+    } else if (builtinConnector) {
       connectorScript = builtinConnector;
       runtime = process.execPath;
     } else {
       throw new Error(`No connector code found for type: ${type}`);
     }
-    const logsDir = resolve3(agentDir2, ".volute", "logs");
+    const logsDir = resolve2(agentDir2, ".volute", "logs");
     mkdirSync2(logsDir, { recursive: true });
-    const logStream = createWriteStream2(resolve3(logsDir, `${type}.log`), { flags: "a" });
+    const logStream = createWriteStream(resolve2(logsDir, `${type}.log`), { flags: "a" });
     const agentEnv = loadMergedEnv(agentDir2);
     const prefix = `${type.toUpperCase()}_`;
     const connectorEnv = Object.fromEntries(
       Object.entries(agentEnv).filter(([k]) => k.startsWith(prefix))
     );
-    const child = spawn2(runtime, [connectorScript], {
+    const child = spawn(runtime, [connectorScript], {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
         ...process.env,
         VOLUTE_AGENT_PORT: String(agentPort),
         VOLUTE_AGENT_NAME: agentName,
+        ...daemonPort ? {
+          VOLUTE_DAEMON_URL: `http://localhost:${daemonPort}`,
+          VOLUTE_DAEMON_TOKEN: process.env.VOLUTE_DAEMON_TOKEN
+        } : {},
         ...connectorEnv
       }
     });
@@ -342,6 +171,7 @@ var ConnectorManager = class {
     }
     this.connectors.get(agentName).set(type, { child, type });
     const stopKey = `${agentName}:${type}`;
+    this.restartAttempts.delete(stopKey);
     child.on("exit", (code) => {
       const agentMap = this.connectors.get(agentName);
       if (agentMap?.get(type)?.child === child) {
@@ -350,13 +180,24 @@ var ConnectorManager = class {
       if (this.shuttingDown) return;
       if (this.stopping.has(stopKey)) return;
       console.error(`[daemon] connector ${type} for ${agentName} exited with code ${code}`);
-      console.error(`[daemon] restarting connector ${type} for ${agentName} in 3s`);
+      const attempts = this.restartAttempts.get(stopKey) ?? 0;
+      if (attempts >= MAX_RESTART_ATTEMPTS) {
+        console.error(
+          `[daemon] connector ${type} for ${agentName} crashed ${attempts} times \u2014 giving up`
+        );
+        return;
+      }
+      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
+      this.restartAttempts.set(stopKey, attempts + 1);
+      console.error(
+        `[daemon] restarting connector ${type} for ${agentName} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, in ${delay}ms`
+      );
       setTimeout(() => {
         if (this.shuttingDown || this.stopping.has(stopKey)) return;
-        this.startConnector(agentName, agentDir2, agentPort, type).catch((err) => {
+        this.startConnector(agentName, agentDir2, agentPort, type, daemonPort).catch((err) => {
           console.error(`[daemon] failed to restart connector ${type} for ${agentName}:`, err);
         });
-      }, 3e3);
+      }, delay);
     });
     console.error(`[daemon] started connector ${type} for ${agentName}`);
   }
@@ -384,6 +225,7 @@ var ConnectorManager = class {
       }, 5e3);
     });
     this.stopping.delete(stopKey);
+    this.restartAttempts.delete(stopKey);
     try {
       this.removeConnectorPid(agentDir(agentName), type);
     } catch {
@@ -411,24 +253,24 @@ var ConnectorManager = class {
     }));
   }
   connectorPidPath(agentDir2, type) {
-    return resolve3(agentDir2, ".volute", "connectors", `${type}.pid`);
+    return resolve2(agentDir2, ".volute", "connectors", `${type}.pid`);
   }
   saveConnectorPid(agentDir2, type, pid) {
     const pidPath = this.connectorPidPath(agentDir2, type);
-    mkdirSync2(dirname(pidPath), { recursive: true });
+    mkdirSync2(dirname2(pidPath), { recursive: true });
     writeFileSync2(pidPath, String(pid));
   }
   removeConnectorPid(agentDir2, type) {
     try {
-      unlinkSync2(this.connectorPidPath(agentDir2, type));
+      unlinkSync(this.connectorPidPath(agentDir2, type));
     } catch {
     }
   }
   killOrphanConnector(agentDir2, type) {
     const pidPath = this.connectorPidPath(agentDir2, type);
-    if (!existsSync3(pidPath)) return;
+    if (!existsSync2(pidPath)) return;
     try {
-      const pid = parseInt(readFileSync3(pidPath, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
       if (pid > 0) {
         process.kill(pid, "SIGTERM");
         console.error(`[daemon] killed orphan connector ${type} (pid ${pid})`);
@@ -436,38 +278,26 @@ var ConnectorManager = class {
     } catch {
     }
     try {
-      unlinkSync2(pidPath);
+      unlinkSync(pidPath);
     } catch {
     }
   }
   resolveBuiltinConnector(type) {
-    let searchDir = dirname(new URL(import.meta.url).pathname);
-    for (let i = 0; i < 5; i++) {
-      const candidate = resolve3(searchDir, "connectors", `${type}.js`);
-      if (existsSync3(candidate)) return candidate;
-      searchDir = dirname(searchDir);
-    }
-    return null;
+    return searchUpwards("connectors", `${type}.js`);
   }
   resolveVoluteTsx() {
-    let searchDir = dirname(new URL(import.meta.url).pathname);
-    for (let i = 0; i < 5; i++) {
-      const candidate = resolve3(searchDir, "node_modules", ".bin", "tsx");
-      if (existsSync3(candidate)) return candidate;
-      searchDir = dirname(searchDir);
-    }
-    return "tsx";
+    return searchUpwards("node_modules", ".bin", "tsx") ?? "tsx";
   }
 };
-var instance2 = null;
+var instance = null;
 function initConnectorManager() {
-  if (instance2) throw new Error("ConnectorManager already initialized");
-  instance2 = new ConnectorManager();
-  return instance2;
+  if (instance) throw new Error("ConnectorManager already initialized");
+  instance = new ConnectorManager();
+  return instance;
 }
 function getConnectorManager() {
-  if (!instance2) instance2 = new ConnectorManager();
-  return instance2;
+  if (!instance) instance = new ConnectorManager();
+  return instance;
 }
 
 // src/lib/scheduler.ts
@@ -477,7 +307,11 @@ var Scheduler = class {
   interval = null;
   lastFired = /* @__PURE__ */ new Map();
   // "agent:scheduleId" → epoch minute
-  start() {
+  daemonPort = null;
+  daemonToken = null;
+  start(daemonPort, daemonToken) {
+    this.daemonPort = daemonPort ?? null;
+    this.daemonToken = daemonToken ?? null;
     this.interval = setInterval(() => this.tick(), 6e4);
   }
   stop() {
@@ -486,6 +320,7 @@ var Scheduler = class {
   loadSchedules(agentName) {
     const dir = agentDir(agentName);
     const config = readVoluteConfig(dir);
+    if (!config) return;
     const schedules = config.schedules ?? [];
     if (schedules.length > 0) {
       this.schedules.set(agentName, schedules);
@@ -497,6 +332,9 @@ var Scheduler = class {
     this.schedules.delete(agentName);
   }
   tick() {
+    for (const agent of this.schedules.keys()) {
+      this.loadSchedules(agent);
+    }
     const now = /* @__PURE__ */ new Date();
     for (const [agent, schedules] of this.schedules) {
       for (const schedule of schedules) {
@@ -520,43 +358,67 @@ var Scheduler = class {
         return true;
       }
       return false;
-    } catch {
+    } catch (err) {
+      console.error(
+        `[scheduler] invalid cron "${schedule.cron}" for ${agent}:${schedule.id}:`,
+        err
+      );
       return false;
     }
   }
   async fire(agentName, schedule) {
     const entry = findAgent(agentName);
     if (!entry) return;
+    const body = JSON.stringify({
+      content: [{ type: "text", text: schedule.message }],
+      channel: "system:scheduler",
+      sender: schedule.id
+    });
     try {
-      await fetch(`http://localhost:${entry.port}/message`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          content: [{ type: "text", text: schedule.message }],
-          channel: "system:scheduler",
-          sender: "scheduler"
-        })
-      });
-      console.error(`[scheduler] fired "${schedule.id}" for ${agentName}`);
+      let res;
+      if (this.daemonPort && this.daemonToken) {
+        const daemonUrl = `http://localhost:${this.daemonPort}`;
+        res = await fetch(`${daemonUrl}/api/agents/${encodeURIComponent(agentName)}/message`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.daemonToken}`,
+            Origin: daemonUrl
+          },
+          body
+        });
+      } else {
+        res = await fetch(`http://localhost:${entry.port}/message`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body
+        });
+      }
+      if (!res.ok) {
+        console.error(`[scheduler] "${schedule.id}" for ${agentName} got HTTP ${res.status}`);
+      } else {
+        console.error(`[scheduler] fired "${schedule.id}" for ${agentName}`);
+      }
     } catch (err) {
       console.error(`[scheduler] failed to fire "${schedule.id}" for ${agentName}:`, err);
     }
   }
 };
-var instance3 = null;
+var instance2 = null;
 function getScheduler() {
-  if (!instance3) instance3 = new Scheduler();
-  return instance3;
+  if (!instance2) instance2 = new Scheduler();
+  return instance2;
 }
 
 // src/web/server.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname3, extname, resolve as resolve7 } from "path";
+import { dirname as dirname4, extname, resolve as resolve7 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/web/app.ts
 import { Hono as Hono11 } from "hono";
+import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
@@ -569,8 +431,8 @@ import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq } from "drizzle-orm";
 
 // src/lib/db.ts
-import { existsSync as existsSync4 } from "fs";
-import { dirname as dirname2, resolve as resolve4 } from "path";
+import { chmodSync, existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import { drizzle } from "drizzle-orm/libsql";
 import { migrate } from "drizzle-orm/libsql/migrator";
@@ -639,18 +501,26 @@ var messages = sqliteTable(
 );
 
 // src/lib/db.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync4(resolve4(__dirname, "../drizzle")) ? resolve4(__dirname, "../drizzle") : resolve4(__dirname, "../../drizzle");
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var migrationsFolder = existsSync3(resolve3(__dirname, "../drizzle")) ? resolve3(__dirname, "../drizzle") : resolve3(__dirname, "../../drizzle");
 var db = null;
 async function getDb() {
   if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve4(VOLUTE_HOME, "volute.db");
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve3(voluteHome(), "volute.db");
   db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
   try {
     await migrate(db, { migrationsFolder });
   } catch (e) {
     if (!(e instanceof Error) || !e.message.includes("already exists")) throw e;
   }
+  try {
+    chmodSync(dbPath, 384);
+  } catch (err) {
+    console.error(
+      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
+      err
+    );
+  }
   return db;
 }
 
@@ -739,6 +609,13 @@ function getSessionUserId(sessionId) {
   }
   return session.userId;
 }
+var requireAdmin = createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin") {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+  await next();
+});
 var authMiddleware = createMiddleware(async (c, next) => {
   const authHeader = c.req.header("Authorization");
   if (authHeader?.startsWith("Bearer ")) {
@@ -761,7 +638,8 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/routes/agents.ts
-import { existsSync as existsSync5, rmSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync } from "fs";
+import { resolve as resolve4 } from "path";
 import { and as and2, desc, eq as eq2 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
@@ -771,11 +649,20 @@ var CHANNELS = {
   web: { name: "web", displayName: "Web UI", showToolCalls: true },
   discord: { name: "discord", displayName: "Discord", showToolCalls: false },
   cli: { name: "cli", displayName: "CLI", showToolCalls: true },
+  agent: { name: "agent", displayName: "Agent", showToolCalls: true },
   system: { name: "system", displayName: "System", showToolCalls: false }
 };
 
 // src/web/routes/agents.ts
-async function getAgentStatus(name, _dir, port) {
+function getDaemonPort() {
+  try {
+    const data = JSON.parse(readFileSync3(resolve4(voluteHome(), "daemon.json"), "utf-8"));
+    return data.port;
+  } catch {
+    return void 0;
+  }
+}
+async function getAgentStatus(name, port) {
   const manager = getAgentManager();
   let status = "stopped";
   if (manager.isRunning(name)) {
@@ -789,25 +676,15 @@ async function getAgentStatus(name, _dir, port) {
     status: status === "running" ? "connected" : "disconnected",
     showToolCalls: CHANNELS.web.showToolCalls
   });
-  const connectorManager = getConnectorManager();
-  const connectorStatuses = connectorManager.getConnectorStatus(name);
+  const connectorStatuses = getConnectorManager().getConnectorStatus(name);
   for (const cs of connectorStatuses) {
-    const channelConfig = CHANNELS[cs.type];
-    if (channelConfig) {
-      channels.push({
-        name: channelConfig.name,
-        displayName: channelConfig.displayName,
-        status: cs.running ? "connected" : "disconnected",
-        showToolCalls: channelConfig.showToolCalls
-      });
-    } else {
-      channels.push({
-        name: cs.type,
-        displayName: cs.type,
-        status: cs.running ? "connected" : "disconnected",
-        showToolCalls: false
-      });
-    }
+    const config = CHANNELS[cs.type];
+    channels.push({
+      name: config?.name ?? cs.type,
+      displayName: config?.displayName ?? cs.type,
+      status: cs.running ? "connected" : "disconnected",
+      showToolCalls: config?.showToolCalls ?? false
+    });
   }
   return { status, channels };
 }
@@ -815,8 +692,7 @@ var app = new Hono().get("/", async (c) => {
   const entries = readRegistry();
   const agents = await Promise.all(
     entries.map(async (entry) => {
-      const dir = agentDir(entry.name);
-      const { status, channels } = await getAgentStatus(entry.name, dir, entry.port);
+      const { status, channels } = await getAgentStatus(entry.name, entry.port);
       return { ...entry, status, channels };
     })
   );
@@ -825,65 +701,97 @@ var app = new Hono().get("/", async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const dir = agentDir(name);
-  if (!existsSync5(dir)) return c.json({ error: "Agent directory missing" }, 404);
-  const { status, channels } = await getAgentStatus(name, dir, entry.port);
-  return c.json({ ...entry, status, channels });
-}).post("/:name/start", async (c) => {
+  if (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  const { status, channels } = await getAgentStatus(name, entry.port);
+  const variants = readVariants(name);
+  const manager = getAgentManager();
+  const variantStatuses = await Promise.all(
+    variants.map(async (v) => {
+      const compositeKey = `${name}@${v.name}`;
+      let variantStatus = "stopped";
+      if (manager.isRunning(compositeKey)) {
+        const health = await checkHealth(v.port);
+        variantStatus = health.ok ? "running" : "starting";
+      }
+      return { name: v.name, port: v.port, status: variantStatus };
+    })
+  );
+  return c.json({ ...entry, status, channels, variants: variantStatuses });
+}).post("/:name/start", requireAdmin, async (c) => {
   const name = c.req.param("name");
-  const entry = findAgent(name);
+  const [baseName, variantName] = name.split("@", 2);
+  const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const dir = agentDir(name);
-  if (!existsSync5(dir)) return c.json({ error: "Agent directory missing" }, 404);
+  if (variantName) {
+    const variant = findVariant(baseName, variantName);
+    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+  } else {
+    const dir = agentDir(baseName);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+  }
   const manager = getAgentManager();
   if (manager.isRunning(name)) {
     return c.json({ error: "Agent already running" }, 409);
   }
   try {
     await manager.startAgent(name);
-    setAgentRunning(name, true);
-    await getConnectorManager().startConnectors(name, dir, entry.port);
+    if (!variantName) {
+      const dir = agentDir(baseName);
+      await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
+    }
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to start agent" }, 500);
   }
-}).post("/:name/restart", async (c) => {
+}).post("/:name/restart", requireAdmin, async (c) => {
   const name = c.req.param("name");
-  const entry = findAgent(name);
+  const [baseName, variantName] = name.split("@", 2);
+  const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const dir = agentDir(name);
-  if (!existsSync5(dir)) return c.json({ error: "Agent directory missing" }, 404);
+  if (variantName) {
+    const variant = findVariant(baseName, variantName);
+    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+  } else {
+    const dir = agentDir(baseName);
+    if (!existsSync4(dir)) return c.json({ error: "Agent directory missing" }, 404);
+  }
   const manager = getAgentManager();
   const connectorManager = getConnectorManager();
   try {
     if (manager.isRunning(name)) {
-      await connectorManager.stopConnectors(name);
+      if (!variantName) await connectorManager.stopConnectors(baseName);
       await manager.stopAgent(name);
     }
     await manager.startAgent(name);
-    setAgentRunning(name, true);
-    await connectorManager.startConnectors(name, dir, entry.port);
+    if (!variantName) {
+      const dir = agentDir(baseName);
+      await connectorManager.startConnectors(baseName, dir, entry.port, getDaemonPort());
+    }
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to restart agent" }, 500);
   }
-}).post("/:name/stop", async (c) => {
+}).post("/:name/stop", requireAdmin, async (c) => {
   const name = c.req.param("name");
-  const entry = findAgent(name);
+  const [baseName, variantName] = name.split("@", 2);
+  const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
+  if (variantName) {
+    const variant = findVariant(baseName, variantName);
+    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+  }
   const manager = getAgentManager();
   if (!manager.isRunning(name)) {
     return c.json({ error: "Agent is not running" }, 409);
   }
   try {
-    await getConnectorManager().stopConnectors(name);
+    if (!variantName) await getConnectorManager().stopConnectors(baseName);
     await manager.stopAgent(name);
-    setAgentRunning(name, false);
     return c.json({ ok: true });
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : "Failed to stop agent" }, 500);
   }
-}).delete("/:name", async (c) => {
+}).delete("/:name", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
@@ -896,35 +804,48 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
-  if (force && existsSync5(dir)) {
+  if (force && existsSync4(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
 }).post("/:name/message", async (c) => {
   const name = c.req.param("name");
-  const entry = findAgent(name);
+  const [baseName, variantName] = name.split("@", 2);
+  const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
-  const manager = getAgentManager();
-  if (!manager.isRunning(name)) {
+  let port = entry.port;
+  if (variantName) {
+    const variant = findVariant(baseName, variantName);
+    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+    port = variant.port;
+  }
+  if (!getAgentManager().isRunning(name)) {
     return c.json({ error: "Agent is not running" }, 409);
   }
   const body = await c.req.text();
-  const db2 = await getDb();
+  let parsed = null;
   try {
-    const parsed = JSON.parse(body);
-    const channel = parsed.channel ?? "unknown";
-    const sender = parsed.sender ?? null;
-    const content = typeof parsed.content === "string" ? parsed.content : JSON.stringify(parsed.content);
-    await db2.insert(agentMessages).values({
-      agent: name,
-      channel,
-      role: "user",
-      sender,
-      content
-    });
+    parsed = JSON.parse(body);
   } catch {
   }
-  const res = await fetch(`http://localhost:${entry.port}/message`, {
+  const channel = parsed?.channel ?? "unknown";
+  const db2 = await getDb();
+  if (parsed) {
+    try {
+      const sender = parsed.sender ?? null;
+      const content = typeof parsed.content === "string" ? parsed.content : JSON.stringify(parsed.content);
+      await db2.insert(agentMessages).values({
+        agent: baseName,
+        channel,
+        role: "user",
+        sender,
+        content
+      });
+    } catch (err) {
+      console.error(`[daemon] failed to persist inbound message for ${baseName}:`, err);
+    }
+  }
+  const res = await fetch(`http://localhost:${port}/message`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body
@@ -941,12 +862,7 @@ var app = new Hono().get("/", async (c) => {
     const decoder = new TextDecoder();
     let buffer = "";
     const textParts = [];
-    let channel = "unknown";
     try {
-      try {
-        channel = JSON.parse(body).channel ?? "unknown";
-      } catch {
-      }
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
@@ -975,13 +891,16 @@ var app = new Hono().get("/", async (c) => {
         }
       }
       if (textParts.length > 0) {
-        const db3 = await getDb();
-        await db3.insert(agentMessages).values({
-          agent: name,
-          channel,
-          role: "assistant",
-          content: textParts.join("")
-        });
+        try {
+          await db2.insert(agentMessages).values({
+            agent: baseName,
+            channel,
+            role: "assistant",
+            content: textParts.join("")
+          });
+        } catch (err) {
+          console.error(`[daemon] failed to persist assistant response for ${baseName}:`, err);
+        }
       }
     } finally {
       reader.releaseLock();
@@ -1094,11 +1013,17 @@ async function createConversation(agentName, channel, opts) {
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function getConversation(id) {
+async function getConversationForUser(id, userId) {
   const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(eq3(conversations.id, id)).get();
+  const row = await db2.select().from(conversations).where(and3(eq3(conversations.id, id), eq3(conversations.user_id, userId))).get();
   return row ?? null;
 }
+async function deleteConversationForUser(id, userId) {
+  const conv = await getConversationForUser(id, userId);
+  if (!conv) return false;
+  await deleteConversation(id);
+  return true;
+}
 async function listConversations(agentName, opts) {
   const db2 = await getDb();
   if (opts?.userId != null) {
@@ -1159,8 +1084,19 @@ var chatSchema = z2.object({
 });
 var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), async (c) => {
   const name = c.req.param("name");
-  const entry = findAgent(name);
+  const [baseName, variantName] = name.split("@", 2);
+  const entry = findAgent(baseName);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
+  let port = entry.port;
+  if (variantName) {
+    const variant = findVariant(baseName, variantName);
+    if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
+    port = variant.port;
+  }
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-SSJUZWOV.js");
+  if (!getAgentManager2().isRunning(name)) {
+    return c.json({ error: "Agent is not running" }, 409);
+  }
   const body = c.req.valid("json");
   if (!body.message && (!body.images || body.images.length === 0)) {
     return c.json({ error: "message or images required" }, 400);
@@ -1168,49 +1104,39 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
   const user = c.get("user");
   let conversationId = body.conversationId;
   if (conversationId) {
-    const conv = await getConversation(conversationId);
+    const conv = await getConversationForUser(conversationId, user.id);
     if (!conv) return c.json({ error: "Conversation not found" }, 404);
   } else {
     const title = body.message ? body.message.slice(0, 80) : "Image message";
-    const conv = await createConversation(name, "web", {
+    const conv = await createConversation(baseName, "web", {
       userId: user.id,
       title
     });
     conversationId = conv.id;
   }
-  const userContent = [];
+  const contentBlocks = [];
   if (body.message) {
-    userContent.push({ type: "text", text: body.message });
+    contentBlocks.push({ type: "text", text: body.message });
   }
   if (body.images) {
     for (const img of body.images) {
-      userContent.push({ type: "image", media_type: img.media_type, data: img.data });
+      contentBlocks.push({ type: "image", media_type: img.media_type, data: img.data });
     }
   }
-  await addMessage(conversationId, "user", user.username, userContent);
-  const userText = body.message ?? "[image]";
+  await addMessage(conversationId, "user", user.username, contentBlocks);
   const db2 = await getDb();
   await db2.insert(agentMessages).values({
-    agent: name,
+    agent: baseName,
     channel: "web",
     role: "user",
     sender: user.username,
-    content: userText
+    content: body.message ?? "[image]"
   });
-  const agentContent = [];
-  if (body.message) {
-    agentContent.push({ type: "text", text: body.message });
-  }
-  if (body.images) {
-    for (const img of body.images) {
-      agentContent.push({ type: "image", media_type: img.media_type, data: img.data });
-    }
-  }
-  const res = await fetch(`http://localhost:${entry.port}/message`, {
+  const res = await fetch(`http://localhost:${port}/message`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
-      content: agentContent,
+      content: contentBlocks,
       channel: "web",
       sender: user.username
     })
@@ -1227,36 +1153,34 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
     });
     const assistantContent = [];
     for await (const event of readNdjson(res.body)) {
-      const voluteEvent = event;
-      await stream2.writeSSE({ data: JSON.stringify(voluteEvent) });
-      if (voluteEvent.type === "text") {
+      await stream2.writeSSE({ data: JSON.stringify(event) });
+      if (event.type === "text") {
         const last = assistantContent[assistantContent.length - 1];
         if (last && last.type === "text") {
-          last.text += voluteEvent.content;
+          last.text += event.content;
         } else {
-          assistantContent.push({ type: "text", text: voluteEvent.content });
+          assistantContent.push({ type: "text", text: event.content });
         }
-      } else if (voluteEvent.type === "tool_use") {
+      } else if (event.type === "tool_use") {
         assistantContent.push({
           type: "tool_use",
-          name: voluteEvent.name,
-          input: voluteEvent.input
+          name: event.name,
+          input: event.input
         });
-      } else if (voluteEvent.type === "tool_result") {
+      } else if (event.type === "tool_result") {
         assistantContent.push({
           type: "tool_result",
-          output: voluteEvent.output,
-          ...voluteEvent.is_error ? { is_error: true } : {}
+          output: event.output,
+          ...event.is_error ? { is_error: true } : {}
         });
       }
-      if (voluteEvent.type === "done") {
+      if (event.type === "done") {
         if (assistantContent.length > 0) {
-          await addMessage(conversationId, "assistant", name, assistantContent);
+          await addMessage(conversationId, "assistant", baseName, assistantContent);
           const textParts = assistantContent.filter((b) => b.type === "text").map((b) => b.text);
           if (textParts.length > 0) {
-            const db3 = await getDb();
-            await db3.insert(agentMessages).values({
-              agent: name,
+            await db2.insert(agentMessages).values({
+              agent: baseName,
               channel: "web",
               role: "assistant",
               content: textParts.join("")
@@ -1272,12 +1196,13 @@ var chat_default = app3;
 
 // src/web/routes/connectors.ts
 import { Hono as Hono4 } from "hono";
+var CONNECTOR_TYPE_RE = /^[a-z][a-z0-9-]*$/;
 var app4 = new Hono4().get("/:name/connectors", (c) => {
   const name = c.req.param("name");
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const config = readVoluteConfig(dir);
+  const config = readVoluteConfig(dir) ?? {};
   const configured = config.connectors ?? [];
   const manager = getConnectorManager();
   const runningStatus = manager.getConnectorStatus(name);
@@ -1286,13 +1211,16 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
     return { type, running: status?.running ?? false };
   });
   return c.json(connectors);
-}).post("/:name/connectors/:type", async (c) => {
+}).post("/:name/connectors/:type", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const type = c.req.param("type");
+  if (!CONNECTOR_TYPE_RE.test(type)) {
+    return c.json({ error: "Invalid connector type" }, 400);
+  }
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const config = readVoluteConfig(dir);
+  const config = readVoluteConfig(dir) ?? {};
   const connectors = config.connectors ?? [];
   if (!connectors.includes(type)) {
     config.connectors = [...connectors, type];
@@ -1308,15 +1236,18 @@ var app4 = new Hono4().get("/:name/connectors", (c) => {
       500
     );
   }
-}).delete("/:name/connectors/:type", async (c) => {
+}).delete("/:name/connectors/:type", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const type = c.req.param("type");
+  if (!CONNECTOR_TYPE_RE.test(type)) {
+    return c.json({ error: "Invalid connector type" }, 400);
+  }
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
   const manager = getConnectorManager();
   await manager.stopConnector(name, type);
-  const config = readVoluteConfig(dir);
+  const config = readVoluteConfig(dir) ?? {};
   config.connectors = (config.connectors ?? []).filter((t) => t !== type);
   writeVoluteConfig(dir, config);
   return c.json({ ok: true });
@@ -1332,17 +1263,22 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
   return c.json(convs);
 }).get("/:name/conversations/:id/messages", async (c) => {
   const id = c.req.param("id");
+  const user = c.get("user");
+  const conv = await getConversationForUser(id, user.id);
+  if (!conv) return c.json({ error: "Conversation not found" }, 404);
   const msgs = await getMessages(id);
   return c.json(msgs);
 }).delete("/:name/conversations/:id", async (c) => {
   const id = c.req.param("id");
-  await deleteConversation(id);
+  const user = c.get("user");
+  const deleted = await deleteConversationForUser(id, user.id);
+  if (!deleted) return c.json({ error: "Conversation not found" }, 404);
   return c.json({ ok: true });
 });
 var conversations_default = app5;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readdir, readFile, writeFile } from "fs/promises";
 import { resolve as resolve5 } from "path";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
@@ -1356,7 +1292,7 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
   const homeDir = resolve5(dir, "home");
-  if (!existsSync6(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
   const allFiles = await readdir(homeDir);
   const files = allFiles.filter((f) => f.endsWith(".md") && ALLOWED_FILES.has(f));
   return c.json(files);
@@ -1370,7 +1306,7 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
   const filePath = resolve5(dir, "home", filename);
-  if (!existsSync6(filePath)) {
+  if (!existsSync5(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1392,8 +1328,8 @@ var app6 = new Hono6().get("/:name/files", async (c) => {
 var files_default = app6;
 
 // src/web/routes/logs.ts
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve6 } from "path";
 import { Hono as Hono7 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
@@ -1403,11 +1339,11 @@ var app7 = new Hono7().get("/:name/logs", async (c) => {
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
   const logFile = resolve6(dir, ".volute", "logs", "agent.log");
-  if (!existsSync7(logFile)) {
+  if (!existsSync6(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream2) => {
-    const tail = spawn3("tail", ["-n", "200", "-f", logFile]);
+    const tail = spawn2("tail", ["-n", "200", "-f", logFile]);
     const onData = (data) => {
       const lines = data.toString().split("\n");
       for (const line of lines) {
@@ -1432,11 +1368,11 @@ var logs_default = app7;
 // src/web/routes/schedules.ts
 import { Hono as Hono8 } from "hono";
 function readSchedules(name) {
-  return readVoluteConfig(agentDir(name)).schedules ?? [];
+  return readVoluteConfig(agentDir(name))?.schedules ?? [];
 }
 function writeSchedules(name, schedules) {
   const dir = agentDir(name);
-  const config = readVoluteConfig(dir);
+  const config = readVoluteConfig(dir) ?? {};
   config.schedules = schedules.length > 0 ? schedules : void 0;
   writeVoluteConfig(dir, config);
   getScheduler().loadSchedules(name);
@@ -1445,7 +1381,7 @@ var app8 = new Hono8().get("/:name/schedules", (c) => {
   const name = c.req.param("name");
   if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
   return c.json(readSchedules(name));
-}).post("/:name/schedules", async (c) => {
+}).post("/:name/schedules", requireAdmin, async (c) => {
   const name = c.req.param("name");
   if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
   const body = await c.req.json();
@@ -1460,7 +1396,7 @@ var app8 = new Hono8().get("/:name/schedules", (c) => {
   schedules.push({ id, cron: body.cron, message: body.message, enabled: body.enabled ?? true });
   writeSchedules(name, schedules);
   return c.json({ ok: true, id }, 201);
-}).put("/:name/schedules/:id", async (c) => {
+}).put("/:name/schedules/:id", requireAdmin, async (c) => {
   const name = c.req.param("name");
   const id = c.req.param("id");
   if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
@@ -1473,7 +1409,7 @@ var app8 = new Hono8().get("/:name/schedules", (c) => {
   if (body.enabled !== void 0) schedules[idx].enabled = body.enabled;
   writeSchedules(name, schedules);
   return c.json({ ok: true });
-}).delete("/:name/schedules/:id", (c) => {
+}).delete("/:name/schedules/:id", requireAdmin, (c) => {
   const name = c.req.param("name");
   const id = c.req.param("id");
   if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
@@ -1583,6 +1519,7 @@ app11.use("*", async (c, next) => {
 app11.get("/api/health", (c) => {
   return c.json({ ok: true, version: "0.1.0" });
 });
+app11.use("/api/*", bodyLimit({ maxSize: 10 * 1024 * 1024 }));
 app11.use("/api/*", csrf());
 app11.use("/api/agents/*", authMiddleware);
 app11.use("/api/system/*", authMiddleware);
@@ -1599,16 +1536,19 @@ var MIME_TYPES = {
   ".png": "image/png",
   ".ico": "image/x-icon"
 };
-async function startServer({ port }) {
+async function startServer({
+  port,
+  hostname = "127.0.0.1"
+}) {
   let assetsDir = "";
-  let searchDir = dirname3(new URL(import.meta.url).pathname);
+  let searchDir = dirname4(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
     const candidate = resolve7(searchDir, "dist", "web-assets");
-    if (existsSync8(candidate)) {
+    if (existsSync7(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname3(searchDir);
+    searchDir = dirname4(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
@@ -1631,10 +1571,10 @@ async function startServer({ port }) {
       return c.text("Not found", 404);
     });
   }
-  const server = serve({ fetch: app_default.fetch, port });
+  const server = serve({ fetch: app_default.fetch, port, hostname });
   await new Promise((resolve9, reject) => {
     server.on("listening", () => {
-      logger_default.info("Volute UI running", { port });
+      logger_default.info("Volute UI running", { hostname, port });
       resolve9();
     });
     server.on("error", (err) => {
@@ -1645,17 +1585,18 @@ async function startServer({ port }) {
 }
 
 // src/daemon.ts
-var DAEMON_PID_PATH = resolve8(VOLUTE_HOME, "daemon.pid");
-var DAEMON_JSON_PATH = resolve8(VOLUTE_HOME, "daemon.json");
 async function startDaemon(opts) {
-  const { port } = opts;
+  const { port, hostname } = opts;
   const myPid = String(process.pid);
-  mkdirSync3(VOLUTE_HOME, { recursive: true });
+  const home = voluteHome();
+  const DAEMON_PID_PATH = resolve8(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve8(home, "daemon.json");
+  mkdirSync3(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
   let server;
   try {
-    server = await startServer({ port });
+    server = await startServer({ port, hostname });
   } catch (err) {
     const e = err;
     if (e.code === "EADDRINUSE") {
@@ -1664,36 +1605,49 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync3(DAEMON_PID_PATH, myPid);
+  writeFileSync3(DAEMON_PID_PATH, myPid, { mode: 384 });
   writeFileSync3(DAEMON_JSON_PATH, `${JSON.stringify({ port, token }, null, 2)}
-`);
+`, { mode: 384 });
   const manager = initAgentManager();
   const connectors = initConnectorManager();
   const scheduler = getScheduler();
-  scheduler.start();
+  scheduler.start(port, token);
   const registry = readRegistry();
   for (const entry of registry) {
     if (!entry.running) continue;
     try {
       await manager.startAgent(entry.name);
       const dir = agentDir(entry.name);
-      await connectors.startConnectors(entry.name, dir, entry.port);
+      await connectors.startConnectors(entry.name, dir, entry.port, port);
       scheduler.loadSchedules(entry.name);
     } catch (err) {
       console.error(`[daemon] failed to start agent ${entry.name}:`, err);
       setAgentRunning(entry.name, false);
     }
   }
-  console.error(`[daemon] running on port ${port}, pid ${myPid}`);
+  const runningVariants = getAllRunningVariants();
+  for (const { agentName, variant } of runningVariants) {
+    const compositeKey = `${agentName}@${variant.name}`;
+    try {
+      await manager.startAgent(compositeKey);
+    } catch (err) {
+      console.error(`[daemon] failed to start variant ${compositeKey}:`, err);
+      setVariantRunning(agentName, variant.name, false);
+    }
+  }
+  console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
       if (readFileSync4(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
-        unlinkSync3(DAEMON_PID_PATH);
+        unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      unlinkSync3(DAEMON_JSON_PATH);
+      const data = JSON.parse(readFileSync4(DAEMON_JSON_PATH, "utf-8"));
+      if (data.token === token) {
+        unlinkSync2(DAEMON_JSON_PATH);
+      }
     } catch {
     }
   }
@@ -1715,16 +1669,20 @@ async function startDaemon(opts) {
 }
 if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("daemon.ts")) {
   let port = 4200;
+  let hostname = "127.0.0.1";
   let foreground = false;
   for (let i = 2; i < process.argv.length; i++) {
     if (process.argv[i] === "--port" && process.argv[i + 1]) {
       port = parseInt(process.argv[i + 1], 10);
       i++;
+    } else if (process.argv[i] === "--host" && process.argv[i + 1]) {
+      hostname = process.argv[i + 1];
+      i++;
     } else if (process.argv[i] === "--foreground") {
       foreground = true;
     }
   }
-  startDaemon({ port, foreground });
+  startDaemon({ port, hostname, foreground });
 }
 export {
   startDaemon