peri-fuse 0.1.0

package/dist/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1785554966737,
+      "tag": "0000_init",
+      "breakpoints": true
+    }
+  ]
+}

package/dist/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Peri-Fuse CLI entry point.
+ *
+ * Manages the background observability server as a detached daemon.
+ * Commands: start / stop / restart / status / logs.
+ */
+const commander_1 = require("commander");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const logs_1 = require("./commands/logs");
+const restart_1 = require("./commands/restart");
+const start_1 = require("./commands/start");
+const status_1 = require("./commands/status");
+const stop_1 = require("./commands/stop");
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+const program = new commander_1.Command();
+program
+    .name("peri-fuse")
+    .description("Manage the Peri-Fuse background observability server")
+    .version(pkg.version);
+program
+    .command("start")
+    .description("Start the server as a background daemon")
+    .action(start_1.startCommand);
+program
+    .command("stop")
+    .description("Stop the background server")
+    .action(stop_1.stopCommand);
+program
+    .command("restart")
+    .description("Restart the background server")
+    .action(restart_1.restartCommand);
+program
+    .command("status")
+    .description("Show whether the server is running")
+    .action(status_1.statusCommand);
+program
+    .command("logs")
+    .description("View server logs")
+    .option("-n, --lines <number>", "Number of lines to show", "50")
+    .option("-f, --follow", "Follow log output")
+    .action(logs_1.logsCommand);
+// No subcommand given: print help and exit cleanly (code 0) instead of erroring.
+program.action(() => {
+    program.outputHelp();
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/lib/daemon.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlive = isAlive;
+exports.getRunningState = getRunningState;
+exports.startServer = startServer;
+exports.stopServer = stopServer;
+exports.waitForHealthy = waitForHealthy;
+exports.checkHealth = checkHealth;
+/**
+ * Daemon management — spawn/stop/inspect the background server process.
+ *
+ * The server runs as a detached child process so the CLI can exit while the
+ * server keeps running. State (pid/port/startedAt/logFile) is persisted to
+ * <root>/.peri-fuse/server.json; combined stdout/stderr goes to server.log.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const dotenv = __importStar(require("dotenv"));
+const paths_1 = require("./paths");
+const DEFAULT_PORT = 23332;
+/** Check whether a process with the given pid is alive. */
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Read state and confirm the recorded process is actually running. */
+function getRunningState() {
+    const state = (0, paths_1.readState)();
+    if (!state)
+        return null;
+    if (!isAlive(state.pid))
+        return null;
+    return state;
+}
+/** Resolve the port to use, honoring LITE_SERVER_PORT and .env. */
+function resolvePort(env) {
+    const raw = env.LITE_SERVER_PORT ?? process.env.LITE_SERVER_PORT;
+    const parsed = raw ? parseInt(raw, 10) : DEFAULT_PORT;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PORT;
+}
+/**
+ * Start the server as a detached background process.
+ * Returns the runtime state, or indicates it was already running.
+ */
+function startServer() {
+    const existing = getRunningState();
+    if (existing) {
+        return { state: existing, alreadyRunning: true };
+    }
+    const entry = (0, paths_1.serverEntry)();
+    if (!fs.existsSync(entry)) {
+        throw new Error(`Server build not found at ${entry}\n  Run "pnpm build" first to compile the server.`);
+    }
+    (0, paths_1.ensureRuntimeDir)();
+    // Load .env from project root (server does not read it itself).
+    const dotenvEnv = {};
+    const envPath = (0, paths_1.envFile)();
+    if (fs.existsSync(envPath)) {
+        const parsed = dotenv.parse(fs.readFileSync(envPath, "utf8"));
+        Object.assign(dotenvEnv, parsed);
+    }
+    const mergedEnv = { ...process.env, ...dotenvEnv };
+    const port = resolvePort(mergedEnv);
+    const log = (0, paths_1.logFile)();
+    const out = fs.openSync(log, "a");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [entry], {
+        detached: true,
+        stdio: ["ignore", out, out],
+        cwd: (0, paths_1.findProjectRoot)(),
+        env: { ...mergedEnv, LITE_SERVER_PORT: String(port) },
+    });
+    fs.closeSync(out);
+    if (child.pid == null) {
+        throw new Error("Failed to spawn server process (no pid returned).");
+    }
+    const state = {
+        pid: child.pid,
+        port,
+        startedAt: Date.now(),
+        logFile: log,
+    };
+    (0, paths_1.writeState)(state);
+    child.unref();
+    return { state, alreadyRunning: false };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Stop the background server. Sends SIGTERM, waits for exit, escalates to
+ * SIGKILL on timeout, then clears the state file.
+ */
+async function stopServer(timeoutMs = 8000) {
+    const state = (0, paths_1.readState)();
+    if (!state) {
+        return { stopped: false, wasRunning: false };
+    }
+    if (!isAlive(state.pid)) {
+        // Stale state — clean up.
+        (0, paths_1.clearState)();
+        return { stopped: false, wasRunning: false };
+    }
+    process.kill(state.pid, "SIGTERM");
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isAlive(state.pid)) {
+            (0, paths_1.clearState)();
+            return { stopped: true, wasRunning: true };
+        }
+        await sleep(200);
+    }
+    // Escalate.
+    try {
+        process.kill(state.pid, "SIGKILL");
+    }
+    catch {
+        /* already gone */
+    }
+    await sleep(300);
+    (0, paths_1.clearState)();
+    return { stopped: true, wasRunning: true };
+}
+/** Poll the server health endpoint until it responds OK or times out. */
+async function waitForHealthy(port, timeoutMs = 10000) {
+    const url = `http://localhost:${port}/api/public/health`;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(url);
+            if (res.ok)
+                return true;
+        }
+        catch {
+            /* not up yet */
+        }
+        await sleep(300);
+    }
+    return false;
+}
+/** One-shot health check (no retry). */
+async function checkHealth(port) {
+    try {
+        const res = await fetch(`http://localhost:${port}/api/public/health`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/output.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = void 0;
+exports.formatUptime = formatUptime;
+/**
+ * Colored console output helpers for the Peri-Fuse CLI.
+ */
+const picocolors_1 = __importDefault(require("picocolors"));
+exports.output = {
+    info(msg) {
+        console.log(picocolors_1.default.cyan("ℹ"), msg);
+    },
+    success(msg) {
+        console.log(picocolors_1.default.green("✔"), msg);
+    },
+    warn(msg) {
+        console.log(picocolors_1.default.yellow("⚠"), msg);
+    },
+    error(msg) {
+        console.error(picocolors_1.default.red("✖"), msg);
+    },
+    dim(msg) {
+        console.log(picocolors_1.default.dim(msg));
+    },
+    plain(msg) {
+        console.log(msg);
+    },
+};
+/** Format a millisecond duration into a human-readable string. */
+function formatUptime(ms) {
+    const sec = Math.floor(ms / 1000);
+    const d = Math.floor(sec / 86400);
+    const h = Math.floor((sec % 86400) / 3600);
+    const m = Math.floor((sec % 3600) / 60);
+    const s = sec % 60;
+    const parts = [];
+    if (d)
+        parts.push(`${d}d`);
+    if (h)
+        parts.push(`${h}h`);
+    if (m)
+        parts.push(`${m}m`);
+    parts.push(`${s}s`);
+    return parts.join(" ");
+}

package/dist/lib/paths.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = findProjectRoot;
+exports.runtimeDir = runtimeDir;
+exports.stateFile = stateFile;
+exports.logFile = logFile;
+exports.serverEntry = serverEntry;
+exports.envFile = envFile;
+exports.ensureRuntimeDir = ensureRuntimeDir;
+exports.readState = readState;
+exports.writeState = writeState;
+exports.clearState = clearState;
+/**
+ * Path resolution for the Peri-Fuse CLI.
+ *
+ * Locates the monorepo root (by walking up to `pnpm-workspace.yaml`), the
+ * server entry point, and the runtime directory used for the PID/state file
+ * and server logs. Mirrors the `findProjectRoot` logic in the server's env.ts
+ * so data directories resolve identically.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+let cachedRoot = null;
+/** Walk up from the CLI package until we find the monorepo root. */
+function findProjectRoot() {
+    if (cachedRoot)
+        return cachedRoot;
+    let dir = __dirname;
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) {
+            cachedRoot = dir;
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    // Fallback to cwd if no workspace marker found.
+    cachedRoot = process.cwd();
+    return cachedRoot;
+}
+/**
+ * Global data/runtime directory. Shared with the server and gateway so the
+ * PID/state file, logs, databases and salt all live in one place, independent
+ * of the repo location. Override with PERIFUSE_HOME. Defaults to ~/.peri-fuse.
+ */
+function runtimeDir() {
+    return process.env.PERIFUSE_HOME || path.join(os.homedir(), ".peri-fuse");
+}
+/** State file: ~/.peri-fuse/server.json */
+function stateFile() {
+    return path.join(runtimeDir(), "server.json");
+}
+/** Log file: ~/.peri-fuse/server.log */
+function logFile() {
+    return path.join(runtimeDir(), "server.log");
+}
+/**
+ * Server entry point.
+ * - Published package: bundled dist/server.cjs (self-contained).
+ * - Monorepo dev: falls back to <root>/packages/server/dist/index.js.
+ */
+function serverEntry() {
+    const bundled = path.join(__dirname, "server.cjs");
+    if (fs.existsSync(bundled))
+        return bundled;
+    return path.join(findProjectRoot(), "packages", "server", "dist", "index.js");
+}
+/** Path to the project root .env file (may not exist). */
+function envFile() {
+    return path.join(findProjectRoot(), ".env");
+}
+function ensureRuntimeDir() {
+    const dir = runtimeDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function readState() {
+    const file = stateFile();
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeState(state) {
+    ensureRuntimeDir();
+    fs.writeFileSync(stateFile(), JSON.stringify(state, null, 2), "utf8");
+}
+function clearState() {
+    const file = stateFile();
+    if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+    }
+}