@nessielabs/daemon 0.3.2 → 0.5.26

package/dist/nera/process.js

@@ -0,0 +1,78 @@
+import { spawn } from "node:child_process";
+import { mkdir, open } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getHealth } from "./client.js";
+import { readRuntimeFile } from "./runtimeFile.js";
+import { neraBinaryPath } from "../platform/binary.js";
+import { daemonPaths } from "../platform/paths.js";
+export async function probeRuntime() {
+    const endpoint = await readRuntimeFile();
+    if (!endpoint)
+        return null;
+    try {
+        await getHealth(endpoint);
+        return endpoint;
+    }
+    catch {
+        return null;
+    }
+}
+export async function ensureRuntime(options) {
+    const existing = await probeRuntime();
+    if (existing)
+        return { ...existing, started: false };
+    const paths = daemonPaths();
+    await mkdir(dirname(paths.logFile), { recursive: true });
+    const log = await open(paths.logFile, "a");
+    let child;
+    try {
+        child = spawn(neraBinaryPath(), [], {
+            detached: options.detached,
+            stdio: ["ignore", log.fd, log.fd],
+        });
+        if (options.detached)
+            child.unref();
+    }
+    finally {
+        await log.close();
+    }
+    try {
+        const endpoint = await waitForRuntime(child, paths.logFile);
+        return { ...endpoint, started: true, child };
+    }
+    catch (error) {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // The runtime may have exited before cleanup.
+        }
+        throw error;
+    }
+}
+export async function stopRuntime() {
+    const endpoint = await probeRuntime();
+    if (!endpoint)
+        return null;
+    process.kill(endpoint.pid, "SIGTERM");
+    return endpoint.pid;
+}
+async function waitForRuntime(child, logFile) {
+    const deadline = Date.now() + 30_000;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null)
+            throw new Error(`Nessie exited before it was ready with code ${child.exitCode}. Check ${logFile}.`);
+        const endpoint = await readRuntimeFile();
+        if (endpoint) {
+            try {
+                await getHealth(endpoint);
+                return endpoint;
+            }
+            catch {
+                // Keep waiting until the server accepts connections.
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    throw new Error(`Timed out starting Nessie. Check ${logFile}.`);
+}

package/dist/nera/runtimeFile.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export async function readRuntimeFile() {
+    try {
+        const parsed = JSON.parse(await readFile(runtimeFilePath(), "utf8"));
+        if (!parsed.host || !parsed.port || !parsed.token || !parsed.pid)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function runtimeFilePath() {
+    if (process.env.NERA_CONNECTION_CONFIG)
+        return process.env.NERA_CONNECTION_CONFIG;
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "com.nessielabs.Nessie", "connection-config.json");
+    }
+    if (process.platform === "win32") {
+        return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "Nessie Labs", "Nessie", "data", "connection-config.json");
+    }
+    return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "nessie", "connection-config.json");
+}

package/dist/platform/binary.js

@@ -0,0 +1,21 @@
+import { accessSync, constants } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function neraBinaryPath() {
+    const explicit = process.env.NERA_BIN;
+    if (explicit)
+        return explicit;
+    const fileName = process.platform === "win32" ? "nera.exe" : "nera";
+    const packaged = resolve(dirname(fileURLToPath(import.meta.url)), "../../vendor/nera", platformKey(), fileName);
+    try {
+        accessSync(packaged, constants.X_OK);
+        return packaged;
+    }
+    catch {
+        throw new Error(`Embedded Nessie runtime binary not found for ${platformKey()}. Run npm run build from apps/nessie-daemon.`);
+    }
+}
+export function platformKey() {
+    const arch = process.arch;
+    return `${process.platform}-${arch}`;
+}

package/dist/platform/openBrowser.js

@@ -0,0 +1,14 @@
+import { spawn } from "node:child_process";
+export async function openBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    await new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: "ignore", detached: true });
+        child.once("error", () => {
+            console.log(`Open this URL to sign in: ${url}`);
+            resolve();
+        });
+        child.once("exit", () => resolve());
+        child.unref();
+    });
+}

package/dist/platform/paths.js

@@ -0,0 +1,13 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function daemonPaths() {
+    const stateDir = process.env.XDG_STATE_HOME
+        ? join(process.env.XDG_STATE_HOME, "nessie-daemon")
+        : process.platform === "darwin"
+            ? join(homedir(), "Library", "Logs", "NessieDaemon")
+            : join(homedir(), ".local", "state", "nessie-daemon");
+    return {
+        stateDir,
+        logFile: join(stateDir, "nera.log"),
+    };
+}

