@hera-al/standardnode 1.0.1

package/dist/config.js

@@ -0,0 +1,141 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { hostname as osHostname } from "node:os";
+import { randomUUID, randomBytes } from "node:crypto";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+import { z } from "zod";
+const ConfigSchema = z.object({
+    node: z.object({
+        id: z.string().default(""),
+        displayName: z.string().default(""),
+    }),
+    gateway: z.object({
+        enabled: z.boolean().default(true),
+        url: z.string().default("ws://localhost:3001/nostromo/ws/nodes"),
+        token: z.string().default(""),
+        signature: z.string().default(""),
+        reconnectMs: z.number().default(5000),
+    }),
+    logs: z.object({
+        dir: z.string().default("./logs-stdnode"),
+    }).default({ dir: "./logs-stdnode" }),
+    commands: z.object({
+        shell: z.object({
+            enabled: z.boolean().default(true),
+            allowlist: z.array(z.string()).default([]),
+            timeout: z.number().default(30000),
+        }),
+    }),
+    browser: z.object({
+        enabled: z.boolean().default(false),
+        controlPort: z.number().default(3002),
+        headless: z.boolean().default(false),
+        noSandbox: z.boolean().default(false),
+        attachOnly: z.boolean().default(false),
+        executablePath: z.string().optional(),
+        allowProfiles: z.array(z.string()).default([]),
+    }).default({
+        enabled: false,
+        controlPort: 3002,
+        headless: false,
+        noSandbox: false,
+        attachOnly: false,
+        allowProfiles: [],
+    }),
+});
+const DEFAULT_CONFIG_NAME = "config.stdnode.yaml";
+const DEFAULT_GATEWAY_URL = "ws://localhost:3001/nostromo/ws/nodes";
+/**
+ * Try to read the Hera server config.yaml from the parent directory
+ * and extract Nostromo port + basePath to build the gateway URL.
+ * Returns the auto-detected URL or the default.
+ */
+function detectGatewayUrl(configDir) {
+    const serverConfigPath = join(dirname(configDir), "config.yaml");
+    try {
+        if (!existsSync(serverConfigPath))
+            return DEFAULT_GATEWAY_URL;
+        const raw = readFileSync(serverConfigPath, "utf-8");
+        const parsed = yamlParse(raw);
+        const port = parsed?.nostromo?.port ?? 3001;
+        const basePath = parsed?.nostromo?.basePath ?? "/nostromo";
+        const host = parsed?.host ?? "localhost";
+        return `ws://${host}:${port}${basePath}/ws/nodes`;
+    }
+    catch {
+        return DEFAULT_GATEWAY_URL;
+    }
+}
+export function loadConfig(opts) {
+    const path = resolve(opts?.configPath ?? DEFAULT_CONFIG_NAME);
+    // If config doesn't exist, create a minimal one
+    if (!existsSync(path)) {
+        writeFileSync(path, yamlStringify({
+            node: { id: "", displayName: "" },
+            gateway: { enabled: true, url: "ws://localhost:3001/nostromo/ws/nodes" },
+            logs: { dir: "./logs-stdnode" },
+            commands: { shell: { enabled: true, allowlist: [], timeout: 30000 } },
+            browser: { enabled: false, controlPort: 3002 },
+        }), "utf-8");
+    }
+    const raw = readFileSync(path, "utf-8");
+    const parsed = yamlParse(raw);
+    const config = ConfigSchema.parse(parsed);
+    // Auto-generate node ID and signature if empty
+    let needsWrite = false;
+    const updated = yamlParse(raw) ?? {};
+    if (!config.node.id) {
+        config.node.id = randomUUID();
+        if (!updated.node)
+            updated.node = {};
+        updated.node.id = config.node.id;
+        needsWrite = true;
+    }
+    if (!config.gateway.signature) {
+        config.gateway.signature = randomBytes(64).toString("hex");
+        if (!updated.gateway)
+            updated.gateway = {};
+        updated.gateway.signature = config.gateway.signature;
+        needsWrite = true;
+    }
+    // Default displayName to hostname
+    if (!config.node.displayName) {
+        config.node.displayName = osHostname();
+        if (!updated.node)
+            updated.node = {};
+        updated.node.displayName = config.node.displayName;
+        needsWrite = true;
+    }
+    // Auto-detect gateway URL from ../config.yaml if still default
+    if (!opts?.ws && config.gateway.url === DEFAULT_GATEWAY_URL) {
+        const detected = detectGatewayUrl(resolve(path, ".."));
+        if (detected !== DEFAULT_GATEWAY_URL) {
+            config.gateway.url = detected;
+            if (!updated.gateway)
+                updated.gateway = {};
+            updated.gateway.url = detected;
+            needsWrite = true;
+        }
+    }
+    // CLI overrides: --ws (takes priority over auto-detect)
+    if (opts?.ws) {
+        config.gateway.url = opts.ws;
+        if (!updated.gateway)
+            updated.gateway = {};
+        updated.gateway.url = opts.ws;
+        needsWrite = true;
+    }
+    // CLI overrides: --name
+    if (opts?.name) {
+        config.node.displayName = opts.name;
+        if (!updated.node)
+            updated.node = {};
+        updated.node.displayName = opts.name;
+        needsWrite = true;
+    }
+    if (needsWrite) {
+        writeFileSync(path, yamlStringify(updated), "utf-8");
+    }
+    return config;
+}
+//# sourceMappingURL=config.js.map

