@k2b/cloud 0.43.0 → 0.45.0

package/src/browser/cloud-id.ts

@@ -0,0 +1,86 @@
+import { i18n } from "@k2b/stdlib";
+import { type DropdownItem, toast, useLocale } from "@k2b/ui";
+import { createMemo, onMount } from "solid-js";
+import type { CloudResourceRef } from "../contracts/capabilities";
+import { cloudResourceHref } from "../contracts/resource-href";
+import { cloudOrigin } from "./resource-links";
+
+export const cloudIdMessages = i18n.define({
+  baseLocale: "en",
+  messages: {
+    en: {
+      copy: "Copy Cloud ID",
+      copied: "Cloud ID copied",
+      copyFailed: "Could not copy the Cloud ID",
+    },
+    de: {
+      copy: "Cloud-ID kopieren",
+      copied: "Cloud-ID kopiert",
+      copyFailed: "Cloud-ID konnte nicht kopiert werden",
+    },
+  },
+});
+
+type ClipboardModule = typeof import("./resource-clipboard");
+// The clipboard contract validates with Zod, which stays out of an island's first load. It loads once the page is
+// idle, so a copy usually writes the structured reference inside the click that asked for it.
+let clipboardModule: ClipboardModule | undefined;
+const loadClipboard = () => import("./resource-clipboard").then((module) => (clipboardModule = module));
+
+/** One entry of the menu; `label` names the resource when a menu offers several, such as a message and its conversation. */
+export type CloudIdTarget = { ref: CloudResourceRef; label?: string };
+
+/**
+ * "Copy Cloud ID" for the "…" menu of a resource. It copies the structured reference and its `/open` permalink as
+ * text: Cloud paste surfaces recognize the resource, and anywhere else the text opens it after sign-in. Without a
+ * configured Cloud URL the menu shows nothing.
+ */
+export const useCloudIdCopy = () => {
+  const locale = useLocale();
+  const t = createMemo(() => cloudIdMessages.resolve([locale()]).t);
+  onMount(() => {
+    if (clipboardModule || !cloudOrigin()) return;
+    const warm = () => void loadClipboard().catch(() => undefined);
+    if (typeof requestIdleCallback === "function") requestIdleCallback(warm, { timeout: 2000 });
+    else setTimeout(warm, 0);
+  });
+
+  const copy = (ref: CloudResourceRef) => {
+    const cloudUrl = cloudOrigin();
+    if (!cloudUrl) return;
+    const failed = () => void toast.error(t().copyFailed);
+    const write = (module: ClipboardModule) => {
+      try {
+        const { cloudResourceClipboard } = module;
+        return cloudResourceClipboard
+          .write({ cloudUrl, ref, fallbackText: cloudResourceClipboard.url(ref, cloudUrl) })
+          .then(() => void toast.success(t().copied), failed);
+      } catch {
+        failed();
+      }
+    };
+    if (clipboardModule) return void write(clipboardModule);
+    // Before the clipboard code loads, copy the permalink alone: WebKit allows a write only while the click is handled.
+    try {
+      void navigator.clipboard.writeText(new URL(cloudResourceHref(ref), cloudUrl).href).then(() => void toast.success(t().copied), failed);
+    } catch {
+      failed();
+    }
+    void loadClipboard().catch(() => undefined);
+  };
+
+  return {
+    available: () => Boolean(cloudOrigin()),
+    copy,
+    /** The last section of a resource's "…" menu; empty without a resource or a configured Cloud URL. */
+    section: (...targets: readonly (CloudResourceRef | CloudIdTarget | null | undefined | false)[]): DropdownItem[] => {
+      if (!cloudOrigin()) return [];
+      const items = targets.flatMap((target) => {
+        if (!target) return [];
+        const { ref, label } = "ref" in target ? target : { ref: target, label: undefined };
+        return [{ label: label ?? t().copy, icon: "ti ti-id", immediate: true, action: () => copy(ref) }];
+      });
+      return items.length > 0 ? [{ items }] : [];
+    },
+  };
+};

package/src/browser/resource-clipboard.ts

