volute 0.18.0 → 0.20.0

package/dist/{chunk-AYB7XAWO.js → chunk-PUVXOZ6T.js}

@@ -1,12 +1,21 @@
 #!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
 import {
   loadMergedEnv
-} from "./chunk-OYSZNX5I.js";
+} from "./chunk-VDWCHYTS.js";
+import {
+  getDb
+} from "./chunk-5XNT2472.js";
+import {
+  systemPrompts
+} from "./chunk-NSE7VJQA.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   wrapForIsolation
-} from "./chunk-ZCEYUUID.js";
+} from "./chunk-OGXOMR65.js";
 import {
   findMind,
   findVariant,
@@ -15,15 +24,12 @@ import {
   setVariantRunning,
   stateDir,
   voluteHome
-} from "./chunk-M77QBTEH.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/mind-manager.ts
 import { execFile, spawn } from "child_process";
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
 import { promisify } from "util";
 
 // src/lib/json-state.ts
@@ -63,210 +69,8 @@ function clearJsonMap(path, map) {
   }
 }
 
-// src/lib/log-buffer.ts
-var LogBuffer = class {
-  entries = [];
-  maxSize = 1e3;
-  subscribers = /* @__PURE__ */ new Set();
-  append(entry) {
-    this.entries.push(entry);
-    if (this.entries.length > this.maxSize) {
-      this.entries.shift();
-    }
-    for (const sub of this.subscribers) {
-      sub(entry);
-    }
-  }
-  getEntries() {
-    return [...this.entries];
-  }
-  subscribe(fn) {
-    this.subscribers.add(fn);
-    return () => this.subscribers.delete(fn);
-  }
-};
-var logBuffer = new LogBuffer();
-
-// src/lib/logger.ts
-var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
-var minLevel = LEVELS[process.env.VOLUTE_LOG_LEVEL || "info"] ?? LEVELS.info;
-var output = (line) => process.stderr.write(`${line}
-`);
-function write(level, cat, msg, data) {
-  if (LEVELS[level] < minLevel) return;
-  const entry = {
-    level,
-    cat,
-    msg,
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    ...data ? { data } : {}
-  };
-  output(JSON.stringify(entry));
-  logBuffer.append(entry);
-}
-function child(cat) {
-  return {
-    debug: (msg, data) => write("debug", cat, msg, data),
-    info: (msg, data) => write("info", cat, msg, data),
-    warn: (msg, data) => write("warn", cat, msg, data),
-    error: (msg, data) => write("error", cat, msg, data)
-  };
-}
-function errorData(err) {
-  if (err instanceof Error) return { error: err.stack ?? err.message };
-  return { error: String(err) };
-}
-var log = {
-  ...child("system"),
-  child,
-  errorData,
-  setLevel(level) {
-    minLevel = LEVELS[level];
-  },
-  setOutput(fn) {
-    output = fn;
-  }
-};
-var logger_default = log;
-
 // src/lib/prompts.ts
 import { eq } from "drizzle-orm";
