Add missed files

src/apps/webapp/test-entry.ts

@@ -0,0 +1,203 @@
+/**
+ * LiveSync WebApp E2E test entry point.
+ *
+ * When served by vite dev server (at /test.html), this module wires up
+ * `window.livesyncTest`, a plain JS API that Playwright tests can call via
+ * `page.evaluate()`.  All methods are async and serialisation-safe.
+ *
+ * Vault storage is backed by OPFS so no `showDirectoryPicker()` interaction
+ * is required, making it fully headless-compatible.
+ */
+
+import { LiveSyncWebApp } from "./main";
+import type { ObsidianLiveSyncSettings } from "@lib/common/types";
+import type { FilePathWithPrefix } from "@lib/common/types";
+
+// --------------------------------------------------------------------------
+// Internal state – one app instance per page / browser context
+// --------------------------------------------------------------------------
+let app: LiveSyncWebApp | null = null;
+
+// --------------------------------------------------------------------------
+// Helpers
+// --------------------------------------------------------------------------
+
+/** Strip the "plain:" / "enc:" / … prefix used internally in PouchDB paths. */
+function stripPrefix(raw: string): string {
+    return raw.replace(/^[^:]+:/, "");
+}
+
+/**
+ * Poll every 300 ms until all known processing queues are drained, or until
+ * the timeout elapses.  Mirrors `waitForIdle` in the existing vitest harness.
+ */
+async function waitForIdle(core: any, timeoutMs = 60_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const q =
+            (core.services?.replication?.databaseQueueCount?.value ?? 0) +
+            (core.services?.fileProcessing?.totalQueued?.value ?? 0) +
+            (core.services?.fileProcessing?.batched?.value ?? 0) +
+            (core.services?.fileProcessing?.processing?.value ?? 0) +
+            (core.services?.replication?.storageApplyingCount?.value ?? 0);
+        if (q === 0) return;
+        await new Promise<void>((r) => setTimeout(r, 300));
+    }
+    throw new Error(`waitForIdle timed out after ${timeoutMs} ms`);
+}
+
+function getCore(): any {
+    const core = (app as any)?.core;
+    if (!core) throw new Error("Vault not initialised – call livesyncTest.init() first");
+    return core;
+}
+
+// --------------------------------------------------------------------------
+// Public test API
+// --------------------------------------------------------------------------
+
+export interface LiveSyncTestAPI {
+    /**
+     * Initialise a vault in OPFS under the given name and apply `settings`.
+     * Any previous contents of the OPFS directory are wiped first so each
+     * test run starts clean.
+     */
+    init(vaultName: string, settings: Partial<ObsidianLiveSyncSettings>): Promise<void>;
+
+    /**
+     * Write `content` to the local PouchDB under `vaultPath` (equivalent to
+     * the CLI `put` command).  Waiting for the DB write to finish is
+     * included; you still need to call `replicate()` to push to remote.
+     */
+    putFile(vaultPath: string, content: string): Promise<boolean>;
+
+    /**
+     * Mark `vaultPath` as deleted in the local PouchDB (equivalent to CLI
+     * `rm`).  Call `replicate()` afterwards to propagate to remote.
+     */
+    deleteFile(vaultPath: string): Promise<boolean>;
+
+    /**
+     * Run one full replication cycle (push + pull) against the remote CouchDB,
+     * then wait for the local storage-application queue to drain.
+     */
+    replicate(): Promise<boolean>;
+
+    /**
+     * Wait until all processing queues are idle.  Usually not needed after
+     * `putFile` / `deleteFile` since those already await, but useful when
+     * testing results after `replicate()`.
+     */
+    waitForIdle(timeoutMs?: number): Promise<void>;
+
+    /**
+     * Return metadata for `vaultPath` from the local database, or `null` if
+     * not found / deleted.
+     */
+    getInfo(vaultPath: string): Promise<{
+        path: string;
+        revision: string;
+        conflicts: string[];
+        size: number;
+        mtime: number;
+    } | null>;
+
+    /** Convenience wrapper: returns true when the doc has ≥1 conflict revision. */
+    hasConflict(vaultPath: string): Promise<boolean>;
+
+    /** Tear down the current app instance. */
+    shutdown(): Promise<void>;
+}
+
+// --------------------------------------------------------------------------
+// Implementation
+// --------------------------------------------------------------------------
+
+const livesyncTest: LiveSyncTestAPI = {
+    async init(vaultName: string, settings: Partial<ObsidianLiveSyncSettings>): Promise<void> {
+        // Clean up any stale OPFS data from previous runs.
+        const opfsRoot = await navigator.storage.getDirectory();
+        try {
+            await opfsRoot.removeEntry(vaultName, { recursive: true });
+        } catch {
+            // directory did not exist – that's fine
+        }
+        const vaultDir = await opfsRoot.getDirectoryHandle(vaultName, { create: true });
+
+        // Pre-write settings so they are loaded during initialise().
+        const livesyncDir = await vaultDir.getDirectoryHandle(".livesync", { create: true });
+        const settingsFile = await livesyncDir.getFileHandle("settings.json", { create: true });
+        const writable = await settingsFile.createWritable();
+        await writable.write(JSON.stringify(settings));
+        await writable.close();
+
+        app = new LiveSyncWebApp(vaultDir);
+        await app.initialize();
+
+        // Give background startup tasks a moment to settle.
+        await waitForIdle(getCore(), 30_000);
+    },
+
+    async putFile(vaultPath: string, content: string): Promise<boolean> {
+        const core = getCore();
+        const result = await core.serviceModules.databaseFileAccess.storeContent(
+            vaultPath as FilePathWithPrefix,
+            content
+        );
+        await waitForIdle(core);
+        return result !== false;
+    },
+
+    async deleteFile(vaultPath: string): Promise<boolean> {
+        const core = getCore();
+        const result = await core.serviceModules.databaseFileAccess.delete(vaultPath as FilePathWithPrefix);
+        await waitForIdle(core);
+        return result !== false;
+    },
+
+    async replicate(): Promise<boolean> {
+        const core = getCore();
+        const result = await core.services.replication.replicate(true);
+        // After replicate() resolves, remote docs may still be queued for
+        // local storage application – wait until all queues are drained.
+        await waitForIdle(core);
+        return result !== false;
+    },
+
+    async waitForIdle(timeoutMs?: number): Promise<void> {
+        await waitForIdle(getCore(), timeoutMs ?? 60_000);
+    },
+
+    async getInfo(vaultPath: string) {
+        const core = getCore();
+        const db = core.services?.database;
+        for await (const doc of db.localDatabase.findAllNormalDocs({ conflicts: true })) {
+            if (doc._deleted || doc.deleted) continue;
+            const docPath = stripPrefix(doc.path ?? "");
+            if (docPath !== vaultPath) continue;
+            return {
+                path: docPath,
+                revision: (doc._rev as string) ?? "",
+                conflicts: (doc._conflicts as string[]) ?? [],
+                size: (doc.size as number) ?? 0,
+                mtime: (doc.mtime as number) ?? 0,
+            };
+        }
+        return null;
+    },
+
+    async hasConflict(vaultPath: string): Promise<boolean> {
+        const info = await livesyncTest.getInfo(vaultPath);
+        return (info?.conflicts?.length ?? 0) > 0;
+    },
+
+    async shutdown(): Promise<void> {
+        if (app) {
+            await app.shutdown();
+            app = null;
+        }
+    },
+};
+
+// Expose on window for Playwright page.evaluate() calls.
+(window as any).livesyncTest = livesyncTest;