volute 0.2.1 → 0.3.0

package/dist/daemon.js

@@ -1,18 +1,27 @@
 #!/usr/bin/env node
 import {
+  clearJsonMap,
   getAgentManager,
-  initAgentManager
-} from "./chunk-L3BQEZ4Z.js";
+  initAgentManager,
+  loadJsonMap,
+  saveJsonMap
+} from "./chunk-IPIPLGME.js";
 import {
   logBuffer,
   logger_default,
   readNdjson
 } from "./chunk-N4YNKR3Q.js";
+import {
+  readVoluteConfig,
+  writeVoluteConfig
+} from "./chunk-NETNFBA5.js";
 import {
   loadMergedEnv
-} from "./chunk-KFNNHQK7.js";
+} from "./chunk-YEIHRP2J.js";
+import {
+  applyIsolation
+} from "./chunk-DEUAVGSA.js";
 import {
-  __export,
   agentDir,
   checkHealth,
   findAgent,
@@ -25,59 +34,33 @@ import {
   setAgentRunning,
   setVariantRunning,
   voluteHome
-} from "./chunk-6UCG6MIX.js";
+} from "./chunk-RALYNMHR.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve as resolve8 } from "path";
 
 // src/lib/connector-manager.ts
 import { spawn } from "child_process";
 import {
   createWriteStream,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
+  existsSync,
+  mkdirSync,
+  readFileSync,
   unlinkSync,
-  writeFileSync as writeFileSync2
+  writeFileSync
 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname2, resolve as resolve2 } from "path";
-
-// src/lib/volute-config.ts
-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 = configPath(agentDir2);
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writeVoluteConfig(agentDir2, config) {
-  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);
+  let searchDir = dirname(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);
+    const candidate = resolve(searchDir, ...segments);
+    if (existsSync(candidate)) return candidate;
+    searchDir = dirname(searchDir);
   }
   return null;
 }
@@ -123,15 +106,15 @@ var ConnectorManager = class {
       this.connectors.get(agentName)?.delete(type);
     }
     this.killOrphanConnector(agentDir2, type);
-    const agentConnector = resolve2(agentDir2, "connectors", type, "index.ts");
-    const userConnector = resolve2(homedir(), ".volute", "connectors", type, "index.ts");
+    const agentConnector = resolve(agentDir2, "connectors", type, "index.ts");
+    const userConnector = resolve(voluteHome(), "connectors", type, "index.ts");
     const builtinConnector = this.resolveBuiltinConnector(type);
     let connectorScript;
     let runtime;
