@ohmaseclaro/fleetwatch 0.1.0

package/dist/server/ngrokConfig.js

@@ -0,0 +1,78 @@
+/**
+ * Read the user's existing ngrok authtoken from ngrok's own config file.
+ *
+ * If they've already run `ngrok config add-authtoken <token>` at some point,
+ * the token is sitting in ngrok.yml — no reason to make them paste it again.
+ *
+ * Supported locations (in order):
+ *   - macOS (v3):        ~/Library/Application Support/ngrok/ngrok.yml
+ *   - Linux/Win (v3):    ~/.config/ngrok/ngrok.yml  (or $LOCALAPPDATA/ngrok/)
+ *   - Legacy (v2):       ~/.ngrok2/ngrok.yml
+ *
+ * Supported formats:
+ *   v2:  `authtoken: <token>`     (top-level)
+ *   v3:  `agent:\n  authtoken: <token>`  (nested under agent)
+ *
+ * We don't add a YAML dependency for this — a single-line regex over the file
+ * is sufficient since ngrok.yml has exactly one `authtoken:` key.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+/** Default locations to probe, in priority order. */
+function candidatePaths() {
+    const home = os.homedir();
+    const paths = [];
+    if (process.platform === "darwin") {
+        paths.push(path.join(home, "Library", "Application Support", "ngrok", "ngrok.yml"));
+    }
+    // Linux + common cross-platform location
+    paths.push(path.join(home, ".config", "ngrok", "ngrok.yml"));
+    if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+        paths.push(path.join(process.env.LOCALAPPDATA, "ngrok", "ngrok.yml"));
+    }
+    // Legacy v2 location
+    paths.push(path.join(home, ".ngrok2", "ngrok.yml"));
+    return paths;
+}
+/**
+ * Probe known ngrok config paths and return the first authtoken found.
+ * Returns null if no ngrok config file exists or none contain an authtoken.
+ */
+export function findNgrokAuthtoken() {
+    for (const p of candidatePaths()) {
+        if (!existsSync(p))
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(p, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const token = parseAuthtoken(raw);
+        if (token)
+            return { authtoken: token, source: p };
+    }
+    return null;
+}
+/**
+ * Extract the authtoken value from a ngrok.yml file's contents.
+ *
+ * Handles both v2 (top-level `authtoken:`) and v3 (`agent: authtoken:` nested
+ * with 2-space indent). Strips optional surrounding quotes. Skips commented
+ * lines.
+ */
+export function parseAuthtoken(yaml) {
+    for (const line of yaml.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        // Match `authtoken: value`  (optionally quoted, any indentation)
+        const m = trimmed.match(/^authtoken:\s*['"]?([^'"\s#]+)['"]?\s*(#.*)?$/);
+        if (m && m[1])
+            return m[1];
+    }
+    return null;
+}
+//# sourceMappingURL=ngrokConfig.js.map

package/dist/server/pairing.js

@@ -0,0 +1,94 @@
+import { promises as fs } from "node:fs";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { nanoid } from "nanoid";
+import QRCode from "qrcode";
+/**
+ * Where persisted state lives. We migrated from `~/.config/claude-watcher/`
+ * to `~/.config/fleetwatch/` when the project was renamed — `loadOrInitConfig`
+ * silently picks up the old location if the new one doesn't exist yet.
+ */
+const CONFIG_DIR = path.join(os.homedir(), ".config", "fleetwatch");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const LEGACY_CONFIG_FILE = path.join(os.homedir(), ".config", "claude-watcher", "config.json");
+export async function loadOrInitConfig() {
+    try {
+        // Prefer the new location; transparently fall back to the legacy one
+        // from when this project was called claude-watcher. Once we successfully
+        // save back, future loads come from the new path only.
+        let raw;
+        try {
+            raw = await fs.readFile(CONFIG_FILE, "utf8");
+        }
+        catch {
+            if (!existsSync(LEGACY_CONFIG_FILE))
+                throw new Error("no config yet");
+            raw = await fs.readFile(LEGACY_CONFIG_FILE, "utf8");
+        }
+        const parsed = JSON.parse(raw);
+        const result = {
+            token: parsed.token ?? nanoid(32),
+            jwtSecret: parsed.jwtSecret ?? nanoid(48),
+            hostLabel: parsed.hostLabel ?? os.hostname(),
+            ngrokAuthtoken: parsed.ngrokAuthtoken,
+            ngrokDisabled: parsed.ngrokDisabled,
+            preferences: {
+                includeCowork: parsed.preferences?.includeCowork ?? false,
+                showLibrarySessions: parsed.preferences?.showLibrarySessions ?? false,
+            },
+        };
+        // Persist on first read after migration / when we auto-generated fields.
+        if (!parsed.jwtSecret || !existsSync(CONFIG_FILE))
+            await saveConfig(result);
+        return result;
+    }
+    catch {
+        const fresh = {
+            token: nanoid(32),
+            jwtSecret: nanoid(48),
+            hostLabel: os.hostname(),
+            preferences: { includeCowork: false, showLibrarySessions: false },
+        };
+        await saveConfig(fresh);
+        return fresh;
+    }
+}
+export async function saveConfig(cfg) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf8");
+}
+export async function rotateToken(cfg) {
+    const next = { ...cfg, token: nanoid(32) };
+    await saveConfig(next);
+    return next;
+}
+export async function buildPairingPayload(host, port, token, overrideUrl) {
+    const url = overrideUrl
+        ? `${overrideUrl}/?token=${encodeURIComponent(token)}`
+        : `http://${host}:${port}/?token=${encodeURIComponent(token)}`;
+    const qrSvg = await QRCode.toString(url, { type: "svg", margin: 1, width: 320, color: { dark: "#3D3929", light: "#FAF9F5" } });
+    const qrAscii = await QRCode.toString(url, { type: "terminal", small: true });
+    return { url, qrSvg, qrAscii };
+}
+export function pickLanIp() {
+    const ifaces = os.networkInterfaces();
+    let candidate = null;
+    for (const [name, addrs] of Object.entries(ifaces)) {
+        if (!addrs)
+            continue;
+        for (const addr of addrs) {
+            if (addr.family !== "IPv4" || addr.internal)
+                continue;
+            // Prefer en0/en1 on macOS, but pick any non-internal IPv4.
+            if (name.startsWith("en") || name.startsWith("wlan") || name.startsWith("eth")) {
+                if (addr.address.startsWith("192.168.") || addr.address.startsWith("10.") || addr.address.startsWith("172.")) {
+                    return addr.address;
+                }
+            }
+            candidate = candidate ?? addr.address;
+        }
+    }
+    return candidate;
+}
+//# sourceMappingURL=pairing.js.map

package/dist/server/projectPath.js

@@ -0,0 +1,57 @@
+/**
+ * Claude Code stores sessions under ~/.claude/projects/<encoded-cwd>/<uuid>.jsonl
+ * where <encoded-cwd> is the absolute path with '/' replaced by '-' (leading
+ * '/' becomes a leading '-').
+ *
+ * Decoding back is ambiguous because real directory names may contain '-',
+ * so we use a heuristic: walk the candidate path checking which prefix
+ * actually exists on disk, and reconstruct.
+ *
+ * For display purposes we don't need full fidelity — the last two segments
+ * are enough.
+ */
+import { existsSync } from "node:fs";
+const cache = new Map();
+export function decodeProjectDir(encoded) {
+    const cached = cache.get(encoded);
+    if (cached)
+        return cached;
+    // Strategy: assume the typical case is /Users/name/... — try filesystem-resolution first.
+    const guessed = `/${encoded.replace(/^-/, "").split("-").join("/")}`;
+    let resolved = guessed;
+    if (!existsSync(guessed)) {
+        // Try resolving with a smarter walk: prefer the deepest prefix that exists.
+        resolved = bestExistingPath(encoded) ?? guessed;
+    }
+    const segments = resolved.split("/").filter(Boolean);
+    const label = segments.length >= 2
+        ? `${segments[segments.length - 2]} / ${segments[segments.length - 1]}`
+        : segments[segments.length - 1] ?? encoded;
+    const result = { projectPath: resolved, projectLabel: label };
+    cache.set(encoded, result);
+    return result;
+}
+function bestExistingPath(encoded) {
+    const parts = encoded.replace(/^-/, "").split("-");
+    if (parts.length === 0)
+        return null;
+    // Greedy: walk parts left-to-right; at each step try joining the next
+    // chunk with either "-" or "/". Prefer "/" when the candidate exists.
+    let acc = `/${parts[0]}`;
+    for (let i = 1; i < parts.length; i++) {
+        const withSlash = `${acc}/${parts[i]}`;
+        const withDash = `${acc}-${parts[i]}`;
+        if (existsSync(withSlash)) {
+            acc = withSlash;
+        }
+        else if (existsSync(withDash)) {
+            acc = withDash;
+        }
+        else {
+            // Neither prefix exists. Default to slash (typical case).
+            acc = withSlash;
+        }
+    }
+    return acc;
+}
+//# sourceMappingURL=projectPath.js.map

package/dist/server/providers/base.js

@@ -0,0 +1,85 @@
+import { discover } from "./discovery.js";
+/**
+ * Implementers focus on three things:
+ *   1. `info` — provider metadata
+ *   2. `onStart` — open files / DBs / connections, seed the registry
+ *   3. `backfillSession` — fetch events for a session the user just opened
+ *
+ * Everything else (state tracking, log prefixing, idempotent stop) is handled
+ * here so subclasses don't reinvent it.
+ */
+export class BaseProvider {
+    registry;
+    _rawLog;
+    _state = "idle";
+    constructor(opts) {
+        this.registry = opts.registry;
+        this._rawLog = opts.onLog;
+    }
+    /** Provider id (mirrors info.id) — satisfies Provider interface. */
+    get id() {
+        return this.info.id;
+    }
+    /** Current lifecycle phase. */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Public lifecycle entry — handles state bookkeeping and error trapping
+     * so ProviderManager doesn't need to know which phase a provider is in.
+     */
+    async start() {
+        if (this._state === "running" || this._state === "starting")
+            return;
+        this._state = "starting";
+        try {
+            await this.onStart();
+            // onStart may set state to "skipped" itself (via skipStartup()); if it
+            // didn't, we assume it ran successfully.
+            if (this._state === "starting")
+                this._state = "running";
+        }
+        catch (err) {
+            this._state = "stopped";
+            this.log(`failed to start: ${err.message}`);
+            throw err;
+        }
+    }
+    async stop() {
+        if (this._state === "stopped" || this._state === "idle" || this._state === "skipped")
+            return;
+        this._state = "stopping";
+        try {
+            await this.onStop();
+        }
+        finally {
+            this._state = "stopped";
+        }
+    }
+    // ─── helpers available to subclasses ───────────────────────────────────
+    /**
+     * Mark startup as deliberately skipped (e.g. dependency missing on disk).
+     * Call from inside onStart() before returning. The provider stays alive but
+     * does nothing — useful when a provider is optional.
+     */
+    skipStartup(reason) {
+        this.log(`skipping: ${reason}`);
+        this._state = "skipped";
+    }
+    /** Prefixed logger. Use this instead of console.* so messages are routable. */
+    log(msg) {
+        this._rawLog?.(`[${this.info.id}] ${msg}`);
+    }
+    /**
+     * Discover a data location using the shared discovery primitive — candidate
+     * path list with bounded filesystem search fallback. Logs results with the
+     * provider's prefix so users can see where each piece of data was found.
+     *
+     * Returns the resolved path, or null when nothing matched. The caller
+     * decides whether to skipStartup or surface a more specific error.
+     */
+    async discover(spec) {
+        return discover(spec, (msg) => this.log(msg));
+    }
+}
+//# sourceMappingURL=base.js.map