@@ -3,7 +3,9 @@ import {
   CLOUD_RESOURCE_CLIPBOARD_MAX_BYTES,
   CLOUD_RESOURCE_CLIPBOARD_MIME_TYPE,
   CLOUD_RESOURCE_CLIPBOARD_WEB_FORMAT,
+  formatCloudResourceUrl,
   parseCloudResourceClipboard,
+  parseCloudResourceUrl,
   serializeCloudResourceClipboard,
 } from "../contracts/resource-clipboard";
 
@@ -65,6 +67,8 @@ export const cloudResourceClipboard = {
   webFormat: CLOUD_RESOURCE_CLIPBOARD_WEB_FORMAT,
   parse: parseCloudResourceClipboard,
   serialize: serializeCloudResourceClipboard,
+  url: formatCloudResourceUrl,
+  parseUrl: parseCloudResourceUrl,
   write: writeCloudResourceClipboard,
   read: readCloudResourceClipboard,
 } as const;

package/src/browser/resource-links.ts

@@ -0,0 +1,52 @@
+import type { CoreApiType } from "../api";
+import { localCloudResourceUrl } from "../contracts/resource-pages";
+import type { ResolvedCloudResourceUrl } from "../contracts/resource-resolution";
+import { createApiClient } from "../server/api-client";
+import { readShellData } from "../ssr/shell-data";
+
+export type { ResolvedCloudResourceUrl } from "../contracts/resource-resolution";
+
+/** Available on Layout and AdminLayout pages; MinimalLayout does not install shell data. */
+export const cloudOrigin = (): string | null => readShellData()?.cloudOrigin ?? null;
+
+/** Recognize one pasted Cloud link. Unsupported, unreadable, and unavailable links all return null. */
+export const resolveCloudUrl = async (text: string, options: { signal?: AbortSignal } = {}): Promise<ResolvedCloudResourceUrl | null> => {
+  const url = text.trim();
+  if (!localCloudResourceUrl(url, cloudOrigin())) return null;
+  try {
+    const response = await createApiClient<CoreApiType>().resources.resolve.$post({ json: { url } }, { init: { signal: options.signal } });
+    if (!response.ok) return null;
+    // Validate only after a successful response; Zod stays out of the initial browser graph.
+    const { ResolvedCloudResourceUrlSchema } = await import("../contracts/resource-resolution");
+    const result = ResolvedCloudResourceUrlSchema.safeParse(await response.json());
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+};
+
+// Ctrl+Shift+V (Cmd+Shift+V, also with Option, which changes the key's character) asks for plain text; that paste
+// keeps the link as it is.
+let plainPasteAt = -Infinity;
+if (typeof window !== "undefined")
+  window.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.shiftKey && (event.ctrlKey || event.metaKey) && (event.code === "KeyV" || event.key.toLowerCase() === "v"))
+        plainPasteAt = event.timeStamp;
+    },
+    true,
+  );
+
+/**
+ * The Cloud link a paste carries: one absolute URL on this Cloud, as copied from the address bar or "Copy Cloud ID",
+ * and nothing else. Returns null for other text, other origins, and a paste as plain text. Recognize the link with
+ * `resolveCloudUrl()`.
+ */
+export const pastedCloudLink = (event: ClipboardEvent): string | null => {
+  const plain = event.timeStamp - plainPasteAt < 1_000;
+  plainPasteAt = -Infinity;
+  const text = (event.clipboardData?.getData("text/plain") ?? "").trim();
+  if (plain || text.startsWith("/")) return null;
+  return localCloudResourceUrl(text, cloudOrigin()) ? text : null;
+};

package/src/browser/session.ts

