volute 0.49.0 → 0.50.0

package/dist/{chunk-RSBL3FAD.js → chunk-CAIYV33P.js}

@@ -5,31 +5,208 @@ import {
   conversations,
   deliveryQueue,
   mindHistory,
-  mindNotices,
   minds,
   schema_exports,
   summaries,
+  systemEvents,
   turns,
   users
-} from "./chunk-P4LHVRNE.js";
+} from "./chunk-5IIVOWSP.js";
 
 // packages/daemon/src/lib/db.ts
-import { chmodSync, existsSync } from "fs";
-import { dirname, resolve as resolve2 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync2 } from "fs";
+import { dirname, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { sql } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/libsql";
 import { migrate } from "drizzle-orm/libsql/migrator";
 
 // packages/daemon/src/lib/mind/registry.ts
-import { mkdirSync } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
 import { homedir } from "os";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import { and, eq, inArray, isNull, or } from "drizzle-orm";
-var SPIRIT_NAME = "volute";
+
+// packages/daemon/src/lib/config/setup.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function configPath() {
+  return resolve(voluteSystemDir(), "config.json");
+}
+function secretsPath() {
+  return resolve(voluteSystemDir(), "secrets.json");
+}
+function hasEntries(obj) {
+  return !!obj && Object.keys(obj).length > 0;
+}
+function splitConfig(config) {
+  const publicConfig = { ...config };
+  const secrets = {};
+  if (config.ai) {
+    const { providers, ...rest } = config.ai;
+    publicConfig.ai = { ...rest, providers: {} };
+    if (hasEntries(providers)) secrets.ai = { providers };
+  }
+  if (config.imagegen) {
+    const { providers, ...rest } = config.imagegen;
+    publicConfig.imagegen = { ...rest };
+    if (providers && Object.keys(providers).length > 0) secrets.imagegen = { providers };
+  }
+  if (config.backup) {
+    const { password, env, ...rest } = config.backup;
+    publicConfig.backup = { ...rest };
+    if (password || hasEntries(env)) {
+      secrets.backup = {};
+      if (password) secrets.backup.password = password;
+      if (hasEntries(env)) secrets.backup.env = env;
+    }
+  }
+  return { publicConfig, secrets };
+}
+function mergeSecrets(publicConfig, secrets) {
+  const merged = { ...publicConfig };
+  if (secrets.ai?.providers) {
+    merged.ai = { ...merged.ai ?? { providers: {} }, providers: secrets.ai.providers };
+  }
+  if (secrets.imagegen?.providers) {
+    merged.imagegen = { ...merged.imagegen ?? {}, providers: secrets.imagegen.providers };
+  }
+  if (secrets.backup) {
+    merged.backup = { ...merged.backup ?? {}, ...secrets.backup };
+  }
+  return merged;
+}
+function readSecrets() {
+  const path = secretsPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var _cachedConfig = null;
+var CONFIG_CACHE_TTL = 2e3;
+function _resetConfigCache() {
+  _cachedConfig = null;
+}
+function readGlobalConfig() {
+  if (_cachedConfig && Date.now() - _cachedConfig.ts < CONFIG_CACHE_TTL) {
+    return { ..._cachedConfig.config };
+  }
+  const path = configPath();
+  if (!existsSync(path)) {
+    _cachedConfig = null;
+    return {};
+  }
+  let publicConfig;
+  try {
+    publicConfig = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    console.error(`Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
+    return {};
+  }
+  const config = mergeSecrets(publicConfig, readSecrets());
+  _cachedConfig = { config, ts: Date.now() };
+  return config;
+}
+function writeGlobalConfig(config) {
+  mkdirSync(voluteSystemDir(), { recursive: true });
+  const { publicConfig, secrets } = splitConfig(config);
+  const cfgPath = configPath();
+  writeFileSync(cfgPath, `${JSON.stringify(publicConfig, null, 2)}
+`, { mode: 420 });
+  chmodSync(cfgPath, 420);
+  const secPath = secretsPath();
+  writeFileSync(secPath, `${JSON.stringify(secrets, null, 2)}
+`, { mode: 384 });
+  chmodSync(secPath, 384);
+  _cachedConfig = { config, ts: Date.now() };
+}
+function migrateConfigSecrets() {
+  const path = configPath();
+  if (!existsSync(path)) return;
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const embedsSecrets = hasEntries(parsed.ai?.providers) || hasEntries(parsed.imagegen?.providers) || !!parsed.backup?.password || hasEntries(parsed.backup?.env);
+  const mode = statSync(path).mode & 511;
+  if (!embedsSecrets && mode === 420) return;
+  _resetConfigCache();
+  writeGlobalConfig(readGlobalConfig());
+}
+function computeSetupStatus(config) {
+  if (config.setupCompleted === true) return "complete";
+  if (config.setup != null && config.setupCompleted == null) return "complete";
+  if (config.setup != null) return "in-progress";
+  return "none";
+}
+function setupStatus() {
+  return computeSetupStatus(readGlobalConfig());
+}
+function readGlobalConfigStrict() {
+  const path = configPath();
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+function isSetupComplete() {
+  return setupStatus() === "complete";
+}
+function setupUrl() {
+  const config = readGlobalConfig();
+  const port = config.port || 1618;
+  let host = config.hostname || "127.0.0.1";
+  if (host === "0.0.0.0" || host === "::") host = "localhost";
+  if (host.includes(":") && !host.startsWith("[")) host = `[${host}]`;
+  return `http://${host}:${port}`;
+}
+function getSpiritName() {
+  return readGlobalConfig().setup?.spiritName ?? "volute";
+}
+function getSystemName() {
+  return readGlobalConfig().name ?? "this system";
+}
+var IMAGEGEN_AI_PROVIDERS = ["openai-codex", "xai"];
+function isImagegenEnabled() {
+  const config = readGlobalConfig();
+  const ig = config.imagegen;
+  if (ig?.enabled === true) return true;
+  if (ig?.providers && Object.keys(ig.providers).length > 0) return true;
+  const aiProviders = config.ai?.providers;
+  for (const id of IMAGEGEN_AI_PROVIDERS) {
+    const p = aiProviders?.[id];
+    if (p?.oauth || p?.apiKey) return true;
+  }
+  return false;
+}
+function mindLimitError(count, limit) {
+  if (limit == null) return null;
+  if (count >= limit) {
+    return `Mind limit reached (${count}/${limit}). An admin can raise maxMinds in Settings.`;
+  }
+  return null;
+}
+function migrateSetupCompleted() {
+  const config = readGlobalConfig();
+  if (config.setup != null && config.setupCompleted == null) {
+    config.setupCompleted = true;
+    writeGlobalConfig(config);
+  }
+}
+
+// packages/daemon/src/lib/mind/registry.ts
 function isSpiritName(name) {
-  return name === SPIRIT_NAME;
+  return name === getSpiritName();
 }
 function voluteHome() {
   if (process.env.VOLUTE_HOME) return process.env.VOLUTE_HOME;
@@ -38,21 +215,21 @@ function voluteHome() {
       '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");
+  return resolve2(homedir(), ".volute");
 }
 function voluteUserHome() {
   if (process.env.VOLUTE_USER_HOME) return process.env.VOLUTE_USER_HOME;
-  return resolve(homedir(), ".volute");
+  return resolve2(homedir(), ".volute");
 }
 function voluteSystemDir() {
-  return resolve(voluteHome(), "system");
+  return resolve2(voluteHome(), "system");
 }
 function ensureSystemDir() {
-  mkdirSync(voluteSystemDir(), { recursive: true });
+  mkdirSync2(voluteSystemDir(), { recursive: true });
 }
 function ensureVoluteHome() {
-  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve(voluteHome(), "minds");
-  mkdirSync(mindsBase, { recursive: true });
+  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve2(voluteHome(), "minds");
+  mkdirSync2(mindsBase, { recursive: true });
   ensureSystemDir();
 }
 function rowToEntry(row) {
@@ -98,6 +275,18 @@ function validateMindName(name) {
   if (RESERVED_NAMES.has(name.toLowerCase())) {
     return `"${name}" is a reserved name`;
   }
+  if (isSpiritName(name)) {
+    return `"${name}" is the spirit's name`;
+  }
+  return null;
+}
+function validateSpiritName(name) {
+  if (!name) return "Spirit name is required";
+  if (name.length > MIND_NAME_MAX) return `Spirit name must be at most ${MIND_NAME_MAX} characters`;
+  if (!MIND_NAME_RE.test(name)) {
+    return "Spirit name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
+  }
+  if (name.toLowerCase() === "system") return `"${name}" is a reserved name`;
   return null;
 }
 async function addMind(name, port, stage, template, createdBy) {
@@ -165,7 +354,7 @@ async function deleteMindDbFootprint(name) {
     await tx.delete(turns).where(eq(turns.mind, name));
     await tx.delete(mindHistory).where(eq(mindHistory.mind, name));
     await tx.delete(summaries).where(eq(summaries.mind, name));
-    await tx.delete(mindNotices).where(eq(mindNotices.mind, name));
+    await tx.delete(systemEvents).where(eq(systemEvents.mind, name));
     await tx.delete(channelGates).where(eq(channelGates.mind, name));
   });
 }
@@ -202,19 +391,23 @@ async function getBaseName(name) {
 }
 function mindDir(name) {
   if (process.env.VOLUTE_MINDS_DIR) {
-    return resolve(process.env.VOLUTE_MINDS_DIR, name);
+    return resolve2(process.env.VOLUTE_MINDS_DIR, name);
   }
-  return resolve(voluteHome(), "minds", name);
+  return resolve2(voluteHome(), "minds", name);
 }
 async function resolveMindDir(name) {
   const entry = await findMind(name);
   return entry?.dir ?? mindDir(name);
 }
 function stateDir(name) {
-  return resolve(voluteSystemDir(), "state", name);
+  return resolve2(voluteSystemDir(), "state", name);
+}
+function mindTmpEnv(dir) {
+  const tmp = mindTmpDir(dir);
+  return { TMPDIR: tmp, CLAUDE_CODE_TMPDIR: tmp };
 }
 function mindTmpDir(dir) {
-  return resolve(dir, ".mind", "tmp");
+  return resolve2(dir, ".mind", "tmp");
 }
 async function nextPort() {
   const db2 = await getDb();
@@ -235,7 +428,7 @@ function daemonLoopback() {
 
 // packages/daemon/src/lib/db.ts
 var __dirname = dirname(fileURLToPath2(import.meta.url));
-var migrationsFolder = existsSync(resolve2(__dirname, "../drizzle")) ? resolve2(__dirname, "../drizzle") : existsSync(resolve2(__dirname, "../../drizzle")) ? resolve2(__dirname, "../../drizzle") : resolve2(__dirname, "../../../../drizzle");
+var migrationsFolder = existsSync2(resolve3(__dirname, "../drizzle")) ? resolve3(__dirname, "../drizzle") : existsSync2(resolve3(__dirname, "../../drizzle")) ? resolve3(__dirname, "../../drizzle") : resolve3(__dirname, "../../../../drizzle");
 var db = null;
 var dbPromise = null;
 async function cleanupConversationColumns(db2) {
@@ -253,7 +446,7 @@ async function getDb() {
   if (dbPromise) return dbPromise;
   dbPromise = (async () => {
     try {
-      const dbPath = process.env.VOLUTE_DB_PATH || resolve2(voluteSystemDir(), "volute.db");
+      const dbPath = process.env.VOLUTE_DB_PATH || resolve3(voluteSystemDir(), "volute.db");
       const instance = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
       await instance.run(sql.raw("PRAGMA journal_mode=WAL"));
       await instance.run(sql.raw("PRAGMA busy_timeout=5000"));
@@ -261,7 +454,7 @@ async function getDb() {
       await migrate(instance, { migrationsFolder });
       await cleanupConversationColumns(instance);
       try {
-        chmodSync(dbPath, 384);
+        chmodSync2(dbPath, 384);
       } catch (err) {
         console.error(
           `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
@@ -280,7 +473,6 @@ async function getDb() {
 
 export {
   getDb,
-  SPIRIT_NAME,
   isSpiritName,
   voluteHome,
   voluteUserHome,
@@ -291,6 +483,7 @@ export {
   countCappedMinds,
   readAllMinds,
   validateMindName,
+  validateSpiritName,
   addMind,
   addSpirit,
   readSpirits,
@@ -307,7 +500,24 @@ export {
   mindDir,
   resolveMindDir,
   stateDir,
+  mindTmpEnv,
   mindTmpDir,
   nextPort,
-  daemonLoopback
+  daemonLoopback,
+  configPath,
+  secretsPath,
+  _resetConfigCache,
+  readGlobalConfig,
+  writeGlobalConfig,
+  migrateConfigSecrets,
+  computeSetupStatus,
+  setupStatus,
+  readGlobalConfigStrict,
+  isSetupComplete,
+  setupUrl,
+  getSpiritName,
+  getSystemName,
+  isImagegenEnabled,
+  mindLimitError,
+  migrateSetupCompleted
 };

package/dist/{chunk-ZX46PGCC.js → chunk-E5S3ILVA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   publish
-} from "./chunk-3B427GUK.js";
+} from "./chunk-3BAFMGCJ.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";

package/dist/{chunk-SHKM5RGD.js → chunk-EEOMA4DX.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-BCG45AQB.js";
+} from "./chunk-M74I3HHF.js";
 import {
   command
 } from "./chunk-TXSA4Q3V.js";