@ohmaseclaro/fleetwatch 0.1.0

package/dist/server/tail.js

@@ -0,0 +1,122 @@
+import { promises as fs } from "node:fs";
+import { open } from "node:fs/promises";
+export async function readEntireFile(file) {
+    const stat = await fs.stat(file);
+    const content = await fs.readFile(file, "utf8");
+    const lines = splitLines(content);
+    return {
+        state: {
+            inode: stat.ino,
+            offset: stat.size,
+            partial: lines.partial,
+        },
+        lines: lines.complete,
+    };
+}
+export async function readDelta(file, state) {
+    let stat;
+    try {
+        stat = await fs.stat(file);
+    }
+    catch (err) {
+        // File disappeared — treat as no new lines.
+        return { newState: state, lines: [], rotated: false };
+    }
+    const rotated = stat.ino !== state.inode || stat.size < state.offset;
+    if (rotated) {
+        const content = await fs.readFile(file, "utf8");
+        const lines = splitLines((state.partial || "") + content);
+        return {
+            newState: { inode: stat.ino, offset: stat.size, partial: lines.partial },
+            lines: lines.complete,
+            rotated: true,
+        };
+    }
+    if (stat.size === state.offset) {
+        return { newState: state, lines: [], rotated: false };
+    }
+    const handle = await open(file, "r");
+    try {
+        const length = stat.size - state.offset;
+        const buf = Buffer.alloc(length);
+        await handle.read(buf, 0, length, state.offset);
+        const chunk = (state.partial || "") + buf.toString("utf8");
+        const lines = splitLines(chunk);
+        return {
+            newState: { inode: state.inode, offset: stat.size, partial: lines.partial },
+            lines: lines.complete,
+            rotated: false,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Read the first `headCount` lines and last `tailCount` lines of a file
+ * without buffering the whole file. Used for metadata-only initial scans.
+ *
+ * For small files where the total lines fit within head+tail we return all
+ * lines in headLines (tailLines will be empty to avoid duplicates).
+ */
+export async function readHeadTail(file, headCount, tailCount) {
+    const stat = await fs.stat(file);
+    const content = await fs.readFile(file, "utf8");
+    const all = content.split(/\r?\n/).filter((l) => l.length > 0);
+    const state = { inode: stat.ino, offset: stat.size, partial: "" };
+    if (all.length <= headCount + tailCount) {
+        return { headLines: all, tailLines: [], state };
+    }
+    const headLines = all.slice(0, headCount);
+    const tailLines = all.slice(all.length - tailCount);
+    return { headLines, tailLines, state };
+}
+/**
+ * Read the last `n` complete lines from a large file WITHOUT reading the whole
+ * file into memory. Works by seeking backwards from EOF in 64 KB chunks.
+ *
+ * Returns the lines in forward (chronological) order plus a TailState pointing
+ * at EOF so the caller can resume with readDelta for subsequent changes.
+ */
+export async function readTailLines(file, n) {
+    const stat = await fs.stat(file);
+    const fileSize = stat.size;
+    const state = { inode: stat.ino, offset: fileSize, partial: "" };
+    if (fileSize === 0 || n === 0)
+        return { lines: [], state };
+    const CHUNK = 64 * 1024; // 64 KB — large enough to hold many events
+    const handle = await open(file, "r");
+    try {
+        let pos = fileSize;
+        let accumulated = "";
+        let complete = [];
+        while (pos > 0 && complete.length <= n) {
+            const readSize = Math.min(CHUNK, pos);
+            pos -= readSize;
+            const buf = Buffer.alloc(readSize);
+            await handle.read(buf, 0, readSize, pos);
+            accumulated = buf.toString("utf8") + accumulated;
+            // Count complete lines found so far (split, filter, keep going if not enough)
+            const parts = accumulated.split(/\r?\n/);
+            // parts[0] might be a partial line — preserve it for the next iteration
+            if (pos > 0) {
+                accumulated = parts[0]; // keep the head fragment for next chunk
+                complete = parts.slice(1).filter((l) => l.length > 0).concat(complete);
+            }
+            else {
+                // Reached beginning of file — include everything
+                complete = parts.filter((l) => l.length > 0);
+            }
+        }
+        return { lines: complete.slice(-n), state };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function splitLines(input) {
+    const lines = input.split(/\r?\n/);
+    const partial = lines.pop() ?? "";
+    return { complete: lines.filter((l) => l.length > 0), partial };
+}
+//# sourceMappingURL=tail.js.map

package/dist/server/tunnel.js

@@ -0,0 +1,103 @@
+/**
+ * Manages a single ngrok HTTPS tunnel that forwards traffic to the local
+ * Fastify server. The tunnel is started once at boot and torn down on exit.
+ *
+ * Free tier (free.ngrok.com account, no credit card):
+ *   https://dashboard.ngrok.com/get-started/your-authtoken
+ */
+import ngrok from "@ngrok/ngrok";
+let active = null;
+let lastError = null;
+/**
+ * Map raw ngrok error strings to a stable error code + actionable hint.
+ * Free-tier errors usually include `ERR_NGROK_<code>`; we sniff for that.
+ */
+function classifyError(raw) {
+    const lower = raw.toLowerCase();
+    if (lower.includes("err_ngrok_105") || lower.includes("invalid") && lower.includes("token")) {
+        return {
+            code: "invalid_authtoken",
+            raw,
+            hint: "ngrok rejected the authtoken. Double-check it at https://dashboard.ngrok.com/get-started/your-authtoken",
+        };
+    }
+    if (lower.includes("err_ngrok_3200") || lower.includes("limit") || lower.includes("simultaneous")) {
+        return {
+            code: "limited_tier",
+            raw,
+            hint: "Free tier limit hit — only one ngrok agent can run at a time. Stop other ngrok instances first.",
+        };
+    }
+    if (lower.includes("enotfound") || lower.includes("econnrefused") || lower.includes("etimedout") || lower.includes("network")) {
+        return {
+            code: "network",
+            raw,
+            hint: "Could not reach ngrok servers. Check your internet connection and try again.",
+        };
+    }
+    return {
+        code: "unknown",
+        raw,
+        hint: "Tunnel start failed. See the raw error for details — and try restarting the daemon.",
+    };
+}
+/**
+ * Start the ngrok tunnel. Returns the public HTTPS URL, or null if it fails.
+ * Only one tunnel is kept alive at a time — calling again closes the old one.
+ */
+export async function startTunnel(opts) {
+    // Tear down any existing tunnel first.
+    if (active) {
+        await active.stop().catch(() => { });
+        active = null;
+    }
+    lastError = null;
+    try {
+        opts.onLog?.("[ngrok] connecting tunnel…");
+        const listener = await ngrok.forward({
+            addr: opts.port,
+            authtoken: opts.authtoken,
+            schemes: ["https"],
+            // Skip the browser interstitial page on free tier.
+            request_header_add: ["ngrok-skip-browser-warning: 1"],
+        });
+        const url = listener.url();
+        if (!url)
+            throw new Error("ngrok returned no URL");
+        opts.onLog?.(`[ngrok] tunnel active: ${url}`);
+        active = {
+            url,
+            stop: async () => {
+                try {
+                    await listener.close();
+                }
+                catch { }
+                active = null;
+            },
+        };
+        return active;
+    }
+    catch (err) {
+        const raw = err.message;
+        lastError = classifyError(raw);
+        opts.onLog?.(`[ngrok] ${lastError.code}: ${lastError.hint}`);
+        opts.onLog?.(`[ngrok] (raw: ${raw})`);
+        return null;
+    }
+}
+export function lastTunnelError() {
+    return lastError;
+}
+/**
+ * Stop the currently active tunnel (if any). Safe to call when not running.
+ */
+export async function stopTunnel() {
+    if (active) {
+        await active.stop().catch(() => { });
+        active = null;
+    }
+}
+export function activeTunnel() {
+    return active;
+}
+//# sourceMappingURL=tunnel.js.map