volute 0.5.0 → 0.7.0

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

@@ -6,39 +6,42 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "create":
-      await import("./create-RVCZN6HE.js").then((m) => m.run(args.slice(1)));
+      await import("./create-G525LWEA.js").then((m) => m.run(args.slice(1)));
       break;
     case "start":
-      await import("./start-TUOXDSFL.js").then((m) => m.run(args.slice(1)));
+      await import("./start-VHQ7LNWM.js").then((m) => m.run(args.slice(1)));
       break;
     case "stop":
-      await import("./stop-AOJZLQ5X.js").then((m) => m.run(args.slice(1)));
+      await import("./stop-CAGCT5NI.js").then((m) => m.run(args.slice(1)));
+      break;
+    case "restart":
+      await import("./restart-O4ETYLJF.js").then((m) => m.run(args.slice(1)));
       break;
     case "delete":
-      await import("./delete-3QH7VYIN.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-A36EHRO4.js").then((m) => m.run(args.slice(1)));
+      await import("./status-QAJWXKMZ.js").then((m) => m.run(args.slice(1)));
       break;
     case "status": {
       const rest = args.slice(1);
       if (!rest[0] && process.env.VOLUTE_AGENT) {
         rest.unshift(process.env.VOLUTE_AGENT);
       }
-      await import("./status-A36EHRO4.js").then((m) => m.run(rest));
+      await import("./status-QAJWXKMZ.js").then((m) => m.run(rest));
       break;
     }
     case "logs": {
       const rest = args.slice(1);
       const logsArgs = transformAgentFlag(rest);
-      await import("./logs-DF342W4M.js").then((m) => m.run(logsArgs));
+      await import("./logs-EDGK26AK.js").then((m) => m.run(logsArgs));
       break;
     }
     case "upgrade":
-      await import("./upgrade-FX2TKJ2S.js").then((m) => m.run(args.slice(1)));
+      await import("./upgrade-YXKPWDRU.js").then((m) => m.run(args.slice(1)));
       break;
     case "import":