-
-// src/lib/db.ts
-import { chmodSync, existsSync as existsSync2 } 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, {
-  conversationParticipants: () => conversationParticipants,
-  conversations: () => conversations,
-  messages: () => messages,
-  mindHistory: () => mindHistory,
-  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 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(),
-    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 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 = existsSync2(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/prompts.ts
 var PROMPT_KEYS = [
   "seed_soul",
   "default_soul",
@@ -372,8 +176,8 @@ async function getPrompt(key, vars) {
   if (!isValidKey(key)) return "";
   let content = PROMPT_DEFAULTS[key].content;
   try {
-    const db2 = await getDb();
-    const row = await db2.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key)).get();
+    const db = await getDb();
+    const row = await db.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key)).get();
     if (row) content = row.content;
   } catch (err) {
     console.error(`[prompts] failed to read DB override for "${key}":`, err);
@@ -383,8 +187,8 @@ async function getPrompt(key, vars) {
 async function getPromptIfCustom(key) {
   if (!isValidKey(key)) return null;
   try {
-    const db2 = await getDb();
-    const row = await db2.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key)).get();
+    const db = await getDb();
+    const row = await db.select({ content: systemPrompts.content }).from(systemPrompts).where(eq(systemPrompts.key, key)).get();
     return row?.content ?? null;
   } catch (err) {
     console.error(`[prompts] failed to check DB customization for "${key}":`, err);
@@ -398,8 +202,8 @@ async function getMindPromptDefaults() {
     result[key] = PROMPT_DEFAULTS[key].content;
   }
   try {
-    const db2 = await getDb();
-    const rows = await db2.select().from(systemPrompts).all();
+    const db = await getDb();
+    const rows = await db.select().from(systemPrompts).all();
     for (const row of rows) {
       if (MIND_PROMPT_KEYS.includes(row.key)) {
         result[row.key] = row.content;
@@ -411,10 +215,55 @@ async function getMindPromptDefaults() {
   return result;
 }
 
+// src/lib/restart-tracker.ts
+var DEFAULT_MAX_ATTEMPTS = 5;
+var DEFAULT_BASE_DELAY = 3e3;
+var DEFAULT_MAX_DELAY = 6e4;
+var RestartTracker = class {
+  attempts = /* @__PURE__ */ new Map();
+  maxAttempts;
+  baseDelay;
+  maxDelay;
+  constructor(opts) {
+    this.maxAttempts = opts?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    this.baseDelay = opts?.baseDelay ?? DEFAULT_BASE_DELAY;
+    this.maxDelay = opts?.maxDelay ?? DEFAULT_MAX_DELAY;
+  }
+  recordCrash(key) {
+    const attempts = this.attempts.get(key) ?? 0;
+    if (attempts >= this.maxAttempts) {
+      return { shouldRestart: false, delay: 0, attempt: attempts };
+    }
+    const delay = Math.min(this.baseDelay * 2 ** attempts, this.maxDelay);
+    this.attempts.set(key, attempts + 1);
+    return { shouldRestart: true, delay, attempt: attempts + 1 };
+  }
+  reset(key) {
+    return this.attempts.delete(key);
+  }
+  getAttempts(key) {
+    return this.attempts.get(key) ?? 0;
+  }
+  get maxRestartAttempts() {
+    return this.maxAttempts;
+  }
+  /** Bulk-load attempts from a Map (for persistence). */
+  load(data) {
+    this.attempts = new Map(data);
+  }
+  /** Export current attempts as a Map (for persistence). */
+  save() {
+    return new Map(this.attempts);
+  }
+  clear() {
+    this.attempts.clear();
+  }
+};
+
 // src/lib/rotating-log.ts
 import {
   createWriteStream,
-  existsSync as existsSync3,
+  existsSync as existsSync2,
   renameSync,
   rmSync,
   statSync
@@ -430,7 +279,7 @@ var RotatingLog = class extends Writable {
     this.on("error", () => {
     });
     try {
-      this.size = existsSync3(path) ? statSync(path).size : 0;
+      this.size = existsSync2(path) ? statSync(path).size : 0;
     } catch {
       this.size = 0;
     }
@@ -443,11 +292,11 @@ var RotatingLog = class extends Writable {
     if (this.size > this.maxSize) {
       try {
         const oldest = `${this.path}.${this.maxFiles}`;
-        if (existsSync3(oldest)) rmSync(oldest);
+        if (existsSync2(oldest)) rmSync(oldest);
         for (let i = this.maxFiles - 1; i >= 1; i--) {
           const from = `${this.path}.${i}`;
           const to = `${this.path}.${i + 1}`;
-          if (existsSync3(from)) renameSync(from, to);
+          if (existsSync2(from)) renameSync(from, to);
         }
         renameSync(this.path, `${this.path}.1`);
         const oldStream = this.stream;
@@ -468,16 +317,13 @@ var RotatingLog = class extends Writable {
 var mlog = logger_default.child("minds");
 var execFileAsync = promisify(execFile);
 function mindPidPath(name) {
-  return resolve2(stateDir(name), "mind.pid");
+  return resolve(stateDir(name), "mind.pid");
 }
-var MAX_RESTART_ATTEMPTS = 5;
-var BASE_RESTART_DELAY = 3e3;
-var MAX_RESTART_DELAY = 6e4;
 var MindManager = class {
   minds = /* @__PURE__ */ new Map();
   stopping = /* @__PURE__ */ new Set();
   shuttingDown = false;
-  restartAttempts = /* @__PURE__ */ new Map();
+  restartTracker = new RestartTracker();
   pendingContext = /* @__PURE__ */ new Map();
   resolveTarget(name) {
     const [baseName, variantName] = name.split("@", 2);
@@ -489,7 +335,7 @@ var MindManager = class {
       return { dir: variant.path, port: variant.port, isVariant: true, baseName, variantName };
     }
     const dir = mindDir(baseName);
-    if (!existsSync4(dir)) throw new Error(`Mind directory missing: ${dir}`);
+    if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
     return { dir, port: entry.port, isVariant: false, baseName };
   }
   async startMind(name) {
@@ -501,7 +347,7 @@ var MindManager = class {
     const port = target.port;
     const pidFile = mindPidPath(name);
     try {
-      if (existsSync4(pidFile)) {
+      if (existsSync3(pidFile)) {
         const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
         if (stalePid > 0) {
           try {
@@ -535,7 +381,7 @@ var MindManager = class {
     } catch {
     }
     const mindStateDir = stateDir(name);
-    const logsDir = resolve2(mindStateDir, "logs");
+    const logsDir = resolve(mindStateDir, "logs");
     mkdirSync(logsDir, { recursive: true });
     if (isIsolationEnabled()) {
       try {
@@ -546,7 +392,7 @@ var MindManager = class {
         );
       }
     }
-    const logStream = new RotatingLog(resolve2(logsDir, "mind.log"));
+    const logStream = new RotatingLog(resolve(logsDir, "mind.log"));
     const mindEnv = loadMergedEnv(name);
     const env = {
       ...process.env,
@@ -559,9 +405,9 @@ var MindManager = class {
       CLAUDECODE: void 0
     };
     if (isIsolationEnabled()) {
-      env.HOME = resolve2(dir, "home");
+      env.HOME = resolve(dir, "home");
     }
-    const tsxBin = resolve2(dir, "node_modules", ".bin", "tsx");
+    const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
     const tsxArgs = ["src/server.ts", "--port", String(port)];
     const [spawnCmd, spawnArgs] = wrapForIsolation(tsxBin, tsxArgs, name);
     const spawnOpts = {
@@ -570,28 +416,28 @@ var MindManager = class {
       detached: true,
       env
     };
-    const child2 = spawn(spawnCmd, spawnArgs, spawnOpts);
-    this.minds.set(name, { child: child2, port });
-    child2.stdout?.pipe(logStream);
-    child2.stderr?.pipe(logStream);
+    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
+    this.minds.set(name, { child, port });
+    child.stdout?.pipe(logStream);
+    child.stderr?.pipe(logStream);
     try {
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve2, reject) => {
         const timeout = setTimeout(() => {
           reject(new Error(`Mind ${name} did not start within 30s`));
         }, 3e4);
         function checkOutput(data) {
           if (data.toString().match(/listening on :\d+/)) {
             clearTimeout(timeout);
-            resolve3();
+            resolve2();
           }
         }
-        child2.stdout?.on("data", checkOutput);
-        child2.stderr?.on("data", checkOutput);
-        child2.on("error", (err) => {
+        child.stdout?.on("data", checkOutput);
+        child.stderr?.on("data", checkOutput);
+        child.on("error", (err) => {
           clearTimeout(timeout);
           reject(err);
         });
-        child2.on("exit", (code) => {
+        child.on("exit", (code) => {
           clearTimeout(timeout);
           reject(new Error(`Mind ${name} exited with code ${code} during startup`));
         });
@@ -599,20 +445,20 @@ var MindManager = class {
     } catch (err) {
       this.minds.delete(name);
       try {
-        child2.kill();
+        child.kill();
       } catch {
       }
       throw err;
     }
-    if (child2.pid) {
+    if (child.pid) {
       try {
-        writeFileSync2(pidFile, String(child2.pid));
+        writeFileSync2(pidFile, String(child.pid));
       } catch (err) {
         mlog.warn(`failed to write PID file for ${name}`, logger_default.errorData(err));
       }
     }
-    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    this.setupCrashRecovery(name, child2);
+    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
+    this.setupCrashRecovery(name, child);
     if (isVariant) {
       setVariantRunning(baseName, variantName, true);
     } else {
@@ -654,14 +500,21 @@ var MindManager = class {
       mlog.warn(`failed to deliver pending context to ${name}`, logger_default.errorData(err));
     }
   }
-  setupCrashRecovery(name, child2) {
-    child2.on("exit", async (code) => {
+  setupCrashRecovery(name, child) {
+    child.on("exit", async (code) => {
       this.minds.delete(name);
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
-      const attempts = this.restartAttempts.get(name) ?? 0;
-      if (attempts >= MAX_RESTART_ATTEMPTS) {
-        mlog.error(`${name} crashed ${attempts} times \u2014 giving up on restart`);
+      import("./mind-activity-tracker-624QLQLC.js").then(({ markIdle }) => markIdle(name)).catch(() => {
+      });
+      import("./activity-events-OMXKXD5N.js").then(
+        ({ publish }) => publish({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
+      ).catch(() => {
+      });
+      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
+      this.saveCrashAttempts();
+      if (!shouldRestart) {
+        mlog.error(`${name} crashed ${attempt} times \u2014 giving up on restart`);
         const [base, variant] = name.split("@", 2);
         if (variant) {
           setVariantRunning(base, variant, false);
@@ -670,11 +523,8 @@ var MindManager = class {
         }
         return;
       }
-      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
-      this.restartAttempts.set(name, attempts + 1);
-      this.saveCrashAttempts();
       mlog.info(
-        `crash recovery for ${name} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, restarting in ${delay}ms`
+        `crash recovery for ${name} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, restarting in ${delay}ms`
       );
       setTimeout(() => {
         if (this.shuttingDown) return;
@@ -688,25 +538,25 @@ var MindManager = class {
     const tracked = this.minds.get(name);
     if (!tracked) return;
     this.stopping.add(name);
-    const { child: child2 } = tracked;
+    const { child } = tracked;
     this.minds.delete(name);
-    await new Promise((resolve3) => {
-      child2.on("exit", () => resolve3());
+    await new Promise((resolve2) => {
+      child.on("exit", () => resolve2());
       try {
-        process.kill(-child2.pid, "SIGTERM");
+        process.kill(-child.pid, "SIGTERM");
       } catch {
-        resolve3();
+        resolve2();
       }
       setTimeout(() => {
         try {
-          process.kill(-child2.pid, "SIGKILL");
+          process.kill(-child.pid, "SIGKILL");
         } catch {
         }
-        resolve3();
+        resolve2();
       }, 5e3);
     });
     this.stopping.delete(name);
-    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
+    if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     rmSync2(mindPidPath(name), { force: true });
     if (!this.shuttingDown) {
       const [baseName, variantName] = name.split("@", 2);
@@ -734,16 +584,17 @@ var MindManager = class {
     return [...this.minds.keys()];
   }
   get crashAttemptsPath() {
-    return resolve2(voluteHome(), "crash-attempts.json");
+    return resolve(voluteHome(), "crash-attempts.json");
   }
   loadCrashAttempts() {
-    this.restartAttempts = loadJsonMap(this.crashAttemptsPath);
+    this.restartTracker.load(loadJsonMap(this.crashAttemptsPath));
   }
   saveCrashAttempts() {
-    saveJsonMap(this.crashAttemptsPath, this.restartAttempts);
+    saveJsonMap(this.crashAttemptsPath, this.restartTracker.save());
   }
   clearCrashAttempts() {
-    clearJsonMap(this.crashAttemptsPath, this.restartAttempts);
+    this.restartTracker.clear();
+    clearJsonMap(this.crashAttemptsPath, /* @__PURE__ */ new Map());
   }
 };
 async function killProcessOnPort(port) {
@@ -780,26 +631,16 @@ function initMindManager() {
   return instance;
 }
 function getMindManager() {
-  if (!instance) instance = new MindManager();
+  if (!instance) throw new Error("MindManager not initialized \u2014 call initMindManager() first");
   return instance;
 }
 
 export {
-  logBuffer,
-  logger_default,
+  RestartTracker,
   RotatingLog,
   loadJsonMap,
   saveJsonMap,
   clearJsonMap,
-  users,
-  conversations,
-  mindHistory,
-  conversationParticipants,
-  sessions,
-  systemPrompts,
-  sharedSkills,
-  messages,
-  getDb,
   PROMPT_KEYS,
   PROMPT_DEFAULTS,
   substitute,

package/dist/{chunk-GK4E7LM7.js → chunk-RHEGSQFJ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   stateDir
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/slugify.ts
 function slugify(text) {

package/dist/{chunk-MVSXRMJJ.js → chunk-SCUDS4US.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-M77QBTEH.js";
+} from "./chunk-EBGCNDMM.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";