volute 0.6.0 → 0.7.0

package/dist/daemon.js

@@ -6,18 +6,37 @@ import {
   initAgentManager,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-G6ZNGLUX.js";
+} from "./chunk-62X577Y7.js";
 import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-AOKAQGO4.js";
+} from "./chunk-NKXULRSW.js";
 import {
   collectPart
 } from "./chunk-B3R6L2GW.js";
 import {
   CHANNELS
 } from "./chunk-ZZOOTYXK.js";
+import {
+  agentMessages,
+  approveUser,
+  conversationParticipants,
+  conversations,
+  createUser,
+  deleteAgentUser,
+  getDb,
+  getOrCreateAgentUser,
+  getUser,
+  getUserByUsername,
+  listPendingUsers,
+  listUsers,
+  listUsersByType,
+  messages,
+  sessions,
+  users,
+  verifyUser
+} from "./chunk-7ACDT3P2.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
@@ -25,7 +44,10 @@ import {
 import {
   loadMergedEnv
 } from "./chunk-H7AMDUIA.js";
-import "./chunk-BX7KI4S3.js";
+import {
+  slugify,
+  writeChannelEntry
+} from "./chunk-BX7KI4S3.js";
 import {
   applyIsolation
 } from "./chunk-W76KWE23.js";
@@ -47,15 +69,13 @@ import {
   setVariantRunning,
   voluteHome
 } from "./chunk-UWHWAPGO.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
+import "./chunk-K3NQKI34.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve9 } from "path";
 import { format } from "util";
 
 // src/lib/connector-manager.ts
@@ -295,19 +315,19 @@ var ConnectorManager = class {
     const stopKey = `${agentName}:${type}`;
     this.stopping.add(stopKey);
     agentMap.delete(type);
-    await new Promise((resolve11) => {
-      tracked.child.on("exit", () => resolve11());
+    await new Promise((resolve10) => {
+      tracked.child.on("exit", () => resolve10());
       try {
         tracked.child.kill("SIGTERM");
       } catch {
-        resolve11();
+        resolve10();
       }
       setTimeout(() => {
         try {
           tracked.child.kill("SIGKILL");
         } catch {
         }
-        resolve11();
+        resolve10();
       }, 5e3);
     });
     this.stopping.delete(stopKey);
@@ -705,245 +725,9 @@ function getTokenBudget() {
 
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq as eq2, lt } from "drizzle-orm";
+import { eq, lt } from "drizzle-orm";
 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 { chmodSync, existsSync as existsSync3 } 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,
-  conversationParticipants: () => conversationParticipants,
-  conversations: () => conversations,
-  messages: () => messages,
-  sessions: () => sessions,
-  users: () => users
-});
-import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text, uniqueIndex } 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"),
-  user_type: text("user_type").notNull().default("human"),
-  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 conversationParticipants = sqliteTable(
-  "conversation_participants",
-  {
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    role: text("role").notNull().default("member"),
-    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
-    index("idx_cp_user_id").on(table.user_id)
-  ]
-);
-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",
-  {
-    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 = existsSync3(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(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  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).where(eq(users.user_type, "human"));
-  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,
-    user_type: users.user_type,
-    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 (row.user_type === "agent") 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,
-    user_type: users.user_type,
-    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,
-    user_type: users.user_type,
-    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,
-    user_type: users.user_type,
-    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,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
-}
-async function listUsersByType(userType) {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
-}
-async function getOrCreateAgentUser(agentName) {
-  const db2 = await getDb();
-  const existing = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
-  if (existing) return existing;
-  try {
-    const [result] = await db2.insert(users).values({
-      username: agentName,
-      password_hash: "!agent",
-      role: "agent",
-      user_type: "agent"
-    }).returning({
-      id: users.id,
-      username: users.username,
-      role: users.role,
-      user_type: users.user_type,
-      created_at: users.created_at
-    });
-    return result;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db2.select({
-        id: users.id,
-        username: users.username,
-        role: users.role,
-        user_type: users.user_type,
-        created_at: users.created_at
-      }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
-      if (retried) return retried;
-    }
-    throw err;
-  }
-}
-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
 function isValidDaemonToken(token) {
   const expected = process.env.VOLUTE_DAEMON_TOKEN;
   if (!expected || token.length !== expected.length) return false;
@@ -951,29 +735,29 @@ function isValidDaemonToken(token) {
 }
 var SESSION_MAX_AGE = 864e5;
 async function createSession(userId) {
-  const db2 = await getDb();
+  const db = await getDb();
   const sessionId = crypto.randomUUID();
-  await db2.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
   return sessionId;
 }
 async function deleteSession(sessionId) {
-  const db2 = await getDb();
-  await db2.delete(sessions).where(eq2(sessions.id, sessionId));
+  const db = await getDb();
+  await db.delete(sessions).where(eq(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
-  const db2 = await getDb();
-  const row = await db2.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const db = await getDb();
+  const row = await db.select().from(sessions).where(eq(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));
+    await db.delete(sessions).where(eq(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
 }
 async function cleanExpiredSessions() {
-  const db2 = await getDb();
+  const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db2.delete(sessions).where(lt(sessions.createdAt, cutoff));
+  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -1004,9 +788,9 @@ var authMiddleware = createMiddleware(async (c, next) => {
 });
 
 // src/web/server.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname3, extname, resolve as resolve9 } from "path";
+import { dirname as dirname2, extname, resolve as resolve8 } from "path";
 import { serve } from "@hono/node-server";
 
 // src/lib/log-buffer.ts
@@ -1060,9 +844,9 @@ 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 { resolve as resolve5 } from "path";
-import { and as and2, desc, eq as eq3 } from "drizzle-orm";
+import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
+import { resolve as resolve4 } from "path";
+import { and, desc, eq as eq2 } from "drizzle-orm";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
 
@@ -1175,7 +959,7 @@ function getTypingMap() {
 // src/web/routes/agents.ts
 function getDaemonPort() {
   try {
-    const data = JSON.parse(readFileSync3(resolve5(voluteHome(), "daemon.json"), "utf-8"));
+    const data = JSON.parse(readFileSync3(resolve4(voluteHome(), "daemon.json"), "utf-8"));
     return data.port;
   } catch {
     return void 0;
@@ -1224,7 +1008,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();
@@ -1250,7 +1034,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)) {
@@ -1285,7 +1069,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();
@@ -1353,7 +1137,8 @@ var app = new Hono().get("/", async (c) => {
   }
   removeAllVariants(name);
   removeAgent(name);
-  if (force && existsSync4(dir)) {
+  await deleteAgentUser(name);
+  if (force && existsSync3(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
   return c.json({ ok: true });
@@ -1379,10 +1164,10 @@ var app = new Hono().get("/", async (c) => {
     console.error(`[daemon] failed to parse message body for ${baseName}:`, err);
   }
   const channel = parsed?.channel ?? "unknown";
-  const db2 = await getDb();
+  const db = await getDb();
   if (parsed) {
     try {
-      const sender = parsed.sender ?? null;
+      const sender2 = parsed.sender ?? null;
       let content;
       if (typeof parsed.content === "string") {
         content = parsed.content;
@@ -1391,11 +1176,11 @@ var app = new Hono().get("/", async (c) => {
       } else {
         content = JSON.stringify(parsed.content);
       }
-      await db2.insert(agentMessages).values({
+      await db.insert(agentMessages).values({
         agent: baseName,
         channel,
         role: "user",
-        sender,
+        sender: sender2,
         content
       });
     } catch (err) {
@@ -1432,6 +1217,8 @@ var app = new Hono().get("/", async (c) => {
     });
   }
   const typingMap = getTypingMap();
+  const sender = parsed?.sender ?? "";
+  if (sender) typingMap.delete(channel, sender);
   const currentlyTyping = typingMap.get(channel).filter((s) => s !== baseName);
   let forwardBody = body;
   if (parsed && currentlyTyping.length > 0) {
@@ -1493,7 +1280,7 @@ var app = new Hono().get("/", async (c) => {
       const content = [textParts.join(""), ...toolParts].filter(Boolean).join("\n");
       if (content) {
         try {
-          await db2.insert(agentMessages).values({
+          await db.insert(agentMessages).values({
             agent: baseName,
             channel,
             role: "assistant",
@@ -1526,9 +1313,9 @@ var app = new Hono().get("/", async (c) => {
   if (!body.channel || !body.content) {
     return c.json({ error: "channel and content required" }, 400);
   }
-  const db2 = await getDb();
+  const db = await getDb();
   try {
-    await db2.insert(agentMessages).values({
+    await db.insert(agentMessages).values({
       agent: baseName,
       channel: body.channel,
       role: "assistant",
@@ -1542,20 +1329,20 @@ var app = new Hono().get("/", async (c) => {
   return c.json({ ok: true });
 }).get("/:name/history/channels", async (c) => {
   const name = c.req.param("name");
-  const db2 = await getDb();
-  const rows = await db2.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq3(agentMessages.agent, name));
+  const db = await getDb();
+  const rows = await db.selectDistinct({ channel: agentMessages.channel }).from(agentMessages).where(eq2(agentMessages.agent, name));
   return c.json(rows.map((r) => r.channel));
 }).get("/:name/history", async (c) => {
   const name = c.req.param("name");
   const channel = c.req.query("channel");
   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 = [eq3(agentMessages.agent, name)];
+  const db = await getDb();
+  const conditions = [eq2(agentMessages.agent, name)];
   if (channel) {
-    conditions.push(eq3(agentMessages.channel, 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);
+  const rows = await db.select().from(agentMessages).where(and(...conditions)).orderBy(desc(agentMessages.created_at)).limit(limit).offset(offset);
   return c.json(rows);
 });
 var agents_default = app;
@@ -1703,9 +1490,9 @@ var app3 = new Hono3().get("/:name/connectors", (c) => {
 var connectors_default = app3;
 
 // 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 resolve6 } from "path";
+import { resolve as resolve5 } from "path";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Hono as Hono4 } from "hono";
 import { z as z2 } from "zod";
@@ -1716,8 +1503,8 @@ var app4 = new Hono4().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const homeDir = resolve6(dir, "home");
-  if (!existsSync5(homeDir)) return c.json({ error: "Home directory missing" }, 404);
+  const homeDir = resolve5(dir, "home");
+  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);
@@ -1730,8 +1517,8 @@ var app4 = new Hono4().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve6(dir, "home", filename);
-  if (!existsSync5(filePath)) {
+  const filePath = resolve5(dir, "home", filename);
+  if (!existsSync4(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
   const content = await readFile(filePath, "utf-8");
@@ -1745,7 +1532,7 @@ var app4 = new Hono4().get("/:name/files", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const filePath = resolve6(dir, "home", filename);
+  const filePath = resolve5(dir, "home", filename);
   const { content } = c.req.valid("json");
   await writeFile(filePath, content);
   return c.json({ ok: true });
@@ -1754,8 +1541,8 @@ var files_default = app4;
 
 // src/web/routes/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve6 } from "path";
 import { Hono as Hono5 } from "hono";
 import { streamSSE } from "hono/streaming";
 var app5 = new Hono5().get("/:name/logs", async (c) => {
@@ -1763,8 +1550,8 @@ var app5 = new Hono5().get("/:name/logs", async (c) => {
   const entry = findAgent(name);
   if (!entry) return c.json({ error: "Agent not found" }, 404);
   const dir = agentDir(name);
-  const logFile = resolve7(dir, ".volute", "logs", "agent.log");
-  if (!existsSync6(logFile)) {
+  const logFile = resolve6(dir, ".volute", "logs", "agent.log");
+  if (!existsSync5(logFile)) {
     return c.json({ error: "No log file found" }, 404);
   }
   return streamSSE(c, async (stream2) => {
@@ -1782,9 +1569,9 @@ var app5 = new Hono5().get("/:name/logs", async (c) => {
     stream2.onAbort(() => {
       tail.kill();
     });
-    await new Promise((resolve11) => {
-      tail.on("exit", resolve11);
-      stream2.onAbort(resolve11);
+    await new Promise((resolve10) => {
+      tail.on("exit", resolve10);
+      stream2.onAbort(resolve10);
     });
   });
 });
@@ -1886,10 +1673,10 @@ var app7 = new Hono7().get("/logs", async (c) => {
       stream2.writeSSE({ data: JSON.stringify(entry) }).catch(() => {
       });
     });
-    await new Promise((resolve11) => {
+    await new Promise((resolve10) => {
       stream2.onAbort(() => {
         unsubscribe();
-        resolve11();
+        resolve10();
       });
     });
   });
@@ -1965,7 +1752,7 @@ var variants_default = app10;
 
 // src/web/routes/volute/chat.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve7 } from "path";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Hono as Hono11 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
@@ -1973,11 +1760,11 @@ import { z as z4 } from "zod";
 
 // src/lib/conversations.ts
 import { randomUUID } from "crypto";
-import { and as and3, desc as desc2, eq as eq4, inArray, isNull, sql as sql2 } from "drizzle-orm";
+import { and as and2, desc as desc2, eq as eq3, inArray, isNull, sql } from "drizzle-orm";
 async function createConversation(agentName, channel, opts) {
-  const db2 = await getDb();
+  const db = await getDb();
   const id = randomUUID();
-  await db2.insert(conversations).values({
+  await db.insert(conversations).values({
     id,
     agent_name: agentName,
     channel,
@@ -1985,7 +1772,7 @@ async function createConversation(agentName, channel, opts) {
     title: opts?.title ?? null
   });
   if (opts?.participantIds && opts.participantIds.length > 0) {
-    await db2.insert(conversationParticipants).values(
+    await db.insert(conversationParticipants).values(
       opts.participantIds.map((uid, i) => ({
         conversation_id: id,
         user_id: uid,
@@ -2004,41 +1791,41 @@ async function createConversation(agentName, channel, opts) {
   };
 }
 async function getConversation(id) {
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(eq4(conversations.id, id)).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(eq3(conversations.id, id)).get();
   return row ?? null;
 }
 async function getParticipants(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select({
+  const db = await getDb();
+  const rows = await db.select({
     userId: conversationParticipants.user_id,
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(eq4(conversationParticipants.conversation_id, conversationId)).all();
+  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(eq3(conversationParticipants.conversation_id, conversationId)).all();
   return rows;
 }
 async function isParticipant(conversationId, userId) {
-  const db2 = await getDb();
-  const row = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
-    and3(
-      eq4(conversationParticipants.conversation_id, conversationId),
-      eq4(conversationParticipants.user_id, userId)
+  const db = await getDb();
+  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
+    and2(
+      eq3(conversationParticipants.conversation_id, conversationId),
+      eq3(conversationParticipants.user_id, userId)
     )
   ).get();
   return row != null;
 }
 async function listConversationsForUser(userId) {
-  const db2 = await getDb();
-  const participantRows = await db2.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq4(conversationParticipants.user_id, userId)).all();
+  const db = await getDb();
+  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq3(conversationParticipants.user_id, userId)).all();
   if (participantRows.length === 0) return [];
   const convIds = participantRows.map((r) => r.conversation_id);
-  return db2.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc2(conversations.updated_at)).all();
+  return db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc2(conversations.updated_at)).all();
 }
 async function isParticipantOrOwner(conversationId, userId) {
   if (await isParticipant(conversationId, userId)) return true;
-  const db2 = await getDb();
-  const row = await db2.select().from(conversations).where(and3(eq4(conversations.id, conversationId), eq4(conversations.user_id, userId))).get();
+  const db = await getDb();
+  const row = await db.select().from(conversations).where(and2(eq3(conversations.id, conversationId), eq3(conversations.user_id, userId))).get();
   return row != null;
 }
 async function deleteConversationForUser(id, userId) {
@@ -2047,15 +1834,15 @@ async function deleteConversationForUser(id, userId) {
   return true;
 }
 async function addMessage(conversationId, role, senderName, content) {
-  const db2 = await getDb();
+  const db = 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(eq4(conversations.id, conversationId));
+  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
+  await db.update(conversations).set({ updated_at: sql`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(eq4(conversations.id, conversationId), isNull(conversations.title)));
+      await db.update(conversations).set({ title }).where(and2(eq3(conversations.id, conversationId), isNull(conversations.title)));
     }
   }
   return {
@@ -2068,8 +1855,8 @@ async function addMessage(conversationId, role, senderName, content) {
   };
 }
 async function getMessages(conversationId) {
-  const db2 = await getDb();
-  const rows = await db2.select().from(messages).where(eq4(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
+  const db = await getDb();
+  const rows = await db.select().from(messages).where(eq3(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
   return rows.map((row) => {
     let content;
     try {
@@ -2084,15 +1871,15 @@ async function getMessages(conversationId) {
 async function listConversationsWithParticipants(userId) {
   const convs = await listConversationsForUser(userId);
   if (convs.length === 0) return [];
-  const db2 = await getDb();
+  const db = await getDb();
   const convIds = convs.map((c) => c.id);
-  const rows = await db2.select({
+  const rows = await db.select({
     conversationId: conversationParticipants.conversation_id,
     userId: users.id,
     username: users.username,
     userType: users.user_type,
     role: conversationParticipants.role
-  }).from(conversationParticipants).innerJoin(users, eq4(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  }).from(conversationParticipants).innerJoin(users, eq3(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
   const byConv = /* @__PURE__ */ new Map();
   for (const r of rows) {
     let arr = byConv.get(r.conversationId);
@@ -2110,10 +1897,10 @@ async function listConversationsWithParticipants(userId) {
   return convs.map((c) => ({ ...c, participants: byConv.get(c.id) ?? [] }));
 }
 async function findDMConversation(agentName, participantIds) {
-  const db2 = await getDb();
-  const agentConvs = await db2.select({ id: conversations.id }).from(conversations).where(eq4(conversations.agent_name, agentName)).all();
+  const db = await getDb();
+  const agentConvs = await db.select({ id: conversations.id }).from(conversations).where(eq3(conversations.agent_name, agentName)).all();
   for (const conv of agentConvs) {
-    const rows = await db2.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq4(conversationParticipants.conversation_id, conv.id)).all();
+    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq3(conversationParticipants.conversation_id, conv.id)).all();
     if (rows.length !== 2) continue;
     const ids = new Set(rows.map((r) => r.user_id));
     if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
@@ -2123,8 +1910,8 @@ async function findDMConversation(agentName, participantIds) {
   return null;
 }
 async function deleteConversation(id) {
-  const db2 = await getDb();
-  await db2.delete(conversations).where(eq4(conversations.id, id));
+  const db = await getDb();
+  await db.delete(conversations).where(eq3(conversations.id, id));
 }
 
 // src/web/routes/volute/chat.ts
@@ -2140,7 +1927,7 @@ var chatSchema = z4.object({
   ).optional()
 });
 function getDaemonUrl() {
-  const data = JSON.parse(readFileSync4(resolve8(voluteHome(), "daemon.json"), "utf-8"));
+  const data = JSON.parse(readFileSync4(resolve7(voluteHome(), "daemon.json"), "utf-8"));
   return `http://${daemonLoopback()}:${data.port}`;
 }
 function daemonFetchInternal(path, body) {
@@ -2223,15 +2010,17 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
       }
     }
     if (!conversationId) {
-      const conv = await createConversation(baseName, "volute", {
+      const conv2 = await createConversation(baseName, "volute", {
         userId: user.id !== 0 ? user.id : void 0,
         title,
         participantIds
       });
-      conversationId = conv.id;
+      conversationId = conv2.id;
     }
   }
-  const channel = `volute:${conversationId}`;
+  const conv = await getConversation(conversationId);
+  const convTitle = conv?.title;
+  const channel = convTitle ? `volute:${slugify(convTitle)}` : `volute:${conversationId}`;
   const contentBlocks = [];
   if (body.message) {
     contentBlocks.push({ type: "text", text: body.message });
@@ -2245,13 +2034,20 @@ var app11 = new Hono11().post("/:name/chat", zValidator4("json", chatSchema), as
   const participants = await getParticipants(conversationId);
   const agentParticipants = participants.filter((p) => p.userType === "agent");
   const participantNames = participants.map((p) => p.username);
-  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-JDVXU3ON.js");
+  const { getAgentManager: getAgentManager2 } = await import("./agent-manager-IMZ7ZMBF.js");
   const manager = getAgentManager2();
   const runningAgents = agentParticipants.map((ap) => {
     const agentKey = ap.username === baseName ? name : ap.username;
     return manager.isRunning(agentKey) ? ap.username : null;
   }).filter((n) => n !== null && n !== senderName);
   const isDM = participants.length === 2;
+  const dir = agentDir(baseName);
+  writeChannelEntry(dir, channel, {
+    platformId: conversationId,
+    platform: "volute",
+    name: convTitle ?? void 0,
+    type: isDM ? "dm" : "group"
+  });
   const typingMap = getTypingMap();
   const currentlyTyping = typingMap.get(channel);
   const payload = JSON.stringify({
@@ -2548,20 +2344,20 @@ async function startServer({
   hostname = "127.0.0.1"
 }) {
   let assetsDir = "";
-  let searchDir = dirname3(new URL(import.meta.url).pathname);
+  let searchDir = dirname2(new URL(import.meta.url).pathname);
   for (let i = 0; i < 5; i++) {
-    const candidate = resolve9(searchDir, "dist", "web-assets");
-    if (existsSync7(candidate)) {
+    const candidate = resolve8(searchDir, "dist", "web-assets");
+    if (existsSync6(candidate)) {
       assetsDir = candidate;
       break;
     }
-    searchDir = dirname3(searchDir);
+    searchDir = dirname2(searchDir);
   }
   if (assetsDir) {
     app_default.get("*", async (c) => {
       const urlPath = new URL(c.req.url).pathname;
       if (urlPath.startsWith("/api/")) return c.notFound();
-      const filePath = resolve9(assetsDir, urlPath.slice(1));
+      const filePath = resolve8(assetsDir, urlPath.slice(1));
       if (!filePath.startsWith(assetsDir)) return c.text("Forbidden", 403);
       const s = await stat(filePath).catch(() => null);
       if (s?.isFile()) {
@@ -2570,7 +2366,7 @@ async function startServer({
         const body = await readFile2(filePath);
         return c.body(body, 200, { "Content-Type": mime });
       }
-      const indexPath = resolve9(assetsDir, "index.html");
+      const indexPath = resolve8(assetsDir, "index.html");
       const indexStat = await stat(indexPath).catch(() => null);
       if (indexStat?.isFile()) {
         const body = await readFile2(indexPath, "utf-8");
@@ -2580,10 +2376,10 @@ async function startServer({
     });
   }
   const server = serve({ fetch: app_default.fetch, port, hostname });
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve10, reject) => {
     server.on("listening", () => {
       logger_default.info("Volute UI running", { hostname, port });
-      resolve11();
+      resolve10();
     });
     server.on("error", (err) => {
       reject(err);
@@ -2594,14 +2390,14 @@ async function startServer({
 
 // src/daemon.ts
 if (!process.env.VOLUTE_HOME) {
-  process.env.VOLUTE_HOME = resolve10(homedir(), ".volute");
+  process.env.VOLUTE_HOME = resolve9(homedir(), ".volute");
 }
 async function startDaemon(opts) {
   const { port, hostname } = opts;
   const myPid = String(process.pid);
   const home = voluteHome();
   if (!opts.foreground) {
-    const log2 = new RotatingLog(resolve10(home, "daemon.log"));
+    const log2 = new RotatingLog(resolve9(home, "daemon.log"));
     const write2 = (...args) => log2.write(`${format(...args)}
 `);
     console.log = write2;
@@ -2609,8 +2405,8 @@ async function startDaemon(opts) {
     console.warn = write2;
     console.info = write2;
   }
-  const DAEMON_PID_PATH = resolve10(home, "daemon.pid");
-  const DAEMON_JSON_PATH = resolve10(home, "daemon.json");
+  const DAEMON_PID_PATH = resolve9(home, "daemon.pid");
+  const DAEMON_JSON_PATH = resolve9(home, "daemon.json");
   mkdirSync2(home, { recursive: true });
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   process.env.VOLUTE_DAEMON_TOKEN = token;