volute 0.6.0 → 0.7.0

package/dist/{agent-X7GJLBLW.js → agent-7JF7MT73.js}

@@ -18,7 +18,7 @@ async function run(args) {
       await import("./restart-O4ETYLJF.js").then((m) => m.run(args.slice(1)));
       break;
     case "delete":
-      await import("./delete-2PH2CGDY.js").then((m) => m.run(args.slice(1)));
+      await import("./delete-UOU4AFQN.js").then((m) => m.run(args.slice(1)));
       break;
     case "list":
       await import("./status-QAJWXKMZ.js").then((m) => m.run(args.slice(1)));

package/dist/{agent-manager-JDVXU3ON.js → agent-manager-IMZ7ZMBF.js}

@@ -3,7 +3,7 @@ import {
   AgentManager,
   getAgentManager,
   initAgentManager
-} from "./chunk-G6ZNGLUX.js";
+} from "./chunk-62X577Y7.js";
 import "./chunk-H7AMDUIA.js";
 import "./chunk-W76KWE23.js";
 import "./chunk-UWHWAPGO.js";

package/dist/{chunk-G6ZNGLUX.js → chunk-62X577Y7.js}

@@ -285,11 +285,13 @@ var AgentManager = class {
     });
     this.stopping.delete(name);
     if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    const [baseName, variantName] = name.split("@", 2);
-    if (variantName) {
-      setVariantRunning(baseName, variantName, false);
-    } else {
-      setAgentRunning(name, false);
+    if (!this.shuttingDown) {
+      const [baseName, variantName] = name.split("@", 2);
+      if (variantName) {
+        setVariantRunning(baseName, variantName, false);
+      } else {
+        setAgentRunning(name, false);
+      }
     }
     console.error(`[daemon] stopped agent ${name}`);
   }

