c64bridge 0.7.4 → 0.8.1

package/dist/vice/process.js

@@ -0,0 +1,310 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import net from "node:net";
+import { createOutputTailCapture, getDiagnosticsSessionInfo, writeDiagnosticEvent } from "../diagnostics.js";
+const DEFAULT_DISPLAY = ":99";
+export function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function hasGraphicalSession() {
+    return configuredDisplay() !== undefined || configuredWaylandDisplay() !== undefined;
+}
+function configuredDisplay() {
+    const display = process.env.DISPLAY?.trim();
+    return display ? display : undefined;
+}
+function configuredWaylandDisplay() {
+    const display = process.env.WAYLAND_DISPLAY?.trim();
+    return display ? display : undefined;
+}
+function currentDisplayLabel() {
+    return configuredDisplay() ?? configuredWaylandDisplay() ?? DEFAULT_DISPLAY;
+}
+export function shouldUseXvfb(visible) {
+    if (process.env.FORCE_XVFB === "1") {
+        return { useXvfb: true, display: process.env.VICE_XVFB_DISPLAY ?? DEFAULT_DISPLAY };
+    }
+    if (visible === false) {
+        if (process.env.DISABLE_XVFB === "1") {
+            return { useXvfb: false, display: currentDisplayLabel() };
+        }
+        return { useXvfb: true, display: process.env.VICE_XVFB_DISPLAY ?? DEFAULT_DISPLAY };
+    }
+    if (hasGraphicalSession()) {
+        return { useXvfb: false, display: currentDisplayLabel() };
+    }
+    if (process.env.DISABLE_XVFB === "1") {
+        return { useXvfb: false, display: currentDisplayLabel() };
+    }
+    const ci = (process.env.CI || "").toLowerCase();
+    if (ci === "true" || ci === "1" || ci === "yes") {
+        return { useXvfb: true, display: process.env.VICE_XVFB_DISPLAY ?? DEFAULT_DISPLAY };
+    }
+    return { useXvfb: true, display: process.env.VICE_XVFB_DISPLAY ?? DEFAULT_DISPLAY };
+}
+export async function waitForPort(host, port, timeoutMs = 4000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            await new Promise((resolve, reject) => {
+                const socket = net.connect({ host, port }, () => {
+                    socket.end();
+                    resolve();
+                });
+                socket.on("error", reject);
+                socket.setTimeout(300, () => {
+                    socket.destroy(new Error("timeout"));
+                });
+            });
+            return;
+        }
+        catch {
+            await delay(50);
+        }
+    }
+    throw new Error(`Timeout waiting for VICE monitor at ${host}:${port}`);
+}
+async function waitForXvfb(display, timeoutMs = 5000) {
+    const match = /^:([0-9]+)/.exec(display.trim());
+    if (!match) {
+        await delay(500);
+        return;
+    }
+    const socketPath = `/tmp/.X11-unix/X${match[1]}`;
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            if (fs.existsSync(socketPath)) {
+                return;
+            }
+        }
+        catch {
+            // Ignore transient fs errors while polling for the display socket.
+        }
+        await delay(50);
+    }
+    throw new Error(`Timeout waiting for Xvfb display socket ${socketPath}`);
+}
+export function waitForExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            child.removeListener("exit", onExit);
+            resolve();
+        }, Math.max(0, timeoutMs));
+        const onExit = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        child.once("exit", onExit);
+    });
+}
+export async function terminateProcess(child, signal = "SIGTERM", timeoutMs = 1000) {
+    if (!child)
+        return;
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        child.kill(signal);
+    }
+    catch { }
+    await waitForExit(child, timeoutMs);
+}
+export async function startViceProcess(options) {
+    const debugEnabled = process.env.VICE_DEVICE_TEST_DEBUG === "1";
+    const { useXvfb, display } = shouldUseXvfb(options.visible);
+    const viceEnv = { ...process.env };
+    let xvfb = null;
+    const xvfbOutput = createOutputTailCapture("xvfb");
+    const viceOutput = createOutputTailCapture("vice");
+    writeDiagnosticEvent("vice_process_start_requested", {
+        binary: options.binary,
+        directory: options.directory,
+        display,
+        extraArgs: options.extraArgs ?? [],
+        host: options.host,
+        port: options.port,
+        useXvfb,
+        visible: options.visible === true,
+        warp: options.warp !== false,
+    });
+    if (useXvfb) {
+        ensureXvfbSocketDir(debugEnabled);
+        if (debugEnabled) {
+            console.error("[vice-process] launching Xvfb", { display });
+        }
+        xvfb = spawn("Xvfb", [display, "-screen", "0", "640x480x24"], { stdio: ["ignore", "pipe", "pipe"] });
+        if (debugEnabled) {
+            console.error("[vice-process] Xvfb pid", { pid: xvfb.pid });
+        }
+        xvfb.stdout?.on("data", (chunk) => {
+            xvfbOutput.pushStdout(chunk);
+            if (debugEnabled)
+                console.error("[vice-process][xvfb stdout]", chunk.toString().trim());
+        });
+        xvfb.stderr?.on("data", (chunk) => {
+            xvfbOutput.pushStderr(chunk);
+            if (debugEnabled)
+                console.error("[vice-process][xvfb stderr]", chunk.toString().trim());
+        });
+        xvfb.once("exit", (code, signal) => {
+            writeDiagnosticEvent("xvfb_exit", {
+                code,
+                signal,
+                output: xvfbOutput.snapshot(),
+            });
+        });
+        viceEnv.DISPLAY = display;
+        await waitForXvfb(display);
+    }
+    const args = [
+        "-binarymonitor",
+        "-binarymonitoraddress", `${options.host}:${options.port}`,
+        "-sounddev", "dummy",
+        "-config", "/dev/null",
+        ...(options.directory ? ["-directory", options.directory] : []),
+        ...(options.extraArgs ?? []),
+    ];
+    if (options.warp !== false)
+        args.push("-warp");
+    if (debugEnabled) {
+        console.error("[vice-process] starting VICE", {
+            binary: options.binary,
+            args,
+            display: viceEnv.DISPLAY,
+            warp: options.warp !== false,
+        });
+    }
+    const spawnOptions = { stdio: ["ignore", "pipe", "pipe"], env: viceEnv };
+    let spawnError = null;
+    const child = spawn(options.binary, args, spawnOptions);
+    if (debugEnabled) {
+        console.error("[vice-process] VICE pid", { pid: child.pid });
+    }
+    child.stdout?.on("data", (chunk) => {
+        viceOutput.pushStdout(chunk);
+        if (debugEnabled)
+            console.error("[vice-process][vice stdout]", chunk.toString().trim());
+    });
+    child.stderr?.on("data", (chunk) => {
+        viceOutput.pushStderr(chunk);
+        if (debugEnabled)
+            console.error("[vice-process][vice stderr]", chunk.toString().trim());
+    });
+    child.once("exit", (code, signal) => {
+        writeDiagnosticEvent("vice_process_exit", {
+            code,
+            signal,
+            output: viceOutput.snapshot(),
+        });
+    });
+    child.once("error", (err) => { spawnError = err; });
+    try {
+        await new Promise((resolve, reject) => {
+            const onExit = (code, signal) => {
+                child.removeListener("error", onError);
+                if (spawnError)
+                    reject(spawnError);
+                else
+                    reject(new Error(`VICE process exited before monitor became ready (code=${code}, signal=${signal ?? "null"})`));
+            };
+            const onError = (err) => {
+                child.removeListener("exit", onExit);
+                reject(err);
+            };
+            child.once("exit", onExit);
+            child.once("error", onError);
+            waitForPort(options.host, options.port)
+                .then(() => {
+                if (debugEnabled) {
+                    console.error("[vice-process] monitor port is ready", { host: options.host, port: options.port });
+                }
+                writeDiagnosticEvent("vice_process_monitor_ready", {
+                    host: options.host,
+                    port: options.port,
+                    pid: child.pid,
+                });
+                child.removeListener("exit", onExit);
+                child.removeListener("error", onError);
+                resolve();
+            })
+                .catch((err) => {
+                child.removeListener("exit", onExit);
+                child.removeListener("error", onError);
+                reject(err);
+            });
+        });
+    }
+    catch (err) {
+        const diagnosticsFile = getDiagnosticsSessionInfo()?.filePath;
+        const detail = {
+            diagnosticsFile,
+            display,
+            host: options.host,
+            output: {
+                vice: viceOutput.snapshot(),
+                xvfb: xvfbOutput.snapshot(),
+            },
+            pid: child.pid,
+            useXvfb,
+            error: err,
+        };
+        writeDiagnosticEvent("vice_process_start_failed", detail);
+        if (debugEnabled) {
+            console.error("[vice-process] failed to start VICE", err instanceof Error ? err : new Error(String(err)));
+        }
+        await terminateProcess(child, "SIGTERM", 500);
+        await terminateProcess(child, "SIGKILL", 200);
+        await terminateProcess(xvfb, "SIGTERM", 500);
+        await terminateProcess(xvfb, "SIGKILL", 200);
+        const stderrTail = viceOutput.snapshot().stderrTail || xvfbOutput.snapshot().stderrTail;
+        const suffix = diagnosticsFile
+            ? ` Diagnostics: ${diagnosticsFile}`
+            : "";
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (stderrTail) {
+            error.message = `${error.message}${suffix} Last stderr: ${stderrTail}`;
+        }
+        else if (suffix) {
+            error.message = `${error.message}${suffix}`;
+        }
+        throw error;
+    }
+    const stop = async () => {
+        if (debugEnabled) {
+            console.error("[vice-process] stopping VICE/xvfb");
+        }
+        writeDiagnosticEvent("vice_process_stop_requested", {
+            pid: child.pid,
+            useXvfb,
+        });
+        await terminateProcess(child, "SIGTERM", 750);
+        if (child.exitCode === null && child.signalCode === null) {
+            await terminateProcess(child, "SIGKILL", 300);
+        }
+        await terminateProcess(xvfb, "SIGTERM", 500);
+        if (xvfb && xvfb.exitCode === null && xvfb.signalCode === null) {
+            await terminateProcess(xvfb, "SIGKILL", 200);
+        }
+    };
+    child.once("exit", async () => {
+        await terminateProcess(xvfb, "SIGTERM", 0);
+    });
+    return { host: options.host, port: options.port, process: child, stop };
+}
+export function ensureXvfbSocketDir(debugEnabled) {
+    const socketDir = "/tmp/.X11-unix";
+    try {
+        if (!fs.existsSync(socketDir)) {
+            fs.mkdirSync(socketDir, { mode: 0o1777 });
+        }
+        fs.chmodSync(socketDir, 0o1777);
+    }
+    catch (error) {
+        writeDiagnosticEvent("xvfb_socket_dir_failed", { socketDir, error });
+        if (debugEnabled) {
+            console.error("[vice-process] failed to prepare Xvfb socket dir", error);
+        }
+    }
+}

