@zkov/pi-md-viewer 0.1.0

package/dist/src-ts/config.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { builtInDefaultConfig, } from "./types.js";
+function pathApi(platform) {
+    return platform === "win32" ? path.win32 : path.posix;
+}
+export function userConfigCandidates(options) {
+    const p = pathApi(options.platform);
+    const result = [];
+    const explicit = options.env.PI_MD_VIEWER_CONFIG?.trim();
+    if (explicit)
+        result.push(explicit);
+    if (options.platform === "win32" && options.env.APPDATA) {
+        result.push(p.join(options.env.APPDATA, "pi-md-viewer", "config.json"));
+    }
+    if (options.platform === "darwin") {
+        result.push(p.join(options.homeDir, "Library", "Application Support", "pi-md-viewer", "config.json"));
+    }
+    if (options.platform !== "win32" && options.env.XDG_CONFIG_HOME) {
+        result.push(p.join(options.env.XDG_CONFIG_HOME, "pi-md-viewer", "config.json"));
+    }
+    result.push(p.join(options.homeDir, ".config", "pi-md-viewer", "config.json"));
+    return [...new Set(result)];
+}
+function parseConfig(text, source) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`Invalid config in ${source}: expected object`);
+    }
+    const raw = value;
+    const config = {};
+    if (raw.defaultViewer !== undefined) {
+        if (typeof raw.defaultViewer !== "string" || raw.defaultViewer.trim() === "") {
+            throw new Error(`Invalid config in ${source}: defaultViewer must be a non-empty string`);
+        }
+        config.defaultViewer = raw.defaultViewer;
+    }
+    if (raw.playwright !== undefined) {
+        if (typeof raw.playwright !== "object" || raw.playwright === null || Array.isArray(raw.playwright)) {
+            throw new Error(`Invalid config in ${source}: playwright must be an object`);
+        }
+        const browser = raw.playwright.browser;
+        if (browser !== undefined && browser !== "chromium" && browser !== "firefox" && browser !== "webkit") {
+            throw new Error(`Invalid config in ${source}: playwright.browser must be chromium, firefox, or webkit`);
+        }
+        config.playwright = { browser: (browser ?? "chromium") };
+    }
+    if (raw.viewers !== undefined) {
+        if (typeof raw.viewers !== "object" || raw.viewers === null || Array.isArray(raw.viewers)) {
+            throw new Error(`Invalid config in ${source}: viewers must be an object`);
+        }
+        const viewers = {};
+        for (const [name, viewer] of Object.entries(raw.viewers)) {
+            if (typeof viewer !== "object" || viewer === null || Array.isArray(viewer)) {
+                throw new Error(`Invalid config in ${source}: viewers.${name} must be an object`);
+            }
+            const command = viewer.command;
+            if (!Array.isArray(command) || command.length === 0 || !command.every((item) => typeof item === "string")) {
+                throw new Error(`Invalid config in ${source}: viewers.${name}.command must be a non-empty string array`);
+            }
+            viewers[name] = { command };
+        }
+        config.viewers = viewers;
+    }
+    return config;
+}
+function mergeConfig(base, next) {
+    return {
+        defaultViewer: next.defaultViewer ?? base.defaultViewer,
+        playwright: { ...base.playwright, ...next.playwright },
+        viewers: { ...base.viewers, ...next.viewers },
+    };
+}
+function readConfig(pathname, options) {
+    const reader = options.readFile ?? ((file) => (existsSync(file) ? readFileSync(file, "utf8") : undefined));
+    const content = reader(pathname);
+    return content === undefined ? undefined : parseConfig(content, pathname);
+}
+export function loadEffectiveConfig(options) {
+    const p = pathApi(options.platform);
+    let config = builtInDefaultConfig;
+    for (const candidate of userConfigCandidates(options)) {
+        const loaded = readConfig(candidate, options);
+        if (loaded !== undefined) {
+            config = mergeConfig(config, loaded);
+            break;
+        }
+    }
+    config = mergeConfig(config, readConfig(p.join(options.cwd, ".md-viewer.json"), options) ?? {});
+    if (options.launchedFromPi && options.projectTrusted) {
+        config = mergeConfig(config, readConfig(p.join(options.cwd, ".pi", "pi-md-viewer.json"), options) ?? {});
+    }
+    const plugin = options.launchedFromPi ? options.piOverrides : undefined;
+    const viewerCommand = options.cliOverrides?.viewerCommand ?? plugin?.viewerCommand;
+    const viewer = options.cliOverrides?.viewer ?? plugin?.viewer ?? config.defaultViewer;
+    return { viewer, viewerCommand, config };
+}
+export function loadDefaultEffectiveConfig(overrides = {}) {
+    return loadEffectiveConfig({
+        cwd: process.cwd(),
+        env: process.env,
+        platform: process.platform,
+        homeDir: os.homedir(),
+        launchedFromPi: false,
+        cliOverrides: overrides,
+    });
+}