package/dist/platform/table.js

@@ -0,0 +1,85 @@
+const TAB_WIDTH = 8;
+const ANSI = {
+    bold: "1",
+    dim: "2",
+    green: "32",
+    yellow: "33",
+    red: "31",
+    cyan: "36",
+};
+export function renderTabTable(rows, colors) {
+    const normalized = rows.map((row) => row.map(normalizeCell));
+    const first = normalized[0];
+    if (!first || first.length === 0)
+        return "";
+    const columnCount = first.length;
+    const columnStops = Array(columnCount).fill(0);
+    let start = 0;
+    for (let column = 0; column < columnCount - 1; column += 1) {
+        let widest = 0;
+        for (const row of normalized) {
+            if (column < row.length)
+                widest = Math.max(widest, visibleWidth(row[column] ?? ""));
+        }
+        const stop = (Math.floor((start + widest) / TAB_WIDTH) + 1) * TAB_WIDTH;
+        columnStops[column] = stop;
+        start = stop;
+    }
+    const lines = normalized.map((row, rowIndex) => {
+        let position = 0;
+        let line = "";
+        for (let column = 0; column < row.length; column += 1) {
+            const cell = row[column] ?? "";
+            line += colorize(cell, colors?.[rowIndex]?.[column]);
+            position += visibleWidth(cell);
+            if (column < columnCount - 1) {
+                while (position < columnStops[column]) {
+                    line += "\t";
+                    position = (Math.floor(position / TAB_WIDTH) + 1) * TAB_WIDTH;
+                }
+            }
+        }
+        return line;
+    });
+    return `${lines.join("\n")}\n`;
+}
+function normalizeCell(cell) {
+    return cell.replace(/[\n\r\t]/g, " ").trim();
+}
+function visibleWidth(cell) {
+    let width = 0;
+    for (const segment of graphemes(stripAnsi(cell))) {
+        width += isWide(segment) ? 2 : 1;
+    }
+    return width;
+}
+function colorize(cell, color) {
+    if (!color || !process.stdout.isTTY)
+        return cell;
+    return `\u001B[${ANSI[color]}m${cell}\u001B[0m`;
+}
+function stripAnsi(cell) {
+    return cell.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function graphemes(cell) {
+    if (typeof Intl.Segmenter === "function") {
+        const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+        return Array.from(segmenter.segment(cell), (segment) => segment.segment);
+    }
+    return Array.from(cell);
+}
+function isWide(segment) {
+    const codePoint = segment.codePointAt(0);
+    if (codePoint === undefined)
+        return false;
+    return ((codePoint >= 0x1100 && codePoint <= 0x115F)
+        || (codePoint >= 0x2329 && codePoint <= 0x232A)
+        || (codePoint >= 0x2E80 && codePoint <= 0xA4CF)
+        || (codePoint >= 0xAC00 && codePoint <= 0xD7A3)
+        || (codePoint >= 0xF900 && codePoint <= 0xFAFF)
+        || (codePoint >= 0xFE10 && codePoint <= 0xFE19)
+        || (codePoint >= 0xFE30 && codePoint <= 0xFE6F)
+        || (codePoint >= 0xFF00 && codePoint <= 0xFF60)
+        || (codePoint >= 0xFFE0 && codePoint <= 0xFFE6)
+        || (codePoint >= 0x1F300 && codePoint <= 0x1FAFF));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nessielabs/daemon",
-  "version": "0.3.2",
-  "description": "Headless Linux ingestion daemon for Nessie agent traces.",
+  "version": "0.5.26",
+  "description": "Headless Nessie daemon for macOS and Linux agent trace ingestion.",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/**/*.js",
+    "vendor/**/*",
     "README.md"
   ],
   "publishConfig": {
@@ -18,12 +19,17 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "build": "rm -rf dist && node scripts/build-nera.mjs && tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "build:ts": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/cli.js",
+    "build:nera": "node scripts/build-nera.mjs",
     "check": "tsc -p tsconfig.json --noEmit",
     "dev": "tsx src/cli.ts",
+    "prepack": "npm run build",
     "test": "vitest run"
   },
   "dependencies": {
+    "@grpc/grpc-js": "^1.14.1",
+    "@grpc/proto-loader": "^0.8.0",
     "@inquirer/prompts": "^7.8.0",
     "commander": "^14.0.2"
   },