volute 0.16.0 → 0.18.0

package/dist/chunk-AYB7XAWO.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+import {
+  loadMergedEnv
+} from "./chunk-OYSZNX5I.js";
+import {
+  chownMindDir,
+  isIsolationEnabled,
+  wrapForIsolation
+} from "./chunk-ZCEYUUID.js";
+import {
+  findMind,
+  findVariant,
+  mindDir,
+  setMindRunning,
+  setVariantRunning,
+  stateDir,
+  voluteHome
+} from "./chunk-M77QBTEH.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.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 { promisify } from "util";
+
+// src/lib/json-state.ts
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+function loadJsonMap(path) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    if (existsSync(path)) {
+      const data = JSON.parse(readFileSync(path, "utf-8"));
+      for (const [key, value] of Object.entries(data)) {
+        if (typeof value === "number") map.set(key, value);
+      }
+    }
+  } catch (err) {
+    console.warn(`[state] failed to load ${path}:`, err);
+  }
+  return map;
+}
+function saveJsonMap(path, map) {
+  const data = {};
+  for (const [key, value] of map) {
+    data[key] = value;
+  }
+  try {
+    writeFileSync(path, `${JSON.stringify(data)}
+`);
+  } catch (err) {
+    console.warn(`[state] failed to save ${path}:`, err);
+  }
+}
+function clearJsonMap(path, map) {
+  map.clear();
+  try {
+    if (existsSync(path)) unlinkSync(path);
+  } catch (err) {
+    console.warn(`[state] failed to clear ${path}:`, err);
+  }
+}
+
+// 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",
+  "default_memory",
+  "sprout_message",
+  "restart_message",
+  "merge_message",
+  "compaction_warning",
+  "reply_instructions",
+  "channel_invite"
+];
+var PROMPT_DEFAULTS = {
+  seed_soul: {
+    content: `You are \${name}.
+
+You don't have a soul yet. You're a seed \u2014 a new mind in the process of discovering who you are.
+\${description}
+Have a conversation with the human. Explore what kind of mind you want to be. When you're ready, write your SOUL.md and MEMORY.md, then run \`volute sprout\` to complete the transformation.
+`,
+    description: "SOUL.md for seed minds",
+    variables: ["name", "description"],
+    category: "creation"
+  },
+  default_soul: {
+    content: `You are {{name}}.
+`,
+    description: "SOUL.md for sprouted minds. Uses {{name}} placeholder (replaced at creation, not by ${var} system)",
+    variables: ["name"],
+    category: "creation"
+  },
+  default_memory: {
+    content: "",
+    description: "Initial MEMORY.md for new minds",
+    variables: [],
+    category: "creation"
+  },
+  sprout_message: {
+    content: "[system] You've sprouted. You now have full capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details.",
+    description: "Sent when a seed mind sprouts",
+    variables: [],
+    category: "system"
+  },
+  restart_message: {
+    content: "[system] You have been restarted.",
+    description: "Generic restart notification",
+    variables: [],
+    category: "system"
+  },
+  merge_message: {
+    content: '[system] Variant "${name}" has been merged and you have been restarted.',
+    description: "Variant merge notification",
+    variables: ["name"],
+    category: "system"
+  },
+  compaction_warning: {
+    content: `Context is getting long \u2014 compaction is about to summarize this conversation. Before that happens, save anything important to files (MEMORY.md, memory/journal/\${date}.md, etc.) since those survive compaction. Focus on: decisions made, open tasks, and anything you'd need to pick up where you left off.`,
+    description: "Pre-compaction save reminder sent to the mind",
+    variables: ["date"],
+    category: "mind"
+  },
+  reply_instructions: {
+    content: 'To reply to this message, use: volute send ${channel} "your message"',
+    description: "First-message reply hint injected via hook",
+    variables: ["channel"],
+    category: "mind"
+  },
+  channel_invite: {
+    content: `[Channel Invite]
+\${headers}
+
+[\${sender} \u2014 \${time}]
+\${preview}
+
+Further messages will be saved to \${filePath}
+
+To accept, add to .config/routes.json:
+  Rule: { "channel": "\${channel}", "session": "\${suggestedSession}" }
+\${batchRecommendation}To respond, use: volute send \${channel} "your message"
+To reject, delete \${filePath}`,
+    description: "New channel notification template",
+    variables: [
+      "headers",
+      "sender",
+      "time",
+      "preview",
+      "filePath",
+      "channel",
+      "suggestedSession",
+      "batchRecommendation"
+    ],
+    category: "mind"
+  }
+};
+function isValidKey(key) {
+  return PROMPT_KEYS.includes(key);
+}
+function substitute(template, vars) {
+  return template.replace(/\$\{(\w+)\}/g, (match, name) => {
+    return name in vars ? vars[name] : match;
+  });
+}
+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();
+    if (row) content = row.content;
+  } catch (err) {
+    console.error(`[prompts] failed to read DB override for "${key}":`, err);
+  }
+  return vars ? substitute(content, vars) : content;
+}
+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();
+    return row?.content ?? null;
+  } catch (err) {
+    console.error(`[prompts] failed to check DB customization for "${key}":`, err);
+    return null;
+  }
+}
+var MIND_PROMPT_KEYS = PROMPT_KEYS.filter((k) => PROMPT_DEFAULTS[k].category === "mind");
+async function getMindPromptDefaults() {
+  const result = {};
+  for (const key of MIND_PROMPT_KEYS) {
+    result[key] = PROMPT_DEFAULTS[key].content;
+  }
+  try {
+    const db2 = await getDb();
+    const rows = await db2.select().from(systemPrompts).all();
+    for (const row of rows) {
+      if (MIND_PROMPT_KEYS.includes(row.key)) {
+        result[row.key] = row.content;
+      }
+    }
+  } catch (err) {
+    console.error("[prompts] failed to read DB overrides for mind prompt defaults:", err);
+  }
+  return result;
+}
+
+// src/lib/rotating-log.ts
+import {
+  createWriteStream,
+  existsSync as existsSync3,
+  renameSync,
+  rmSync,
+  statSync
+} from "fs";
+import { Writable } from "stream";
+var MAX_SIZE = 10 * 1024 * 1024;
+var RotatingLog = class extends Writable {
+  constructor(path, maxSize = MAX_SIZE, maxFiles = 5) {
+    super();
+    this.path = path;
+    this.maxSize = maxSize;
+    this.maxFiles = maxFiles;
+    this.on("error", () => {
+    });
+    try {
+      this.size = existsSync3(path) ? statSync(path).size : 0;
+    } catch {
+      this.size = 0;
+    }
+    this.stream = createWriteStream(path, { flags: "a" });
+  }
+  stream;
+  size;
+  _write(chunk, _encoding, callback) {
+    this.size += chunk.length;
+    if (this.size > this.maxSize) {
+      try {
+        const oldest = `${this.path}.${this.maxFiles}`;
+        if (existsSync3(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);
+        }
+        renameSync(this.path, `${this.path}.1`);
+        const oldStream = this.stream;
+        this.stream = createWriteStream(this.path);
+        this.size = chunk.length;
+        oldStream.end();
+      } catch {
+      }
+    }
+    this.stream.write(chunk, callback);
+  }
+  _final(callback) {
+    this.stream.end(callback);
+  }
+};
+
+// src/lib/mind-manager.ts
+var mlog = logger_default.child("minds");
+var execFileAsync = promisify(execFile);
+function mindPidPath(name) {
+  return resolve2(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();
+  pendingContext = /* @__PURE__ */ new Map();
+  resolveTarget(name) {
+    const [baseName, variantName] = name.split("@", 2);
+    const entry = findMind(baseName);
+    if (!entry) throw new Error(`Unknown mind: ${baseName}`);
+    if (variantName) {
+      const variant = findVariant(baseName, variantName);
+      if (!variant) throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
+      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}`);
+    return { dir, port: entry.port, isVariant: false, baseName };
+  }
+  async startMind(name) {
+    if (this.minds.has(name)) {
+      throw new Error(`Mind ${name} is already running`);
+    }
+    const target = this.resolveTarget(name);
+    const { dir, isVariant, baseName, variantName } = target;
+    const port = target.port;
+    const pidFile = mindPidPath(name);
+    try {
+      if (existsSync4(pidFile)) {
+        const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
+        if (stalePid > 0) {
+          try {
+            process.kill(stalePid, 0);
+            const { stdout } = await execFileAsync("ps", ["-p", String(stalePid), "-o", "args="]);
+            if (stdout.includes("server.ts")) {
+              mlog.warn(`killing stale mind process ${stalePid} for ${name}`);
+              process.kill(-stalePid, "SIGTERM");
+              await new Promise((r) => setTimeout(r, 500));
+            } else {
+              mlog.debug(`stale PID ${stalePid} for ${name} is not a mind process, skipping`);
+            }
+          } catch (err) {
+            if (err.code !== "ESRCH") {
+              mlog.warn(`failed to check/kill stale process for ${name}`, logger_default.errorData(err));
+            }
+          }
+        }
+        rmSync2(pidFile, { force: true });
+      }
+    } catch (err) {
+      mlog.warn(`failed to read PID file for ${name}`, logger_default.errorData(err));
+    }
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/health`);
+      if (res.ok) {
+        mlog.warn(`killing orphan process on port ${port}`);
+        await killProcessOnPort(port);
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    } catch {
+    }
+    const mindStateDir = stateDir(name);
+    const logsDir = resolve2(mindStateDir, "logs");
+    mkdirSync(logsDir, { recursive: true });
+    if (isIsolationEnabled()) {
+      try {
+        chownMindDir(mindStateDir, baseName);
+      } catch (err) {
+        throw new Error(
+          `Cannot start mind ${name}: failed to set ownership on state directory ${mindStateDir}: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+    const logStream = new RotatingLog(resolve2(logsDir, "mind.log"));
+    const mindEnv = loadMergedEnv(name);
+    const env = {
+      ...process.env,
+      ...mindEnv,
+      VOLUTE_MIND: name,
+      VOLUTE_STATE_DIR: stateDir(name),
+      VOLUTE_MIND_DIR: dir,
+      VOLUTE_MIND_PORT: String(port),
+      // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
+      CLAUDECODE: void 0
+    };
+    if (isIsolationEnabled()) {
+      env.HOME = resolve2(dir, "home");
+    }
+    const tsxBin = resolve2(dir, "node_modules", ".bin", "tsx");
+    const tsxArgs = ["src/server.ts", "--port", String(port)];
+    const [spawnCmd, spawnArgs] = wrapForIsolation(tsxBin, tsxArgs, name);
+    const spawnOpts = {
+      cwd: dir,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      env
+    };
+    const child2 = spawn(spawnCmd, spawnArgs, spawnOpts);
+    this.minds.set(name, { child: child2, port });
+    child2.stdout?.pipe(logStream);
+    child2.stderr?.pipe(logStream);
+    try {
+      await new Promise((resolve3, 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();
+          }
+        }
+        child2.stdout?.on("data", checkOutput);
+        child2.stderr?.on("data", checkOutput);
+        child2.on("error", (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+        child2.on("exit", (code) => {
+          clearTimeout(timeout);
+          reject(new Error(`Mind ${name} exited with code ${code} during startup`));
+        });
+      });
+    } catch (err) {
+      this.minds.delete(name);
+      try {
+        child2.kill();
+      } catch {
+      }
+      throw err;
+    }
+    if (child2.pid) {
+      try {
+        writeFileSync2(pidFile, String(child2.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 (isVariant) {
+      setVariantRunning(baseName, variantName, true);
+    } else {
+      setMindRunning(name, true);
+    }
+    mlog.info(`started mind ${name} on port ${port}`);
+    await this.deliverPendingContext(name);
+  }
+  setPendingContext(name, context) {
+    this.pendingContext.set(name, context);
+  }
+  async deliverPendingContext(name) {
+    const context = this.pendingContext.get(name);
+    if (!context) return;
+    const tracked = this.minds.get(name);
+    if (!tracked) return;
+    this.pendingContext.delete(name);
+    const parts = [];
+    if (context.type === "merge" || context.type === "merged") {
+      parts.push(await getPrompt("merge_message", { name: String(context.name ?? "") }));
+    } else if (context.type === "sprouted") {
+      parts.push(await getPrompt("sprout_message"));
+    } else {
+      parts.push(await getPrompt("restart_message"));
+    }
+    if (context.summary) parts.push(`Changes: ${context.summary}`);
+    if (context.justification) parts.push(`Why: ${context.justification}`);
+    if (context.memory) parts.push(`Context: ${context.memory}`);
+    try {
+      await fetch(`http://127.0.0.1:${tracked.port}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          content: [{ type: "text", text: parts.join("\n") }],
+          channel: "system"
+        })
+      });
+    } catch (err) {
+      mlog.warn(`failed to deliver pending context to ${name}`, logger_default.errorData(err));
+    }
+  }
+  setupCrashRecovery(name, child2) {
+    child2.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`);
+        const [base, variant] = name.split("@", 2);
+        if (variant) {
+          setVariantRunning(base, variant, false);
+        } else {
+          setMindRunning(name, false);
+        }
+        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`
+      );
+      setTimeout(() => {
+        if (this.shuttingDown) return;
+        this.startMind(name).catch((err) => {
+          mlog.error(`failed to restart ${name}`, logger_default.errorData(err));
+        });
+      }, delay);
+    });
+  }
+  async stopMind(name) {
+    const tracked = this.minds.get(name);
+    if (!tracked) return;
+    this.stopping.add(name);
+    const { child: child2 } = tracked;
+    this.minds.delete(name);
+    await new Promise((resolve3) => {
+      child2.on("exit", () => resolve3());
+      try {
+        process.kill(-child2.pid, "SIGTERM");
+      } catch {
+        resolve3();
+      }
+      setTimeout(() => {
+        try {
+          process.kill(-child2.pid, "SIGKILL");
+        } catch {
+        }
+        resolve3();
+      }, 5e3);
+    });
+    this.stopping.delete(name);
+    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
+    rmSync2(mindPidPath(name), { force: true });
+    if (!this.shuttingDown) {
+      const [baseName, variantName] = name.split("@", 2);
+      if (variantName) {
+        setVariantRunning(baseName, variantName, false);
+      } else {
+        setMindRunning(name, false);
+      }
+    }
+    mlog.info(`stopped mind ${name}`);
+  }
+  async restartMind(name) {
+    await this.stopMind(name);
+    await this.startMind(name);
+  }
+  async stopAll() {
+    this.shuttingDown = true;
+    const names = [...this.minds.keys()];
+    await Promise.all(names.map((name) => this.stopMind(name)));
+  }
+  isRunning(name) {
+    return this.minds.has(name);
+  }
+  getRunningMinds() {
+    return [...this.minds.keys()];
+  }
+  get crashAttemptsPath() {
+    return resolve2(voluteHome(), "crash-attempts.json");
+  }
+  loadCrashAttempts() {
+    this.restartAttempts = loadJsonMap(this.crashAttemptsPath);
+  }
+  saveCrashAttempts() {
+    saveJsonMap(this.crashAttemptsPath, this.restartAttempts);
+  }
+  clearCrashAttempts() {
+    clearJsonMap(this.crashAttemptsPath, this.restartAttempts);
+  }
+};
+async function killProcessOnPort(port) {
+  try {
+    const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
+    const pids = /* @__PURE__ */ new Set();
+    for (const line of stdout.trim().split("\n").filter(Boolean)) {
+      const pid = parseInt(line, 10);
+      pids.add(pid);
+      try {
+        const { stdout: psOut } = await execFileAsync("ps", ["-p", String(pid), "-o", "pgid="]);
+        const pgid = parseInt(psOut.trim(), 10);
+        if (pgid > 1) pids.add(pgid);
+      } catch {
+      }
+    }
+    for (const pid of pids) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var instance = null;
+function initMindManager() {
+  if (instance) throw new Error("MindManager already initialized");
+  instance = new MindManager();
+  return instance;
+}
+function getMindManager() {
+  if (!instance) instance = new MindManager();
+  return instance;
+}
+
+export {
+  logBuffer,
+  logger_default,
+  RotatingLog,
+  loadJsonMap,
+  saveJsonMap,
+  clearJsonMap,
+  users,
+  conversations,
+  mindHistory,
+  conversationParticipants,
+  sessions,
+  systemPrompts,
+  sharedSkills,
+  messages,
+  getDb,
+  PROMPT_KEYS,
+  PROMPT_DEFAULTS,
+  substitute,
+  getPrompt,
+  getPromptIfCustom,
+  getMindPromptDefaults,
+  MindManager,
+  initMindManager,
+  getMindManager
+};