package/dist/vice/readiness.js

@@ -1,5 +1,13 @@
 function nowNs() { return process.hrtime.bigint(); }
 function msSince(start) { return Number((process.hrtime.bigint() - start) / 1000000n); }
+async function exitMonitorIfNeeded(bm) {
+    try {
+        await bm.exitMonitor();
+    }
+    catch {
+        // Ignore errors while resuming; monitor may already be running.
+    }
+}
 export function buildReadyPattern() {
     // Screen-codes for "READY." in power-on uppercase
     return Buffer.from([0x12, 0x05, 0x01, 0x04, 0x19, 0x2E]);
@@ -14,10 +22,12 @@ export async function waitForScreenPattern(bm, pattern, timeoutMs, tickMs = 50,
         idx = screen.indexOf(pattern);
         if (idx >= 0)
             break;
+        await exitMonitorIfNeeded(bm);
         if (between)
             await between();
         await new Promise((r) => setTimeout(r, Math.max(1, tickMs)));
     }
+    await exitMonitorIfNeeded(bm);
     return idx;
 }
 /** Wait until any non-blank (non-0x00/0x20) character appears on the text screen. */
@@ -33,10 +43,12 @@ export async function waitForAnyScreenText(bm, timeoutMs, tickMs = 50, onRead, b
                 return true;
             }
         }
