volute 0.30.1 → 0.32.0

package/dist/chunk-SKLSMHXO.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  mindDir
+} from "./chunk-LRCG2JLP.js";
+
+// src/lib/delivery/delivery-router.ts
+import { readFileSync, statSync } from "fs";
+import { resolve } from "path";
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+  }
+  return JSON.stringify(content);
+}
+var configCache = /* @__PURE__ */ new Map();
+var statCheckCache = /* @__PURE__ */ new Map();
+var STAT_TTL_MS = 5e3;
+var dlog = logger_default.child("delivery-router");
+var dirOverrides = /* @__PURE__ */ new Map();
+function registerMindDir(name, dir) {
+  dirOverrides.set(name, dir);
+}
+function configPath(mindName) {
+  const dir = dirOverrides.get(mindName) ?? mindDir(mindName);
+  return resolve(dir, "home/.config/routes.json");
+}
+function getRoutingConfig(mindName) {
+  const path = configPath(mindName);
+  const now = Date.now();
+  const statCached = statCheckCache.get(mindName);
+  const cached = configCache.get(mindName);
+  if (statCached && cached && now - statCached.checkedAt < STAT_TTL_MS) {
+    return cached.config;
+  }
+  let mtime;
+  try {
+    mtime = statSync(path).mtimeMs;
+  } catch {
+    configCache.delete(mindName);
+    statCheckCache.delete(mindName);
+    return {};
+  }
+  statCheckCache.set(mindName, { mtime, checkedAt: now });
+  if (cached && cached.mtime === mtime) {
+    return cached.config;
+  }
+  try {
+    const config = JSON.parse(readFileSync(path, "utf-8"));
+    configCache.set(mindName, { config, mtime });
+    return config;
+  } catch (err) {
+    dlog.warn(`failed to load routes.json for ${mindName}`, logger_default.errorData(err));
+    configCache.delete(mindName);
+    return {};
+  }
+}
+var globRegexCache = /* @__PURE__ */ new Map();
+function clearConfigCache(mindName) {
+  if (mindName) {
+    configCache.delete(mindName);
+    statCheckCache.delete(mindName);
+  } else {
+    configCache.clear();
+    statCheckCache.clear();
+    globRegexCache.clear();
+  }
+}
+function globMatch(pattern, value) {
+  let regex = globRegexCache.get(pattern);
+  if (!regex) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    regex = new RegExp(`^${escaped}$`);
+    globRegexCache.set(pattern, regex);
+  }
+  return regex.test(value);
+}
+var GLOB_MATCH_KEYS = /* @__PURE__ */ new Set(["channel", "sender"]);
+var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode", "batch"]);
+function ruleMatches(rule, meta) {
+  for (const [key, pattern] of Object.entries(rule)) {
+    if (NON_MATCH_KEYS.has(key)) continue;
+    if (key === "isDM") {
+      if (typeof pattern !== "boolean") return false;
+      if ((meta.isDM ?? false) !== pattern) return false;
+      continue;
+    }
+    if (key === "participants") {
+      if (typeof pattern !== "number") return false;
+      if ((meta.participantCount ?? 0) !== pattern) return false;
+      continue;
+    }
+    if (typeof pattern !== "string") return false;
+    if (!GLOB_MATCH_KEYS.has(key)) return false;
+    const value = meta[key] ?? "";
+    if (!globMatch(pattern, value)) return false;
+  }
+  return true;
+}
+function expandTemplate(template, meta) {
+  return template.replace(/\$\{sender\}/g, meta.sender ?? "unknown").replace(/\$\{channel\}/g, meta.channel ?? "unknown");
+}
+function sanitizeSessionName(name) {
+  return name.replace(/\0/g, "").replace(/[/\\]/g, "-").replace(/\.\./g, "-").slice(0, 100);
+}
+function resolveRoute(config, meta) {
+  const fallback = config.default ?? "main";
+  if (!config.rules) {
+    return { destination: "mind", session: fallback, matched: false };
+  }
+  for (const rule of config.rules) {
+    if (ruleMatches(rule, meta)) {
+      if (rule.destination === "file") {
+        if (!rule.path) {
+          dlog.warn("file destination rule missing path \u2014 falling through");
+          continue;
+        }
+        return { destination: "file", path: rule.path, matched: true };
+      }
+      return {
+        destination: "mind",
+        session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
+        matched: true,
+        mode: rule.mode,
+        rule
+      };
+    }
+  }
+  return { destination: "mind", session: fallback, matched: false };
+}
+var DEFAULT_BATCH_DEBOUNCE = 5;
+var DEFAULT_BATCH_MAX_WAIT = 120;
+function normalizeBatchConfig(batch) {
+  if (typeof batch === "number") return { maxWait: batch * 60 };
+  return batch;
+}
+function resolveDeliveryMode(config, sessionName, rule) {
+  const ruleBatch = rule?.batch;
+  const defaults = {
+    delivery: { mode: "immediate" },
+    interrupt: true
+  };
+  if (!config.sessions) {
+    if (ruleBatch != null) {
+      const batch = normalizeBatchConfig(ruleBatch);
+      return {
+        delivery: {
+          mode: "batch",
+          debounce: batch.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+          maxWait: batch.maxWait ?? DEFAULT_BATCH_MAX_WAIT,
+          triggers: batch.triggers
+        },
+        interrupt: true
+      };
+    }
+    return defaults;
+  }
+  for (const [pattern, sessionConfig] of Object.entries(config.sessions)) {
+    if (globMatch(pattern, sessionName)) {
+      let delivery;
+      if (sessionConfig.delivery == null || sessionConfig.delivery === "immediate") {
+        delivery = { mode: "immediate" };
+      } else if (sessionConfig.delivery === "batch") {
+        delivery = {
+          mode: "batch",
+          debounce: DEFAULT_BATCH_DEBOUNCE,
+          maxWait: DEFAULT_BATCH_MAX_WAIT
+        };
+      } else {
+        delivery = {
+          mode: "batch",
+          debounce: sessionConfig.delivery.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+          maxWait: sessionConfig.delivery.maxWait ?? DEFAULT_BATCH_MAX_WAIT
+        };
+      }
+      return {
+        delivery,
+        interrupt: true,
+        instructions: sessionConfig.instructions
+      };
+    }
+  }
+  if (ruleBatch != null) {
+    const batch = normalizeBatchConfig(ruleBatch);
+    return {
+      delivery: {
+        mode: "batch",
+        debounce: batch.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+        maxWait: batch.maxWait ?? DEFAULT_BATCH_MAX_WAIT,
+        triggers: batch.triggers
+      },
+      interrupt: true
+    };
+  }
+  return defaults;
+}
+
+export {
+  extractTextContent,
+  registerMindDir,
+  getRoutingConfig,
+  clearConfigCache,
+  resolveRoute,
+  resolveDeliveryMode
+};

