@abraca/nuxt 1.9.1 → 2.0.1

package/dist/runtime/composables/useAAViewport.js

@@ -0,0 +1,50 @@
+import { computed, onScopeDispose, watch } from "vue";
+import { useAAEphemeral } from "./useAAEphemeral.js";
+export function useAAViewport(scope, elementRef) {
+  const slot = computed(() => `viewport:${typeof scope === "function" ? scope() : scope?.value ?? scope}`);
+  const { peers, setLocal } = useAAEphemeral(slot);
+  let io = null;
+  let attached = null;
+  let mostVisible = null;
+  function publish() {
+    setLocal(mostVisible?.id ?? null);
+  }
+  function attach(el) {
+    if (attached === el) return;
+    detach();
+    attached = el;
+    io = new IntersectionObserver((entries) => {
+      let best = mostVisible;
+      for (const e of entries) {
+        const id = e.target.dataset.section;
+        if (!id) continue;
+        if (!e.isIntersecting) {
+          if (best?.id === id) best = null;
+          continue;
+        }
+        if (!best || e.intersectionRatio > best.ratio) {
+          best = { id, ratio: e.intersectionRatio };
+        }
+      }
+      mostVisible = best;
+      publish();
+    }, { threshold: [0, 0.25, 0.5, 0.75, 1] });
+    el.querySelectorAll("[data-section]").forEach((s) => io.observe(s));
+  }
+  function detach() {
+    io?.disconnect();
+    io = null;
+    attached = null;
+    mostVisible = null;
+    setLocal(null);
+  }
+  watch(elementRef, (el) => {
+    if (el) attach(el);
+    else detach();
+  }, { immediate: true, flush: "post" });
+  onScopeDispose(detach);
+  const viewports = computed(
+    () => peers.value.filter((p) => !!p.value).map((p) => ({ clientId: p.clientId, section: p.value, user: p.user }))
+  );
+  return { viewports };
+}

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

@@ -0,0 +1,54 @@
+/**
+ * useAbraAdmin
+ *
+ * Admin-only composable. Wraps the `/admin/*` REST endpoints (audit log,
+ * backup dump, user lockout). All methods reject with `Error('not admin')`
+ * when `isAdmin` is false — UI should gate route entry on the same flag.
+ *
+ * Usage:
+ *   const admin = useAbraAdmin()
+ *   if (admin.isAdmin.value) {
+ *     const rows = await admin.auditList({ event_type: 'auth.login_failed' })
+ *   }
+ */
+import type { AuditLogEntry, AuditQueryOpts, AuditVerifyResult } from '@abraca/dabra';
+declare function auditList(opts?: AuditQueryOpts): Promise<AuditLogEntry[]>;
+declare function auditExport(opts?: Omit<AuditQueryOpts, 'limit' | 'offset'>): Promise<string>;
+declare function auditVerify(): Promise<AuditVerifyResult>;
+declare function unlockUser(userId: string): Promise<void>;
+declare function backupDump(opts?: {
+    includeAudit?: boolean;
+}): Promise<Blob>;
+/**
+ * Convenience: download a backup tar to the user's machine. Computes a
+ * filename like `abracadabra-backup-<server>-<isoDate>.tar`.
+ */
+declare function downloadBackup(opts?: {
+    includeAudit?: boolean;
+    filename?: string;
+}): Promise<void>;
+export declare function useAbraAdmin(): {
+    /** True when the current effective role is admin/owner/service. */
+    isAdmin: import("vue").ComputedRef<boolean>;
+    /** Last-fetched audit log rows (best-first). */
+    auditEntries: import("vue").ShallowRef<AuditLogEntry[], AuditLogEntry[]>;
+    /** Last `auditVerify()` result, or null. */
+    auditVerifyResult: import("vue").ShallowRef<AuditVerifyResult | null, AuditVerifyResult | null>;
+    /** Whether an admin call is in flight. */
+    isLoading: import("vue").Ref<boolean, boolean>;
+    /** Last error message, or null. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** GET /admin/audit. */
+    auditList: typeof auditList;
+    /** GET /admin/audit/export — returns NDJSON as a string. */
+    auditExport: typeof auditExport;
+    /** GET /admin/audit/verify — returns the result whether ok or broken. */
+    auditVerify: typeof auditVerify;
+    /** POST /admin/users/:id/unlock. */
+    unlockUser: typeof unlockUser;
+    /** GET /admin/backup/dump — returns the tar Blob. */
+    backupDump: typeof backupDump;
+    /** Convenience: backupDump + browser download. */
+    downloadBackup: typeof downloadBackup;
+};
+export {};

package/dist/runtime/composables/useAbraAdmin.js

