@abraca/nuxt 1.9.1 → 2.0.0

package/dist/runtime/composables/useChat.js

@@ -1,8 +1,32 @@
-import { ref, computed } from "vue";
+import { ref, computed, watch } from "vue";
 import { useAbracadabra } from "./useAbracadabra.js";
+import { tsToMs } from "../utils/time.js";
+import {
+  ChannelKeyResolver,
+  DocKeyManager,
+  decryptChatContent,
+  foldRecords,
+  isEncryptedContent,
+  recordFromYAny
+} from "@abraca/dabra";
+const _docKeys = new DocKeyManager();
+const _resolverByClient = /* @__PURE__ */ new WeakMap();
+function _resolveChannelKey(client) {
+  if (!client) return null;
+  const cached = _resolverByClient.get(client);
+  if (cached) return cached;
+  const { keystore } = useAbracadabra();
+  if (!keystore.value) return null;
+  const resolver = new ChannelKeyResolver(client, _docKeys, keystore.value);
+  _resolverByClient.set(client, resolver);
+  return resolver;
+}
 export function buildDmChannelId(a, b) {
   return `dm:${[a, b].sort().join(":")}`;
 }
+function normalizeChannel(channelId) {
+  return channelId.startsWith("group:") ? channelId.slice("group:".length) : channelId;
+}
 const messagesByChannel = ref({});
 const channels = ref({});
 const typingByChannel = ref({});
@@ -26,6 +50,20 @@ export function _destroyChat() {
   for (const t of typingTimers.values()) clearTimeout(t);
   typingTimers.clear();
 }
