@zkov/pi-md-viewer 0.1.2 → 0.1.3

package/dist/src-ts/cli.js

@@ -9,7 +9,7 @@ import { discover, portRangeFromEnv, sendFiles, shutdownInstance } from "./disco
 import { FileRegistry } from "./registry.js";
 import { MarkdownRenderer } from "./renderer.js";
 import { ViewerServer } from "./server.js";
-import { launchViewer } from "./viewer-launcher.js";
+import { launchViewer, runPlaywrightViewerHost } from "./viewer-launcher.js";
 const STARTUP_TIMEOUT_MS = 5000;
 function operationResult(payload) {
     return { url: null, added: [], rejected: [], viewerClients: 0, ...payload };
@@ -50,11 +50,20 @@ function parseArgs(argv, cwd) {
             parsed.viewer = requireValue(argv, ++index, arg);
         else if (arg === "--viewer-command")
             parsed.viewerCommand = requireValue(argv, ++index, arg);
+        else if (arg === "--playwright-viewer")
+            parsed.playwrightViewer = requireValue(argv, ++index, arg);
+        else if (arg === "--browser")
+            parsed.browser = parseBrowser(requireValue(argv, ++index, arg));
         else
             parsed.paths.push(arg);
     }
     return parsed;
 }
+function parseBrowser(value) {
+    if (value === "chromium" || value === "firefox" || value === "webkit")
+        return value;
+    throw new Error("--browser must be chromium, firefox, or webkit");
+}
 function requireValue(argv, index, flag) {
     const value = argv[index];
     if (value === undefined)
@@ -78,6 +87,10 @@ export async function main(argv, io = {}) {
     let args;
     try {
         args = parseArgs(argv, process.cwd());
+        if (args.playwrightViewer) {
+            await runPlaywrightViewerHost({ url: args.playwrightViewer, browserName: args.browser ?? "chromium", env });
+            return 0;
+        }
         if (args.serve)
             return await serve(args.port, args.paths);
         const result = await operate(args, env);

package/dist/src-ts/viewer-launcher.js

@@ -1,4 +1,7 @@
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { headedPlaywrightUnavailableReason, systemOpenCommand } from "./platform.js";
 import { expandViewerCommand, parseViewerCommand } from "./viewer-command.js";
 async function defaultSpawnDetached(command, args) {
@@ -51,37 +54,129 @@ function playwrightLaunchOptions(browserName, platform, env) {
     return options;
 }
 async function launchPlaywright(request) {
-    const reason = headedPlaywrightUnavailableReason(request.platform, request.env);
+    const browserName = request.selection.config.playwright.browser;
+    if (!request.importPlaywright) {
+        await launchDetachedPlaywrightHost(request.url, browserName, request.spawnPlaywrightHost ?? defaultSpawnPlaywrightHost);
+        return;
+    }
+    await openPlaywrightPage({
+        url: request.url,
+        browserName,
+        platform: request.platform,
+        env: request.env,
+        importPlaywright: request.importPlaywright,
+    });
+}
+async function openPlaywrightPage(options) {
+    const reason = headedPlaywrightUnavailableReason(options.platform, options.env);
     if (reason === "unsupported-platform")
         throw new Error('Viewer "playwright" is not available on this platform');
     if (reason)
         throw new Error(`Viewer "playwright" is not available: ${reason}`);
-    const browserName = request.selection.config.playwright.browser;
     let imported;
     try {
-        imported = request.importPlaywright ? await request.importPlaywright() : await import("playwright");
+        imported = options.importPlaywright ? await options.importPlaywright() : await import("playwright");
     }
     catch (error) {
         if (isMissingPlaywrightPackage(error))
-            throw new Error(playwrightInstallHint(browserName));
+            throw new Error(playwrightInstallHint(options.browserName));
         throw error;
     }
     const api = imported;
-    const browserType = api[browserName];
+    const browserType = api[options.browserName];
     if (!browserType)
-        throw new Error(`Playwright browser "${browserName}" is unavailable`);
+        throw new Error(`Playwright browser "${options.browserName}" is unavailable`);
     let browser;
     try {
-        browser = await browserType.launch(playwrightLaunchOptions(browserName, request.platform, request.env));
+        browser = await browserType.launch(playwrightLaunchOptions(options.browserName, options.platform, options.env));
     }
     catch (error) {
         if (isMissingPlaywrightBrowser(error))
-            throw new Error(playwrightBrowserInstallHint(browserName));
+            throw new Error(playwrightBrowserInstallHint(options.browserName));
         throw error;
     }
     const context = await browser.newContext({ viewport: null });
     const page = await context.newPage();
-    await page.goto(request.url);
+    await page.goto(options.url);
+    return browser;
+}
+async function launchDetachedPlaywrightHost(url, browserName, spawnPlaywrightHost) {
+    const result = await spawnPlaywrightHost(["--playwright-viewer", url, "--browser", browserName]);
+    if (!result.ok)
+        throw new Error(result.message);
+}
+function defaultSpawnPlaywrightHost(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [entrypointPath(), ...args], {
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe", "ignore"],
+            windowsHide: true,
+            env: { ...process.env, NODE_NO_WARNINGS: "1" },
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timeout = setTimeout(() => finish({ ok: false, message: "Timed out waiting for Playwright viewer to open" }), 10_000);
+        function finish(result) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            if (result.ok)
+                child.unref();
+            resolve(result);
+        }
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            if (!settled)
+                finish({ ok: false, message: stderr.trim() || `Playwright viewer exited with status ${code ?? "unknown"}` });
+        });
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+            const newline = stdout.indexOf("\n");
+            if (newline === -1)
+                return;
+            const line = stdout.slice(0, newline).trim();
+            try {
+                const payload = JSON.parse(line);
+                finish(payload.ok === true ? { ok: true } : { ok: false, message: typeof payload.message === "string" ? payload.message : "Playwright viewer failed to open" });
+            }
+            catch (error) {
+                finish({ ok: false, message: `Invalid Playwright viewer response: ${error instanceof Error ? error.message : String(error)}` });
+            }
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => { stderr += chunk; });
+    });
+}
+function entrypointPath() {
+    const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    const dist = path.join(root, "dist", "src-ts", "main.js");
+    if (existsSync(dist))
+        return dist;
+    return fileURLToPath(import.meta.url).replace(/viewer-launcher\.(ts|js)$/, "main.js");
+}
+export async function runPlaywrightViewerHost(options) {
+    const output = options.stdout ?? console.log;
+    try {
+        const browser = await openPlaywrightPage({
+            url: options.url,
+            browserName: options.browserName,
+            platform: options.platform ?? process.platform,
+            env: options.env ?? process.env,
+            importPlaywright: options.importPlaywright,
+        });
+        output(JSON.stringify({ ok: true }));
+        await new Promise((resolve) => {
+            browser.on?.("disconnected", resolve);
+        });
+    }
+    catch (error) {
+        output(JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    }
 }
 export async function launchViewer(request) {
     const spawnDetached = request.spawnDetached ?? defaultSpawnDetached;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zkov/pi-md-viewer",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Local loopback Markdown viewer tool for pi with configurable browser launchers",
   "author": "Zkov <zkov@yandex.ru>",
   "license": "MIT",

package/src/pi_md_viewer/static/viewer.css

@@ -247,22 +247,26 @@ hr { margin: 40px 0; border: 0; border-top: 1px solid var(--line); }
 @media (max-width: 980px) {
   .mobile-bar {
     position: sticky;
-    z-index: 20;
+    z-index: 40;
     top: 0;
     display: flex;
     align-items: center;
     justify-content: space-between;
+    min-height: 49px;
     padding: 10px 16px;
     border-bottom: 1px solid var(--line);
     background: rgba(10, 13, 18, .94);
   }
-  .layout { display: block; padding: 20px 18px 80px; }
+  .layout { display: block; padding: 28px 18px 80px; }
   .files-panel {
     display: none;
-    position: relative;
-    top: auto;
-    max-height: 48vh;
-    margin: 0 auto 28px;
+    position: fixed;
+    z-index: 35;
+    top: 57px;
+    left: 18px;
+    right: 18px;
+    max-height: calc(100vh - 73px);
+    margin: 0 auto;
     max-width: 820px;
   }
   .files-panel.open { display: block; }