@@ -0,0 +1,39 @@
+import { apiClient } from "../clients/core";
+
+/** Fence and remove application-owned entries in the authenticated user's browser namespace. */
+const clearUserStorage = (userId: string): void => {
+  const prefix = `cloud:user:${userId}:`;
+  localStorage.setItem(`cloud:user-epoch:${userId}`, crypto.randomUUID());
+  if (typeof window !== "undefined") window.dispatchEvent(new CustomEvent("cloud:user-storage-invalidated", { detail: { userId } }));
+  const keys = Array.from({ length: localStorage.length }, (_, index) => localStorage.key(index));
+  for (const key of keys) if (key?.startsWith(prefix)) localStorage.removeItem(key);
+};
+
+/** Revoke this browser's credential even if local storage cleanup fails. The caller keeps a visible retry until both succeed. */
+export const signOutBrowserSession = async (userId: string | undefined, errorMessage: string): Promise<void> => {
+  await import("./notifications").then(({ browserNotificationClient }) => browserNotificationClient.disable()).catch(() => undefined);
+  let cleanupFailed = false;
+  try {
+    if (userId) {
+      clearUserStorage(userId);
+      const { logoutSharedTextOffline } = await import("./shared-text-offline");
+      await logoutSharedTextOffline(userId);
+    }
+  } catch {
+    cleanupFailed = true;
+  }
+  const response = await apiClient.auth.logout.$post({}, { headers: { "x-cloud-logout-user": userId ?? "none" } });
+  // Close the interval between the first local fence and credential revocation:
+  // a tab that authenticated during it must not retain or recreate device data.
+  if (response.ok && userId) {
+    try {
+      clearUserStorage(userId);
+      const { logoutSharedTextOffline } = await import("./shared-text-offline");
+      await logoutSharedTextOffline(userId);
+      cleanupFailed = false;
+    } catch {
+      cleanupFailed = true;
+    }
+  }
+  if (!response.ok || cleanupFailed) throw new Error(errorMessage);
+};

package/src/browser/shared-text-history-validation.ts