package/dist/gateway-link.d.ts

@@ -0,0 +1,30 @@
+import type { NodeConfig } from "./config.js";
+import type { Logger } from "./logger.js";
+export declare class GatewayLink {
+    private config;
+    private log;
+    private ws;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private stopped;
+    private paired;
+    private shell;
+    private browserProcess;
+    private browserProxy;
+    private browserReady;
+    constructor(config: NodeConfig, log: Logger);
+    start(): void;
+    stop(): void;
+    private startBrowserServer;
+    private stopBrowserServer;
+    private connect;
+    private sendHello;
+    private startHeartbeat;
+    private handleMessage;
+    private handlePairingStatus;
+    private handleCommand;
+    private send;
+    private scheduleReconnect;
+    private clearTimers;
+}
+//# sourceMappingURL=gateway-link.d.ts.map

package/dist/gateway-link.js

@@ -0,0 +1,315 @@
+import WebSocket from "ws";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { platform, hostname, arch } from "node:os";
+import { createShellCommands } from "./commands/shell.js";
+import { createBrowserProxy } from "./commands/browser-proxy.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TAG = "Gateway";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const fg = (n) => `\x1b[38;5;${n}m`;
+const GREEN = fg(82);
+const RED = fg(196);
+const YELLOW = fg(220);
+export class GatewayLink {
+    config;
+    log;
+    ws = null;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    stopped = false;
+    paired = false;
+    shell;
+    browserProcess = null;
+    browserProxy = null;
+    browserReady = false;
+    constructor(config, log) {
+        this.config = config;
+        this.log = log;
+        this.shell = createShellCommands(config, log);
+    }
+    start() {
+        if (this.config.browser.enabled) {
+            this.startBrowserServer();
+        }
+        if (!this.config.gateway.enabled)
+            return;
+        this.stopped = false;
+        this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        this.clearTimers();
+        this.stopBrowserServer();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    // ---------- Browser server subprocess ----------
+    startBrowserServer() {
+        const cfg = this.config.browser;
+        // Try to resolve @hera-al/browser-server package
+        let scriptPath = null;
+        try {
+            // import.meta.resolve returns a file:// URL pointing to the main entry
+            // (dist/server/browser-server.js) — standalone is in the same directory
+            const resolved = import.meta.resolve("@hera-al/browser-server");
+            const entryDir = dirname(fileURLToPath(resolved));
+            const ext = resolved.endsWith(".ts") ? ".ts" : ".js";
+            // The main export points to dist/server/browser-server.js,
+            // so standalone.js is in the same directory (not server/ below it).
+            scriptPath = resolve(entryDir, `standalone${ext}`);
+        }
+        catch {
+            // Fallback: monorepo / dev layout
+            const isTs = import.meta.url.endsWith(".ts");
+            const ext = isTs ? ".ts" : ".js";
+            const srcOrDist = isTs ? "src" : "dist";
+            const fallback = resolve(__dirname, `../../browser-server/${srcOrDist}/server/standalone${ext}`);
+            if (existsSync(fallback))
+                scriptPath = fallback;
+        }
+        if (!scriptPath || !existsSync(scriptPath)) {
+            this.log.warn(TAG, "Browser capability requires @hera-al/browser-server. Install it with: npm install @hera-al/browser-server");
+            return;
+        }
+        const args = [
+            ...process.execArgv,
+            scriptPath,
+            "--port", String(cfg.controlPort),
+        ];
+        if (cfg.headless)
+            args.push("--headless", "true");
+        if (cfg.noSandbox)
+            args.push("--noSandbox", "true");
+        if (cfg.attachOnly)
+            args.push("--attachOnly", "true");
+        if (cfg.executablePath)
+            args.push("--executablePath", cfg.executablePath);
+        this.log.info(TAG, `Starting browser server on port ${cfg.controlPort}...`);
+        const child = spawn(process.execPath, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        child.stdout?.on("data", (data) => {
+            const line = data.toString().trim();
+            if (line)
+                this.log.info("Browser", line);
+            if (line.includes("listening")) {
+                this.browserReady = true;
+                this.log.info(TAG, "Browser server is ready");
+                console.log(`  ${GREEN}${BOLD}🌐 Browser server${RESET} listening on 127.0.0.1:${cfg.controlPort}`);
+            }
+        });
+        child.stderr?.on("data", (data) => {
+            const line = data.toString().trim();
+            if (line)
+                this.log.warn("Browser", line);
+        });
+        child.on("exit", (code) => {
+            this.log.info(TAG, `Browser server exited with code ${code}`);
+            this.browserProcess = null;
+            this.browserReady = false;
+        });
+        // Safety net: kill the child if this process exits for any reason
+        // (crash, uncaught exception, etc.). The 'exit' event is synchronous
+        // and fires even on unhandled errors — only SIGKILL bypasses it.
+        const exitHandler = () => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch { /* already dead */ }
+        };
+        process.on("exit", exitHandler);
+        child.on("exit", () => {
+            process.removeListener("exit", exitHandler);
+        });
+        this.browserProcess = child;
+        this.browserProxy = createBrowserProxy(cfg.controlPort, cfg.allowProfiles, this.log);
+    }
+    stopBrowserServer() {
+        if (this.browserProcess) {
+            this.browserProcess.kill("SIGTERM");
+            this.browserProcess = null;
+            this.browserReady = false;
+            this.browserProxy = null;
+        }
+    }
+    connect() {
+        if (this.stopped)
+            return;
+        const url = this.config.gateway.url;
+        this.log.info(TAG, `Connecting to ${url}...`);
+        this.ws = new WebSocket(url);
+        this.ws.on("open", () => {
+            this.log.info(TAG, "Connected to gateway");
+            this.sendHello();
+            this.startHeartbeat();
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                this.handleMessage(msg);
+            }
+            catch {
+                // Ignore malformed messages
+            }
+        });
+        this.ws.on("close", () => {
+            this.log.warn(TAG, "Disconnected from gateway");
+            this.paired = false;
+            this.clearTimers();
+            this.scheduleReconnect();
+        });
+        this.ws.on("error", (err) => {
+            this.log.error(TAG, `WebSocket error: ${err.message}`);
+        });
+    }
+    sendHello() {
+        const capabilities = [];
+        const commands = [];
+        if (this.config.commands.shell.enabled) {
+            capabilities.push("shell");
+            commands.push("shell.run", "shell.which");
+        }
+        if (this.config.browser.enabled) {
+            capabilities.push("browser");
+            commands.push("browser.proxy");
+        }
+        this.send({
+            type: "hello",
+            nodeId: this.config.node.id,
+            displayName: this.config.node.displayName,
+            platform: platform(),
+            arch: arch(),
+            hostname: hostname(),
+            signature: this.config.gateway.signature,
+            capabilities,
+            commands,
+        });
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.send({ type: "ping" });
+        }, 30000);
+    }
+    handleMessage(msg) {
+        switch (msg.type) {
+            case "pong":
+                break;
+            case "pairing_status":
+                this.handlePairingStatus(msg.status);
+                break;
+            case "command":
+                this.handleCommand(msg);
+                break;
+            default:
+                this.log.debug(TAG, `Received: ${msg.type}`);
+                break;
+        }
+    }
+    handlePairingStatus(status) {
+        switch (status) {
+            case "pending":
+                this.log.info(TAG, "Pairing pending — waiting for admin approval");
+                console.log(`  ${YELLOW}${BOLD}⏳ Pairing pending${RESET} ${DIM}— waiting for admin approval on Nostromo${RESET}`);
+                this.paired = false;
+                break;
+            case "approved":
+                this.log.info(TAG, "Pairing approved — node is active");
+                console.log(`  ${GREEN}${BOLD}✔ Paired!${RESET} Node is active and ready to receive commands.`);
+                this.paired = true;
+                break;
+            case "revoked":
+                this.log.warn(TAG, "Pairing revoked — disconnecting");
+                console.log(`  ${RED}${BOLD}✖ Pairing revoked.${RESET} The node has been disconnected by the admin.`);
+                this.paired = false;
+                this.stop();
+                break;
+        }
+    }
+    async handleCommand(msg) {
+        const id = msg.id;
+        const command = msg.command;
+        const params = msg.params;
+        if (!id || !command) {
+            return;
+        }
+        if (!this.paired) {
+            this.send({
+                type: "command_result",
+                id,
+                ok: false,
+                error: "Node is not paired — awaiting approval",
+            });
+            return;
+        }
+        this.log.info(TAG, `Command: ${command} (${id})`);
+        try {
+            let result;
+            switch (command) {
+                case "shell.run":
+                    result = await this.shell.shellRun(params);
+                    break;
+                case "shell.which":
+                    result = await this.shell.shellWhich(params);
+                    break;
+                case "browser.proxy":
+                    if (!this.browserProxy) {
+                        this.send({ type: "command_result", id, ok: false, error: "Browser is not enabled" });
+                        return;
+                    }
+                    if (!this.browserReady) {
+                        this.send({ type: "command_result", id, ok: false, error: "Browser server not ready" });
+                        return;
+                    }
+                    result = await this.browserProxy.handleProxy(params);
+                    break;
+                default:
+                    this.log.warn(TAG, `Unknown command: ${command}`);
+                    this.send({
+                        type: "command_result",
+                        id,
+                        ok: false,
+                        error: `Unknown command: ${command}`,
+                    });
+                    return;
+            }
+            this.log.info(TAG, `Command ${id} completed`);
+            this.send({ type: "command_result", id, ok: true, result });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.log.error(TAG, `Command ${id} failed: ${message}`);
+            this.send({ type: "command_result", id, ok: false, error: message });
+        }
+    }
+    send(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    scheduleReconnect() {
+        if (this.stopped)
+            return;
+        const delay = this.config.gateway.reconnectMs;
+        this.log.info(TAG, `Reconnecting in ${delay}ms...`);
+        this.reconnectTimer = setTimeout(() => this.connect(), delay);
+    }
+    clearTimers() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=gateway-link.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import { copyFileSync, existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./config.js";
+import { GatewayLink } from "./gateway-link.js";
+import { Logger } from "./logger.js";
+// ─── ANSI helpers ──────────────────────────────────────────────
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const fg = (n) => `\x1b[38;5;${n}m`;
+// ─── Palette (same gem tones as installer) ─────────────────────
+const C = {
+    pk: 205,
+    hp: 199,
+    mg: 200,
+    dp: 197,
+    rd: 196,
+    dr: 161,
+};
+// ─── Banner ────────────────────────────────────────────────────
+function printBanner(name, id, ws, browserPort) {
+    console.log("");
+    console.log(`  ${fg(C.hp)}${BOLD}  ███████╗████████╗██████╗  ███╗   ██╗ ██████╗ ██████╗ ███████╗${RESET}`);
+    console.log(`  ${fg(C.hp)}${BOLD}  ██╔════╝╚══██╔══╝██╔══██╗ ████╗  ██║██╔═══██╗██╔══██╗██╔════╝${RESET}`);
+    console.log(`  ${fg(C.mg)}${BOLD}  ███████╗   ██║   ██║  ██║ ██╔██╗ ██║██║   ██║██║  ██║█████╗  ${RESET}`);
+    console.log(`  ${fg(C.dp)}${BOLD}  ╚════██║   ██║   ██║  ██║ ██║╚██╗██║██║   ██║██║  ██║██╔══╝  ${RESET}`);
+    console.log(`  ${fg(C.rd)}${BOLD}  ███████║   ██║   ██████╔╝ ██║ ╚████║╚██████╔╝██████╔╝███████╗${RESET}`);
+    console.log(`  ${fg(C.dr)}${BOLD}  ╚══════╝   ╚═╝   ╚═════╝  ╚═╝  ╚═══╝ ╚═════╝ ╚═════╝ ╚══════╝${RESET}`);
+    console.log("");
+    console.log(`  ${fg(C.pk)}${BOLD}Hera StandardNode${RESET}`);
+    console.log(`  ${DIM}${"─".repeat(50)}${RESET}`);
+    console.log(`  ${DIM}Name${RESET}    ${BOLD}${name}${RESET}`);
+    console.log(`  ${DIM}ID${RESET}      ${DIM}${id}${RESET}`);
+    console.log(`  ${DIM}Gateway${RESET} ${DIM}${ws}${RESET}`);
+    if (browserPort) {
+        console.log(`  ${DIM}Browser${RESET} ${DIM}127.0.0.1:${browserPort}${RESET}`);
+    }
+    console.log("");
+}
+// ─── Help ──────────────────────────────────────────────────────
+function printHelp() {
+    console.log("");
+    console.log(`  ${fg(C.pk)}${BOLD}Hera StandardNode${RESET}`);
+    console.log("");
+    console.log(`  ${BOLD}Usage:${RESET}  npx tsx src/index.ts [options]`);
+    console.log("");
+    console.log(`  ${BOLD}Options:${RESET}`);
+    console.log(`    --ws <url>       WebSocket URL of the Hera gateway`);
+    console.log(`    --name <name>    Display name for this node (default: hostname)`);
+    console.log(`    --config <path>  Path to config file (default: config.stdnode.yaml)`);
+    console.log(`    --init           Copy example config to current directory and exit`);
+    console.log(`    --help           Show this help message`);
+    console.log("");
+    console.log(`  ${BOLD}WebSocket URL format:${RESET}`);
+    console.log(`    ws[s]://<hostname>:<port><basePath>/ws/nodes`);
+    console.log("");
+    console.log(`    The ${BOLD}<port>${RESET} is the Nostromo UI port configured on the server`);
+    console.log(`    (default 3001). The ${BOLD}<basePath>${RESET} is the Nostromo base path`);
+    console.log(`    (default /nostromo).`);
+    console.log("");
+    console.log(`  ${BOLD}Examples:${RESET}`);
+    console.log(`    --ws ws://localhost:3001/nostromo/ws/nodes`);
+    console.log(`    --ws wss://myhost.tail12345.ts.net:3001/nostromo/ws/nodes`);
+    console.log("");
+    console.log(`  ${BOLD}Auto-detect:${RESET}`);
+    console.log(`    If ../config.yaml exists (Hera server config), the node reads`);
+    console.log(`    the Nostromo port and basePath from it and auto-configures the`);
+    console.log(`    gateway URL. The --ws flag overrides auto-detection.`);
+    console.log("");
+}
+// ─── CLI arg parsing ───────────────────────────────────────────
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            opts.help = true;
+        }
+        else if (arg === "--init") {
+            opts.init = true;
+        }
+        else if (arg === "--config" && args[i + 1]) {
+            opts.configPath = args[++i];
+        }
+        else if (arg === "--ws" && args[i + 1]) {
+            opts.ws = args[++i];
+        }
+        else if (arg === "--name" && args[i + 1]) {
+            opts.name = args[++i];
+        }
+        else if (!arg.startsWith("--") && !opts.configPath) {
+            // Legacy: first positional arg is config path
+            opts.configPath = arg;
+        }
+    }
+    return opts;
+}
+// ─── Init ─────────────────────────────────────────────────────
+function initConfig() {
+    const dest = resolve("config.stdnode.yaml");
+    if (existsSync(dest)) {
+        console.log(`\n  ${fg(C.rd)}${BOLD}config.stdnode.yaml already exists${RESET} — not overwriting.\n`);
+        return;
+    }
+    // Resolve the example config bundled with the package
+    const thisFile = fileURLToPath(import.meta.url);
+    const pkgRoot = dirname(dirname(thisFile)); // up from dist/ or src/
+    const example = join(pkgRoot, "config.stdnode.example.yaml");
+    if (!existsSync(example)) {
+        console.log(`\n  ${fg(C.rd)}${BOLD}Example config not found${RESET} — run from a proper install.\n`);
+        return;
+    }
+    copyFileSync(example, dest);
+    console.log(`\n  ${fg(C.pk)}${BOLD}Created${RESET} config.stdnode.yaml`);
+    console.log(`  ${DIM}Edit it, then run: hera-stdnode${RESET}\n`);
+}
+// ─── Main ──────────────────────────────────────────────────────
+function main() {
+    const opts = parseArgs();
+    if (opts.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (opts.init) {
+        initConfig();
+        process.exit(0);
+    }
+    const config = loadConfig(opts);
+    const log = new Logger(config.logs.dir);
+    printBanner(config.node.displayName, config.node.id, config.gateway.url, config.browser.enabled ? config.browser.controlPort : undefined);
+    log.info("Node", `Starting — ${config.node.displayName} (${config.node.id})`);
+    log.info("Node", `Gateway: ${config.gateway.url}`);
+    log.info("Node", `Logs dir: ${config.logs.dir}`);
+    // Connect to gateway
+    const gateway = new GatewayLink(config, log);
+    gateway.start();
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log(`\n  ${DIM}Shutting down...${RESET}`);
+        log.info("Node", "Shutting down");
+        gateway.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Parent-liveness monitor: when launched from OSXNode, OSXNODE_PARENT=1
+    // is set. Poll the parent PID — when it disappears, shut down so
+    // browser-server and Chrome are cleaned up. Standalone launches are
+    // unaffected. Polling is more reliable than stdin-pipe EOF because
+    // posix_spawn may leak the pipe's write-end to the child.
+    if (process.env.OSXNODE_PARENT) {
+        const parentPid = process.ppid;
+        const parentCheck = setInterval(() => {
+            try {
+                process.kill(parentPid, 0); // signal 0 = existence check
+            }
+            catch {
+                clearInterval(parentCheck);
+                log.info("Node", `Parent (pid ${parentPid}) exited, shutting down`);
+                shutdown();
+            }
+        }, 2000);
+        parentCheck.unref(); // don't keep the event loop alive just for this
+    }
+}
+main();
+//# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+export declare class Logger {
+    private dir;
+    private filePath;
+    constructor(logsDir: string);
+    info(tag: string, msg: string): void;
+    warn(tag: string, msg: string): void;
+    error(tag: string, msg: string): void;
+    debug(tag: string, msg: string): void;
+    private write;
+    private rotate;
+}
+//# sourceMappingURL=logger.d.ts.map