-    if (existsSync2(agentConnector)) {
+    if (existsSync(agentConnector)) {
       connectorScript = agentConnector;
-      runtime = resolve2(agentDir2, "node_modules", ".bin", "tsx");
-    } else if (existsSync2(userConnector)) {
+      runtime = resolve(agentDir2, "node_modules", ".bin", "tsx");
+    } else if (existsSync(userConnector)) {
       connectorScript = userConnector;
       runtime = this.resolveVoluteTsx();
     } else if (builtinConnector) {
@@ -140,15 +123,15 @@ var ConnectorManager = class {
     } else {
       throw new Error(`No connector code found for type: ${type}`);
     }
-    const logsDir = resolve2(agentDir2, ".volute", "logs");
-    mkdirSync2(logsDir, { recursive: true });
-    const logStream = createWriteStream(resolve2(logsDir, `${type}.log`), { flags: "a" });
+    const logsDir = resolve(agentDir2, ".volute", "logs");
+    mkdirSync(logsDir, { recursive: true });
+    const logStream = createWriteStream(resolve(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 = spawn(runtime, [connectorScript], {
+    const spawnOpts = {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
         ...process.env,
@@ -160,7 +143,9 @@ var ConnectorManager = class {
         } : {},
         ...connectorEnv
       }
-    });
+    };
+    await applyIsolation(spawnOpts, agentName);
+    const child = spawn(runtime, [connectorScript], spawnOpts);
     child.stdout?.pipe(logStream);
     child.stderr?.pipe(logStream);
     if (child.pid) {
@@ -253,12 +238,12 @@ var ConnectorManager = class {
     }));
   }
   connectorPidPath(agentDir2, type) {
-    return resolve2(agentDir2, ".volute", "connectors", `${type}.pid`);
+    return resolve(agentDir2, ".volute", "connectors", `${type}.pid`);
   }
   saveConnectorPid(agentDir2, type, pid) {
     const pidPath = this.connectorPidPath(agentDir2, type);
-    mkdirSync2(dirname2(pidPath), { recursive: true });
-    writeFileSync2(pidPath, String(pid));
+    mkdirSync(dirname(pidPath), { recursive: true });
+    writeFileSync(pidPath, String(pid));
   }
   removeConnectorPid(agentDir2, type) {
     try {
@@ -268,9 +253,9 @@ var ConnectorManager = class {
   }
   killOrphanConnector(agentDir2, type) {
     const pidPath = this.connectorPidPath(agentDir2, type);
-    if (!existsSync2(pidPath)) return;
+    if (!existsSync(pidPath)) return;
     try {
-      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
       if (pid > 0) {
         process.kill(pid, "SIGTERM");
         console.error(`[daemon] killed orphan connector ${type} (pid ${pid})`);
@@ -301,6 +286,7 @@ function getConnectorManager() {
 }
 
 // src/lib/scheduler.ts
+import { resolve as resolve2 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
@@ -309,14 +295,27 @@ var Scheduler = class {
   // "agent:scheduleId" → epoch minute
   daemonPort = null;
   daemonToken = null;
+  get statePath() {
+    return resolve2(voluteHome(), "scheduler-state.json");
+  }
   start(daemonPort, daemonToken) {
     this.daemonPort = daemonPort ?? null;
     this.daemonToken = daemonToken ?? null;
+    this.loadState();
     this.interval = setInterval(() => this.tick(), 6e4);
   }
   stop() {
     if (this.interval) clearInterval(this.interval);
   }
+  loadState() {
+    this.lastFired = loadJsonMap(this.statePath);
+  }
+  saveState() {
+    saveJsonMap(this.statePath, this.lastFired);
+  }
+  clearState() {
+    clearJsonMap(this.statePath, this.lastFired);
+  }
   loadSchedules(agentName) {
     const dir = agentDir(agentName);
     const config = readVoluteConfig(dir);
@@ -355,6 +354,7 @@ var Scheduler = class {
       const prevMinute = Math.floor(prev.getTime() / 6e4);
       if (prevMinute === epochMinute) {
         this.lastFired.set(key, epochMinute);
+        this.saveState();
         return true;
       }
       return false;
@@ -410,19 +410,9 @@ function getScheduler() {
   return instance2;
 }
 
-// src/web/server.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile2, stat } from "fs/promises";
-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";
-
 // src/web/middleware/auth.ts
+import { timingSafeEqual } from "crypto";
+import { eq as eq2, lt } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 
@@ -431,8 +421,8 @@ import { compareSync, hashSync } from "bcryptjs";
 import { and, count, eq } from "drizzle-orm";
 
 // src/lib/db.ts
-import { chmodSync, existsSync as existsSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve3 } from "path";
+import { chmodSync, existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import { drizzle } from "drizzle-orm/libsql";
 import { migrate } from "drizzle-orm/libsql/migrator";
@@ -443,6 +433,7 @@ __export(schema_exports, {
   agentMessages: () => agentMessages,
   conversations: () => conversations,
   messages: () => messages,
+  sessions: () => sessions,
   users: () => users
 });
 import { sql } from "drizzle-orm";
@@ -487,6 +478,11 @@ var agentMessages = sqliteTable(
     index("idx_agent_messages_channel").on(table.agent, table.channel)
   ]
 );
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
+  createdAt: integer("created_at").notNull()
+});
 var messages = sqliteTable(
   "messages",
   {
@@ -501,18 +497,14 @@ var messages = sqliteTable(
 );
 
 // src/lib/db.ts
-var __dirname = dirname3(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync3(resolve3(__dirname, "../drizzle")) ? resolve3(__dirname, "../drizzle") : resolve3(__dirname, "../../drizzle");
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var migrationsFolder = existsSync2(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 || 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;
-  }
+  await migrate(db, { migrationsFolder });
   try {
     chmodSync(dbPath, 384);
   } catch (err) {
@@ -590,24 +582,36 @@ async function approveUser(id) {
 }
 
 // src/web/middleware/auth.ts
+function isValidDaemonToken(token) {
+  const expected = process.env.VOLUTE_DAEMON_TOKEN;
+  if (!expected || token.length !== expected.length) return false;
+  return timingSafeEqual(Buffer.from(token), Buffer.from(expected));
+}
 var SESSION_MAX_AGE = 864e5;
-var sessions = /* @__PURE__ */ new Map();
-function createSession(userId) {
+async function createSession(userId) {
+  const db2 = await getDb();
   const sessionId = crypto.randomUUID();
-  sessions.set(sessionId, { userId, createdAt: Date.now() });
+  await db2.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
   return sessionId;
 }
-function deleteSession(sessionId) {
-  sessions.delete(sessionId);
+async function deleteSession(sessionId) {
+  const db2 = await getDb();
+  await db2.delete(sessions).where(eq2(sessions.id, 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);
+async function getSessionUserId(sessionId) {
+  const db2 = await getDb();
+  const row = await db2.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  if (!row) return void 0;
+  if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
+    await db2.delete(sessions).where(eq2(sessions.id, sessionId));
     return void 0;
   }
-  return session.userId;
+  return row.userId;
+}
+async function cleanExpiredSessions() {
+  const db2 = await getDb();
+  const cutoff = Date.now() - SESSION_MAX_AGE;
+  await db2.delete(sessions).where(lt(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -620,7 +624,7 @@ 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) {
+    if (token && isValidDaemonToken(token)) {
       c.set("user", { id: 0, username: "cli", role: "admin" });
       await next();
       return;
@@ -628,7 +632,7 @@ var authMiddleware = createMiddleware(async (c, next) => {
   }
   const sessionId = getCookie(c, "volute_session");
   if (!sessionId) return c.json({ error: "Unauthorized" }, 401);
-  const userId = getSessionUserId(sessionId);
+  const userId = await getSessionUserId(sessionId);
   if (userId == null) return c.json({ error: "Unauthorized" }, 401);
   const user = await getUser(userId);
   if (!user) return c.json({ error: "Unauthorized" }, 401);
@@ -637,10 +641,22 @@ var authMiddleware = createMiddleware(async (c, next) => {
   await next();
 });
 
+// src/web/server.ts
+import { existsSync as existsSync6 } 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 { bodyLimit } from "hono/body-limit";
+import { csrf } from "hono/csrf";
+import { HTTPException } from "hono/http-exception";
+
 // src/web/routes/agents.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, rmSync } from "fs";
 import { resolve as resolve4 } from "path";
-import { and as and2, desc, eq as eq2 } from "drizzle-orm";
+import { and as and2, desc, eq as eq3 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
 
@@ -656,7 +672,7 @@ var CHANNELS = {
 // src/web/routes/agents.ts
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync3(resolve4(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync2(resolve4(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch {
     return void 0;
@@ -701,7 +717,7 @@ 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);
-  if (!existsSync4(agentDir(name))) return c.json({ error: "Agent directory missing" }, 404);
+  if (!existsSync3(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();
@@ -727,7 +743,7 @@ var app = new Hono().get("/", async (c) => {
     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);
+    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   if (manager.isRunning(name)) {
@@ -738,6 +754,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variantName) {
       const dir = agentDir(baseName);
       await getConnectorManager().startConnectors(baseName, dir, entry.port, getDaemonPort());
+      getScheduler().loadSchedules(baseName);
     }
     return c.json({ ok: true });
   } catch (err) {
@@ -753,7 +770,7 @@ var app = new Hono().get("/", async (c) => {
     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);
+    if (!existsSync3(dir)) return c.json({ error: "Agent directory missing" }, 404);
   }
   const manager = getAgentManager();
   const connectorManager = getConnectorManager();
@@ -766,6 +783,7 @@ var app = new Hono().get("/", async (c) => {
     if (!variantName) {
       const dir = agentDir(baseName);
       await connectorManager.startConnectors(baseName, dir, entry.port, getDaemonPort());
+      getScheduler().loadSchedules(baseName);
     }
     return c.json({ ok: true });
   } catch (err) {
@@ -785,7 +803,10 @@ var app = new Hono().get("/", async (c) => {
     return c.json({ error: "Agent is not running" }, 409);
   }
   try {
-    if (!variantName) await getConnectorManager().stopConnectors(baseName);
+    if (!variantName) {
+      await getConnectorManager().stopConnectors(baseName);
+      getScheduler().unloadSchedules(baseName);
+    }
     await manager.stopAgent(name);
     return c.json({ ok: true });
   } catch (err) {
@@ -804,7 +825,7 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
-  if (force && existsSync4(dir)) {
+  if (force && existsSync3(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
@@ -878,6 +899,7 @@ var app = new Hono().get("/", async (c) => {
               textParts.push(event.content);
             }
           } catch {
+            console.warn(`[daemon] malformed NDJSON line from ${baseName}`);
           }
         }
       }
@@ -888,6 +910,7 @@ var app = new Hono().get("/", async (c) => {
             textParts.push(event.content);
           }
         } catch {
+          console.warn(`[daemon] malformed NDJSON trailing data from ${baseName}`);
         }
       }
       if (textParts.length > 0) {
@@ -909,12 +932,12 @@ var app = new Hono().get("/", async (c) => {
 }).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 limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
+  const offset = Math.max(parseInt(c.req.query("offset") ?? "0", 10) || 0, 0);
   const db2 = await getDb();
-  const conditions = [eq2(agentMessages.agent, name)];
+  const conditions = [eq3(agentMessages.agent, name)];
   if (channel) {
-    conditions.push(eq2(agentMessages.channel, channel));
+    conditions.push(eq3(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);
@@ -953,7 +976,7 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
   }
   const user = await createUser(username, password);
   if (user.role === "admin") {
-    const sessionId = createSession(user.id);
+    const sessionId = await 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 });
@@ -963,20 +986,20 @@ var app2 = new Hono2().post("/register", zValidator("json", credentialsSchema),
   if (!user) {
     return c.json({ error: "Invalid credentials" }, 401);
   }
-  const sessionId = createSession(user.id);
+  const sessionId = await 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) => {
+}).post("/logout", async (c) => {
   const sessionId = getCookie2(c, "volute_session");
   if (sessionId) {
-    deleteSession(sessionId);
+    await 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);
+  const userId = await 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);
@@ -992,7 +1015,7 @@ 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";
+import { and as and3, desc as desc2, eq as eq4, isNull, sql as sql2 } from "drizzle-orm";
 async function createConversation(agentName, channel, opts) {
   const db2 = await getDb();
   const id = randomUUID();
@@ -1015,7 +1038,7 @@ async function createConversation(agentName, channel, opts) {
 }
 async function getConversationForUser(id, userId) {
   const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(and3(eq3(conversations.id, id), eq3(conversations.user_id, userId))).get();
+  const row = await db2.select().from(conversations).where(and3(eq4(conversations.id, id), eq4(conversations.user_id, userId))).get();
   return row ?? null;
 }
 async function deleteConversationForUser(id, userId) {
@@ -1027,20 +1050,20 @@ async function deleteConversationForUser(id, userId) {
 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(and3(eq4(conversations.agent_name, agentName), eq4(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();
+  return db2.select().from(conversations).where(eq4(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));
+  await db2.update(conversations).set({ updated_at: sql2`datetime('now')` }).where(eq4(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)));
+      await db2.update(conversations).set({ title }).where(and3(eq4(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
   return {
@@ -1054,7 +1077,7 @@ async function addMessage(conversationId, role, senderName, content) {
 }
 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();
+  const rows = await db2.select().from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
   return rows.map((row) => {
     let content;
     try {
@@ -1068,7 +1091,7 @@ async function getMessages(conversationId) {
 }
 async function deleteConversation(id) {
   const db2 = await getDb();
-  await db2.delete(conversations).where(eq3(conversations.id, id));
+  await db2.delete(conversations).where(eq4(conversations.id, id));
 }
 
 // src/web/routes/chat.ts
@@ -1093,7 +1116,7 @@ var app3 = new Hono3().post("/:name/chat", zValidator2("json", chatSchema), asyn
     if (!variant) return c.json({ error: `Unknown variant: ${variantName}` }, 404);
     port = variant.port;
   }
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-SSJUZWOV.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-2LU6KULR.js");
   if (!getAgentManager2().isRunning(name)) {
     return c.json({ error: "Agent is not running" }, 409);
   }
@@ -1278,7 +1301,7 @@ var app5 = new Hono5().get("/:name/conversations", async (c) => {
 var conversations_default = app5;
 
 // src/web/routes/files.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { readdir, readFile, writeFile } from "fs/promises";
 import { resolve as resolve5 } from "path";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
@@ -1292,7 +1315,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 (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  if (!existsSync4(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);
@@ -1306,7 +1329,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 (!existsSync5(filePath)) {
+  if (!existsSync4(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1329,7 +1352,7 @@ var files_default = app6;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { resolve as resolve6 } from "path";
 import { Hono as Hono7 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
@@ -1339,7 +1362,7 @@ 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 (!existsSync6(logFile)) {
+  if (!existsSync5(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE2(c, async (stream2) => {
@@ -1541,14 +1564,14 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname4(new URL(import.meta.url).pathname);
+  let searchDir = dirname3(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
     const candidate = resolve7(searchDir, "dist", "web-assets");
-    if (existsSync7(candidate)) {
+    if (existsSync6(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname4(searchDir);
+    searchDir = dirname3(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
@@ -1591,7 +1614,7 @@ async function startDaemon(opts) {
   const home = voluteHome();
   const DAEMON_PID_PATH = resolve8(home, "daemon.pid");
   const DAEMON_JSON_PATH = resolve8(home, "daemon.json");
-  mkdirSync3(home, { recursive: true });
+  mkdirSync2(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;
   let server;
@@ -1605,10 +1628,13 @@ async function startDaemon(opts) {
     }
     throw err;
   }
-  writeFileSync3(DAEMON_PID_PATH, myPid, { mode: 384 });
-  writeFileSync3(DAEMON_JSON_PATH, `${JSON.stringify({ port, token }, null, 2)}
-`, { mode: 384 });
+  writeFileSync2(DAEMON_PID_PATH, myPid, { mode: 384 });
+  writeFileSync2(DAEMON_JSON_PATH, `${JSON.stringify({ port, hostname, token }, null, 2)}
+`, {
+    mode: 384
+  });
   const manager = initAgentManager();
+  manager.loadCrashAttempts();
   const connectors = initConnectorManager();
   const scheduler = getScheduler();
   scheduler.start(port, token);
@@ -1635,16 +1661,18 @@ async function startDaemon(opts) {
       setVariantRunning(agentName, variant.name, false);
     }
   }
+  cleanExpiredSessions().catch(() => {
+  });
   console.error(`[daemon] running on ${hostname}:${port}, pid ${myPid}`);
   function cleanup() {
     try {
-      if (readFileSync4(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
+      if (readFileSync3(DAEMON_PID_PATH, "utf-8").trim() === myPid) {
         unlinkSync2(DAEMON_PID_PATH);
       }
     } catch {
     }
     try {
-      const data = JSON.parse(readFileSync4(DAEMON_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync3(DAEMON_JSON_PATH, "utf-8"));
       if (data.token === token) {
         unlinkSync2(DAEMON_JSON_PATH);
       }
@@ -1657,8 +1685,10 @@ async function startDaemon(opts) {
     shuttingDown = true;
     console.error("[daemon] shutting down...");
     scheduler.stop();
+    scheduler.saveState();
     await connectors.stopAll();
     await manager.stopAll();
+    manager.clearCrashAttempts();
     server.close();
     cleanup();
     process.exit(0);