@@ -0,0 +1,151 @@
+import * as T from "@k2b/ui/text-editor/model";
+import * as Y from "yjs";
+
+type NativeFrame = Y.UndoManager["undoStack"][number];
+type Span = { from: number; to: number };
+type Piece = Span & { original: number | null };
+
+export class SharedTextNativeHistoryError extends Error {
+  readonly code = "shared_text_history_target";
+  constructor(readonly reason: "dependency" | "unavailable") {
+    super("The input history target is unavailable");
+  }
+}
+
+const intersect = (set: NativeFrame["insertions"], item: Y.Item): Span[] =>
+  (set.clients.get(item.id.client) ?? []).flatMap((run) => {
+    const from = Math.max(run.clock, item.id.clock) - item.id.clock;
+    const to = Math.min(run.clock + run.len, item.id.clock + item.length) - item.id.clock;
+    return from < to ? [{ from, to }] : [];
+  });
+const subtract = (wanted: Span[], excluded: Span[]): Span[] =>
+  wanted.flatMap((span) => {
+    const result: Span[] = [];
+    let from = span.from;
+    for (const cut of excluded) {
+      if (cut.to <= from || cut.from >= span.to) continue;
+      if (cut.from > from) result.push({ from, to: cut.from });
+      from = Math.max(from, cut.to);
+    }
+    if (from < span.to) result.push({ from, to: span.to });
+    return result;
+  });
+
+type Region = Span & { key: string | undefined };
+const regions = (source: string, original: (position: number) => number | null): Region[] =>
+  T.findTables(source).flatMap((table) =>
+    table.lines.flatMap((line, row) =>
+      line.cells.map((_cell, column) => {
+        const left = line.leadingPipe ? line.pipes[column]! + 1 : column === 0 ? line.from : line.pipes[column - 1]! + 1;
+        const right = (line.leadingPipe ? line.pipes[column + 1] : line.pipes[column]) ?? line.to;
+        const separator = table.lines[1]!.cells[column];
+        const hyphen = separator ? original(separator.from + separator.text.indexOf("-")) : null;
+        const header = original(table.lines[0]!.to);
+        const rowIdentity = row < 2 ? row : original(line.from - 1);
+        // Extra physical cells have no separator hyphen. Their surviving left
+        // delimiter distinguishes them even when columns are inserted/removed.
+        // An unknown identity is never evidence that two targets are the same.
+        const columnIdentity = separator ? hyphen : original(left - 1);
+        return {
+          from: left,
+          to: right,
+          key:
+            header === null || rowIdentity === null || columnIdentity === null
+              ? undefined
+              : `${header}:${rowIdentity}:${separator ? "column" : "extra"}:${columnIdentity}`,
+        };
+      }),
+    ),
+  );
+const locate = (regions: Region[], position: number, end: number) => {
+  let low = 0,
+    high = regions.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if (regions[middle]!.to <= position) low = middle + 1;
+    else high = middle;
+  }
+  const region = regions[low];
+  return region && region.from <= position ? { key: region.key, to: region.to } : { key: null, to: region?.from ?? end };
+};
+
+/** Project root plain-text native effects without a second manager or live mutation.
+ * Identity sets and linked Item/content fields are exported Yjs contracts. Native
+ * restoration occupies the original deleted item's gap; redone items already
+ * have their effect and are not copied again. Unknown content refuses safely.
+ */
+export const validateNativeHistory = (
+  text: Y.Text,
+  frame: NativeFrame,
+  liveInsertions: NativeFrame["insertions"],
+  baseline: Uint8Array | null,
+) => {
+  const known = baseline ? Y.decodeStateVector(baseline) : new Map<number, number>();
+  const chunks: string[] = [];
+  const pieces: Piece[] = [];
+  const protectedSpans: { before: number; after: number; length: number }[] = [];
+  let before = 0,
+    after = 0;
+  const append = (value: string, original: number | null) => {
+    if (!value.length) return;
+    chunks.push(value);
+    pieces.push({ from: after, to: after + value.length, original });
+    after += value.length;
+  };
+  for (const item of Y.getTypeChildren(text)) {
+    // Adopted frames lack correspondence captured by this controller. Native
+    // Undo follows pre-existing redone chains for insertions; projecting only
+    // the original IDs would omit their live effects. Leave such frames intact.
+    if (baseline === null && item.redone !== null && intersect(frame.insertions, item).length)
+      throw new SharedTextNativeHistoryError("unavailable");
+    if (item.deleted) {
+      const restore = subtract(intersect(frame.deletions, item), intersect(frame.insertions, item));
+      if (!restore.length || item.redone !== null) continue;
+      const content = item.content;
+      if (!(content instanceof Y.ContentString)) throw new SharedTextNativeHistoryError("unavailable");
+      for (const span of restore) append(content.str.slice(span.from, span.to), null);
+      continue;
+    }
+    if (!item.countable) continue;
+    const content = item.content;
+    if (!(content instanceof Y.ContentString)) throw new SharedTextNativeHistoryError("unavailable");
+    const keep = subtract([{ from: 0, to: item.length }], intersect(liveInsertions, item));
+    for (const span of keep) {
+      const newer = Math.max(span.from, (known.get(item.id.client) ?? 0) - item.id.clock);
+      if (newer < span.to) protectedSpans.push({ before: before + newer, after: after + newer - span.from, length: span.to - newer });
+      append(content.str.slice(span.from, span.to), before + span.from);
+    }
+    before += item.length;
+  }
+  const source = text.toString();
+  const candidate = chunks.join("");
+  if (before !== source.length) throw new SharedTextNativeHistoryError("unavailable");
+  const original = (position: number) => {
+    let low = 0,
+      high = pieces.length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (pieces[middle]!.to <= position) low = middle + 1;
+      else high = middle;
+    }
+    const piece = pieces[low];
+    return piece?.original != null ? piece.original + position - piece.from : null;
+  };
+  const beforeRegions = regions(source, (position) => position);
+  const afterRegions = regions(candidate, original);
+  for (const span of protectedSpans) {
+    let offset = 0;
+    while (offset < span.length) {
+      const oldAt = span.before + offset,
+        newAt = span.after + offset;
+      const oldTarget = locate(beforeRegions, oldAt, source.length);
+      const newTarget = locate(afterRegions, newAt, candidate.length);
+      if (oldTarget.key === undefined || newTarget.key === undefined || oldTarget.key !== newTarget.key)
+        throw new SharedTextNativeHistoryError("dependency");
+      const length = Math.min(span.length - offset, oldTarget.to - oldAt, newTarget.to - newAt);
+      if (length <= 0) throw new SharedTextNativeHistoryError("unavailable");
+      offset += length;
+    }
+  }
+  return candidate;
+};