(test): improve e2e session helper

test/e2e-obsidian/runner/cli.ts

@@ -7,6 +7,13 @@ export type ObsidianCliResult = {
     stderr: string;
 };
 
+function parseEvalJson(stdout: string): unknown {
+    const marker = "=> ";
+    const markerIndex = stdout.indexOf(marker);
+    const text = markerIndex >= 0 ? stdout.slice(markerIndex + marker.length) : stdout;
+    return JSON.parse(text.trim());
+}
+
 export async function runObsidianCli(
     cliBinary: string,
     args: string[],
@@ -60,3 +67,23 @@ export async function openVaultWithObsidianCli(
         );
     }
 }
+
+export async function evalObsidianJson<T>(
+    cliBinary: string,
+    code: string,
+    env: NodeJS.ProcessEnv = process.env
+): Promise<T> {
+    const result = await runObsidianCli(cliBinary, ["eval", `code=${code}`], env);
+    if (result.code !== 0 || result.stdout.includes("Error:")) {
+        throw new Error(
+            [
+                `Failed to evaluate Obsidian JavaScript through CLI. code=${result.code}, signal=${result.signal}`,
+                result.stdout ? `stdout:\n${result.stdout}` : undefined,
+                result.stderr ? `stderr:\n${result.stderr}` : undefined,
+            ]
+                .filter(Boolean)
+                .join("\n")
+        );
+    }
+    return parseEvalJson(result.stdout) as T;
+}

test/e2e-obsidian/runner/readiness.ts