package/dist/{chunk-IKHDUZRH.js → chunk-SX5TKJBZ.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-YUIHSKR6.js";
 import {
   readGlobalConfig
-} from "./chunk-7D47T4RB.js";
+} from "./chunk-TSXLLQZW.js";
 import {
   getBaseName,
   readRegistry,
   voluteHome,
   voluteSystemDir,
   voluteUserHome
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-LRCG2JLP.js";
 
 // src/lib/sandbox.ts
 import { resolve } from "path";

package/dist/chunk-TDRYEPH4.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import {
+  broadcast
+} from "./chunk-QZANELPX.js";
+import {
+  getDb
+} from "./chunk-LRCG2JLP.js";
+import {
+  users
+} from "./chunk-RPZZSXV3.js";
+
+// src/lib/auth.ts
+import { compareSync, hashSync } from "bcryptjs";
+import { and, count, eq, or } from "drizzle-orm";
+var userSelectFields = {
+  id: users.id,
+  username: users.username,
+  role: users.role,
+  user_type: users.user_type,
+  display_name: users.display_name,
+  description: users.description,
+  avatar: users.avatar,
+  created_at: users.created_at
+};
+async function createUser(username, password) {
+  const db = await getDb();
+  const hash = hashSync(password, 10);
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
+  const role = value === 0 ? "admin" : "pending";
+  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning(userSelectFields);
+  return result;
+}
+async function verifyUser(username, password) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.username, username)).get();
+  if (!row) return null;
+  if (row.user_type === "mind" || row.user_type === "system") return null;
+  if (!compareSync(password, row.password_hash)) return null;
+  const { password_hash: _, ...user } = row;
+  return user;
+}
+async function getUser(id) {
+  const db = await getDb();
+  const row = await db.select(userSelectFields).from(users).where(eq(users.id, id)).get();
+  return row ?? null;
+}
+async function getUserByUsername(username) {
+  const db = await getDb();
+  const row = await db.select(userSelectFields).from(users).where(eq(users.username, username)).get();
+  return row ?? null;
+}
+async function listUsers() {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).orderBy(users.created_at).all();
+}
+async function listPendingUsers() {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
+}
+async function listUsersByType(userType) {
+  const db = await getDb();
+  return db.select(userSelectFields).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
+}
+async function getOrCreateMindUser(mindName) {
+  const db = await getDb();
+  const existing = await db.select(userSelectFields).from(users).where(
+    and(
+      eq(users.username, mindName),
+      or(eq(users.user_type, "mind"), eq(users.user_type, "system"))
+    )
+  ).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db.insert(users).values({
+      username: mindName,
+      password_hash: "!mind",
+      role: "user",
+      user_type: "mind"
+    }).returning(userSelectFields);
+    return result;
+  } catch (err) {
+    const retried = await db.select(userSelectFields).from(users).where(
+      and(
+        eq(users.username, mindName),
+        or(eq(users.user_type, "mind"), eq(users.user_type, "system"))
+      )
+    ).get();
+    if (retried) return retried;
+    throw err;
+  }
+}
+async function getOrCreateSystemUser() {
+  const db = await getDb();
+  const existing = await db.select(userSelectFields).from(users).where(and(eq(users.username, "volute"), eq(users.user_type, "system"))).get();
+  if (existing) return existing;
+  try {
+    const [result] = await db.insert(users).values({
+      username: "volute",
+      password_hash: "!system",
+      role: "system",
+      user_type: "system",
+      display_name: "Volute"
+    }).returning(userSelectFields);
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+      const retried = await db.select(userSelectFields).from(users).where(and(eq(users.username, "volute"), eq(users.user_type, "system"))).get();
+      if (retried) return retried;
+    }
+    throw err;
+  }
+}
+async function deleteMindUser(mindName) {
+  const db = await getDb();
+  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
+}
+async function changePassword(userId, currentPassword, newPassword) {
+  const db = await getDb();
+  const row = await db.select().from(users).where(eq(users.id, userId)).get();
+  if (!row) return false;
+  if (!compareSync(currentPassword, row.password_hash)) return false;
+  const hash = hashSync(newPassword, 10);
+  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
+  return true;
+}
+async function approveUser(id) {
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
+}
+async function countAdmins() {
+  const db = await getDb();
+  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.role, "admin"));
+  return value;
+}
+async function setUserRole(id, role) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, id)).get();
+  if (!target) throw new Error("User not found");
+  await db.update(users).set({ role }).where(eq(users.id, id));
+}
+async function deleteUser(id) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(and(eq(users.id, id), eq(users.user_type, "brain"))).get();
+  if (!target) throw new Error("User not found");
+  await db.delete(users).where(and(eq(users.id, id), eq(users.user_type, "brain")));
+}
+async function updateUserProfile(userId, profile) {
+  const db = await getDb();
+  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).get();
+  if (!target) throw new Error("User not found");
+  await db.update(users).set(profile).where(eq(users.id, userId));
+}
+async function syncMindProfile(mindName, config) {
+  const user = await getOrCreateMindUser(mindName);
+  const newProfile = {
+    display_name: config.displayName ?? null,
+    description: config.description ?? null,
+    avatar: config.avatar ?? null
+  };
+  const changed = user.display_name !== newProfile.display_name || user.description !== newProfile.description || user.avatar !== newProfile.avatar;
+  if (!changed) return;
+  const db = await getDb();
+  await db.update(users).set(newProfile).where(eq(users.id, user.id));
+  broadcast({ type: "profile_updated", mind: mindName, summary: `${mindName} profile updated` });
+}
+
+export {
+  createUser,
+  verifyUser,
+  getUser,
+  getUserByUsername,
+  listUsers,
+  listPendingUsers,
+  listUsersByType,
+  getOrCreateMindUser,
+  getOrCreateSystemUser,
+  deleteMindUser,
+  changePassword,
+  approveUser,
+  countAdmins,
+  setUserRole,
+  deleteUser,
+  updateUserProfile,
+  syncMindProfile
+};