@@ -0,0 +1,115 @@
+import { computed, ref, shallowRef } from "vue";
+import { useAbracadabra } from "#imports";
+const auditEntries = shallowRef([]);
+const auditVerifyResult = shallowRef(null);
+const isLoading = ref(false);
+const error = ref(null);
+function _client() {
+  const abra = useAbracadabra();
+  const c = abra.client.value;
+  if (!c) throw new Error("Not connected");
+  return { abra, client: c };
+}
+function _isAdminRole(role) {
+  return role === "admin" || role === "service" || role === "owner";
+}
+async function auditList(opts) {
+  const { client } = _client();
+  isLoading.value = true;
+  error.value = null;
+  try {
+    const rows = await client.adminAuditList(opts);
+    auditEntries.value = rows;
+    return rows;
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to load audit log";
+    throw e;
+  } finally {
+    isLoading.value = false;
+  }
+}
+async function auditExport(opts) {
+  const { client } = _client();
+  error.value = null;
+  try {
+    return await client.adminAuditExport(opts);
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to export audit log";
+    throw e;
+  }
+}
+async function auditVerify() {
+  const { client } = _client();
+  error.value = null;
+  try {
+    const result = await client.adminAuditVerify();
+    auditVerifyResult.value = result;
+    return result;
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Audit verification failed";
+    throw e;
+  }
+}
+async function unlockUser(userId) {
+  const { client } = _client();
+  error.value = null;
+  try {
+    await client.adminUnlockUser(userId);
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to unlock user";
+    throw e;
+  }
+}
+async function backupDump(opts) {
+  const { client } = _client();
+  error.value = null;
+  try {
+    return await client.adminBackupDump(opts);
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Backup dump failed";
+    throw e;
+  }
+}
+async function downloadBackup(opts) {
+  const { abra } = _client();
+  const blob = await backupDump(opts);
+  if (typeof window === "undefined") return;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const host = abra.currentServerUrl.value.replace(/^https?:\/\//, "").replace(/[^a-z0-9.-]/gi, "_");
+  a.download = opts?.filename ?? `abracadabra-backup-${host}-${date}.tar`;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
+}
+export function useAbraAdmin() {
+  const abra = useAbracadabra();
+  const isAdmin = computed(() => _isAdminRole(abra.effectiveRole.value));
+  return {
+    /** True when the current effective role is admin/owner/service. */
+    isAdmin,
+    /** Last-fetched audit log rows (best-first). */
+    auditEntries,
+    /** Last `auditVerify()` result, or null. */
+    auditVerifyResult,
+    /** Whether an admin call is in flight. */
+    isLoading,
+    /** Last error message, or null. */
+    error,
+    /** GET /admin/audit. */
+    auditList,
+    /** GET /admin/audit/export — returns NDJSON as a string. */
+    auditExport,
+    /** GET /admin/audit/verify — returns the result whether ok or broken. */
+    auditVerify,
+    /** POST /admin/users/:id/unlock. */
+    unlockUser,
+    /** GET /admin/backup/dump — returns the tar Blob. */
+    backupDump,
+    /** Convenience: backupDump + browser download. */
+    downloadBackup
+  };
+}

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

@@ -12,7 +12,15 @@ export declare function useAbracadabraAuth(): {
     userNeutralColorName: any;
     claimAccount: any;
     loginWithHardware: any;
+    loginWithPassword: any;
+    registerWithPassword: any;
     logout: any;
+    logoutServer: any;
+    logoutAll: any;
+    requestPasswordReset: any;
+    confirmPasswordReset: any;
+    changePassword: any;
+    setPassword: any;
     recoverIdentity: any;
     unblockConnection: any;
     setUserName: any;

package/dist/runtime/composables/useAbracadabraAuth.js

@@ -15,7 +15,15 @@ export function useAbracadabraAuth() {
     userNeutralColorName: abra.userNeutralColorName,
     claimAccount: abra.claimAccount,
     loginWithHardware: abra.loginWithHardware,
+    loginWithPassword: abra.loginWithPassword,
+    registerWithPassword: abra.registerWithPassword,
     logout: abra.logout,
+    logoutServer: abra.logoutServer,
+    logoutAll: abra.logoutAll,
+    requestPasswordReset: abra.requestPasswordReset,
+    confirmPasswordReset: abra.confirmPasswordReset,
+    changePassword: abra.changePassword,
+    setPassword: abra.setPassword,
     recoverIdentity: abra.recoverIdentity,
     unblockConnection: abra.unblockConnection,
     setUserName: abra.setUserName,

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

@@ -0,0 +1,23 @@
+export interface PresenceUser {
+    name: string;
+    color: string;
+    publicKey?: string;
+    clientId: number;
+}
+interface AwarenessState {
+    user?: {
+        name?: string;
+        color?: string;
+        publicKey?: string;
+    };
+    docId?: string;
+    viewingDocId?: string;
+    [k: string]: unknown;
+}
+export declare const useAggregatedPresence: () => {
+    allAwarenessStates: import("vue").ComputedRef<AwarenessState[]>;
+    docPresence: import("vue").ComputedRef<Map<string, PresenceUser[]>>;
+    findUserState: (publicKey: string) => AwarenessState | null;
+    selfState: import("vue").ComputedRef<AwarenessState | null>;
+};
+export {};

package/dist/runtime/composables/useAggregatedPresence.js

@@ -0,0 +1,140 @@
+import { ref, computed, watch } from "vue";
+import { createSharedComposable } from "@vueuse/core";
+import { useSpaceConnections } from "./useSpaceConnections.js";
+import { useAbracadabra } from "./useAbracadabra.js";
+const _useAggregatedPresence = () => {
+  const { connections } = useSpaceConnections();
+  const { publicKeyB64 } = useAbracadabra();
+  const awarenessVersion = ref(0);
+  const attachedAwareness = /* @__PURE__ */ new Map();
+  if (import.meta.client) {
+    const onChange = () => {
+      awarenessVersion.value++;
+    };
+    watch(
+      () => [...connections.values()],
+      (conns) => {
+        const current = /* @__PURE__ */ new Set();
+        for (const conn of conns) {
+          const provider = conn.provider;
+          const awareness = provider?.awareness;
+          if (!awareness) continue;
+          current.add(awareness);
+          if (!attachedAwareness.has(awareness)) {
+            const handler = () => onChange();
+            awareness.on("change", handler);
+            attachedAwareness.set(awareness, handler);
+          }
+        }
+        for (const [a, handler] of attachedAwareness) {
+          if (!current.has(a)) {
+            try {
+              a.off("change", handler);
+            } catch {
+            }
+            attachedAwareness.delete(a);
+          }
+        }
+        awarenessVersion.value++;
+      },
+      { immediate: true }
+    );
+  }
+  const allAwarenessStates = computed(() => {
+    void awarenessVersion.value;
+    const seen = /* @__PURE__ */ new Map();
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      let stateMap;
+      try {
+        stateMap = awareness.getStates();
+      } catch {
+        continue;
+      }
+      const selfClientId = awareness.clientID;
+      for (const [clientId, state] of stateMap) {
+        if (clientId === selfClientId) continue;
+        if (!state.user?.publicKey) continue;
+        const key = state.user.publicKey;
+        if (key === publicKeyB64.value) continue;
+        if (!seen.has(key)) {
+          seen.set(key, { ...state, clientId });
+        }
+      }
+    }
+    return [...seen.values()];
+  });
+  const docPresence = computed(() => {
+    void awarenessVersion.value;
+    const map = /* @__PURE__ */ new Map();
+    const addToBucket = (docId, user) => {
+      const users = map.get(docId) ?? [];
+      if (user.publicKey && users.some((u) => u.publicKey === user.publicKey)) return;
+      users.push(user);
+      map.set(docId, users);
+    };
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      let stateMap;
+      try {
+        stateMap = awareness.getStates();
+      } catch {
+        continue;
+      }
+      const selfClientId = awareness.clientID;
+      for (const [clientId, state] of stateMap) {
+        if (clientId === selfClientId) continue;
+        const pk = state.user?.publicKey;
+        if (pk && pk === publicKeyB64.value) continue;
+        const docId = state.docId;
+        const viewingDocId = state.viewingDocId;
+        if (!docId && !viewingDocId) continue;
+        const user = {
+          name: state.user?.name || "?",
+          color: state.user?.color || "#888",
+          publicKey: pk,
+          clientId
+        };
+        if (docId) addToBucket(docId, user);
+        if (viewingDocId && viewingDocId !== docId) addToBucket(viewingDocId, user);
+      }
+    }
+    return map;
+  });
+  function findUserState(publicKey) {
+    void awarenessVersion.value;
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      let stateMap;
+      try {
+        stateMap = awareness.getStates();
+      } catch {
+        continue;
+      }
+      for (const state of stateMap.values()) {
+        if (state.user?.publicKey === publicKey) return state;
+      }
+    }
+    return null;
+  }
+  const selfState = computed(() => {
+    void awarenessVersion.value;
+    if (!publicKeyB64.value) return null;
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      const local = awareness.getLocalState();
+      if (local?.user?.publicKey === publicKeyB64.value) return local;
+    }
+    return null;
+  });
+  return { allAwarenessStates, docPresence, findUserState, selfState };
+};
+export const useAggregatedPresence = createSharedComposable(_useAggregatedPresence);

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

@@ -30,8 +30,22 @@ declare let _userName: import("vue").Ref<string, string>;
 export declare function _initChat(publicKeyB64Ref: typeof _publicKeyB64, userNameRef: typeof _userName): void;
 export declare function _destroyChat(): void;
 export declare function _handleStatelessChat(payload: string): void;
-declare function sendMessage(channelId: string, content: string): void;
-declare function fetchHistory(channelId: string, opts?: {
+declare function sendMessage(channelId: string, content: string, opts?: {
+    mentions?: string[];
+    replyTo?: string;
+}): void;
+/**
+ * Open the wrapper provider for the given channel, observe its
+ * `periods` Y.Array, and attach the active period subdoc so its
+ * `messages` Y.Array entries flow into the local buffer. Idempotent —
+ * calling twice for the same channel is a no-op (observers already
+ * live).
+ *
+ * `channelId` is the raw channel/dm doc UUID. The legacy `group:<uuid>`
+ * prefix is stripped before passing to provider.loadChild (which
+ * validates strict UUIDs).
+ */
+declare function fetchHistory(channelId: string, _opts?: {
     before?: number;
     limit?: number;
 }): void;