package/dist/src-ts/discovery.js

@@ -0,0 +1,95 @@
+export const DEFAULT_PORTS = Array.from({ length: 10 }, (_, index) => 18765 + index);
+export const PROBE_TIMEOUT_MS = 150;
+export function portRangeFromEnv(env = process.env) {
+    const value = env.PI_MD_VIEWER_PORT_RANGE;
+    if (!value)
+        return DEFAULT_PORTS;
+    const ports = [];
+    for (const part of value.split(",")) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.includes("-")) {
+            const [startText, endText] = trimmed.split("-", 2);
+            const start = Number(startText);
+            const end = Number(endText);
+            for (let port = start; port <= end; port += 1)
+                ports.push(port);
+        }
+        else {
+            ports.push(Number(trimmed));
+        }
+    }
+    if (ports.length === 0 || ports.some((port) => !Number.isInteger(port) || port < 1 || port > 65535)) {
+        throw new Error("PI_MD_VIEWER_PORT_RANGE contains invalid ports");
+    }
+    return [...new Set(ports)];
+}
+async function requestJson(method, url, options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method,
+            body: options.payload === undefined ? undefined : JSON.stringify(options.payload),
+            headers: {
+                ...(options.payload === undefined ? {} : { "Content-Type": "application/json" }),
+                ...(options.headers ?? {}),
+            },
+            signal: controller.signal,
+        });
+        const value = await response.json().catch(() => undefined);
+        if (!response.ok) {
+            if (options.raise)
+                throw new Error(String(value?.error?.message ?? response.statusText));
+            return undefined;
+        }
+        return typeof value === "object" && value !== null ? value : undefined;
+    }
+    catch (error) {
+        if (options.raise)
+            throw error;
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function discover(ports = portRangeFromEnv(), _env = process.env) {
+    for (const port of ports) {
+        const payload = await requestJson("GET", `http://127.0.0.1:${port}/api/v1/status`, { timeoutMs: PROBE_TIMEOUT_MS });
+        if (!payload)
+            continue;
+        const protocol = String(payload.protocolVersion ?? "");
+        if (payload.application !== "pi-md-viewer" || protocol.split(".")[0] !== "1")
+            continue;
+        return {
+            host: "127.0.0.1",
+            port,
+            url: String(payload.url),
+            pid: Number(payload.pid),
+            viewerClients: Number(payload.viewerClients ?? 0),
+            files: Number(payload.files ?? 0),
+        };
+    }
+    return undefined;
+}
+export async function sendFiles(instance, paths) {
+    const payload = await requestJson("POST", `${instance.url}api/v1/files`, {
+        payload: { paths },
+        headers: { "X-Pi-Md-Viewer-CLI": "1" },
+        timeoutMs: 3000,
+        raise: true,
+    });
+    if (!payload)
+        throw new Error("Viewer did not return a response");
+    return payload;
+}
+export async function shutdownInstance(instance) {
+    await requestJson("POST", `${instance.url}api/v1/shutdown`, {
+        payload: {},
+        headers: { "X-Pi-Md-Viewer-CLI": "1" },
+        timeoutMs: 3000,
+        raise: true,
+    });
+}

package/dist/src-ts/lifecycle.js

@@ -0,0 +1,54 @@
+export const HEARTBEAT_INTERVAL_SECONDS = 2;
+export const CLIENT_STALE_SECONDS = 8;
+export const LAST_CLIENT_GRACE_SECONDS = 5;
+export const STARTUP_IDLE_SECONDS = 30;
+export class ClientLifecycle {
+    startedAt;
+    clients = new Map();
+    everHadClient = false;
+    lastClientLeftAt;
+    constructor(startedAt) {
+        this.startedAt = startedAt;
+    }
+    get clientCount() {
+        return this.clients.size;
+    }
+    open(clientId, now) {
+        this.clients.set(clientId, now);
+        this.everHadClient = true;
+        this.lastClientLeftAt = undefined;
+    }
+    heartbeat(clientId, now) {
+        if (!this.clients.has(clientId))
+            return false;
+        this.clients.set(clientId, now);
+        return true;
+    }
+    close(clientId, now) {
+        if (!this.clients.delete(clientId))
+            return false;
+        if (this.clients.size === 0)
+            this.lastClientLeftAt = now;
+        return true;
+    }
+    decision(now) {
+        if (this.clients.size > 0) {
+            for (const [clientId, lastSeen] of [...this.clients]) {
+                if (now >= lastSeen + CLIENT_STALE_SECONDS)
+                    this.clients.delete(clientId);
+            }
+            if (this.clients.size > 0)
+                return { shouldShutdown: false };
+            this.lastClientLeftAt ??= now;
+        }
+        if (!this.everHadClient) {
+            return now >= this.startedAt + STARTUP_IDLE_SECONDS
+                ? { shouldShutdown: true, reason: "startup_idle" }
+                : { shouldShutdown: false };
+        }
+        this.lastClientLeftAt ??= now;
+        return now >= this.lastClientLeftAt + LAST_CLIENT_GRACE_SECONDS
+            ? { shouldShutdown: true, reason: "last_client" }
+            : { shouldShutdown: false };
+    }
+}

package/dist/src-ts/main.js

@@ -0,0 +1,5 @@
+import { main } from "./cli.js";
+main(process.argv.slice(2)).then((code) => { process.exitCode = code; }, (error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/src-ts/platform.js

@@ -0,0 +1,26 @@
+export function isTermux(platform, env) {
+    return (platform === "linux" || platform === "android")
+        && typeof env.PREFIX === "string"
+        && env.PREFIX.includes("/com.termux/");
+}
+export function systemOpenCommand(platform, env) {
+    if (isTermux(platform, env))
+        return ["termux-open-url", "{url}"];
+    if (platform === "win32")
+        return ["rundll32", "url.dll,FileProtocolHandler", "{url}"];
+    if (platform === "darwin")
+        return ["open", "{url}"];
+    if (platform === "linux")
+        return ["xdg-open", "{url}"];
+    return null;
+}
+export function headedPlaywrightUnavailableReason(platform, env) {
+    if (isTermux(platform, env))
+        return "unsupported-platform";
+    if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) {
+        return "headed browser requires DISPLAY or WAYLAND_DISPLAY";
+    }
+    if (platform === "win32" || platform === "darwin" || platform === "linux")
+        return null;
+    return "unsupported-platform";
+}

package/dist/src-ts/registry.js

@@ -0,0 +1,81 @@
+import { randomUUID } from "node:crypto";
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+const allowedSuffixes = new Set([".md", ".markdown", ".mdown", ".mkd"]);
+export class FileRegistry {
+    records = new Map();
+    idsByPath = new Map();
+    nextOrder = 0;
+    addMany(paths) {
+        const added = [];
+        const existing = [];
+        const rejected = [];
+        for (const supplied of paths) {
+            let canonical;
+            let stat;
+            try {
+                canonical = realpathSync(supplied);
+                stat = statSync(canonical);
+            }
+            catch {
+                rejected.push({ path: supplied, code: "not_found", message: "File does not exist" });
+                continue;
+            }
+            if (!stat.isFile()) {
+                rejected.push({ path: supplied, code: "not_file", message: "Path is not a file" });
+                continue;
+            }
+            if (!allowedSuffixes.has(path.extname(canonical).toLowerCase())) {
+                rejected.push({ path: supplied, code: "unsupported", message: "Unsupported Markdown file extension" });
+                continue;
+            }
+            try {
+                accessSync(canonical, constants.R_OK);
+            }
+            catch {
+                rejected.push({ path: supplied, code: "unreadable", message: "File is not readable" });
+                continue;
+            }
+            const known = this.idsByPath.get(canonical);
+            if (known) {
+                const record = this.records.get(known);
+                if (record)
+                    existing.push(record);
+                continue;
+            }
+            const record = {
+                id: randomUUID().replaceAll("-", ""),
+                path: canonical,
+                displayName: path.basename(canonical),
+                parentLabel: path.basename(path.dirname(canonical)) || null,
+                size: stat.size,
+                mtimeMs: stat.mtimeMs,
+                order: this.nextOrder++,
+            };
+            this.records.set(record.id, record);
+            this.idsByPath.set(canonical, record.id);
+            added.push(record);
+        }
+        return { added, existing, rejected };
+    }
+    list() {
+        return [...this.records.values()].sort((a, b) => a.order - b.order);
+    }
+    get(id) {
+        return this.records.get(id);
+    }
+    remove(id) {
+        const record = this.records.get(id);
+        if (record) {
+            this.records.delete(id);
+            this.idsByPath.delete(record.path);
+        }
+        return record;
+    }
+    clear() {
+        const removed = this.list();
+        this.records.clear();
+        this.idsByPath.clear();
+        return removed;
+    }
+}

package/dist/src-ts/renderer.js

@@ -0,0 +1,67 @@
+import { readFileSync, statSync } from "node:fs";
+import hljs from "highlight.js";
+import MarkdownIt from "markdown-it";
+import anchor from "markdown-it-anchor";
+import taskLists from "markdown-it-task-lists";
+export class RenderError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RenderError";
+    }
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .trim()
+        .replace(/[^\p{Letter}\p{Number}]+/gu, "-")
+        .replace(/^-+|-+$/g, "") || "section";
+}
+export class MarkdownRenderer {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    render(file) {
+        const maxBytes = this.options.maxBytes ?? 1024 * 1024;
+        const stat = statSync(file);
+        if (stat.size > maxBytes)
+            throw new RenderError("too_large", "Markdown file is too large");
+        const buffer = readFileSync(file);
+        let text;
+        try {
+            text = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+        }
+        catch (error) {
+            throw new RenderError("invalid_utf8", "Markdown file is not valid UTF-8");
+        }
+        const toc = [];
+        const seen = new Map();
+        const md = new MarkdownIt({
+            html: false,
+            linkify: true,
+            typographer: false,
+            highlight(code, language) {
+                const valid = language && hljs.getLanguage(language);
+                const highlighted = valid ? hljs.highlight(code, { language }).value : hljs.highlightAuto(code).value;
+                return `<pre class="highlight"><code class="hljs">${highlighted}</code></pre>`;
+            },
+        })
+            .use(taskLists, { enabled: false, label: false })
+            .use(anchor, {
+            slugify,
+            uniqueSlugStartIndex: 1,
+            callback(token, info) {
+                const base = slugify(info.title);
+                const count = (seen.get(base) ?? 0) + 1;
+                seen.set(base, count);
+                const id = count === 1 ? base : `${base}-${count}`;
+                token.attrSet("id", id);
+                toc.push({ level: Number(token.tag.slice(1)), id, title: info.title });
+            },
+        });
+        const html = md.render(text);
+        return { html, toc, revision: `${stat.mtimeMs}:${stat.size}` };
+    }
+}