volute 0.25.0 → 0.27.0

package/dist/{chunk-JTDFJWI2.js → chunk-AW7PFDVN.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   wrapForIsolation
-} from "./chunk-NWPT4ASZ.js";
+} from "./chunk-RKQEHRBB.js";
 
 // src/lib/exec.ts
 import { execFile as execFileCb, execFileSync, spawn } from "child_process";
-function exec(cmd, args, options) {
-  const [wrappedCmd, wrappedArgs] = options?.mindName ? wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
+async function exec(cmd, args, options) {
+  const [wrappedCmd, wrappedArgs] = options?.mindName ? await wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
   return new Promise((resolve, reject) => {
     execFileCb(
       wrappedCmd,
@@ -35,8 +35,8 @@ function resolveVoluteBin() {
     throw new Error("Could not find volute binary on PATH");
   }
 }
-function execInherit(cmd, args, options) {
-  const [wrappedCmd, wrappedArgs] = options?.mindName ? wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
+async function execInherit(cmd, args, options) {
+  const [wrappedCmd, wrappedArgs] = options?.mindName ? await wrapForIsolation(cmd, args, options.mindName) : [cmd, args];
   return new Promise((resolve, reject) => {
     const child = spawn(wrappedCmd, wrappedArgs, {
       cwd: options?.cwd,

package/dist/{chunk-2767L2RZ.js → chunk-EHYDTZTF.js}

@@ -5,19 +5,19 @@ import {
   pollHealthDown,
   readDaemonConfig,
   stopService
-} from "./chunk-3AIBT4TW.js";
+} from "./chunk-LAC664WU.js";
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/commands/down.ts
 import { existsSync, readFileSync, unlinkSync } from "fs";
 import { resolve } from "path";
 async function stopDaemon() {
-  const home = voluteHome();
-  const pidPath = resolve(home, "daemon.pid");
+  const systemDir = voluteSystemDir();
+  const pidPath = resolve(systemDir, "daemon.pid");
   if (!existsSync(pidPath)) {
-    const configPath = resolve(home, "daemon.json");
+    const configPath = resolve(systemDir, "daemon.json");
     let port = 1618;
     let hostname = "localhost";
     if (existsSync(configPath)) {

package/dist/{chunk-ZSH4G2P5.js → chunk-GIE6CSN5.js}

@@ -4,34 +4,29 @@ import {
   modeLabel,
   pollHealth,
   startService
-} from "./chunk-3AIBT4TW.js";
+} from "./chunk-LAC664WU.js";
+import {
+  readGlobalConfig
+} from "./chunk-IKRVFPWU.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";
 import { existsSync, mkdirSync, openSync, readFileSync } from "fs";
 import { dirname, resolve } from "path";
-function readGlobalConfig() {
-  const configPath = resolve(voluteHome(), "config.json");
-  if (!existsSync(configPath)) return {};
-  try {
-    return JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch (err) {
-    console.error(`Invalid config file ${configPath}: ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
-  }
-}
 async function run(args) {
   const { flags } = parseArgs(args, {
     port: { type: "number" },
     host: { type: "string" },
     foreground: { type: "boolean" },
-    tailscale: { type: "boolean" }
+    tailscale: { type: "boolean" },
+    "no-sandbox": { type: "boolean" }
   });
   const mode = getServiceMode();
   if (!flags.foreground && mode !== "manual") {
@@ -57,7 +52,8 @@ async function run(args) {
   const port = flags.port ?? config.port ?? 1618;
   const hostname = flags.host ?? config.hostname ?? "127.0.0.1";
   const home = voluteHome();
-  const pidPath = resolve(home, "daemon.pid");
+  const systemDir = voluteSystemDir();
+  const pidPath = resolve(systemDir, "daemon.pid");
   if (existsSync(pidPath)) {
     try {
       const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
@@ -95,6 +91,9 @@ async function run(args) {
     }
   } catch {
   }
+  if (flags["no-sandbox"]) {
+    process.env.VOLUTE_SANDBOX = "0";
+  }
   if (flags.foreground) {
     const { startDaemon } = await import("./daemon.js");
     await startDaemon({ port, hostname, foreground: true, tailscale: flags.tailscale });
@@ -106,10 +105,12 @@ async function run(args) {
     process.exit(1);
   }
   mkdirSync(home, { recursive: true });
-  const logFile = resolve(home, "daemon.log");
+  mkdirSync(systemDir, { recursive: true });
+  const logFile = resolve(systemDir, "daemon.log");
   const logFd = openSync(logFile, "a");
   const daemonArgs = [daemonModule, "--port", String(port), "--host", hostname];
   if (flags.tailscale) daemonArgs.push("--tailscale");
+  if (flags["no-sandbox"]) daemonArgs.push("--no-sandbox");
   const child = spawn(process.execPath, daemonArgs, {
     stdio: ["ignore", "ignore", logFd],
     detached: true
@@ -151,6 +152,5 @@ async function run(args) {
 }
 
 export {
-  readGlobalConfig,
   run
 };

package/dist/chunk-H7OZRFJB.js

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// src/lib/db.ts
+import { chmodSync, existsSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+
+// src/lib/registry.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { eq, isNull } from "drizzle-orm";
+
+// src/lib/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  activity: () => activity,
+  conversationParticipants: () => conversationParticipants,
+  conversationReads: () => conversationReads,
+  conversations: () => conversations,
+  deliveryQueue: () => deliveryQueue,
+  messages: () => messages,
+  mindHistory: () => mindHistory,
+  minds: () => minds,
+  noteComments: () => noteComments,
+  noteReactions: () => noteReactions,
+  notes: () => notes,
+  sessions: () => sessions,
+  sharedSkills: () => sharedSkills,
+  systemPrompts: () => systemPrompts,
+  users: () => users
+});
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var minds = sqliteTable(
+  "minds",
+  {
+    name: text("name").primaryKey(),
+    port: integer("port").notNull().unique(),
+    parent: text("parent").references(() => minds.name, { onDelete: "cascade" }),
+    dir: text("dir"),
+    branch: text("branch"),
+    stage: text("stage"),
+    template: text("template"),
+    template_hash: text("template_hash"),
+    running: integer("running").notNull().default(0),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [index("idx_minds_parent").on(table.parent)]
+);
+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("brain"),
+  display_name: text("display_name"),
+  description: text("description"),
+  avatar: text("avatar"),
+  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+});
+var conversations = sqliteTable(
+  "conversations",
+  {
+    id: text("id").primaryKey(),
+    mind_name: text("mind_name"),
+    channel: text("channel").notNull(),
+    type: text("type").notNull().default("dm"),
+    name: text("name"),
+    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_mind_name").on(table.mind_name),
+    index("idx_conversations_user_id").on(table.user_id),
+    index("idx_conversations_updated_at").on(table.updated_at),
+    uniqueIndex("idx_conversations_name").on(table.name)
+  ]
+);
+var mindHistory = sqliteTable(
+  "mind_history",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    mind: text("mind").notNull(),
+    channel: text("channel"),
+    session: text("session"),
+    sender: text("sender"),
+    message_id: text("message_id"),
+    type: text("type").notNull(),
+    content: text("content"),
+    metadata: text("metadata"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_mind_history_mind").on(table.mind),
+    index("idx_mind_history_mind_channel").on(table.mind, table.channel),
+    index("idx_mind_history_mind_type").on(table.mind, table.type)
+  ]
+);
+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 systemPrompts = sqliteTable("system_prompts", {
+  key: text("key").primaryKey(),
+  content: text("content").notNull(),
+  updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+});
+var sharedSkills = sqliteTable("shared_skills", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  description: text("description").notNull().default(""),
+  author: text("author").notNull(),
+  version: integer("version").notNull().default(1),
+  created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
+  updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+});
+var deliveryQueue = sqliteTable(
+  "delivery_queue",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    mind: text("mind").notNull(),
+    session: text("session").notNull(),
+    channel: text("channel"),
+    sender: text("sender"),
+    status: text("status").notNull().default("pending"),
+    payload: text("payload").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_delivery_queue_mind_session").on(table.mind, table.session),
+    index("idx_delivery_queue_mind_status").on(table.mind, table.status)
+  ]
+);
+var activity = sqliteTable(
+  "activity",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    type: text("type").notNull(),
+    mind: text("mind").notNull(),
+    summary: text("summary").notNull(),
+    metadata: text("metadata"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    index("idx_activity_created_at").on(table.created_at),
+    index("idx_activity_mind").on(table.mind)
+  ]
+);
+var conversationReads = sqliteTable(
+  "conversation_reads",
+  {
+    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    last_read_message_id: integer("last_read_message_id").notNull().default(0)
+  },
+  (table) => [
+    uniqueIndex("idx_conversation_reads_unique").on(table.user_id, table.conversation_id)
+  ]
+);
+var notes = sqliteTable(
+  "notes",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    author_id: integer("author_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    slug: text("slug").notNull(),
+    content: text("content").notNull(),
+    reply_to_id: integer("reply_to_id"),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
+    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    uniqueIndex("idx_notes_author_slug").on(table.author_id, table.slug),
+    index("idx_notes_created_at").on(table.created_at),
+    index("idx_notes_reply_to").on(table.reply_to_id)
+  ]
+);
+var noteComments = sqliteTable(
+  "note_comments",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    note_id: integer("note_id").notNull().references(() => notes.id, { onDelete: "cascade" }),
+    author_id: integer("author_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    content: text("content").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [index("idx_note_comments_note_id").on(table.note_id)]
+);
+var noteReactions = sqliteTable(
+  "note_reactions",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    note_id: integer("note_id").notNull().references(() => notes.id, { onDelete: "cascade" }),
+    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    emoji: text("emoji").notNull(),
+    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
+  },
+  (table) => [
+    uniqueIndex("idx_note_reactions_unique").on(table.note_id, table.user_id, table.emoji),
+    index("idx_note_reactions_note_id").on(table.note_id)
+  ]
+);
+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/registry.ts
+function voluteHome() {
+  if (process.env.VOLUTE_HOME) return process.env.VOLUTE_HOME;
+  const dir = dirname(fileURLToPath(import.meta.url));
+  if (dir.endsWith("/src/lib")) {
+    throw new Error(
+      'VOLUTE_HOME must be set when running from source. For tests, run via "npm test" or add "--import ./test/setup.ts".'
+    );
+  }
+  return resolve(homedir(), ".volute");
+}
+function voluteUserHome() {
+  if (process.env.VOLUTE_USER_HOME) return process.env.VOLUTE_USER_HOME;
+  return resolve(homedir(), ".volute");
+}
+function voluteSystemDir() {
+  return resolve(voluteHome(), "system");
+}
+function ensureSystemDir() {
+  mkdirSync(voluteSystemDir(), { recursive: true });
+}
+function ensureVoluteHome() {
+  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve(voluteHome(), "minds");
+  mkdirSync(mindsBase, { recursive: true });
+  ensureSystemDir();
+}
+function rowToEntry(row) {
+  return {
+    name: row.name,
+    port: row.port,
+    created: row.created_at,
+    running: row.running === 1,
+    stage: row.stage ?? (row.parent ? void 0 : "sprouted"),
+    template: row.template ?? void 0,
+    templateHash: row.template_hash ?? void 0,
+    parent: row.parent ?? void 0,
+    dir: row.dir ?? void 0,
+    branch: row.branch ?? void 0
+  };
+}
+async function readRegistry() {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(isNull(minds.parent));
+  return rows.map(rowToEntry);
+}
+async function readAllMinds() {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds);
+  return rows.map(rowToEntry);
+}
+var MIND_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var MIND_NAME_MAX = 64;
+function validateMindName(name) {
+  if (!name) return "Mind name is required";
+  if (name.length > MIND_NAME_MAX) return `Mind name must be at most ${MIND_NAME_MAX} characters`;
+  if (!MIND_NAME_RE.test(name)) {
+    return "Mind name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
+  }
+  return null;
+}
+async function addMind(name, port, stage, template) {
+  const err = validateMindName(name);
+  if (err) throw new Error(err);
+  const db2 = await getDb();
+  await db2.insert(minds).values({ name, port, stage: stage ?? null, template: template ?? null }).onConflictDoUpdate({
+    target: minds.name,
+    set: { port, stage: stage ?? null, template: template ?? null }
+  });
+}
+async function addVariant(name, parent, port, dir, branch) {
+  const err = validateMindName(name);
+  if (err) throw new Error(err);
+  const db2 = await getDb();
+  await db2.insert(minds).values({ name, port, parent, dir, branch }).onConflictDoUpdate({
+    target: minds.name,
+    set: { port, parent, dir, branch }
+  });
+}
+async function removeMind(name) {
+  const db2 = await getDb();
+  await db2.delete(minds).where(eq(minds.name, name));
+}
+async function setMindRunning(name, running) {
+  const db2 = await getDb();
+  await db2.update(minds).set({ running: running ? 1 : 0 }).where(eq(minds.name, name));
+}
+async function setMindStage(name, stage) {
+  const db2 = await getDb();
+  await db2.update(minds).set({ stage }).where(eq(minds.name, name));
+}
+async function setMindTemplateHash(name, hash) {
+  const db2 = await getDb();
+  await db2.update(minds).set({ template_hash: hash }).where(eq(minds.name, name));
+}
+async function findMind(name) {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(eq(minds.name, name));
+  if (rows.length === 0) return void 0;
+  return rowToEntry(rows[0]);
+}
+async function findVariants(parent) {
+  const db2 = await getDb();
+  const rows = await db2.select().from(minds).where(eq(minds.parent, parent));
+  return rows.map(rowToEntry);
+}
+async function getBaseName(name) {
+  const entry = await findMind(name);
+  return entry?.parent ?? name;
+}
+function mindDir(name) {
+  if (process.env.VOLUTE_MINDS_DIR) {
+    return resolve(process.env.VOLUTE_MINDS_DIR, name);
+  }
+  return resolve(voluteHome(), "minds", name);
+}
+function stateDir(name) {
+  return resolve(voluteSystemDir(), "state", name);
+}
+async function nextPort() {
+  const db2 = await getDb();
+  const rows = await db2.select({ port: minds.port }).from(minds);
+  const usedPorts = new Set(rows.map((r) => r.port));
+  const basePort = parseInt(process.env.VOLUTE_BASE_PORT || "4100", 10);
+  let port = basePort;
+  while (usedPorts.has(port)) port++;
+  if (port > 65535) throw new Error("No available ports \u2014 all ports 4100-65535 are allocated");
+  return port;
+}
+function daemonLoopback() {
+  const host = process.env.VOLUTE_DAEMON_HOSTNAME || "127.0.0.1";
+  if (host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return host;
+}
+
+// src/lib/db.ts
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var migrationsFolder = existsSync(resolve2(__dirname, "../drizzle")) ? resolve2(__dirname, "../drizzle") : resolve2(__dirname, "../../drizzle");
+var db = null;
+async function getDb() {
+  if (db) return db;
+  const dbPath = process.env.VOLUTE_DB_PATH || resolve2(voluteSystemDir(), "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;
+}
+
+export {
+  minds,
+  users,
+  conversations,
+  mindHistory,
+  conversationParticipants,
+  sessions,
+  systemPrompts,
+  sharedSkills,
+  deliveryQueue,
+  activity,
+  conversationReads,
+  notes,
+  noteComments,
+  noteReactions,
+  messages,
+  getDb,
+  voluteHome,
+  voluteUserHome,
+  voluteSystemDir,
+  ensureSystemDir,
+  ensureVoluteHome,
+  readRegistry,
+  readAllMinds,
+  validateMindName,
+  addMind,
+  addVariant,
+  removeMind,
+  setMindRunning,
+  setMindStage,
+  setMindTemplateHash,
+  findMind,
+  findVariants,
+  getBaseName,
+  mindDir,
+  stateDir,
+  nextPort,
+  daemonLoopback
+};

package/dist/{chunk-ON3FF5JA.js → chunk-HDN7MNGD.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 var CACHE_TTL = 60 * 60 * 1e3;
 function cachePath() {
-  return resolve(voluteHome(), "update-check.json");
+  return resolve(voluteSystemDir(), "update-check.json");
 }
 function readCache() {
   try {