+        await exitMonitorIfNeeded(bm);
         if (between)
             await between();
         await new Promise((r) => setTimeout(r, Math.max(1, tickMs)));
     }
+    await exitMonitorIfNeeded(bm);
     return false;
 }
 export async function waitForBasicReady(bm, options) {
@@ -57,15 +69,19 @@ export async function waitForBasicReady(bm, options) {
             pointersOk = true;
             break;
         }
+        await exitMonitorIfNeeded(bm);
         await new Promise((r) => setTimeout(r, 50));
     }
     if (!pointersOk)
         return { pointersOk: false, promptOk: false };
-    if (!options?.ensurePrompt)
+    if (!options?.ensurePrompt) {
+        await exitMonitorIfNeeded(bm);
         return { pointersOk: true, promptOk: false };
+    }
     // Coax READY. by hitting RETURN, then poll for READY.
     await bm.keyboardFeed("\r");
-    const promptIdx = await waitForScreenPattern(bm, buildReadyPattern(), timeoutMs, 50, options?.onScreenRead);
+    await exitMonitorIfNeeded(bm);
+    const promptIdx = await waitForScreenPattern(bm, buildReadyPattern(), timeoutMs, 50, options?.onScreenRead, async () => { await exitMonitorIfNeeded(bm); });
     return { pointersOk: true, promptOk: promptIdx >= 0 };
 }
 export function asciiToScreenCodes(text) {