volute 0.49.0 → 0.50.0

package/dist/chunk-7OZWKHA3.js

@@ -0,0 +1,548 @@
+#!/usr/bin/env node
+import {
+  publish
+} from "./chunk-LNNI3MS4.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  getBaseName,
+  getDb
+} from "./chunk-CAIYV33P.js";
+import {
+  mindHistory,
+  systemEvents,
+  turns
+} from "./chunk-5IIVOWSP.js";
+
+// packages/daemon/src/lib/chat/system-events.ts
+import { and, asc, desc, eq, gt, isNull, lte, or, sql } from "drizzle-orm";
+var elog = logger_default.child("system-events");
+var MIND_LEVEL_THREAD = "";
+var MAX_NEXT_TURN_EVENTS = 100;
+var FLUSH_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function parseMeta(meta, context) {
+  if (!meta) return {};
+  try {
+    return JSON.parse(meta);
+  } catch (err) {
+    elog.error(`corrupt event meta${context ? ` (${context})` : ""}: ${meta}`, logger_default.errorData(err));
+    return {};
+  }
+}
+function eventLabel(type, meta) {
+  const m = meta ?? {};
+  const s = (k) => typeof m[k] === "string" ? m[k] : void 0;
+  switch (type) {
+    case "schedule":
+      return s("scheduleId") ? `Schedule: ${s("scheduleId")}` : "Schedule";
+    case "sleep":
+      return "Time to rest";
+    case "wake":
+      return "Woke from sleep";
+    case "lifecycle":
+      switch (s("subtype")) {
+        case "merge":
+          return "Variant merged in";
+        case "split":
+          return "Split into a variant";
+        case "variant-created":
+          return "Variant split off";
+        case "sprout":
+          return "Sprouted";
+        case "upgrade":
+          return "Framework upgraded";
+        case "restart":
+          return "Server restarted";
+        case "farewell":
+          return "Farewell before merge";
+        case "sprout-welcome":
+          return "A mind sprouted";
+        default:
+          return "Lifecycle";
+      }
+    case "orientation":
+      return "Orientation";
+    case "budget":
+      return "Token budget";
+    case "version":
+      return "New version available";
+    case "channel":
+      return "Channel invite";
+    case "file-share":
+      return "File offered";
+    case "webhook":
+      return s("source") ? `Webhook: ${s("source")}` : "Webhook";
+    case "notice":
+      switch (s("subtype")) {
+        case "crash":
+          return "Crash notice";
+        case "turn_error":
+          return "Turn error";
+        case "startup":
+          return "Startup notice";
+        case "extension":
+          return s("reason") ? `Notice: ${s("reason")}` : "Notice";
+        default:
+          return "Notice";
+      }
+    default:
+      return type.charAt(0).toUpperCase() + type.slice(1);
+  }
+}
+async function recordNotice(input) {
+  const type = input.kind === "budget" ? "budget" : "notice";
+  await deliverEvent(input.mind, {
+    type,
+    body: input.detail,
+    thread: input.thread,
+    delivery: "next-turn",
+    meta: {
+      subtype: input.kind,
+      reason: input.reason,
+      ...input.raw ? { raw: input.raw } : {}
+    }
+  });
+}
+function eventChannel(type, id) {
+  return `event:${type}:${id}`;
+}
+async function recordEventRow(mind, event) {
+  const channel = eventChannel(event.type, event.id);
+  const label = eventLabel(event.type, parseMeta(event.meta, `event ${event.id}`));
+  const metadata = { systemEventId: event.id, label };
+  try {
+    const db = await getDb();
+    const baseName = await getBaseName(mind);
+    await db.insert(mindHistory).values({
+      mind: baseName,
+      type: "event",
+      channel,
+      sender: null,
+      content: event.body,
+      metadata: JSON.stringify(metadata)
+    });
+    publish(baseName, {
+      mind: baseName,
+      type: "event",
+      channel,
+      content: event.body,
+      metadata
+    });
+  } catch (err) {
+    elog.warn(`failed to persist event row for ${mind}`, logger_default.errorData(err));
+  }
+}
+var staleTemplateWarned = /* @__PURE__ */ new Set();
+async function postEventEnvelope(mind, event) {
+  const entry = await findMind(mind);
+  if (!entry) {
+    elog.warn(`cannot deliver event ${event.id} to ${mind}: mind not found`);
+    return false;
+  }
+  const meta = parseMeta(event.meta, `event ${event.id}`);
+  try {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        kind: "event",
+        event: {
+          id: event.id,
+          type: event.type,
+          label: eventLabel(event.type, meta),
+          body: event.body,
+          at: event.created_at
+        },
+        session: event.thread
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      elog.warn(`mind ${mind} rejected event ${event.id}: HTTP ${res.status}`);
+      return false;
+    }
+    try {
+      const ack = await res.json();
+      if (ack.event !== true && !staleTemplateWarned.has(mind)) {
+        staleTemplateWarned.add(mind);
+        elog.warn(
+          `mind ${mind} ack'd an event without event support \u2014 its template predates system events; run \`volute mind upgrade ${mind}\``
+        );
+      }
+    } catch {
+      if (!staleTemplateWarned.has(mind)) {
+        staleTemplateWarned.add(mind);
+        elog.warn(
+          `mind ${mind} ack'd an event without event support \u2014 its template predates system events; run \`volute mind upgrade ${mind}\``
+        );
+      }
+    }
+    return true;
+  } catch (err) {
+    elog.warn(`failed to POST event ${event.id} to ${mind}`, logger_default.errorData(err));
+    return false;
+  }
+}
+async function markDelivered(id, extraMeta) {
+  try {
+    const db = await getDb();
+    if (extraMeta) {
+      const row = await db.select({ meta: systemEvents.meta }).from(systemEvents).where(eq(systemEvents.id, id)).get();
+      const merged = { ...parseMeta(row?.meta, `event ${id}`), ...extraMeta };
+      await db.update(systemEvents).set({ delivered_at: sql`(datetime('now'))`, meta: JSON.stringify(merged) }).where(eq(systemEvents.id, id));
+    } else {
+      await db.update(systemEvents).set({ delivered_at: sql`(datetime('now'))` }).where(eq(systemEvents.id, id));
+    }
+  } catch (err) {
+    elog.error(
+      `failed to stamp event ${id} delivered \u2014 it will be redelivered on the next wake/start`,
+      logger_default.errorData(err)
+    );
+  }
+}
+async function deliverEvent(mind, input) {
+  const thread = input.thread ?? "main";
+  const delivery = input.delivery ?? "immediate";
+  let eventId;
+  try {
+    const db = await getDb();
+    const rows = await db.insert(systemEvents).values({
+      mind,
+      type: input.type,
+      body: input.body,
+      meta: input.meta ? JSON.stringify(input.meta) : null,
+      delivery,
+      thread
+    }).returning({ id: systemEvents.id });
+    eventId = rows[0]?.id;
+    if (eventId == null) {
+      elog.error(`event insert for ${mind} (${input.type}) returned no id \u2014 event dropped`);
+      return { delivered: false };
+    }
+    if (delivery === "next-turn") {
+      await db.run(
+        sql`UPDATE system_events SET delivered_at = datetime('now'), meta = json_set(COALESCE(meta, '{}'), '$.dropped', 1) WHERE mind = ${mind} AND thread = ${thread} AND delivery = 'next-turn' AND delivered_at IS NULL AND id NOT IN (SELECT id FROM system_events WHERE mind = ${mind} AND thread = ${thread} AND delivery = 'next-turn' AND delivered_at IS NULL ORDER BY id DESC LIMIT ${MAX_NEXT_TURN_EVENTS})`
+      );
+      return { id: eventId, delivered: false };
+    }
+    const baseName = await getBaseName(mind);
+    const { getSleepManagerIfReady } = await import("./sleep-manager-LIEPO6WG.js");
+    const sleepManager = getSleepManagerIfReady();
+    const sleeping = !input.force && sleepManager?.isSleeping(baseName);
+    const behavior = input.whileSleeping ?? "queue";
+    if (sleeping && behavior === "skip") {
+      await markDelivered(eventId, { skipped: true });
+      return { id: eventId, delivered: false };
+    }
+    if (!sleeping) {
+      const event = await db.select().from(systemEvents).where(eq(systemEvents.id, eventId)).get();
+      if (event && await postEventEnvelope(mind, event)) {
+        await markDelivered(eventId);
+        await recordEventRow(mind, event);
+        return { id: eventId, delivered: true };
+      }
+      elog.warn(
+        `event ${eventId} (${input.type}) for ${mind} was not delivered; left pending for the next wake or mind start`
+      );
+      return { id: eventId, delivered: false };
+    }
+    if (behavior === "trigger-wake") {
+      sleepManager?.initiateWake(baseName, { trigger: { channel: `event:${input.type}` } }).catch(
+        (err) => elog.warn(`failed to trigger-wake ${baseName} for event`, logger_default.errorData(err))
+      );
+    }
+    return { id: eventId, delivered: false };
+  } catch (err) {
+    elog.error(`failed to deliver event to ${mind}`, logger_default.errorData(err));
+    return { id: eventId, delivered: false };
+  }
+}
+var NO_REPLAY_TYPES = /* @__PURE__ */ new Set(["sleep"]);
+async function flushQueuedEvents(mind) {
+  try {
+    const db = await getDb();
+    const rows = await db.select().from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.delivery, "immediate"),
+        isNull(systemEvents.delivered_at)
+      )
+    ).orderBy(asc(systemEvents.id)).all();
+    let delivered = 0;
+    for (const event of rows) {
+      if (NO_REPLAY_TYPES.has(event.type) || eventAgeMs(event.created_at) > FLUSH_MAX_AGE_MS) {
+        elog.info(`expiring stale pending event ${event.id} (${event.type}) for ${mind}`);
+        await markDelivered(event.id, { expired: true });
+        continue;
+      }
+      if (await postEventEnvelope(mind, event)) {
+        await markDelivered(event.id);
+        await recordEventRow(mind, event);
+        delivered++;
+      } else {
+        elog.warn(`flush could not deliver event ${event.id} (${event.type}) to ${mind}`);
+      }
+    }
+    return delivered;
+  } catch (err) {
+    elog.warn(`failed to flush queued events for ${mind}`, logger_default.errorData(err));
+    return 0;
+  }
+}
+function eventAgeMs(createdAt) {
+  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
+  const t = new Date(iso).getTime();
+  return Number.isNaN(t) ? 0 : Date.now() - t;
+}
+async function pendingEventCount(mind) {
+  try {
+    const db = await getDb();
+    const row = await db.select({ n: sql`count(*)` }).from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.delivery, "immediate"),
+        isNull(systemEvents.delivered_at)
+      )
+    ).get();
+    return row?.n ?? 0;
+  } catch (err) {
+    elog.warn(`failed to count pending events for ${mind}`, logger_default.errorData(err));
+    return 0;
+  }
+}
+function pendingEventsLine(count) {
+  if (count <= 0) return "";
+  return `${count} system event${count === 1 ? "" : "s"} arrived while you slept and will follow shortly.`;
+}
+async function drainEvents(mind, thread, limit = MAX_NEXT_TURN_EVENTS) {
+  const db = await getDb();
+  return db.select().from(systemEvents).where(
+    and(
+      eq(systemEvents.mind, mind),
+      eq(systemEvents.delivery, "next-turn"),
+      isNull(systemEvents.delivered_at),
+      or(eq(systemEvents.thread, thread), eq(systemEvents.thread, MIND_LEVEL_THREAD))
+    )
+  ).orderBy(asc(systemEvents.id)).limit(limit);
+}
+function metaOf(e) {
+  return parseMeta(e.meta, `event ${e.id}`);
+}
+var FAILURE_SUBTYPES = /* @__PURE__ */ new Set(["turn_error", "crash", "startup"]);
+var NOTICE_HEADER = "[Notices] While you were unavailable, one or more turns failed. You're back now:";
+function formatEvents(events) {
+  if (events.length === 0) return null;
+  const failures = [];
+  const budgets = [];
+  const versions = [];
+  const extensions = [];
+  const others = [];
+  for (const e of events) {
+    if (e.type === "budget") budgets.push(e);
+    else if (e.type === "version") versions.push(e);
+    else if (e.type === "notice") {
+      const subtype = String(metaOf(e).subtype);
+      if (FAILURE_SUBTYPES.has(subtype)) failures.push(e);
+      else if (subtype === "extension") extensions.push(e);
+      else others.push(e);
+    } else others.push(e);
+  }
+  const blocks = [];
+  if (failures.length > 0) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const e of failures) {
+      const reason = String(metaOf(e).reason ?? "unknown");
+      const time = localHM(e.created_at);
+      const g = groups.get(reason);
+      if (g) {
+        g.count += 1;
+        g.detail = e.body;
+        g.last = time;
+      } else {
+        groups.set(reason, { count: 1, detail: e.body, first: time, last: time });
+      }
+    }
+    const lines = [...groups.values()].map((g) => {
+      const span = g.first === g.last ? g.first : `${g.first}\u2013${g.last}`;
+      const plural = g.count === 1 ? "turn" : "turns";
+      return `- ${g.count} ${plural} failed (${span}): ${g.detail}`;
+    });
+    blocks.push(`${NOTICE_HEADER}
+${lines.join("\n")}`);
+  }
+  if (budgets.length > 0) {
+    const lines = budgets.map((e) => `- ${localHM(e.created_at)} ${e.body}`);
+    blocks.push(`[Budget]
+${lines.join("\n")}`);
+  }
+  if (versions.length > 0) {
+    const lines = versions.map((e) => `- ${localHM(e.created_at)} ${e.body}`);
+    blocks.push(`[Update]
+${lines.join("\n")}`);
+  }
+  if (extensions.length > 0) {
+    const byExt = /* @__PURE__ */ new Map();
+    for (const e of extensions) {
+      const ext = String(metaOf(e).reason ?? "extension");
+      const arr = byExt.get(ext);
+      if (arr) arr.push(e);
+      else byExt.set(ext, [e]);
+    }
+    for (const [ext, items] of byExt) {
+      const header = `[${ext.charAt(0).toUpperCase()}${ext.slice(1)}]`;
+      const lines = items.map((e) => `- ${localHM(e.created_at)} ${e.body}`);
+      blocks.push(`${header}
+${lines.join("\n")}`);
+    }
+  }
+  if (others.length > 0) {
+    const lines = others.map(
+      (e) => `- ${localHM(e.created_at)} (${eventLabel(e.type, metaOf(e))}) ${e.body}`
+    );
+    blocks.push(`[Events]
+${lines.join("\n")}`);
+  }
+  return blocks.join("\n\n");
+}
+function localHM(createdAt) {
+  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
+  return new Date(iso).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+}
+async function clearDeliveredEvents(mind, thread, uptoId) {
+  try {
+    const db = await getDb();
+    await db.update(systemEvents).set({ delivered_at: sql`(datetime('now'))` }).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.delivery, "next-turn"),
+        isNull(systemEvents.delivered_at),
+        or(eq(systemEvents.thread, thread), eq(systemEvents.thread, MIND_LEVEL_THREAD)),
+        lte(systemEvents.id, uptoId)
+      )
+    );
+  } catch (err) {
+    elog.warn(`failed to clear delivered events for ${mind}:${thread}`, logger_default.errorData(err));
+  }
+}
+var failureReadErrorLogged = false;
+async function latestFailureEvent(mind) {
+  try {
+    const db = await getDb();
+    const e = await db.select().from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, mind),
+        eq(systemEvents.type, "notice"),
+        isNull(systemEvents.delivered_at),
+        // Closed set of literal subtypes (not user input).
+        sql`json_extract(${systemEvents.meta}, '$.subtype') IN ('turn_error', 'crash', 'startup')`
+      )
+    ).orderBy(desc(systemEvents.id)).limit(1).get();
+    if (!e) return null;
+    const recovered = await db.select({ id: turns.id }).from(turns).where(
+      and(eq(turns.mind, mind), eq(turns.status, "complete"), gt(turns.created_at, e.created_at))
+    ).limit(1);
+    if (recovered.length > 0) return null;
+    const m = metaOf(e);
+    return {
+      kind: String(m.subtype ?? "notice"),
+      reason: String(m.reason ?? "unknown"),
+      detail: e.body,
+      at: e.created_at
+    };
+  } catch (err) {
+    if (!failureReadErrorLogged) {
+      failureReadErrorLogged = true;
+      elog.error(`failed to read latest failure event for ${mind}`, logger_default.errorData(err));
+    }
+    return null;
+  }
+}
+async function latestEvent(mind) {
+  const db = await getDb();
+  const row = await db.select().from(systemEvents).where(
+    and(
+      eq(systemEvents.mind, mind),
+      eq(systemEvents.delivery, "next-turn"),
+      isNull(systemEvents.delivered_at)
+    )
+  ).orderBy(desc(systemEvents.id)).limit(1).get();
+  if (!row) return null;
+  const m = metaOf(row);
+  return {
+    kind: String(m.subtype ?? row.type),
+    reason: String(m.reason ?? row.type),
+    detail: row.body,
+    created_at: row.created_at
+  };
+}
+async function hasUndeliveredEvent(mind, reason) {
+  const db = await getDb();
+  const row = await db.select({ id: systemEvents.id }).from(systemEvents).where(
+    and(
+      eq(systemEvents.mind, mind),
+      eq(systemEvents.delivery, "next-turn"),
+      isNull(systemEvents.delivered_at),
+      sql`json_extract(${systemEvents.meta}, '$.reason') = ${reason}`
+    )
+  ).limit(1).get();
+  return row != null;
+}
+async function listEvents(mind, limit = 100, before) {
+  const db = await getDb();
+  const conditions = [eq(systemEvents.mind, mind)];
+  if (before != null) conditions.push(sql`${systemEvents.id} < ${before}`);
+  return db.select().from(systemEvents).where(and(...conditions)).orderBy(desc(systemEvents.id)).limit(limit);
+}
+async function recordReflection(mind, eventId, text) {
+  try {
+    const db = await getDb();
+    await db.update(systemEvents).set({ reflection: text }).where(and(eq(systemEvents.id, eventId), eq(systemEvents.mind, mind)));
+  } catch (err) {
+    elog.warn(`failed to record reflection for event ${eventId}`, logger_default.errorData(err));
+  }
+}
+async function captureReflection(mind, turnId) {
+  if (!turnId) return;
+  try {
+    const db = await getDb();
+    const turn = await db.select({ trigger: turns.trigger_event_id }).from(turns).where(eq(turns.id, turnId)).get();
+    if (turn?.trigger == null) return;
+    const trigger = await db.select({ metadata: mindHistory.metadata }).from(mindHistory).where(eq(mindHistory.id, turn.trigger)).get();
+    const eventId = trigger?.metadata ? parseMeta(trigger.metadata, `event row ${turn.trigger}`).systemEventId : void 0;
+    if (typeof eventId !== "number") return;
+    const row = await db.select({ content: mindHistory.content }).from(mindHistory).where(
+      and(
+        eq(mindHistory.mind, mind),
+        eq(mindHistory.turn_id, turnId),
+        eq(mindHistory.type, "text")
+      )
+    ).orderBy(desc(mindHistory.id)).limit(1).get();
+    const text = row?.content?.trim();
+    if (text) await recordReflection(mind, eventId, text);
+  } catch (err) {
+    elog.warn(`failed to capture reflection for turn ${turnId}`, logger_default.errorData(err));
+  }
+}
+
+export {
+  MIND_LEVEL_THREAD,
+  parseMeta,
+  eventLabel,
+  recordNotice,
+  eventChannel,
+  deliverEvent,
+  flushQueuedEvents,
+  pendingEventCount,
+  pendingEventsLine,
+  drainEvents,
+  formatEvents,
+  clearDeliveredEvents,
+  latestFailureEvent,
+  latestEvent,
+  hasUndeliveredEvent,
+  listEvents,
+  recordReflection,
+  captureReflection
+};

