volute 0.28.0 → 0.30.0

package/dist/{archive-UA4BDFXQ.js → archive-WWDBWYN2.js}

@@ -5,8 +5,8 @@ import {
   extractArchive,
   isHomeOnlyArchive,
   readManifest
-} from "./chunk-XBLSAVJF.js";
-import "./chunk-H7OZRFJB.js";
+} from "./chunk-DTC6EH5I.js";
+import "./chunk-HHTXM4JT.js";
 import "./chunk-K3NQKI34.js";
 export {
   addHistoryToArchive,

package/dist/{bridge-FQHZL3MC.js → bridge-RO37CUFM.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-JGFVMROS.js";
+} from "./chunk-EFVHR7KH.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
-import "./chunk-H7OZRFJB.js";
+import "./chunk-HHTXM4JT.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/chat/bridge.ts

package/dist/{chat-M4SX42JD.js → chat-TCUNPFGO.js}

@@ -7,28 +7,28 @@ async function run(args) {
   const subArgs = args.slice(1);
   switch (subcommand) {
     case "send":
-      await import("./send-TAOEZ4NH.js").then((m) => m.run(subArgs));
+      await import("./send-OAN3RYYY.js").then((m) => m.run(subArgs));
       break;
     case "list":
-      await import("./list-R73GENNL.js").then((m) => m.run(subArgs));
+      await import("./list-Q6O7FGAN.js").then((m) => m.run(subArgs));
       break;
     case "read":
-      await import("./read-36UFXN3G.js").then((m) => m.run(subArgs));
+      await import("./read-WQMPTSN2.js").then((m) => m.run(subArgs));
       break;
     case "create":
-      await import("./create-D7J73A6H.js").then((m) => m.run(subArgs));
+      await import("./create-JTLS7GX3.js").then((m) => m.run(subArgs));
       break;
     case "bridge":
-      await import("./bridge-FQHZL3MC.js").then((m) => m.run(subArgs));
+      await import("./bridge-RO37CUFM.js").then((m) => m.run(subArgs));
       break;
     case "files":
-      await import("./files-M546TKVN.js").then((m) => m.run(subArgs));
+      await import("./files-4VEJDASH.js").then((m) => m.run(subArgs));
       break;
     case "accept":
-      await import("./accept-666DIZX2.js").then((m) => m.run(subArgs));
+      await import("./accept-E3PAH3QJ.js").then((m) => m.run(subArgs));
       break;
     case "reject":
-      await import("./reject-LXIZFJ4Q.js").then((m) => m.run(subArgs));
+      await import("./reject-2HZOJEIJ.js").then((m) => m.run(subArgs));
       break;
     case "--help":
     case "-h":

package/dist/{chunk-IAYBDWVG.js → chunk-2C2VXEBB.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   subscribe
-} from "./chunk-VIVMW2H2.js";
+} from "./chunk-P27RV5WM.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
@@ -12,7 +12,7 @@ import {
   getDb,
   messages,
   users
-} from "./chunk-H7OZRFJB.js";
+} from "./chunk-HHTXM4JT.js";
 
 // src/lib/events/conversations.ts
 import { randomUUID } from "crypto";
@@ -109,6 +109,53 @@ function publish(conversationId, event) {
 }
 
 // src/lib/events/conversations.ts
+async function migrateGroupDMsToChannels() {
+  const db = await getDb();
+  await db.transaction(async (tx) => {
+    const overloadedDMs = await tx.select({
+      conversationId: conversationParticipants.conversation_id,
+      count: sql`COUNT(*)`
+    }).from(conversationParticipants).innerJoin(conversations, eq(conversationParticipants.conversation_id, conversations.id)).where(eq(conversations.type, "dm")).groupBy(conversationParticipants.conversation_id).having(sql`COUNT(*) > 2`);
+    const dmIds = overloadedDMs.map((r) => r.conversationId);
+    await tx.update(conversations).set({
+      type: "channel",
+      name: sql`COALESCE(${conversations.name}, ${conversations.title})`
+    }).where(eq(conversations.type, "group"));
+    if (dmIds.length > 0) {
+      await tx.update(conversations).set({
+        type: "channel",
+        name: sql`COALESCE(${conversations.name}, ${conversations.title})`
+      }).where(inArray(conversations.id, dmIds));
+    }
+  });
+  await migrateChannelEntryTypes();
+}
+async function migrateChannelEntryTypes() {
+  const { existsSync, readdirSync, readFileSync, writeFileSync } = await import("fs");
+  const { join } = await import("path");
+  const home = join((await import("os")).homedir(), ".volute", "state");
+  if (!existsSync(home)) return;
+  for (const name of readdirSync(home)) {
+    const filePath = join(home, name, "channels.json");
+    if (!existsSync(filePath)) continue;
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const map = JSON.parse(raw);
+      let changed = false;
+      for (const entry of Object.values(map)) {
+        if (entry.type === "group") {
+          entry.type = "channel";
+          changed = true;
+        }
+      }
+      if (changed) {
+        writeFileSync(filePath, `${JSON.stringify(map, null, 2)}
+`);
+      }
+    } catch {
+    }
+  }
+}
 async function createConversation(mindName, channel, opts) {
   const db = await getDb();
   const id = randomUUID();
@@ -380,6 +427,101 @@ async function findDMConversation(mindName, participantIds) {
   }
   return null;
 }
