stream-doctor 0.0.4 → 0.0.5

package/dist/stream_doctor.d.ts

@@ -1,5 +1,4 @@
 import { type ChildProcess } from "node:child_process";
-export declare function bundledBinary(): string | null;
 export type Status = "streaming" | "receiving" | "waiting_for_playlist" | "ended" | "failed" | "stopped";
 export interface StreamerStatus {
     input: string;
@@ -32,6 +31,7 @@ export declare function session({ server, binary, }?: {
     server?: string;
     binary?: string;
 }): Promise<Session>;
+export declare function bundledBinary(): string | null;
 declare class Session {
     server: string;
     child: ChildProcess | null;

package/dist/stream_doctor.js

@@ -1,48 +1,15 @@
-// Client for the stream_doctor server. `session()` spawns the binary (the one
-// bundled for this platform, or `binary`) when no server is listening;
-// `session.close()` stops it. The daemon's output goes to `session.logFile`.
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 const DEFAULT_SERVER = "http://localhost:4040";
+const LOG_FILE = path.join(os.tmpdir(), "stream_doctor.log");
 const PLATFORM_PACKAGES = {
     "darwin-arm64": "@stream-doctor/darwin-arm64",
     "linux-arm64": "@stream-doctor/linux-arm64",
     "linux-x64": "@stream-doctor/linux-x64",
 };
-// The daemon ships as one package per platform, all optional dependencies of
-// this one, so only the matching one is installed.
-export function bundledBinary() {
-    const pkg = PLATFORM_PACKAGES[`${process.platform}-${process.arch}`];
-    if (!pkg)
-        return null;
-    try {
-        return createRequire(import.meta.url).resolve(`${pkg}/bin/stream_doctor`);
-    }
-    catch {
-        return null;
-    }
-}
-async function api(method, path, body, server) {
-    let res;
-    try {
-        res = await fetch(server + path, {
-            method,
-            headers: body ? { "content-type": "application/json" } : undefined,
-            body: body ? JSON.stringify(body) : undefined,
-        });
-    }
-    catch (e) {
-        throw new Error(`${method} ${path}: cannot reach ${server} (is the server running?): ${e.message}`);
-    }
-    const text = await res.text();
-    if (!res.ok)
-        throw new Error(`${method} ${path}: HTTP ${res.status}: ${text}`);
-    return JSON.parse(text);
-}
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const TERMINAL_STATUSES = ["ended", "failed", "stopped"];
 export async function session({ server = DEFAULT_SERVER, binary, } = {}) {
     try {
@@ -51,48 +18,27 @@ export async function session({ server = DEFAULT_SERVER, binary, } = {}) {
     }
     catch (e) {
         let installDir;
-        const logFile = path.join(os.tmpdir(), "stream_doctor.log");
         if (!binary) {
             binary = bundledBinary() ?? undefined;
             if (!binary) {
                 throw new Error(`${e.message}; no stream_doctor binary bundled for ${process.platform}-${process.arch}, pass one with \`binary\``);
             }
-            // Burrito unpacks the payload once per release name + ERTS + app version,
-            // none of which change between npm releases, so its default cache under
-            // ~/.local/share would keep serving the previous package's daemon.
             installDir = path.join(path.dirname(binary), "..", ".burrito");
         }
-        const child = await spawnServer(binary, server, logFile, installDir);
-        return new Session(server, child, logFile);
+        const child = await spawnServer(binary, server, installDir);
+        return new Session(server, child, LOG_FILE);
     }
 }
-async function spawnServer(binary, server, logFile, installDir) {
-    if (!fs.existsSync(binary)) {
-        throw new Error(`${binary} not found, build it with: MIX_ENV=prod mix release`);
+export function bundledBinary() {
+    const pkg = PLATFORM_PACKAGES[`${process.platform}-${process.arch}`];
+    if (!pkg)
+        return null;
+    try {
+        return createRequire(import.meta.url).resolve(`${pkg}/bin/stream_doctor`);
     }
-    const env = {
-        ...process.env,
-        // the daemon quits once its stdin (the pipe below) breaks, i.e. when this
-        // process dies, however it dies
-        STREAM_DOCTOR_EXIT_ON_STDIN_EOF: "1",
-        ...(installDir ? { STREAM_DOCTOR_INSTALL_DIR: installDir } : {}),
-    };
-    const log = fs.openSync(logFile, "a");
-    // own process group, so that killing the burrito launcher takes the BEAM with it
-    const child = spawn(binary, [], { stdio: ["pipe", log, log], detached: true, env });
-    child.on("exit", () => fs.closeSync(log));
-    for (const deadline = Date.now() + 120_000; Date.now() < deadline;) {
-        if (child.exitCode !== null) {
-            throw new Error(`server exited with ${child.exitCode}, see ${logFile}`);
-        }
-        await sleep(1000);
-        try {
-            await api("GET", "/status", null, server);
-            return child;
-        }
-        catch { }
+    catch {
+        return null;
     }
-    throw new Error(`server didn't come up in 2 minutes, see ${logFile}`);
 }
 class Session {
     server;
@@ -185,3 +131,46 @@ class Viewer {
         return metrics;
     }
 }
+async function spawnServer(binary, server, installDir) {
+    if (!fs.existsSync(binary)) {
+        throw new Error(`${binary} not found, build it with: MIX_ENV=prod mix release`);
+    }
+    const env = {
+        ...process.env,
+        STREAM_DOCTOR_EXIT_ON_STDIN_EOF: "1",
+        ...(installDir ? { STREAM_DOCTOR_INSTALL_DIR: installDir } : {}),
+    };
+    const log = fs.openSync(LOG_FILE, "a");
+    const child = spawn(binary, [], { stdio: ["pipe", log, log], detached: true, env });
+    child.on("exit", () => fs.closeSync(log));
+    for (const deadline = Date.now() + 120_000; Date.now() < deadline;) {
+        if (child.exitCode !== null) {
+            throw new Error(`server exited with ${child.exitCode}, see ${LOG_FILE}`);
+        }
+        await sleep(1000);
+        try {
+            await api("GET", "/status", null, server);
+            return child;
+        }
+        catch { }
+    }
+    throw new Error(`server didn't come up in 2 minutes, see ${LOG_FILE}`);
+}
+async function api(method, path, body, server) {
+    let res;
+    try {
+        res = await fetch(server + path, {
+            method,
+            headers: body ? { "content-type": "application/json" } : undefined,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    catch (e) {
+        throw new Error(`${method} ${path}: cannot reach ${server} (is the server running?): ${e.message}`);
+    }
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`${method} ${path}: HTTP ${res.status}: ${text}`);
+    return JSON.parse(text);
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-doctor",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Automated end-to-end testing for video infrastructure (early proof of concept)",
   "license": "Apache-2.0",
   "repository": {
@@ -33,8 +33,8 @@
     "typescript-eslint": "^8.70.0"
   },
   "optionalDependencies": {
-    "@stream-doctor/darwin-arm64": "0.0.4",
-    "@stream-doctor/linux-arm64": "0.0.4",
-    "@stream-doctor/linux-x64": "0.0.4"
+    "@stream-doctor/darwin-arm64": "0.0.5",
+    "@stream-doctor/linux-arm64": "0.0.5",
+    "@stream-doctor/linux-x64": "0.0.5"
   }
 }