-      await import("./import-MXJB2EII.js").then((m) => m.run(args.slice(1)));
+      await import("./import-AVKQJDYC.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":
@@ -61,6 +64,7 @@ function printUsage() {
   volute agent create <name> [--template <name>]
   volute agent start <name>
   volute agent stop [name]
+  volute agent restart [name]
   volute agent delete [name] [--force]
   volute agent list
   volute agent status [name]

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

@@ -3,10 +3,10 @@ import {
   AgentManager,
   getAgentManager,
   initAgentManager
-} from "./chunk-MW2KFO3B.js";
-import "./chunk-HE67X4T6.js";
-import "./chunk-UAVD2AHX.js";
-import "./chunk-UX25Z2ND.js";
+} from "./chunk-62X577Y7.js";
+import "./chunk-H7AMDUIA.js";
+import "./chunk-W76KWE23.js";
+import "./chunk-UWHWAPGO.js";
 import "./chunk-K3NQKI34.js";
 export {
   AgentManager,

package/dist/channel-SMCNOIVQ.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import {
+  readStdin
+} from "./chunk-ZYGKG6VC.js";
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  CHANNELS,
+  getChannelDriver
+} from "./chunk-ZZOOTYXK.js";
+import {
+  loadMergedEnv
+} from "./chunk-H7AMDUIA.js";
+import {
+  writeChannelEntry
+} from "./chunk-BX7KI4S3.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  daemonFetch
+} from "./chunk-JR4UXCTO.js";
+import {
+  resolveAgent
+} from "./chunk-UWHWAPGO.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/channel.ts
+async function run(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "read":
+      await readChannel(args.slice(1));
+      break;
+    case "send":
+      await sendChannel(args.slice(1));
+      break;
+    case "list":
+      await listChannels(args.slice(1));
+      break;
+    case "users":
+      await listUsers(args.slice(1));
+      break;
+    case "create":
+      await createChannel(args.slice(1));
+      break;
+    case "typing":
+      await typingChannel(args.slice(1));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printUsage();
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`Usage:
+  volute channel read <channel-uri> [--limit N] [--agent <name>]
+  volute channel send <channel-uri> "<message>" [--agent <name>]
+  volute channel list [<platform>] [--agent <name>]
+  volute channel users <platform> [--agent <name>]
+  volute channel create <platform> --participants user1,user2 [--name "..."] [--agent <name>]
+  volute channel typing <channel-uri> [--agent <name>]
+  echo "message" | volute channel send <channel-uri> [--agent <name>]`);
+}
+async function readChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" },
+    limit: { type: "number" }
+  });
+  const uri = positional[0];
+  if (!uri) {
+    console.error("Usage: volute channel read <channel-uri> [--limit N] [--agent <name>]");
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const { platform } = parseUri(uri);
+  const driver = requireDriver(platform);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
+  try {
+    const limit = flags.limit ?? 20;
+    const output = await driver.read(env, uri, limit);
+    console.log(output);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function sendChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const uri = positional[0];
+  const message = positional[1] ?? await readStdin();
+  if (!uri || !message) {
+    console.error('Usage: volute channel send <channel-uri> "<message>" [--agent <name>]');
+    console.error('       echo "message" | volute channel send <channel-uri> [--agent <name>]');
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const { platform } = parseUri(uri);
+  const driver = requireDriver(platform);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
+  try {
+    await driver.send(env, uri, message);
+    try {
+      await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/history`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ channel: uri, content: message })
+      });
+    } catch (err) {
+      console.error(`Failed to persist to history: ${err instanceof Error ? err.message : err}`);
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function listChannels(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const platform = positional[0];
+  const agentName = resolveAgentName(flags);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
+  const platforms = platform ? [platform] : Object.keys(CHANNELS);
+  for (const p of platforms) {
+    const driver = getChannelDriver(p);
+    if (!driver?.listConversations) continue;
+    try {
+      const convs = await driver.listConversations(env);
+      for (const conv of convs) {
+        writeChannelEntry(dir, conv.id, {
+          platformId: conv.platformId,
+          platform: p,
+          name: conv.name,
+          type: conv.type
+        });
+        const parts = [conv.id.padEnd(24), conv.name.padEnd(28), conv.type];
+        if (conv.participantCount != null) {
+          parts.push(String(conv.participantCount));
+        }
+        console.log(parts.join("  "));
+      }
+    } catch (err) {
+      console.error(`${p}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+async function listUsers(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const platform = positional[0];
+  if (!platform) {
+    console.error("Usage: volute channel users <platform> [--agent <name>]");
+    process.exit(1);
+  }
+  const driver = requireDriver(platform);
+  if (!driver.listUsers) {
+    console.error(`Platform ${platform} does not support listing users`);
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
+  try {
+    const users = await driver.listUsers(env);
+    for (const user of users) {
+      console.log(`${user.username.padEnd(20)}  ${user.id.padEnd(20)}  ${user.type ?? ""}`);
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function createChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" },
+    participants: { type: "string" },
+    name: { type: "string" }
+  });
+  const platform = positional[0];
+  if (!platform || !flags.participants) {
+    console.error(
+      'Usage: volute channel create <platform> --participants user1,user2 [--name "..."] [--agent <name>]'
+    );
+    process.exit(1);
+  }
+  const driver = requireDriver(platform);
+  if (!driver.createConversation) {
+    console.error(`Platform ${platform} does not support creating conversations`);
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
+  const participants = flags.participants.split(",").map((s) => s.trim());
+  try {
+    const slug = await driver.createConversation(env, participants, flags.name);
+    console.log(slug);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function typingChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const uri = positional[0];
+  if (!uri) {
+    console.error("Usage: volute channel typing <channel-uri> [--agent <name>]");
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  try {
+    const res = await daemonFetch(
+      `/api/agents/${encodeURIComponent(agentName)}/typing?channel=${encodeURIComponent(uri)}`
+    );
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(body.error ?? `Server responded with ${res.status}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    if (data.typing.length > 0) {
+      console.log(data.typing.join(", "));
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function parseUri(uri) {
+  const colonIdx = uri.indexOf(":");
+  if (colonIdx === -1) {
+    console.error(`Invalid channel URI: ${uri} (expected format: platform:id)`);
+    process.exit(1);
+  }
+  return { platform: uri.slice(0, colonIdx), channelId: uri.slice(colonIdx + 1) };
+}
+function requireDriver(platform) {
+  const driver = getChannelDriver(platform);
+  if (!driver) {
+    console.error(`No channel driver for platform: ${platform}`);
+    process.exit(1);
+  }
+  return driver;
+}
+export {
+  run
+};

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-HE67X4T6.js";
+} from "./chunk-H7AMDUIA.js";
 import {
   applyIsolation
-} from "./chunk-UAVD2AHX.js";
+} from "./chunk-W76KWE23.js";
 import {
   agentDir,
   findAgent,
@@ -13,7 +13,7 @@ import {
   setVariantRunning,
   validateBranchName,
   voluteHome
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 
 // src/lib/agent-manager.ts
 import { execFile, spawn } from "child_process";
@@ -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
+};