+function resolveSenderName(senderId, fallback = "User") {
+  if (!senderId) return fallback;
+  try {
+    const { provider } = useAbracadabra();
+    const awareness = provider.value?.awareness;
+    if (!awareness) return fallback;
+    const states = awareness.getStates();
+    for (const state of states.values()) {
+      if (state?.user?.publicKey === senderId && state.user.name) return state.user.name;
+    }
+  } catch {
+  }
+  return fallback;
+}
 function resolveChannelLabel(channelId, senderName, senderId) {
   const { doc } = useAbracadabra();
   if (channelId.startsWith("group:")) {
@@ -60,50 +98,56 @@ function ensureChannel(channelId, label) {
 function addMessage(msg) {
   const list = messagesByChannel.value[msg.channel] ?? [];
   if (list.some((m) => m.id === msg.id)) return;
-  const sorted = [...list, msg].sort((a, b) => a.createdAt - b.createdAt);
+  const isServerEcho = !msg.id.startsWith("local-");
+  let filtered = list;
+  if (isServerEcho) {
+    filtered = list.filter(
+      (m) => !(m.id.startsWith("local-") && m.senderId === msg.senderId && m.content === msg.content && Math.abs(m.createdAt - msg.createdAt) < 3e4)
+    );
+  }
+  const sorted = [...filtered, msg].sort((a, b) => a.createdAt - b.createdAt);
   messagesByChannel.value = { ...messagesByChannel.value, [msg.channel]: sorted };
   const chan = channels.value[msg.channel];
   if (chan) {
     const isActive = activeChannel.value === msg.channel;
+    const isOwn = msg.senderId === _publicKeyB64.value;
     channels.value = {
       ...channels.value,
       [msg.channel]: {
         ...chan,
         lastMessage: msg,
-        unreadCount: isActive ? 0 : chan.unreadCount + 1
+        unreadCount: isActive || isOwn ? chan.unreadCount : chan.unreadCount + 1
       }
     };
   }
 }
 export function _handleStatelessChat(payload) {
-  if (!payload.includes('"chat:')) return;
+  if (!payload.includes('"messages:')) return;
   try {
     const data = JSON.parse(payload);
-    if (!data.type?.startsWith("chat:")) return;
-    switch (data.type) {
-      case "chat:history": {
-        const msgs = (data.messages || []).map((m) => ({
-          id: m.id,
-          channel: m.channel,
-          senderId: m.sender_id ?? "",
-          senderName: m.sender_name ?? "User",
-          content: m.content,
-          createdAt: typeof m.created_at === "number" ? m.created_at : new Date(m.created_at).getTime()
-        }));
-        for (const msg of msgs) {
-          ensureChannel(msg.channel, resolveChannelLabel(msg.channel, msg.senderName, msg.senderId));
-          addMessage(msg);
-        }
-        break;
-      }
-      case "chat:message": {
+    const t = data.type;
+    if (!t || !t.startsWith("messages:")) return;
+    switch (t) {
+      case "messages:new_message": {
+        const rec = data.record;
+        if (!rec || rec.record_kind && rec.record_kind !== "message") break;
+        const channelDocId = rec.channel_doc_id;
+        if (!channelDocId) break;
+        const tsMs = tsToMs(rec.ts) ?? Date.now();
+        const senderId = rec.sender_id ?? "";
         const msg = {
-          id: data.id ?? crypto.randomUUID(),
-          channel: data.channel,
-          senderId: data.sender_id ?? "",
-          senderName: data.sender_name ?? "User",
-          content: data.content,
-          createdAt: typeof data.created_at === "number" ? data.created_at : Date.now()
+          id: rec.id ?? `${senderId}-${tsMs}`,
+          // Use the raw doc id as the channel key; the legacy `group:`
+          // prefix scheme is on its way out across the codebase.
+          channel: channelDocId,
+          senderId,
+          // Server records carry only `sender_id` (publicKey). Resolve a
+          // human-readable name from awareness so peers don't all show as
+          // the placeholder "User" — that visual collapse was being read
+          // as "chat is broken / messages aren't syncing".
+          senderName: rec.sender_name ?? resolveSenderName(senderId),
+          content: rec.content ?? "",
+          createdAt: tsMs
         };
         ensureChannel(msg.channel, resolveChannelLabel(msg.channel, msg.senderName, msg.senderId));
         addMessage(msg);
@@ -115,26 +159,61 @@ export function _handleStatelessChat(payload) {
         }
         break;
       }
-      case "chat:typing": {
-        const channel = data.channel;
+      case "messages:typing": {
+        const channelDocId = data.channel_doc_id;
+        if (!channelDocId) break;
         const senderId = data.sender_id ?? "";
         const name = data.sender_name ?? "User";
         if (senderId === _publicKeyB64.value) break;
-        const current = typingByChannel.value[channel] ?? /* @__PURE__ */ new Map();
+        const current = typingByChannel.value[channelDocId] ?? /* @__PURE__ */ new Map();
         const next = new Map(current);
         next.set(senderId, name);
-        typingByChannel.value = { ...typingByChannel.value, [channel]: next };
-        const timerKey = `${channel}:${senderId}`;
+        typingByChannel.value = { ...typingByChannel.value, [channelDocId]: next };
+        const timerKey = `${channelDocId}:${senderId}`;
         const existing = typingTimers.get(timerKey);
         if (existing) clearTimeout(existing);
         typingTimers.set(timerKey, setTimeout(() => {
           typingTimers.delete(timerKey);
-          const cur = typingByChannel.value[channel];
-          if (!cur) return;
-          const updated = new Map(cur);
-          updated.delete(senderId);
-          typingByChannel.value = { ...typingByChannel.value, [channel]: updated };
-        }, 4e3));
+          const cur = typingByChannel.value[channelDocId];
+          if (cur?.has(senderId)) {
+            const n2 = new Map(cur);
+            n2.delete(senderId);
+            typingByChannel.value = { ...typingByChannel.value, [channelDocId]: n2 };
+          }
+        }, 5e3));
+        break;
+      }
+      case "permissions:rewrap_needed": {
+        const docId = data.doc_id;
+        const targetUserId = data.target_user_id;
+        if (!docId || !targetUserId) break;
+        if (targetUserId === _publicKeyB64.value) break;
+        (async () => {
+          const { client } = useAbracadabra();
+          if (!client?.value) return;
+          try {
+            const resolver = _resolveChannelKey(client.value);
+            if (!resolver) return;
+            const docKey = await resolver.docKeyFor(docId);
+            if (!docKey) return;
+            const granteeKeys = await client.value.listUserKeys(targetUserId);
+            if (!granteeKeys.length) return;
+            const granteeKey = granteeKeys[0];
+            if (!granteeKey.x25519Key) return;
+            const x25519Pub = Uint8Array.from(
+              atob(granteeKey.x25519Key.replace(/-/g, "+").replace(/_/g, "/")),
+              (c) => c.charCodeAt(0)
+            );
+            const wrapped = await _docKeys.wrapKeyForRecipient(docKey, x25519Pub, docId);
+            const b64 = btoa(String.fromCharCode(...wrapped));
+            await client.value.uploadKeyEnvelopes(docId, {
+              key_epoch: 1,
+              envelopes: [{ recipient_key_id: granteeKey.id, encrypted_key: b64 }]
+            });
+          } catch (err) {
+            if (import.meta.dev) console.warn("[abracadabra] rewrap_needed handler failed:", err);
+          }
+        })();
         break;
       }
     }
@@ -142,39 +221,140 @@ export function _handleStatelessChat(payload) {
     if (import.meta.dev) console.warn("[abracadabra] chat: failed to handle stateless message:", e);
   }
 }
-function sendMessage(channelId, content) {
-  const { provider } = useAbracadabra();
+function sendMessage(channelId, content, opts) {
+  const { provider, userName } = useAbracadabra();
   if (!provider.value || !content.trim()) return;
+  const channelDocId = normalizeChannel(channelId);
+  const trimmed = content.trim();
+  ensureChannel(channelDocId);
+  addMessage({
+    id: `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    channel: channelDocId,
+    senderId: _publicKeyB64.value,
+    senderName: userName?.value ?? _userName.value,
+    content: trimmed,
+    createdAt: Date.now()
+  });
   provider.value.sendStateless(JSON.stringify({
-    type: "chat:send",
-    channel: channelId,
-    content: content.trim()
+    type: "messages:send",
+    channel_doc_id: channelDocId,
+    content: trimmed,
+    mentions: opts?.mentions ?? [],
+    ...opts?.replyTo ? { reply_to: opts.replyTo } : {}
   }));
 }
-function fetchHistory(channelId, opts) {
+const _channelHandles = /* @__PURE__ */ new Map();
+async function _attachPeriodProvider(channel, rootProv, periodId) {
+  const handle = _channelHandles.get(channel);
+  if (!handle) return;
+  if (handle.periodProv && handle.periodProv.name === periodId) return;
+  try {
+    const periodChild = await rootProv.loadChild(periodId);
+    handle.periodProv = periodChild;
+    const arr = periodChild.document.getArray("messages");
+    const channelDocIdRaw = channel.startsWith("group:") ? channel.slice("group:".length) : channel;
+    const { client } = useAbracadabra();
+    const resolver = _resolveChannelKey(client?.value);
+    let channelDocKey = null;
+    let docKeyError = null;
+    if (resolver) {
+      try {
+        channelDocKey = await resolver.docKeyFor(channelDocIdRaw);
+      } catch (e) {
+        docKeyError = e;
+      }
+    }
+    const pumpAll = async () => {
+      const records = arr.toArray().map((v) => recordFromYAny(v)).filter((r) => r !== null);
+      const folded = foldRecords(records);
+      for (const f of folded) {
+        let content = f.content;
+        if (isEncryptedContent(content)) {
+          if (channelDocKey) {
+            const decrypted = await decryptChatContent(content, channelDocKey);
+            content = decrypted ?? "[decryption failed]";
+          } else {
+            content = docKeyError ? "[encrypted \u2014 no key available for this channel]" : "[encrypted]";
+          }
+        }
+        addMessage({
+          id: f.id,
+          channel,
+          senderId: f.senderId,
+          senderName: "",
+          content,
+          createdAt: f.createdAt
+        });
+      }
+    };
+    const onChange = () => {
+      void pumpAll();
+    };
+    arr.observe(onChange);
+    handle.disposers.push(() => arr.unobserve(onChange));
+    const tryPump = () => {
+      if (arr.length > 0) void pumpAll();
+    };
+    if (periodChild.synced) tryPump();
+    else periodChild.on("synced", tryPump);
+  } catch (err) {
+    if (import.meta.dev) console.warn(`[abracadabra] loadChild(period ${periodId}) for ${channel} failed:`, err);
+  }
+}
+function fetchHistory(channelId, _opts) {
+  const channelDocId = normalizeChannel(channelId);
+  if (_channelHandles.has(channelDocId)) return;
   const { provider } = useAbracadabra();
-  if (!provider.value) return;
-  provider.value.sendStateless(JSON.stringify({
-    type: "chat:history",
-    channel: channelId,
-    before: opts?.before,
-    limit: opts?.limit ?? 50
-  }));
+  const rootProv = provider.value;
+  if (!rootProv) {
+    if (import.meta.dev) console.warn(`[abracadabra] fetchHistory(${channelDocId}): no provider attached yet`);
+    return;
+  }
+  const handle = { wrapperProv: null, periodProv: null, disposers: [] };
+  _channelHandles.set(channelDocId, handle);
+  const rootName = rootProv?.configuration?.name ?? rootProv?.document?.guid;
+  const isSelfChannel = rootName === channelDocId;
+  const wireUp = (wrapperChild) => {
+    handle.wrapperProv = wrapperChild;
+    const periods = wrapperChild.document.getArray("periods");
+    const pickActive = () => {
+      const len = periods.length;
+      if (len === 0) return;
+      const last = periods.get(len - 1);
+      const periodId = last?.id ?? last?.get?.("id");
+      if (periodId) void _attachPeriodProvider(channelDocId, rootProv, periodId);
+    };
+    const onPeriods = () => pickActive();
+    periods.observe(onPeriods);
+    handle.disposers.push(() => periods.unobserve(onPeriods));
+    if (wrapperChild.synced) pickActive();
+    else wrapperChild.on("synced", pickActive);
+  };
+  if (isSelfChannel) {
+    wireUp(rootProv);
+    return;
+  }
+  rootProv.loadChild(channelDocId).then(wireUp).catch((err) => {
+    if (import.meta.dev) console.warn(`[abracadabra] loadChild(${channelDocId}) failed:`, err);
+    _channelHandles.delete(channelDocId);
+  });
 }
 function sendTyping(channelId) {
   const { provider } = useAbracadabra();
   if (!provider.value) return;
+  const channelDocId = normalizeChannel(channelId);
   provider.value.sendStateless(JSON.stringify({
-    type: "chat:typing",
-    channel: channelId
+    type: "messages:typing",
+    channel_doc_id: channelDocId
   }));
 }
 function setActiveChannel(channelId) {
-  activeChannel.value = channelId;
-  if (channelId && channels.value[channelId]) {
+  const key = channelId ? normalizeChannel(channelId) : null;
+  activeChannel.value = key;
+  if (key && channels.value[key]) {
     channels.value = {
       ...channels.value,
-      [channelId]: { ...channels.value[channelId], unreadCount: 0 }
+      [key]: { ...channels.value[key], unreadCount: 0 }
     };
   }
 }
@@ -196,24 +376,35 @@ export function useChat() {
   };
 }
 export function useChatChannel(channelId) {
-  const messages = computed(() => messagesByChannel.value[channelId] ?? []);
-  const channel = computed(() => channels.value[channelId]);
-  const typingUsers = computed(() => [...typingByChannel.value[channelId]?.values() ?? []]);
-  const unreadCount = computed(() => channels.value[channelId]?.unreadCount ?? 0);
+  const key = normalizeChannel(channelId);
+  const messages = computed(() => messagesByChannel.value[key] ?? []);
+  const channel = computed(() => channels.value[key]);
+  const typingUsers = computed(() => [...typingByChannel.value[key]?.values() ?? []]);
+  const unreadCount = computed(() => channels.value[key]?.unreadCount ?? 0);
+  ensureChannel(key);
+  const { provider } = useAbracadabra();
+  if (provider.value) fetchHistory(key);
+  else {
+    const stop = watch(provider, (p) => {
+      if (!p) return;
+      fetchHistory(key);
+      stop();
+    });
+  }
   function send(content) {
-    sendMessage(channelId, content);
+    sendMessage(key, content);
   }
   function loadHistory(opts) {
-    fetchHistory(channelId, opts);
+    fetchHistory(key, opts);
   }
   function typing() {
-    sendTyping(channelId);
+    sendTyping(key);
   }
   function focus() {
-    setActiveChannel(channelId);
+    setActiveChannel(key);
   }
   function blur() {
-    if (activeChannel.value === channelId) setActiveChannel(null);
+    if (activeChannel.value === key) setActiveChannel(null);
   }
   return { messages, channel, typingUsers, unreadCount, send, loadHistory, typing, focus, blur };
 }

package/dist/runtime/composables/useChatUsers.d.ts

@@ -14,6 +14,8 @@ export interface ChatUserAppearance {
     neutralName: string;
     publicKey: string;
     isOnline: boolean;
+    /** Doc the user is currently viewing (from awareness `docId` field). */
+    docId?: string;
 }
 export declare function useChatUsers(): {
     onlineUsers: import("vue").ComputedRef<ChatUserAppearance[]>;

package/dist/runtime/composables/useChatUsers.js

@@ -16,7 +16,8 @@ export function useChatUsers() {
             color: u.color ?? "#888",
             neutralName: "zinc",
             publicKey: u.publicKey,
-            isOnline: true
+            isOnline: true,
+            docId: typeof state.docId === "string" ? state.docId : void 0
           });
         }
       }

package/dist/runtime/composables/useDocLookup.d.ts

@@ -0,0 +1,4 @@
+export declare function useDocLookup(): {
+    docToSpace: import("vue").ComputedRef<Map<string, string>>;
+    resolveDocSpace: (docId: string) => string | undefined;
+};

package/dist/runtime/composables/useDocLookup.js

@@ -0,0 +1,25 @@
+import { computed } from "vue";
+import { useSpaceConnections } from "./useSpaceConnections.js";
+import { useAbracadabra } from "./useAbracadabra.js";
+export function useDocLookup() {
+  const { connections } = useSpaceConnections();
+  const state = useAbracadabra();
+  const docToSpace = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const [spaceId, conn] of connections) {
+      if (state.spaceDocId.value) map.set(state.spaceDocId.value, spaceId);
+      const treeData = conn.treeData.value;
+      for (const docId of Object.keys(treeData)) {
+        map.set(docId, spaceId);
+      }
+    }
+    return map;
+  });
+  function resolveDocSpace(docId) {
+    return docToSpace.value.get(docId);
+  }
+  return {
+    docToSpace,
+    resolveDocSpace
+  };
+}

package/dist/runtime/composables/useDocSnapshots.d.ts

@@ -0,0 +1,79 @@
+/**
+ * useDocSnapshots
+ *
+ * CRUD over a document's snapshot history with paginated fetch and a
+ * derived "display items" view that collapses runs of consecutive
+ * auto-snapshots from the same author within a 30-min window into one
+ * cluster (manual / unload / shutdown / labelled snapshots stay
+ * individual). Keeps the side-panel timeline scannable while losing
+ * nothing.
+ *
+ * Mirrors the `cou-sh` implementation 1-to-1 — the cou-sh version is the
+ * source of truth (see project memory: nuxt-module-must-match-coush). If
+ * this composable drifts from cou-sh's, fix it back rather than
+ * "improving" it here.
+ *
+ * Usage:
+ *   const docId = computed(() => route.params.id as string)
+ *   const snaps = useDocSnapshots(docId)
+ *   onMounted(() => snaps.fetchList())
+ */
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+import type { SnapshotMeta } from '@abraca/dabra';
+import type { AbracadabraLocale } from '../locale.js';
+export type DocSnapshotsCtx = ReturnType<typeof useDocSnapshots>;
+export declare const DOC_SNAPSHOTS_KEY: InjectionKey<DocSnapshotsCtx>;
+/** Trigger badge color, matching cou-sh's mapping exactly. */
+export declare function triggerBadgeColor(trigger: string): 'primary' | 'neutral' | 'warning';
+/**
+ * Trigger label key — consumers translate via their own i18n if they
+ *  don't use `useAbraLocale`. Returns the dot-path key cou-sh uses.
+ */
+export declare function triggerLabelKey(trigger: string): string;
+/**
+ * Per-row item for the side-panel list. Auto runs collapse into a
+ *  single `cluster` item; everything else stays as its own `snap`.
+ */
+export type SnapshotDisplayItem = {
+    kind: 'snap';
+    snap: SnapshotMeta;
+} | {
+    kind: 'cluster';
+    items: SnapshotMeta[];
+    firstAt: number;
+    lastAt: number;
+    createdBy: string | null;
+};
+export declare function useDocSnapshots(docId: Ref<string> | ComputedRef<string>, overrides?: Partial<AbracadabraLocale['snapshots']> | null): {
+    snapshots: Ref<{
+        version: number;
+        size_bytes: number;
+        trigger: string;
+        label?: string | null | undefined;
+        created_by?: string | null | undefined;
+        created_at: number;
+        file_count?: number | undefined;
+        delta_bytes?: number | null | undefined;
+    }[], SnapshotMeta[] | {
+        version: number;
+        size_bytes: number;
+        trigger: string;
+        label?: string | null | undefined;
+        created_by?: string | null | undefined;
+        created_at: number;
+        file_count?: number | undefined;
+        delta_bytes?: number | null | undefined;
+    }[]>;
+    displayItems: ComputedRef<SnapshotDisplayItem[]>;
+    loading: Ref<boolean, boolean>;
+    error: Ref<string | null, string | null>;
+    hasMore: Ref<boolean, boolean>;
+    creating: Ref<boolean, boolean>;
+    pending: Ref<Record<number, "delete" | "restore" | "fork" | undefined>, Record<number, "delete" | "restore" | "fork" | undefined>>;
+    fetchList: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    create: (label?: string) => Promise<void>;
+    remove: (version: number) => Promise<void>;
+    restore: (version: number) => Promise<void>;
+    fork: (version: number) => Promise<void>;
+};