package/dist/{chunk-PY24ZL62.js → chunk-7UWXAJMK.js}

@@ -2,7 +2,7 @@
 import {
   stateDir,
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-CAIYV33P.js";
 
 // packages/daemon/src/lib/config/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-MG3Z34YE.js → chunk-7XDOTN4R.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-QUSMYGNQ.js";
 import {
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-CAIYV33P.js";
 
 // packages/daemon/src/lib/bridges/bridges.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-SX72DOO3.js → chunk-AFSLNUTT.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteSystemDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-CAIYV33P.js";
 
 // packages/daemon/src/lib/update-check.ts
 import { execFile as execFileCb, execFileSync } from "child_process";

package/dist/{chunk-DVN6DNMI.js → chunk-AJWFDIEY.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   getBaseName,
+  isSpiritName,
   validateMindName
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-CAIYV33P.js";
 
 // packages/daemon/src/lib/mind/isolation.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -63,7 +64,7 @@ function isIsolationEnabled() {
 }
 function mindUserName(mindName) {
   const err = validateMindName(mindName);
-  if (err && mindName !== "volute") {
+  if (err && !isSpiritName(mindName)) {
     throw new Error(`Invalid mind name for isolation: ${err}`);
   }
   const prefix = process.env.VOLUTE_USER_PREFIX ?? "mind-";
@@ -255,6 +256,19 @@ async function chownMindDir(dir, name) {
     throw new Error(`Failed to chmod ${dir}${stderr ? `: ${stderr}` : ""}`);
   }
 }
+async function chownMindFile(filePath, name) {
+  if (!isIsolationEnabled()) return;
+  const user = mindUserName(name);
+  const group = process.platform === "darwin" ? "volute" : user;
+  try {
+    await exec("chown", [`${user}:${group}`, filePath]);
+  } catch (err) {
+    const stderr = String(err?.stderr ?? "").trim();
+    throw new Error(
+      `Failed to chown ${filePath} to ${user}:${group}${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+}
 
 export {
   isIsolationEnabled,
@@ -265,6 +279,7 @@ export {
   wrapForIsolation,
   chownTargets,
   chownMindDir,
+  chownMindFile,
   exec,
   gitExec,
   resolveVoluteBin,