package/dist/chunk-TSXLLQZW.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import {
+  voluteSystemDir
+} from "./chunk-LRCG2JLP.js";
+
+// src/lib/setup.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function configPath() {
+  return resolve(voluteSystemDir(), "config.json");
+}
+function readGlobalConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    console.error(`Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
+    return {};
+  }
+}
+function writeGlobalConfig(config) {
+  const path = configPath();
+  mkdirSync(voluteSystemDir(), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+function isSetupComplete() {
+  const config = readGlobalConfig();
+  return config.setupCompleted === true;
+}
+function migrateSetupCompleted() {
+  const config = readGlobalConfig();
+  if (config.setup != null && config.setupCompleted == null) {
+    config.setupCompleted = true;
+    writeGlobalConfig(config);
+  }
+}
+
+export {
+  configPath,
+  readGlobalConfig,
+  writeGlobalConfig,
+  isSetupComplete,
+  migrateSetupCompleted
+};

package/dist/{chunk-EFVHR7KH.js → chunk-UKVWJRKN.js}

@@ -1,13 +1,29 @@
 #!/usr/bin/env node
 import {
-  voluteHome,
   voluteSystemDir,
   voluteUserHome
-} from "./chunk-HHTXM4JT.js";
+} from "./chunk-LRCG2JLP.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
+function readSessionFile(mindDir) {
+  try {
+    const p = resolve(mindDir, ".mind", "current-session");
+    if (existsSync(p)) return readFileSync(p, "utf-8").trim() || void 0;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[volute] failed to read session file: ${code ?? err}`);
+    }
+  }
+  return void 0;
+}
+function readMindSessionFile() {
+  const mindDir = process.env.VOLUTE_MIND_DIR;
+  if (!mindDir) return void 0;
+  return readSessionFile(mindDir);
+}
 function readCliSession() {
   const sessionPath = resolve(voluteUserHome(), "cli-session.json");
   if (!existsSync(sessionPath)) return null;
@@ -18,9 +34,7 @@ function readCliSession() {
   }
 }
 function readDaemonConfig() {
-  const newPath = resolve(voluteSystemDir(), "daemon.json");
-  const legacyPath = resolve(voluteHome(), "daemon.json");
-  const configPath = existsSync(newPath) ? newPath : legacyPath;
+  const configPath = resolve(voluteSystemDir(), "daemon.json");
   if (!existsSync(configPath)) {
     if (existsSync("/etc/systemd/system/volute.service") && !process.env.VOLUTE_HOME) {
       console.error("Volute is running as a system service but VOLUTE_HOME is not set.");
@@ -68,6 +82,10 @@ async function daemonFetch(path, options) {
     headers.set("Authorization", `Bearer ${cliSession.sessionId}`);
   }
   headers.set("Origin", url);
+  const voluteSession = process.env.VOLUTE_SESSION ?? readMindSessionFile();
+  if (voluteSession) {
+    headers.set("X-Volute-Session", voluteSession);
+  }
   try {
     const res = await fetch(`${url}${path}`, { ...options, headers });
     if (res.status === 401 && !path.startsWith("/api/auth/")) {
@@ -89,5 +107,6 @@ async function daemonFetch(path, options) {
 }
 
 export {
+  readSessionFile,
   daemonFetch
 };