package/dist/chunk-7ACDT3P2.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import {
+  voluteHome
+} from "./chunk-UWHWAPGO.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// src/lib/auth.ts
+import { compareSync, hashSync } from "bcryptjs";
+import { and, count, eq } from "drizzle-orm";
+
+// src/lib/db.ts
+import { chmodSync, existsSync } from "fs";
+import { dirname, resolve } 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 = dirname(fileURLToPath(import.meta.url));
+var migrationsFolder = existsSync(resolve(__dirname, "../drizzle")) ? resolve(__dirname, "../drizzle") : resolve(__dirname, "../../drizzle");
+var db = null;
+async function getDb() {
+  if (db) return db;
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve(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 deleteAgentUser(agentName) {
+  const db2 = await getDb();
+  await db2.delete(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent")));
+}
+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")));
+}
+
+export {
+  users,
+  conversations,
+  agentMessages,
+  conversationParticipants,
+  sessions,
+  messages,
+  getDb,
+  createUser,
+  verifyUser,
+  getUser,
+  getUserByUsername,
+  listUsers,
+  listPendingUsers,
+  listUsersByType,
+  getOrCreateAgentUser,
+  deleteAgentUser,
+  approveUser
+};

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

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

package/dist/{down-FXWAN66A.js → chunk-LLJNZPCU.js}

@@ -2,12 +2,11 @@
 import {
   voluteHome
 } from "./chunk-UWHWAPGO.js";
-import "./chunk-K3NQKI34.js";
 
 // src/commands/down.ts
 import { existsSync, readFileSync, unlinkSync } from "fs";
 import { resolve } from "path";
-async function run(_args) {
+async function stopDaemon() {
   const home = voluteHome();
   const pidPath = resolve(home, "daemon.pid");
   if (!existsSync(pidPath)) {
@@ -28,16 +27,21 @@ async function run(_args) {
       url.port = String(port);
       const res = await fetch(`${url.origin}/api/health`);
       if (res.ok) {
-        console.error(`Daemon appears to be running on port ${port} but PID file is missing.`);
-        console.error(`Kill the process manually: lsof -ti :${port} | xargs kill`);
-        process.exit(1);
+        return { stopped: false, reason: "orphan", port };
       }
     } catch {
     }
-    console.error("Daemon is not running (no PID file found).");
-    process.exit(1);
+    return { stopped: false, reason: "not-running" };
   }
   const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    console.error(`Stale or corrupt PID file (${pidPath}), removing.`);
+    try {
+      unlinkSync(pidPath);
+    } catch {
+    }
+    return { stopped: false, reason: "not-running" };
+  }
   try {
     process.kill(pid, 0);
   } catch {
@@ -46,21 +50,28 @@ async function run(_args) {
     } catch {
     }
     console.log("Daemon was not running (cleaned up stale PID file).");
-    return;
+    return { stopped: false, reason: "not-running" };
   }
   try {
     process.kill(-pid, "SIGTERM");
     console.log(`Sent SIGTERM to daemon group (pid ${pid})`);
   } catch {
-    process.kill(pid, "SIGTERM");
-    console.log(`Sent SIGTERM to daemon (pid ${pid})`);
+    try {
+      process.kill(pid, "SIGTERM");
+      console.log(`Sent SIGTERM to daemon (pid ${pid})`);
+    } catch (e) {
+      console.error(
+        `Failed to send SIGTERM to daemon (pid ${pid}): ${e instanceof Error ? e.message : e}`
+      );
+      return { stopped: false, reason: "kill-failed", port: pid };
+    }
   }
   const maxWait = 1e4;
   const start = Date.now();
   while (Date.now() - start < maxWait) {
     if (!existsSync(pidPath)) {
       console.log("Daemon stopped.");
-      return;
+      return { stopped: true, clean: true };
     }
     await new Promise((r) => setTimeout(r, 200));
   }
@@ -69,11 +80,35 @@ async function run(_args) {
   } catch {
     try {
       process.kill(pid, "SIGKILL");
-    } catch {
+    } catch (e) {
+      console.error(
+        `Failed to force-kill daemon (pid ${pid}): ${e instanceof Error ? e.message : e}`
+      );
+      console.error(`The daemon may still be running. Kill it manually: kill -9 ${pid}`);
+      return { stopped: false, reason: "kill-failed" };
     }
   }
+  try {
+    unlinkSync(pidPath);
+  } catch {
+  }
+  await new Promise((r) => setTimeout(r, 500));
   console.error("Daemon did not exit cleanly, sent SIGKILL.");
+  return { stopped: true, clean: false };
 }
+async function run(_args) {
+  const result = await stopDaemon();
+  if (result.stopped) return;
+  if (result.reason === "orphan") {
+    console.error(`Daemon appears to be running on port ${result.port} but PID file is missing.`);
+    console.error(`Kill the process manually: lsof -ti :${result.port} | xargs kill`);
+  } else if (result.reason === "not-running") {
+    console.error("Daemon is not running (no PID file found).");
+  }
+  process.exit(1);
+}
+
 export {
+  stopDaemon,
   run
 };

package/dist/{chunk-AOKAQGO4.js → chunk-NKXULRSW.js}

@@ -28,6 +28,7 @@ function writeCache(latest) {
 function getCurrentVersion() {
   const thisDir = new URL(".", import.meta.url).pathname;
   const candidates = [
+    resolve(thisDir, "../package.json"),
     resolve(thisDir, "../../package.json"),
     resolve(thisDir, "../../../package.json")
   ];

package/dist/cli.js

@@ -9,13 +9,13 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-4DP4Y4UO.js");
+  const { default: pkg } = await import("./package-T2WAVJOU.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-X7GJLBLW.js").then((m) => m.run(args));
+    await import("./agent-7JF7MT73.js").then((m) => m.run(args));
     break;
   case "message":
     await import("./message-SCOQDR3P.js").then((m) => m.run(args));
@@ -36,10 +36,13 @@ switch (command) {
     await import("./env-7GLUJCWS.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-CSX3ZUIU.js").then((m) => m.run(args));
+    await import("./up-RWZF6MLT.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-FXWAN66A.js").then((m) => m.run(args));
+    await import("./down-AZVH5TCD.js").then((m) => m.run(args));
+    break;
+  case "restart":
+    await import("./daemon-restart-4HVEKYFY.js").then((m) => m.run(args));
     break;
   case "setup":
     await import("./setup-F4TCWVSP.js").then((m) => m.run(args));
@@ -48,7 +51,7 @@ switch (command) {
     await import("./service-HZNIDNJF.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-XSIX3GGP.js").then((m) => m.run(args));
+    await import("./update-F7QWV2LB.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -92,6 +95,7 @@ Commands:
 
   volute up [--port N]                    Start the daemon (default: 4200)
   volute down                             Stop the daemon
+  volute restart [--port N]               Restart the daemon
 
   volute service install [--port N]       Install as system service (auto-start)
   volute service uninstall                Remove system service
@@ -114,7 +118,7 @@ Run 'volute --help' for usage.`);
     process.exit(1);
 }
 if (command !== "update") {
-  import("./update-check-5ZADDHCK.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-B4J6IEQ4.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);

package/dist/connectors/discord.js

@@ -122,6 +122,7 @@ client.on(Events.MessageCreate, async (message) => {
     ...message.guild?.name ? { serverName: message.guild.name } : {},
     ...participantCount ? { participantCount } : {}
   };
+  reportTyping(env, channelKey, senderName, false);
   if (isFollowedChannel && !isMentioned) {
     await fireAndForget(env, payload);
     return;
@@ -130,7 +131,7 @@ client.on(Events.MessageCreate, async (message) => {
 });
 client.on(Events.TypingStart, (typing) => {
   if (typing.user.bot) return;
-  const sender = typing.member?.displayName ?? typing.user.username ?? typing.user.id ?? "unknown";
+  const sender = typing.user.displayName || typing.user.username || typing.user.id || "unknown";
   const typingChannel = typing.guild ? `discord:${slugify(typing.guild.name)}/${slugify("name" in typing.channel ? String(typing.channel.name) : typing.channel.id)}` : `discord:@${slugify(typing.user.username ?? typing.user.id)}`;
   reportTyping(env, typingChannel, sender, true);
 });
@@ -138,10 +139,12 @@ async function handleDiscordMessage(message, payload) {
   const channel = message.channel;
   if (!("sendTyping" in channel)) return;
   const typingInterval = setInterval(() => {
-    channel.sendTyping().catch(() => {
+    channel.sendTyping().catch((err) => {
+      console.warn(`[discord] sendTyping failed: ${err}`);
     });
   }, TYPING_INTERVAL_MS);
-  channel.sendTyping().catch(() => {
+  channel.sendTyping().catch((err) => {
+    console.warn(`[discord] sendTyping failed: ${err}`);
   });
   let replied = false;
   try {
@@ -182,7 +185,8 @@ async function handleDiscordMessage(message, payload) {
         }
       },
       onError: async (msg) => {
-        await message.reply(msg).catch(() => {
+        await message.reply(msg).catch((err) => {
+          console.error(`[discord] failed to send error reply: ${err}`);
         });
       }
     });

package/dist/daemon-restart-4HVEKYFY.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  run
+} from "./chunk-EG45HBSJ.js";
+import {
+  stopDaemon
+} from "./chunk-LLJNZPCU.js";
+import "./chunk-D424ZQGI.js";
+import "./chunk-UWHWAPGO.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/daemon-restart.ts
+async function run2(args) {
+  const result = await stopDaemon();
+  if (!result.stopped && result.reason === "kill-failed") {
+    console.error("Cannot restart: failed to stop the running daemon.");
+    process.exit(1);
+  }
+  await run(args);
+}
+export {
+  run2 as run
+};