@bli-cockpit/mcp 0.1.0

package/dist/token-resolver.js

@@ -0,0 +1,217 @@
+/**
+ * Token resolution for the MCP server.
+ *
+ * Two auth paths, matching the `bli-event` bash CLI precedence:
+ *
+ *   1. `BLI_OPERATOR_TOKEN` env var — used verbatim (CI / explicit override)
+ *   2. Fallback: spawn `node <bli-event-session.mjs> get-token` — refreshes
+ *      the cached Supabase session if the access_token is near expiry, and
+ *      prints a fresh access_token on stdout. Exits non-zero if no session
+ *      exists (user must run `bli-event login`).
+ *
+ * The session-helper path spawns a subprocess per resolution. To keep the
+ * overhead invisible for bursts of tool calls (e.g. agent emitting a
+ * timeline fetch + multiple events in sequence), resolved tokens are cached
+ * in-process for a short window. The cache is time-based only — if the
+ * underlying session refresh fails, the NEXT call (after TTL expiry) will
+ * surface the error.
+ */
+import { spawn as defaultSpawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// ---- env resolver -----------------------------------------------------------
+/**
+ * Resolver that returns a static token verbatim. Use for the
+ * `BLI_OPERATOR_TOKEN` env var path (CI / override).
+ */
+export function createEnvTokenResolver(token) {
+    if (!token) {
+        throw new Error("createEnvTokenResolver: token must be non-empty");
+    }
+    return async () => token;
+}
+const DEFAULT_CACHE_TTL_MS = 30_000;
+/** Thrown when the session helper is missing or fails to resolve a token. */
+export class SessionHelperError extends Error {
+    exitCode;
+    stderr;
+    constructor(message, exitCode, stderr) {
+        super(message);
+        this.name = "SessionHelperError";
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+    }
+}
+/**
+ * Resolver that shells out to the Node session helper to get (and refresh)
+ * the operator's Supabase access_token.
+ */
+export function createSessionHelperTokenResolver(options) {
+    const spawnImpl = options.spawn ?? defaultSpawn;
+    const nodePath = options.nodePath ?? process.execPath;
+    const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    const now = options.now ?? Date.now;
+    const env = options.env ?? process.env;
+    const helperPath = options.helperPath;
+    let cache = null;
+    return async () => {
+        if (cache && now() < cache.expiresAt) {
+            return cache.token;
+        }
+        const token = await invokeSessionHelper({
+            nodePath,
+            helperPath,
+            spawn: spawnImpl,
+            env,
+        });
+        if (cacheTtlMs > 0) {
+            cache = { token, expiresAt: now() + cacheTtlMs };
+        }
+        else {
+            cache = null;
+        }
+        return token;
+    };
+}
+/**
+ * Spawn `node <helper> get-token`, capture stdout, and return the token.
+ * Rejects with `SessionHelperError` on non-zero exit.
+ */
+function invokeSessionHelper(args) {
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = args.spawn(args.nodePath, [args.helperPath, "get-token"], {
+                stdio: ["ignore", "pipe", "pipe"],
+                env: args.env,
+            });
+        }
+        catch (err) {
+            reject(new SessionHelperError(`Failed to spawn session helper: ${err instanceof Error ? err.message : String(err)}`, null, ""));
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", (err) => {
+            reject(new SessionHelperError(`Session helper process error: ${err.message}`, null, stderr));
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                const token = stdout.trim();
+                if (!token) {
+                    reject(new SessionHelperError("Session helper exited 0 but produced no token on stdout", code, stderr));
+                    return;
+                }
+                resolve(token);
+                return;
+            }
+            // Non-zero exit — helper surfaces errors on stderr (see cmdGetToken).
+            // Exit code 2 is the documented "auth/network failure" from the helper
+            // (e.g. "Not logged in — run 'bli-event login'.").
+            const trimmedStderr = stderr.trim();
+            const baseMsg = code === 2
+                ? "No session found — run 'bli-event login' first."
+                : `Session helper failed (exit code ${code})`;
+            const message = trimmedStderr
+                ? `${baseMsg} (${trimmedStderr})`
+                : baseMsg;
+            reject(new SessionHelperError(message, code, trimmedStderr));
+        });
+    });
+}
+const HELPER_BASENAME = "bli-event-session.mjs";
+/**
+ * Locate `scripts/bli-event-session.mjs` on disk, or return `null`.
+ *
+ * Order:
+ *   1. If `BLI_SESSION_HELPER` env var points at a readable file, use it.
+ *   2. Walk up from `import.meta.url` looking for a sibling
+ *      `scripts/bli-event-session.mjs` (handles dev checkouts + installed
+ *      npm workspaces where the MCP dist/ lives under `packages/bli-cockpit-mcp/`
+ *      inside the monorepo root).
+ *   3. Return `null` — caller surfaces a clear error.
+ */
+export function resolveSessionHelperPath(options = {}) {
+    const env = options.env ?? process.env;
+    const exists = options.existsSync ?? fs.existsSync;
+    // 1. Explicit env override.
+    const envOverride = env.BLI_SESSION_HELPER;
+    if (envOverride && envOverride.length > 0) {
+        if (exists(envOverride))
+            return path.resolve(envOverride);
+        // Env var was set but the file doesn't exist — surface a clear signal by
+        // returning null; the caller message references BLI_SESSION_HELPER.
+        return null;
+    }
+    // 2. Walk up from the module URL looking for scripts/bli-event-session.mjs.
+    const fromUrl = options.fromUrl ?? (typeof import.meta !== "undefined" ? import.meta.url : undefined);
+    if (!fromUrl)
+        return null;
+    let current;
+    try {
+        current = path.dirname(fileURLToPath(fromUrl));
+    }
+    catch (error) {
+        // Returning null still makes the caller print its BLI_SESSION_HELPER
+        // message, but that message accuses the environment when the real problem
+        // is that this module's own URL would not convert to a path — a packaging
+        // problem that reads as a user error. stderr, because stdout is the MCP
+        // protocol channel.
+        process.stderr.write(`[bli-cockpit-mcp] session helper unresolvable: module URL is not a file path (${error instanceof Error ? `${error.name}: ${error.message}`.slice(0, 250) : String(error).slice(0, 250)})\n`);
+        return null;
+    }
+    // Cap the walk at a reasonable depth to avoid pathological cases.
+    for (let i = 0; i < 10; i++) {
+        const candidate = path.join(current, "scripts", HELPER_BASENAME);
+        if (exists(candidate))
+            return path.resolve(candidate);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break; // hit filesystem root
+        current = parent;
+    }
+    return null;
+}
+/**
+ * Build a `TokenResolver` using the documented precedence order:
+ *   1. `BLI_OPERATOR_TOKEN` env var (verbatim)
+ *   2. Session helper (`scripts/bli-event-session.mjs get-token`)
+ *
+ * Throws with a clear, user-actionable message when neither path is
+ * available (no env var, and no session helper on disk).
+ */
+export function createDefaultTokenResolver(options = {}) {
+    const env = options.env ?? process.env;
+    const envToken = env.BLI_OPERATOR_TOKEN;
+    if (envToken && envToken.length > 0) {
+        return {
+            resolver: createEnvTokenResolver(envToken),
+            source: "env",
+        };
+    }
+    const helperPath = (options.resolveHelperPath ?? (() => resolveSessionHelperPath({ env })))();
+    if (!helperPath) {
+        const hint = env.BLI_SESSION_HELPER
+            ? `BLI_SESSION_HELPER=${env.BLI_SESSION_HELPER} does not point at a readable file`
+            : "set BLI_OPERATOR_TOKEN, or set BLI_SESSION_HELPER to the absolute path of bli-event-session.mjs, or run this MCP from inside the bli-cockpit repo where scripts/bli-event-session.mjs is discoverable";
+        throw new Error(`No auth available: ${hint}. Run 'bli-event login' once to create a session file.`);
+    }
+    const resolver = createSessionHelperTokenResolver({
+        helperPath,
+        spawn: options.spawn,
+        nodePath: options.nodePath,
+        cacheTtlMs: options.cacheTtlMs,
+        now: options.now,
+        env,
+    });
+    return { resolver, source: "session-helper", helperPath };
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@bli-cockpit/mcp",
+  "version": "0.1.0",
+  "private": false,
+  "description": "bli-tower — an MCP server over BLI Cockpit's docs/msg agent doors (docs_*, msg_*), plus the legacy event-stream tools (emit_event, get_ticket_timeline, get_active_tickets).",
+  "type": "module",
+  "bin": {
+    "bli-cockpit-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prebuild": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/telemetry-core",
+    "build": "tsc",
+    "prepack": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/telemetry-core && rm -rf dist && tsc",
+    "pretypecheck": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/telemetry-core",
+    "typecheck": "tsc --noEmit",
+    "pretest": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/telemetry-core",
+    "test": "vitest run",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@bli-cockpit/telemetry-core": "0.1.28",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5",
+    "vitest": "^3.2.4"
+  }
+}