@@ -1,4 +1,4 @@
-import { runObsidianCli } from "./cli.ts";
+import { evalObsidianJson } from "./cli.ts";
 
 export type PluginReadiness = {
     status: "ready";
@@ -7,13 +7,6 @@ export type PluginReadiness = {
     vaultName: string;
 };
 
-function parseEvalJson(stdout: string): unknown {
-    const marker = "=> ";
-    const markerIndex = stdout.indexOf(marker);
-    const text = markerIndex >= 0 ? stdout.slice(markerIndex + marker.length) : stdout;
-    return JSON.parse(text.trim());
-}
-
 export async function waitForPluginReady(
     cliBinary: string,
     env: NodeJS.ProcessEnv,
@@ -22,28 +15,24 @@ export async function waitForPluginReady(
     const deadline = Date.now() + timeoutMs;
     let lastOutput = "";
     while (Date.now() < deadline) {
-        const result = await runObsidianCli(
-            cliBinary,
-            [
-                "eval",
+        try {
+            const readiness = await evalObsidianJson<PluginReadiness>(
+                cliBinary,
                 [
-                    "code=(async()=>JSON.stringify({",
+                    "(async()=>JSON.stringify({",
                     "status:!!app.plugins.plugins['obsidian-livesync']?'ready':'pending',",
                     "pluginId:'obsidian-livesync',",
                     "pluginVersion:app.plugins.manifests['obsidian-livesync']?.version,",
                     "vaultName:app.vault.getName()",
                     "}))()",
                 ].join(""),
-            ],
-            env
-        );
-        lastOutput = [result.stdout, result.stderr].filter(Boolean).join("\n");
-        try {
-            const readiness = parseEvalJson(result.stdout) as PluginReadiness;
+                env
+            );
             if (readiness.status === "ready") {
                 return readiness;
             }
-        } catch {
+        } catch (error) {
+            lastOutput = error instanceof Error ? error.message : String(error);
             // Keep polling until Obsidian exposes the vault-side CLI and plug-in state.
         }
         await new Promise((resolve) => setTimeout(resolve, 500));

test/e2e-obsidian/runner/session.ts

@@ -0,0 +1,94 @@
+import { openVaultWithObsidianCli, runObsidianCli } from "./cli.ts";
+import { launchObsidian, type ObsidianProcess } from "./launch.ts";
+import { installBuiltPlugin, type PluginInstallResult } from "./pluginInstaller.ts";
+import { waitForPluginReady, type PluginReadiness } from "./readiness.ts";
+import type { TemporaryVault } from "./vault.ts";
+
+export type ObsidianLiveSyncSession = {
+    app: ObsidianProcess;
+    cliEnv: NodeJS.ProcessEnv;
+    install: PluginInstallResult;
+    readiness: PluginReadiness;
+};
+
+export type StartObsidianLiveSyncSessionOptions = {
+    binary: string;
+    cliBinary: string;
+    vault: TemporaryVault;
+    startupGraceMs?: number;
+};
+
+async function waitForPluginCatalogue(cliBinary: string, env: NodeJS.ProcessEnv): Promise<void> {
+    const deadline = Date.now() + Number(process.env.E2E_OBSIDIAN_CLI_READY_TIMEOUT_MS ?? 15000);
+    let lastOutput = "";
+    while (Date.now() < deadline) {
+        const result = await runObsidianCli(cliBinary, ["plugins", "filter=community"], env);
+        lastOutput = [result.stdout, result.stderr].filter(Boolean).join("\n");
+        if (result.stdout.includes("obsidian-livesync")) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new Error(`Timed out waiting for Obsidian plug-in catalogue through CLI.\n${lastOutput}`);
+}
+
+async function enableCommunityPlugins(cliBinary: string, env: NodeJS.ProcessEnv): Promise<void> {
+    const result = await runObsidianCli(cliBinary, ["eval", "code=(async()=>app.plugins.setEnable(true))()"], env);
+    if (result.code !== 0 || result.stdout.includes("Error:")) {
+        throw new Error(
+            [
+                `Failed to enable Obsidian community plug-ins through CLI. code=${result.code}, signal=${result.signal}`,
+                result.stdout ? `stdout:\n${result.stdout}` : undefined,
+                result.stderr ? `stderr:\n${result.stderr}` : undefined,
+            ]
+                .filter(Boolean)
+                .join("\n")
+        );
+    }
+}
+
+async function reloadLiveSyncPlugin(cliBinary: string, env: NodeJS.ProcessEnv): Promise<void> {
+    const reload = await runObsidianCli(cliBinary, ["plugin:reload", "id=obsidian-livesync"], env);
+    if (reload.code !== 0 || !reload.stdout.includes("Reloaded: obsidian-livesync")) {
+        throw new Error(
+            [
+                `Failed to reload Self-hosted LiveSync through Obsidian CLI. code=${reload.code}, signal=${reload.signal}`,
+                reload.stdout ? `stdout:\n${reload.stdout}` : undefined,
+                reload.stderr ? `stderr:\n${reload.stderr}` : undefined,
+            ]
+                .filter(Boolean)
+                .join("\n")
+        );
+    }
+}
+
+export async function startObsidianLiveSyncSession(
+    options: StartObsidianLiveSyncSessionOptions
+): Promise<ObsidianLiveSyncSession> {
+    const install = await installBuiltPlugin(options.vault.path);
+    const app = await launchObsidian({
+        binary: options.binary,
+        vaultPath: options.vault.path,
+        homePath: options.vault.homePath,
+        xdgConfigPath: options.vault.xdgConfigPath,
+        userDataPath: options.vault.userDataPath,
+        startupGraceMs: options.startupGraceMs,
+    });
+    const cliEnv = {
+        ...process.env,
+        HOME: options.vault.homePath,
+        XDG_CONFIG_HOME: options.vault.xdgConfigPath,
+    };
+
+    try {
+        await openVaultWithObsidianCli(options.cliBinary, options.vault.path, cliEnv);
+        await waitForPluginCatalogue(options.cliBinary, cliEnv);
+        await enableCommunityPlugins(options.cliBinary, cliEnv);
+        await reloadLiveSyncPlugin(options.cliBinary, cliEnv);
+        const readiness = await waitForPluginReady(options.cliBinary, cliEnv);
+        return { app, cliEnv, install, readiness };
+    } catch (error) {
+        await app.stop();
+        throw error;
+    }
+}