+async function listConversationsForMind(mindName) {
+  const db = await getDb();
+  const byName = await db.select().from(conversations).where(eq(conversations.mind_name, mindName)).orderBy(desc(conversations.updated_at)).all();
+  const mindUser = await db.select({ id: users.id }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+  const byNameIds = new Set(byName.map((c) => c.id));
+  let byParticipation = [];
+  if (mindUser) {
+    const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq(conversationParticipants.user_id, mindUser.id)).all();
+    const extraIds = participantRows.map((r) => r.conversation_id).filter((id) => !byNameIds.has(id));
+    if (extraIds.length > 0) {
+      byParticipation = await db.select().from(conversations).where(inArray(conversations.id, extraIds)).orderBy(desc(conversations.updated_at)).all();
+    }
+  }
+  const convs = [...byName, ...byParticipation].sort(
+    (a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime()
+  );
+  if (convs.length === 0) return [];
+  const convIds = convs.map((c) => c.id);
+  const rows = await db.select({
+    conversationId: conversationParticipants.conversation_id,
+    userId: users.id,
+    username: users.username,
+    userType: users.user_type,
+    role: conversationParticipants.role,
+    displayName: users.display_name,
+    description: users.description,
+    avatar: users.avatar
+  }).from(conversationParticipants).innerJoin(users, eq(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
+  const byConv = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    let arr = byConv.get(r.conversationId);
+    if (!arr) {
+      arr = [];
+      byConv.set(r.conversationId, arr);
+    }
+    arr.push({
+      userId: r.userId,
+      username: r.username,
+      userType: r.userType,
+      role: r.role,
+      displayName: r.displayName,
+      description: r.description,
+      avatar: r.avatar
+    });
+  }
+  const lastMsgIds = await db.select({
+    conversationId: messages.conversation_id,
+    maxId: sql`MAX(${messages.id})`
+  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
+  const byLastMsg = /* @__PURE__ */ new Map();
+  if (lastMsgIds.length > 0) {
+    const msgRows = await db.select().from(messages).where(
+      inArray(
+        messages.id,
+        lastMsgIds.map((r) => r.maxId)
+      )
+    );
+    for (const m of msgRows) {
+      let text = "";
+      try {
+        const parsed = JSON.parse(m.content);
+        const blocks = Array.isArray(parsed) ? parsed : [];
+        const textBlock = blocks.find((b) => b.type === "text");
+        if (textBlock && "text" in textBlock) text = textBlock.text;
+      } catch {
+        text = m.content;
+      }
+      byLastMsg.set(m.conversation_id, {
+        role: m.role,
+        senderName: m.sender_name,
+        text,
+        createdAt: m.created_at
+      });
+    }
+  }
+  return convs.map((c) => ({
+    ...c,
+    participants: byConv.get(c.id) ?? [],
+    lastMessage: byLastMsg.get(c.id)
+  }));
+}
+async function isConversationForMind(mindName, conversationId) {
+  const db = await getDb();
+  const byName = await db.select({ id: conversations.id }).from(conversations).where(and(eq(conversations.id, conversationId), eq(conversations.mind_name, mindName))).get();
+  if (byName) return true;
+  const mindUser = await db.select({ id: users.id }).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
+  if (!mindUser) return false;
+  const participant = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(
+    and(
+      eq(conversationParticipants.conversation_id, conversationId),
+      eq(conversationParticipants.user_id, mindUser.id)
+    )
+  ).get();
+  return !!participant;
+}
 async function deleteConversation(id) {
   const db = await getDb();
   await db.delete(conversations).where(eq(conversations.id, id));
@@ -451,6 +593,7 @@ export {
   initWebhook,
   subscribe2 as subscribe,
   publish,
+  migrateGroupDMsToChannels,
   createConversation,
   getOrCreateConversation,
   getConversation,
@@ -466,6 +609,8 @@ export {
   getMessagesPaginated,
   listConversationsWithParticipants,
   findDMConversation,
+  listConversationsForMind,
+  isConversationForMind,
   deleteConversation,
   createChannel,
   getChannelByName,