volute 0.1.0

package/dist/daemon.js

@@ -0,0 +1,1731 @@
+#!/usr/bin/env node
+import {
+  logBuffer,
+  logger_default,
+  readNdjson
+} from "./chunk-KSMIWOCN.js";
+import {
+  loadMergedEnv
+} from "./chunk-A5ZJEMHT.js";
+import {
+  VOLUTE_HOME,
+  __export,
+  agentDir,
+  checkHealth,
+  findAgent,
+  readRegistry,
+  readVariants,
+  removeAgent,
+  removeAllVariants,
+  setAgentRunning
+} from "./chunk-5YW4B7CG.js";
+
+// src/daemon.ts
+import { randomBytes } from "crypto";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync3, 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 {
+  createWriteStream as createWriteStream2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir } from "os";
+import { dirname, resolve as resolve3 } from "path";
+
+// src/lib/volute-config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+function readVoluteConfig(agentDir2) {
+  const path = resolve2(agentDir2, "volute.json");
+  if (!existsSync2(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeVoluteConfig(agentDir2, config) {
+  const path = resolve2(agentDir2, "volute.json");
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+
+// src/lib/connector-manager.ts
+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);
+    const types = config.connectors ?? [];
+    for (const type of types) {
+      try {
+        await this.startConnector(agentName, agentDir2, agentPort, type);
+      } catch (err) {
+        console.error(`[daemon] failed to start connector ${type} for ${agentName}:`, err);
+      }
+    }
+  }
+  async startConnector(agentName, agentDir2, agentPort, type) {
+    const existing = this.connectors.get(agentName)?.get(type);
+    if (existing) {
+      await new Promise((res) => {
+        existing.child.on("exit", () => res());
+        try {
+          existing.child.kill("SIGTERM");
+        } catch {
+          res();
+        }
+        setTimeout(() => {
+          try {
+            existing.child.kill("SIGKILL");
+          } catch {
+          }
+          res();
+        }, 3e3);
+      });
+      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 builtinConnector = this.resolveBuiltinConnector(type);
+    let connectorScript;
+    let runtime;
+    if (existsSync3(agentConnector)) {
+      connectorScript = agentConnector;
+      runtime = resolve3(agentDir2, "node_modules", ".bin", "tsx");
+    } else if (existsSync3(userConnector)) {
+      connectorScript = userConnector;
+      runtime = this.resolveVoluteTsx();
+    } else if (builtinConnector && existsSync3(builtinConnector)) {
+      connectorScript = builtinConnector;
+      runtime = process.execPath;
+    } else {
+      throw new Error(`No connector code found for type: ${type}`);
+    }
+    const logsDir = resolve3(agentDir2, ".volute", "logs");
+    mkdirSync2(logsDir, { recursive: true });
+    const logStream = createWriteStream2(resolve3(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], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        VOLUTE_AGENT_PORT: String(agentPort),
+        VOLUTE_AGENT_NAME: agentName,
+        ...connectorEnv
+      }
+    });
+    child.stdout?.pipe(logStream);
+    child.stderr?.pipe(logStream);
+    if (child.pid) {
+      this.saveConnectorPid(agentDir2, type, child.pid);
+    }
+    if (!this.connectors.has(agentName)) {
+      this.connectors.set(agentName, /* @__PURE__ */ new Map());
+    }
+    this.connectors.get(agentName).set(type, { child, type });
+    const stopKey = `${agentName}:${type}`;
+    child.on("exit", (code) => {
+      const agentMap = this.connectors.get(agentName);
+      if (agentMap?.get(type)?.child === child) {
+        agentMap.delete(type);
+      }
+      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`);
+      setTimeout(() => {
+        if (this.shuttingDown || this.stopping.has(stopKey)) return;
+        this.startConnector(agentName, agentDir2, agentPort, type).catch((err) => {
+          console.error(`[daemon] failed to restart connector ${type} for ${agentName}:`, err);
+        });
+      }, 3e3);
+    });
+    console.error(`[daemon] started connector ${type} for ${agentName}`);
+  }
+  async stopConnector(agentName, type) {
+    const agentMap = this.connectors.get(agentName);
+    if (!agentMap) return;
+    const tracked = agentMap.get(type);
+    if (!tracked) return;
+    const stopKey = `${agentName}:${type}`;
+    this.stopping.add(stopKey);
+    agentMap.delete(type);
+    await new Promise((resolve9) => {
+      tracked.child.on("exit", () => resolve9());
+      try {
+        tracked.child.kill("SIGTERM");
+      } catch {
+        resolve9();
+      }
+      setTimeout(() => {
+        try {
+          tracked.child.kill("SIGKILL");
+        } catch {
+        }
+        resolve9();
+      }, 5e3);
+    });
+    this.stopping.delete(stopKey);
+    try {
+      this.removeConnectorPid(agentDir(agentName), type);
+    } catch {
+    }
+    console.error(`[daemon] stopped connector ${type} for ${agentName}`);
+  }
+  async stopConnectors(agentName) {
+    const agentMap = this.connectors.get(agentName);
+    if (!agentMap) return;
+    const types = [...agentMap.keys()];
+    await Promise.all(types.map((type) => this.stopConnector(agentName, type)));
+    this.connectors.delete(agentName);
+  }
+  async stopAll() {
+    this.shuttingDown = true;
+    const agents = [...this.connectors.keys()];
+    await Promise.all(agents.map((name) => this.stopConnectors(name)));
+  }
+  getConnectorStatus(agentName) {
+    const agentMap = this.connectors.get(agentName);
+    if (!agentMap) return [];
+    return [...agentMap.entries()].map(([type, tracked]) => ({
+      type,
+      running: !tracked.child.killed
+    }));
+  }
+  connectorPidPath(agentDir2, type) {
+    return resolve3(agentDir2, ".volute", "connectors", `${type}.pid`);
+  }
+  saveConnectorPid(agentDir2, type, pid) {
+    const pidPath = this.connectorPidPath(agentDir2, type);
+    mkdirSync2(dirname(pidPath), { recursive: true });
+    writeFileSync2(pidPath, String(pid));
+  }
+  removeConnectorPid(agentDir2, type) {
+    try {
+      unlinkSync2(this.connectorPidPath(agentDir2, type));
+    } catch {
+    }
+  }
+  killOrphanConnector(agentDir2, type) {
+    const pidPath = this.connectorPidPath(agentDir2, type);
+    if (!existsSync3(pidPath)) return;
+    try {
+      const pid = parseInt(readFileSync3(pidPath, "utf-8").trim(), 10);
+      if (pid > 0) {
+        process.kill(pid, "SIGTERM");
+        console.error(`[daemon] killed orphan connector ${type} (pid ${pid})`);
+      }
+    } catch {
+    }
+    try {
+      unlinkSync2(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;
+  }
+  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";
+  }
+};
+var instance2 = null;
+function initConnectorManager() {
+  if (instance2) throw new Error("ConnectorManager already initialized");
+  instance2 = new ConnectorManager();
+  return instance2;
+}
+function getConnectorManager() {
+  if (!instance2) instance2 = new ConnectorManager();
+  return instance2;
+}
+
+// src/lib/scheduler.ts
+import { CronExpressionParser } from "cron-parser";
+var Scheduler = class {
+  schedules = /* @__PURE__ */ new Map();
+  interval = null;
+  lastFired = /* @__PURE__ */ new Map();
+  // "agent:scheduleId" → epoch minute
+  start() {
+    this.interval = setInterval(() => this.tick(), 6e4);
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+  }
+  loadSchedules(agentName) {
+    const dir = agentDir(agentName);
+    const config = readVoluteConfig(dir);
+    const schedules = config.schedules ?? [];
+    if (schedules.length > 0) {
+      this.schedules.set(agentName, schedules);
+    } else {
+      this.schedules.delete(agentName);
+    }
+  }
+  unloadSchedules(agentName) {
+    this.schedules.delete(agentName);
+  }
+  tick() {
+    const now = /* @__PURE__ */ new Date();
+    for (const [agent, schedules] of this.schedules) {
+      for (const schedule of schedules) {
+        if (!schedule.enabled) continue;
+        if (this.shouldFire(schedule, now, agent)) {
+          this.fire(agent, schedule);
+        }
+      }
+    }
+  }
+  shouldFire(schedule, now, agent) {
+    try {
+      const interval = CronExpressionParser.parse(schedule.cron);
+      const prev = interval.prev().toDate();
+      const epochMinute = Math.floor(now.getTime() / 6e4);
+      const key = `${agent}:${schedule.id}`;
+      if (this.lastFired.get(key) === epochMinute) return false;
+      const prevMinute = Math.floor(prev.getTime() / 6e4);
+      if (prevMinute === epochMinute) {
+        this.lastFired.set(key, epochMinute);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async fire(agentName, schedule) {
+    const entry = findAgent(agentName);
+    if (!entry) return;
+    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}`);
+    } catch (err) {
+      console.error(`[scheduler] failed to fire "${schedule.id}" for ${agentName}:`, err);
+    }
+  }
+};
+var instance3 = null;
+function getScheduler() {
+  if (!instance3) instance3 = new Scheduler();
+  return instance3;
+}
+
+// src/web/server.ts
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile2, stat } from "fs/promises";
+import { dirname as dirname3, extname, resolve as resolve7 } from "path";
+import { serve } from "@hono/node-server";
+
+// src/web/app.ts
+import { Hono as Hono11 } from "hono";
+import { csrf } from "hono/csrf";
+import { HTTPException } from "hono/http-exception";
+
+// src/web/middleware/auth.ts
+import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
+
+// src/lib/auth.ts
+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 { fileURLToPath } from "url";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+
+// src/lib/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  agentMessages: () => agentMessages,
+  conversations: () => conversations,
+  messages: () => messages,
+  users: () => users
+});
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  username: text("username").unique().notNull(),
+  password_hash: text("password_hash").notNull(),
+  role: text("role").notNull().default("pending"),
+  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+var conversations = sqliteTable(
+  "conversations",
+  {
+    id: text("id").primaryKey(),
+    agent_name: text("agent_name").notNull(),
+    channel: text("channel").notNull(),
+    user_id: integer("user_id").references(() => users.id),
+    title: text("title"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
+    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_conversations_agent_name").on(table.agent_name),
+    index("idx_conversations_user_id").on(table.user_id),
+    index("idx_conversations_updated_at").on(table.updated_at)
+  ]
+);
+var agentMessages = sqliteTable(
+  "agent_messages",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    agent: text("agent").notNull(),
+    channel: text("channel").notNull(),
+    role: text("role").notNull(),
+    sender: text("sender"),
+    content: text("content").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_agent_messages_agent").on(table.agent),
+    index("idx_agent_messages_channel").on(table.agent, table.channel)
+  ]
+);
+var messages = sqliteTable(
+  "messages",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    role: text("role").notNull(),
+    sender_name: text("sender_name"),
+    content: text("content").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
+);
+
+// src/lib/db.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var migrationsFolder = existsSync4(resolve4(__dirname, "../drizzle")) ? resolve4(__dirname, "../drizzle") : resolve4(__dirname, "../../drizzle");
+var db = null;
+async function getDb() {
+  if (db) return db;
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve4(VOLUTE_HOME, "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;
+  }
+  return db;
+}
+
+// src/lib/auth.ts
+async function createUser(username, password) {
+  const db2 = await getDb();
+  const hash = hashSync(password, 10);
+  const [{ value }] = await db2.select({ value: count() }).from(users);
+  const role = value === 0 ? "admin" : "pending";
+  const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    created_at: users.created_at
+  });
+  return result;
+}
+async function verifyUser(username, password) {
+  const db2 = await getDb();
+  const row = await db2.select().from(users).where(eq(users.username, username)).get();
+  if (!row) return null;
+  if (!compareSync(password, row.password_hash)) return null;
+  const { password_hash: _, ...user } = row;
+  return user;
+}
+async function getUser(id) {
+  const db2 = await getDb();
+  const row = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    created_at: users.created_at
+  }).from(users).where(eq(users.id, id)).get();
+  return row ?? null;
+}
+async function getUserByUsername(username) {
+  const db2 = await getDb();
+  const row = await db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    created_at: users.created_at
+  }).from(users).where(eq(users.username, username)).get();
+  return row ?? null;
+}
+async function listUsers() {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    created_at: users.created_at
+  }).from(users).orderBy(users.created_at).all();
+}
+async function listPendingUsers() {
+  const db2 = await getDb();
+  return db2.select({
+    id: users.id,
+    username: users.username,
+    role: users.role,
+    created_at: users.created_at
+  }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
+}
+async function approveUser(id) {
+  const db2 = await getDb();
+  await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+}
+
+// src/web/middleware/auth.ts
+var SESSION_MAX_AGE = 864e5;
+var sessions = /* @__PURE__ */ new Map();
+function createSession(userId) {
+  const sessionId = crypto.randomUUID();
+  sessions.set(sessionId, { userId, createdAt: Date.now() });
+  return sessionId;
+}
+function deleteSession(sessionId) {
+  sessions.delete(sessionId);
+}
+function getSessionUserId(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) return void 0;
+  if (Date.now() - session.createdAt > SESSION_MAX_AGE) {
+    sessions.delete(sessionId);
+    return void 0;
+  }
+  return session.userId;
+}
+var authMiddleware = createMiddleware(async (c, next) => {
+  const authHeader = c.req.header("Authorization");
+  if (authHeader?.startsWith("Bearer ")) {
+    const token = authHeader.slice(7);
+    if (token && token === process.env.VOLUTE_DAEMON_TOKEN) {
+      c.set("user", { id: 0, username: "cli", role: "admin" });
+      await next();
+      return;
+    }
+  }
+  const sessionId = getCookie(c, "volute_session");
+  if (!sessionId) return c.json({ error: "Unauthorized" }, 401);
+  const userId = getSessionUserId(sessionId);
+  if (userId == null) return c.json({ error: "Unauthorized" }, 401);
+  const user = await getUser(userId);
+  if (!user) return c.json({ error: "Unauthorized" }, 401);
+  if (user.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+  c.set("user", user);
+  await next();
+});
+
+// src/web/routes/agents.ts
+import { existsSync as existsSync5, rmSync } from "fs";
+import { and as and2, desc, eq as eq2 } from "drizzle-orm";
+import { Hono } from "hono";
+import { stream } from "hono/streaming";
+
+// src/lib/channels.ts
+var CHANNELS = {
+  web: { name: "web", displayName: "Web UI", showToolCalls: true },
+  discord: { name: "discord", displayName: "Discord", showToolCalls: false },
+  cli: { name: "cli", displayName: "CLI", showToolCalls: true },
+  system: { name: "system", displayName: "System", showToolCalls: false }
+};
+
+// src/web/routes/agents.ts
+async function getAgentStatus(name, _dir, port) {
+  const manager = getAgentManager();
+  let status = "stopped";
+  if (manager.isRunning(name)) {
+    const health = await checkHealth(port);
+    status = health.ok ? "running" : "starting";
+  }
+  const channels = [];
+  channels.push({
+    name: CHANNELS.web.name,
+    displayName: CHANNELS.web.displayName,
+    status: status === "running" ? "connected" : "disconnected",
+    showToolCalls: CHANNELS.web.showToolCalls
+  });
+  const connectorManager = getConnectorManager();
+  const connectorStatuses = connectorManager.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
+      });
+    }
+  }
+  return { status, channels };
+}
+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);
+      return { ...entry, status, channels };
+    })
+  );
+  return c.json(agents);
+}).get("/:name", 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) => {
+  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 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);
+    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) => {
+  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 manager = getAgentManager();
+  const connectorManager = getConnectorManager();
+  try {
+    if (manager.isRunning(name)) {
+      await connectorManager.stopConnectors(name);
+      await manager.stopAgent(name);
+    }
+    await manager.startAgent(name);
+    setAgentRunning(name, true);
+    await connectorManager.startConnectors(name, dir, entry.port);
+    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) => {
+  const name = c.req.param("name");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const manager = getAgentManager();
+  if (!manager.isRunning(name)) {
+    return c.json({ error: "Agent is not running" }, 409);
+  }
+  try {
+    await getConnectorManager().stopConnectors(name);
+    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) => {
+  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 force = c.req.query("force") === "true";
+  const manager = getAgentManager();
+  if (manager.isRunning(name)) {
+    await getConnectorManager().stopConnectors(name);
+    await manager.stopAgent(name);
+  }
+  removeAllVariants(name);
+  removeAgent(name);
+  if (force && existsSync5(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);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const manager = getAgentManager();
+  if (!manager.isRunning(name)) {
+    return c.json({ error: "Agent is not running" }, 409);
+  }
+  const body = await c.req.text();
+  const db2 = await getDb();
+  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
+    });
+  } catch {
+  }
+  const res = await fetch(`http://localhost:${entry.port}/message`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  });
+  if (!res.ok) {
+    return c.json({ error: `Agent responded with ${res.status}` }, res.status);
+  }
+  if (!res.body) {
+    return c.json({ error: "No response body from agent" }, 502);
+  }
+  c.header("Content-Type", "application/x-ndjson");
+  return stream(c, async (s) => {
+    const reader = res.body.getReader();
+    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;
+        await s.write(value);
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "text") {
+              textParts.push(event.content);
+            }
+          } catch {
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          const event = JSON.parse(buffer);
+          if (event.type === "text") {
+            textParts.push(event.content);
+          }
+        } catch {
+        }
+      }
+      if (textParts.length > 0) {
+        const db3 = await getDb();
+        await db3.insert(agentMessages).values({
+          agent: name,
+          channel,
+          role: "assistant",
+          content: textParts.join("")
+        });
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+}).get("/:name/history", async (c) => {
+  const name = c.req.param("name");
+  const channel = c.req.query("channel");
+  const limit = parseInt(c.req.query("limit") ?? "50", 10);
+  const offset = parseInt(c.req.query("offset") ?? "0", 10);
+  const db2 = await getDb();
+  const conditions = [eq2(agentMessages.agent, name)];
+  if (channel) {
+    conditions.push(eq2(agentMessages.channel, channel));
+  }
+  const rows = await db2.select().from(agentMessages).where(and2(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
+  return c.json(rows);
+});
+var agents_default = app;
+
+// src/web/routes/auth.ts
+import { zValidator } from "@hono/zod-validator";
+import { Hono as Hono2 } from "hono";
+import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
+import { z } from "zod";
+var credentialsSchema = z.object({
+  username: z.string().min(1),
+  password: z.string().min(1)
+});
+var admin = new Hono2().use(authMiddleware).get("/users", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  return c.json(await listUsers());
+}).get("/users/pending", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  return c.json(await listPendingUsers());
+}).post("/users/:id/approve", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  const id = parseInt(c.req.param("id"), 10);
+  await approveUser(id);
+  return c.json({ ok: true });
+});
+var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema), async (c) => {
+  const { username, password } = c.req.valid("json");
+  const existing = await getUserByUsername(username);
+  if (existing) {
+    return c.json({ error: "Username already taken" }, 409);
+  }
+  const user = await createUser(username, password);
+  if (user.role === "admin") {
+    const sessionId = createSession(user.id);
+    setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  }
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).post("/login", zValidator("json", credentialsSchema), async (c) => {
+  const { username, password } = c.req.valid("json");
+  const user = await verifyUser(username, password);
+  if (!user) {
+    return c.json({ error: "Invalid credentials" }, 401);
+  }
+  const sessionId = createSession(user.id);
+  setCookie(c, "volute_session", sessionId, { path: "/", httpOnly: true, sameSite: "Lax" });
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).post("/logout", (c) => {
+  const sessionId = getCookie2(c, "volute_session");
+  if (sessionId) {
+    deleteSession(sessionId);
+    deleteCookie(c, "volute_session", { path: "/" });
+  }
+  return c.json({ ok: true });
+}).get("/me", async (c) => {
+  const sessionId = getCookie2(c, "volute_session");
+  if (!sessionId) return c.json({ error: "Not logged in" }, 401);
+  const userId = getSessionUserId(sessionId);
+  if (userId == null) return c.json({ error: "Not logged in" }, 401);
+  const user = await getUser(userId);
+  if (!user) return c.json({ error: "Not logged in" }, 401);
+  return c.json({ id: user.id, username: user.username, role: user.role });
+}).route("/", admin);
+var auth_default = app2;
+
+// src/web/routes/chat.ts
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { Hono as Hono3 } from "hono";
+import { streamSSE } from "hono/streaming";
+import { z as z2 } from "zod";
+
+// src/lib/conversations.ts
+import { randomUUID } from "crypto";
+import { and as and3, desc as desc2, eq as eq3, isNull, sql as sql2 } from "drizzle-orm";
+async function createConversation(agentName, channel, opts) {
+  const db2 = await getDb();
+  const id = randomUUID();
+  await db2.insert(conversations).values({
+    id,
+    agent_name: agentName,
+    channel,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null
+  });
+  return {
+    id,
+    agent_name: agentName,
+    channel,
+    user_id: opts?.userId ?? null,
+    title: opts?.title ?? null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getConversation(id) {
+  const db2 = await getDb();
+  const row = await db2.select().from(conversations).where(eq3(conversations.id, id)).get();
+  return row ?? null;
+}
+async function listConversations(agentName, opts) {
+  const db2 = await getDb();
+  if (opts?.userId != null) {
+    return db2.select().from(conversations).where(and3(eq3(conversations.agent_name, agentName), eq3(conversations.user_id, opts.userId))).orderBy(desc2(conversations.updated_at)).all();
+  }
+  return db2.select().from(conversations).where(eq3(conversations.agent_name, agentName)).orderBy(desc2(conversations.updated_at)).all();
+}
+async function addMessage(conversationId, role, senderName, content) {
+  const db2 = await getDb();
+  const serialized = JSON.stringify(content);
+  const [result] = await db2.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db2.update(conversations).set({ updated_at: sql2`datetime('now')` }).where(eq3(conversations.id, conversationId));
+  if (role === "user") {
+    const firstText = content.find((b) => b.type === "text");
+    const title = firstText ? firstText.text.slice(0, 80) : "";
+    if (title) {
+      await db2.update(conversations).set({ title }).where(and3(eq3(conversations.id, conversationId), isNull(conversations.title)));
+    }
+  }
+  return {
+    id: result.id,
+    conversation_id: conversationId,
+    role,
+    sender_name: senderName,
+    content,
+    created_at: result.created_at
+  };
+}
+async function getMessages(conversationId) {
+  const db2 = await getDb();
+  const rows = await db2.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  return rows.map((row) => {
+    let content;
+    try {
+      const parsed = JSON.parse(row.content);
+      content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
+    } catch {
+      content = [{ type: "text", text: row.content }];
+    }
+    return { ...row, content };
+  });
+}
+async function deleteConversation(id) {
+  const db2 = await getDb();
+  await db2.delete(conversations).where(eq3(conversations.id, id));
+}
+
+// src/web/routes/chat.ts
+var chatSchema = z2.object({
+  message: z2.string().optional(),
+  conversationId: z2.string().optional(),
+  images: z2.array(
+    z2.object({
+      media_type: z2.string(),
+      data: z2.string()
+    })
+  ).optional()
+});
+var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), async (c) => {
+  const name = c.req.param("name");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const body = c.req.valid("json");
+  if (!body.message && (!body.images || body.images.length === 0)) {
+    return c.json({ error: "message or images required" }, 400);
+  }
+  const user = c.get("user");
+  let conversationId = body.conversationId;
+  if (conversationId) {
+    const conv = await getConversation(conversationId);
+    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", {
+      userId: user.id,
+      title
+    });
+    conversationId = conv.id;
+  }
+  const userContent = [];
+  if (body.message) {
+    userContent.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 });
+    }
+  }
+  await addMessage(conversationId, "user", user.username, userContent);
+  const userText = body.message ?? "[image]";
+  const db2 = await getDb();
+  await db2.insert(agentMessages).values({
+    agent: name,
+    channel: "web",
+    role: "user",
+    sender: user.username,
+    content: userText
+  });
+  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`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      content: agentContent,
+      channel: "web",
+      sender: user.username
+    })
+  });
+  if (!res.ok) {
+    return c.json({ error: `Agent responded with ${res.status}` }, res.status);
+  }
+  if (!res.body) {
+    return c.json({ error: "No response body from agent" }, 502);
+  }
+  return streamSSE(c, async (stream2) => {
+    await stream2.writeSSE({
+      data: JSON.stringify({ type: "meta", conversationId })
+    });
+    const assistantContent = [];
+    for await (const event of readNdjson(res.body)) {
+      const voluteEvent = event;
+      await stream2.writeSSE({ data: JSON.stringify(voluteEvent) });
+      if (voluteEvent.type === "text") {
+        const last = assistantContent[assistantContent.length - 1];
+        if (last && last.type === "text") {
+          last.text += voluteEvent.content;
+        } else {
+          assistantContent.push({ type: "text", text: voluteEvent.content });
+        }
+      } else if (voluteEvent.type === "tool_use") {
+        assistantContent.push({
+          type: "tool_use",
+          name: voluteEvent.name,
+          input: voluteEvent.input
+        });
+      } else if (voluteEvent.type === "tool_result") {
+        assistantContent.push({
+          type: "tool_result",
+          output: voluteEvent.output,
+          ...voluteEvent.is_error ? { is_error: true } : {}
+        });
+      }
+      if (voluteEvent.type === "done") {
+        if (assistantContent.length > 0) {
+          await addMessage(conversationId, "assistant", name, 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,
+              channel: "web",
+              role: "assistant",
+              content: textParts.join("")
+            });
+          }
+        }
+        break;
+      }
+    }
+  });
+});
+var chat_default = app3;
+
+// src/web/routes/connectors.ts
+import { Hono as Hono4 } from "hono";
+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 configured = config.connectors ?? [];
+  const manager = getConnectorManager();
+  const runningStatus = manager.getConnectorStatus(name);
+  const connectors = configured.map((type) => {
+    const status = runningStatus.find((s) => s.type === type);
+    return { type, running: status?.running ?? false };
+  });
+  return c.json(connectors);
+}).post("/:name/connectors/:type", async (c) => {
+  const name = c.req.param("name");
+  const type = c.req.param("type");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const dir = agentDir(name);
+  const config = readVoluteConfig(dir);
+  const connectors = config.connectors ?? [];
+  if (!connectors.includes(type)) {
+    config.connectors = [...connectors, type];
+    writeVoluteConfig(dir, config);
+  }
+  const manager = getConnectorManager();
+  try {
+    await manager.startConnector(name, dir, entry.port, type);
+    return c.json({ ok: true });
+  } catch (err) {
+    return c.json(
+      { error: err instanceof Error ? err.message : "Failed to start connector" },
+      500
+    );
+  }
+}).delete("/:name/connectors/:type", async (c) => {
+  const name = c.req.param("name");
+  const type = c.req.param("type");
+  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);
+  config.connectors = (config.connectors ?? []).filter((t) => t !== type);
+  writeVoluteConfig(dir, config);
+  return c.json({ ok: true });
+});
+var connectors_default = app4;
+
+// src/web/routes/conversations.ts
+import { Hono as Hono5 } from "hono";
+var app5 = new Hono5().get("/:name/conversations", async (c) => {
+  const name = c.req.param("name");
+  const user = c.get("user");
+  const convs = await listConversations(name, { userId: user.id });
+  return c.json(convs);
+}).get("/:name/conversations/:id/messages", async (c) => {
+  const id = c.req.param("id");
+  const msgs = await getMessages(id);
+  return c.json(msgs);
+}).delete("/:name/conversations/:id", async (c) => {
+  const id = c.req.param("id");
+  await deleteConversation(id);
+  return c.json({ ok: true });
+});
+var conversations_default = app5;
+
+// src/web/routes/files.ts
+import { existsSync as existsSync6 } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { Hono as Hono6 } from "hono";
+import { z as z3 } from "zod";
+var ALLOWED_FILES = /* @__PURE__ */ new Set(["SOUL.md", "MEMORY.md", "CLAUDE.md", "VOLUTE.md"]);
+var saveFileSchema = z3.object({ content: z3.string() });
+var app6 = new Hono6().get("/:name/files", 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);
+  const homeDir = resolve5(dir, "home");
+  if (!existsSync6(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);
+}).get("/:name/files/:filename", async (c) => {
+  const name = c.req.param("name");
+  const filename = c.req.param("filename");
+  if (!ALLOWED_FILES.has(filename)) {
+    return c.json({ error: "File not allowed" }, 403);
+  }
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const dir = agentDir(name);
+  const filePath = resolve5(dir, "home", filename);
+  if (!existsSync6(filePath)) {
+    return c.json({ error: "File not found" }, 404);
+  }
+  const content = await readFile(filePath, "utf-8");
+  return c.json({ filename, content });
+}).put("/:name/files/:filename", zValidator3("json", saveFileSchema), async (c) => {
+  const name = c.req.param("name");
+  const filename = c.req.param("filename");
+  if (!ALLOWED_FILES.has(filename)) {
+    return c.json({ error: "File not allowed" }, 403);
+  }
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const dir = agentDir(name);
+  const filePath = resolve5(dir, "home", filename);
+  const { content } = c.req.valid("json");
+  await writeFile(filePath, content);
+  return c.json({ ok: true });
+});
+var files_default = app6;
+
+// src/web/routes/logs.ts
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve6 } from "path";
+import { Hono as Hono7 } from "hono";
+import { streamSSE as streamSSE2 } from "hono/streaming";
+var app7 = new Hono7().get("/:name/logs", 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);
+  const logFile = resolve6(dir, ".volute", "logs", "agent.log");
+  if (!existsSync7(logFile)) {
+    return c.json({ error: "No log file found" }, 404);
+  }
+  return streamSSE2(c, async (stream2) => {
+    const tail = spawn3("tail", ["-n", "200", "-f", logFile]);
+    const onData = (data) => {
+      const lines = data.toString().split("\n");
+      for (const line of lines) {
+        if (line) {
+          stream2.writeSSE({ data: line }).catch(() => {
+          });
+        }
+      }
+    };
+    tail.stdout.on("data", onData);
+    stream2.onAbort(() => {
+      tail.kill();
+    });
+    await new Promise((resolve9) => {
+      tail.on("exit", resolve9);
+      stream2.onAbort(resolve9);
+    });
+  });
+});
+var logs_default = app7;
+
+// src/web/routes/schedules.ts
+import { Hono as Hono8 } from "hono";
+function readSchedules(name) {
+  return readVoluteConfig(agentDir(name)).schedules ?? [];
+}
+function writeSchedules(name, schedules) {
+  const dir = agentDir(name);
+  const config = readVoluteConfig(dir);
+  config.schedules = schedules.length > 0 ? schedules : void 0;
+  writeVoluteConfig(dir, config);
+  getScheduler().loadSchedules(name);
+}
+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) => {
+  const name = c.req.param("name");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  const body = await c.req.json();
+  if (!body.cron || !body.message) {
+    return c.json({ error: "cron and message are required" }, 400);
+  }
+  const schedules = readSchedules(name);
+  const id = body.id || `schedule-${Date.now()}`;
+  if (schedules.some((s) => s.id === id)) {
+    return c.json({ error: `Schedule "${id}" already exists` }, 409);
+  }
+  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) => {
+  const name = c.req.param("name");
+  const id = c.req.param("id");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  const schedules = readSchedules(name);
+  const idx = schedules.findIndex((s) => s.id === id);
+  if (idx === -1) return c.json({ error: "Schedule not found" }, 404);
+  const body = await c.req.json();
+  if (body.cron !== void 0) schedules[idx].cron = body.cron;
+  if (body.message !== void 0) schedules[idx].message = body.message;
+  if (body.enabled !== void 0) schedules[idx].enabled = body.enabled;
+  writeSchedules(name, schedules);
+  return c.json({ ok: true });
+}).delete("/:name/schedules/:id", (c) => {
+  const name = c.req.param("name");
+  const id = c.req.param("id");
+  if (!findAgent(name)) return c.json({ error: "Agent not found" }, 404);
+  const schedules = readSchedules(name);
+  const filtered = schedules.filter((s) => s.id !== id);
+  if (filtered.length === schedules.length) {
+    return c.json({ error: "Schedule not found" }, 404);
+  }
+  writeSchedules(name, filtered);
+  return c.json({ ok: true });
+}).post("/:name/webhook/:event", async (c) => {
+  const name = c.req.param("name");
+  const event = c.req.param("event");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const body = await c.req.text();
+  const message = `[webhook: ${event}] ${body}`;
+  try {
+    const res = await fetch(`http://localhost:${entry.port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: [{ type: "text", text: message }],
+        channel: "system:webhook",
+        sender: "webhook"
+      })
+    });
+    if (!res.ok) {
+      return c.json({ error: `Agent responded with ${res.status}` }, 502);
+    }
+    return c.json({ ok: true });
+  } catch {
+    return c.json({ error: "Failed to reach agent" }, 502);
+  }
+});
+var schedules_default = app8;
+
+// src/web/routes/system.ts
+import { Hono as Hono9 } from "hono";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+var app9 = new Hono9().get("/logs", async (c) => {
+  const user = c.get("user");
+  if (user.role !== "admin") return c.json({ error: "Forbidden" }, 403);
+  return streamSSE3(c, async (stream2) => {
+    for (const entry of logBuffer.getEntries()) {
+      await stream2.writeSSE({ data: JSON.stringify(entry) });
+    }
+    const unsubscribe = logBuffer.subscribe((entry) => {
+      stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
+      });
+    });
+    await new Promise((resolve9) => {
+      stream2.onAbort(() => {
+        unsubscribe();
+        resolve9();
+      });
+    });
+  });
+});
+var system_default = app9;
+
+// src/web/routes/variants.ts
+import { Hono as Hono10 } from "hono";
+var app10 = new Hono10().get("/:name/variants", async (c) => {
+  const name = c.req.param("name");
+  const entry = findAgent(name);
+  if (!entry) return c.json({ error: "Agent not found" }, 404);
+  const variants = readVariants(name);
+  const results = await Promise.all(
+    variants.map(async (v) => {
+      if (!v.port) return { ...v, status: "no-server" };
+      const health = await checkHealth(v.port);
+      return { ...v, status: health.ok ? "running" : "dead" };
+    })
+  );
+  return c.json(results);
+});
+var variants_default = app10;
+
+// src/web/app.ts
+var app11 = new Hono11();
+app11.onError((err, c) => {
+  if (err instanceof HTTPException) {
+    return err.getResponse();
+  }
+  logger_default.error("Unhandled error", {
+    path: c.req.path,
+    method: c.req.method,
+    error: err.message
+  });
+  return c.json({ error: "Internal server error" }, 500);
+});
+app11.notFound((c) => {
+  return c.json({ error: "Not found" }, 404);
+});
+app11.use("*", async (c, next) => {
+  const start = Date.now();
+  await next();
+  const duration = Date.now() - start;
+  logger_default.info("request", {
+    method: c.req.method,
+    path: c.req.path,
+    status: c.res.status,
+    duration
+  });
+});
+app11.get("/api/health", (c) => {
+  return c.json({ ok: true, version: "0.1.0" });
+});
+app11.use("/api/*", csrf());
+app11.use("/api/agents/*", authMiddleware);
+app11.use("/api/system/*", authMiddleware);
+var routes = app11.route("/api/auth", auth_default).route("/api/system", system_default).route("/api/agents", agents_default).route("/api/agents", chat_default).route("/api/agents", connectors_default).route("/api/agents", schedules_default).route("/api/agents", logs_default).route("/api/agents", variants_default).route("/api/agents", files_default).route("/api/agents", conversations_default);
+var app_default = app11;
+
+// src/web/server.ts
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
+};
+async function startServer({ port }) {
+  let assetsDir = "";
+  let searchDir = dirname3(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve7(searchDir, "dist", "web-assets");
+    if (existsSync8(candidate)) {
+      assetsDir = candidate;
+      break;
+    }
+    searchDir = dirname3(searchDir);
+  }
+  if (assetsDir) {
+    app_default.get("*", async (c) => {
+      const urlPath = new URL(c.req.url).pathname;
+      const filePath = resolve7(assetsDir, urlPath.slice(1));
+      if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
+      const s = await stat(filePath).catch(() => null);
+      if (s?.isFile()) {
+        const ext = extname(filePath);
+        const mime = MIME_TYPES[ext] || "application/octet-stream";
+        const body = await readFile2(filePath);
+        return c.body(body, 200, { "Content-Type": mime });
+      }
+      const indexPath = resolve7(assetsDir, "index.html");
+      const indexStat = await stat(indexPath).catch(() => null);
+      if (indexStat?.isFile()) {
+        const body = await readFile2(indexPath, "utf-8");
+        return c.html(body);
+      }
+      return c.text("Not found", 404);
+    });
+  }
+  const server = serve({ fetch: app_default.fetch, port });
+  await new Promise((resolve9, reject) => {
+    server.on("listening", () => {
+      logger_default.info("Volute UI running", { port });
+      resolve9();
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+  });
+  return server;
+}
+
+// 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 myPid = String(process.pid);
+  mkdirSync3(VOLUTE_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 });
+  } catch (err) {
+    const e = err;
+    if (e.code === "EADDRINUSE") {
+      console.error(`[daemon] port ${port} is already in use`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  writeFileSync3(DAEMON_PID_PATH, myPid);
+  writeFileSync3(DAEMON_JSON_PATH, `${JSON.stringify({ port, token }, null, 2)}
+`);
+  const manager = initAgentManager();
+  const connectors = initConnectorManager();
+  const scheduler = getScheduler();
+  scheduler.start();
+  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);
+      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}`);
+  function cleanup() {
+    try {
+      if (readFileSync4(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+        unlinkSync3(DAEMON_PID_PATH);
+      }
+    } catch {
+    }
+    try {
+      unlinkSync3(DAEMON_JSON_PATH);
+    } catch {
+    }
+  }
+  let shuttingDown = false;
+  async function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.error("[daemon] shutting down...");
+    scheduler.stop();
+    await connectors.stopAll();
+    await manager.stopAll();
+    server.close();
+    cleanup();
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("exit", cleanup);
+}
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("daemon.ts")) {
+  let port = 4200;
+  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] === "--foreground") {
+      foreground = true;
+    }
+  }
+  startDaemon({ port, foreground });
+}
+export {
+  startDaemon
+};