@modootoday/datalab-extension-mcp 1.8.11 → 1.8.13

package/dist/{chunk-Q6SOGGKF.js → chunk-QHEJF6FK.js}

@@ -1,15 +1,5 @@
-// ../mcp-server/dist/chunk-377F4BGN.js
+// ../mcp-server/dist/chunk-HS7SL22A.js
 import { createHash } from "crypto";
-import { createHash as createHash2, randomUUID } from "crypto";
-import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
-import { join } from "path";
-import {
-  createServer
-} from "http";
-import { pipeline } from "stream/promises";
-import { constants } from "fs";
-import { lstat, open } from "fs/promises";
-import { basename, isAbsolute } from "path";
 import {
   appendFileSync,
   mkdirSync,
@@ -18,14 +8,24 @@ import {
   statSync
 } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join } from "path";
+import { randomBytes } from "crypto";
+import { readFileSync } from "fs";
+import { mkdir, rename, writeFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { createHash as createHash2, randomUUID } from "crypto";
+import { mkdir as mkdir2, readFile, readdir, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import {
+  createServer
+} from "http";
+import { pipeline } from "stream/promises";
+import { constants } from "fs";
+import { lstat, open } from "fs/promises";
+import { basename, isAbsolute } from "path";
 import { createConnection } from "net";
 import { spawn } from "child_process";
 import { closeSync } from "fs";
-import { randomBytes } from "crypto";
-import { readFileSync } from "fs";
-import { mkdir as mkdir2, rename, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join3 } from "path";
 import { createRequire } from "module";
 import { join as join4 } from "path";
 var __defProp = Object.defineProperty;
@@ -16334,62 +16334,419 @@ var BridgeError = class extends Error {
     if (timing) this.timing = timing;
   }
 };
-var MAX_STAGE_BYTES = 10 * 1024 * 1024;
-var DEFAULT_TOKEN_TTL_MS = 30 * 60 * 1e3;
-var STAGE_CAPABILITY = "datalab-mcp-stage-v1";
-function refuse(reason, retryable, message) {
-  return { state: "REFUSED", reason, retryable, message };
+var LOG_MAX_BYTES = 1024 * 1024;
+var DIR_NAME = ".datalab-mcp";
+var FILE_NAME = "connector.log";
+function logDir(home = homedir()) {
+  return join(home, DIR_NAME);
 }
-function segment(...parts) {
-  return createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
+function logPath(home = homedir()) {
+  return join(logDir(home), FILE_NAME);
 }
-function createMediaStage(opts) {
-  const now = opts.now ?? Date.now;
-  const ttl = opts.tokenTtlMs ?? DEFAULT_TOKEN_TTL_MS;
-  const ledgerDir = join(opts.root, "ledger");
-  const blobDir = join(opts.root, "blob");
-  const tokens = /* @__PURE__ */ new Map();
-  const active = /* @__PURE__ */ new Map();
-  const keyOf = (j) => segment(j.blogId, j.runId, j.actionId, j.jobId);
-  const ledgerPath2 = (key) => join(ledgerDir, `${key}.json`);
-  const blobPath = (key) => join(blobDir, key);
-  async function readRow(key) {
-    try {
-      const raw = await readFile(ledgerPath2(key), "utf8");
-      return JSON.parse(raw);
-    } catch (err) {
-      if (err.code === "ENOENT") return null;
-      return "unreadable";
+function rolledLogPath(home = homedir()) {
+  return `${logPath(home)}.1`;
+}
+function rollIfLarge(home = homedir(), maxBytes = LOG_MAX_BYTES) {
+  try {
+    const size = statSync(logPath(home)).size;
+    if (size < maxBytes) return false;
+    renameSync(logPath(home), rolledLogPath(home));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openLogFd(home = homedir()) {
+  try {
+    mkdirSync(logDir(home), { recursive: true });
+    rollIfLarge(home);
+    return openSync(logPath(home), "a");
+  } catch {
+    return null;
+  }
+}
+var FILE_NAME2 = "browsers.json";
+function ledgerPath(home) {
+  return join2(logDir(home), FILE_NAME2);
+}
+function isRegistration(row) {
+  if (typeof row !== "object" || row === null) return false;
+  const r = row;
+  const id = r["browserId"];
+  const hash2 = r["tokenHash"];
+  return (id === null || typeof id === "string" && id.length > 0) && typeof hash2 === "string" && /^[a-f0-9]{64}$/.test(hash2) && typeof r["label"] === "string" && typeof r["createdAt"] === "string";
+}
+function readLedger(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { state: "absent" };
     }
+    return { state: "unreadable", reason: describe3(err) };
   }
-  async function writeRow(key, row) {
-    await mkdir(ledgerDir, { recursive: true });
-    await writeFile(ledgerPath2(key), JSON.stringify(row), "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { state: "unreadable", reason: describe3(err) };
+  }
+  if (!Array.isArray(parsed)) {
+    return { state: "unreadable", reason: "not a list of browsers" };
+  }
+  if (!parsed.every(isRegistration)) {
+    return { state: "unreadable", reason: "a row is not a browser" };
+  }
+  const browserIds = /* @__PURE__ */ new Set();
+  const tokenHashes = /* @__PURE__ */ new Set();
+  for (const row of parsed) {
+    if (tokenHashes.has(row.tokenHash) || row.browserId !== null && browserIds.has(row.browserId)) {
+      return { state: "unreadable", reason: "duplicate browser authority" };
+    }
+    tokenHashes.add(row.tokenHash);
+    if (row.browserId !== null) browserIds.add(row.browserId);
+  }
+  return { state: "ok", rows: parsed };
+}
+function ledgerOverlapsToken(rows, tokenHash) {
+  return rows.some((row) => row.tokenHash === tokenHash);
+}
+async function writeLedger(path, claims) {
+  const queued = (writing.get(path) ?? Promise.resolve()).then(
+    () => writeOnce(path, claims),
+    () => writeOnce(path, claims)
+  );
+  writing.set(path, queued);
+  try {
+    await queued;
+  } finally {
+    if (writing.get(path) === queued) writing.delete(path);
+  }
+}
+var writing = /* @__PURE__ */ new Map();
+async function writeOnce(path, claims) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(tmp, `${JSON.stringify(claims, null, 2)}
+`, {
+    mode: 384
+  });
+  await rename(tmp, path);
+}
+function claimedDigestsFrom(claims) {
+  const pairs = [];
+  for (const claim of claims) {
+    if (claim.browserId !== null && claim.browserId.length > 0) {
+      pairs.push([claim.browserId, claim.tokenHash]);
+    }
+  }
+  return pairs;
+}
+function describe3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var HANDLE_LENGTH = 8;
+var BrowserRegistryError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "BrowserRegistryError";
+    this.code = code;
   }
+};
+function mintToken() {
+  return randomBytes(32).toString("hex");
+}
+function handleOf(claim) {
+  return claim.tokenHash.slice(0, HANDLE_LENGTH);
+}
+function matches(claim, handle) {
+  return handleOf(claim) === handle || claim.browserId === handle;
+}
+function createBrowserRegistry(opts) {
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const revoked = /* @__PURE__ */ new Set();
+  const initial = readLedger(opts.path);
+  const unreadable = initial.state === "unreadable" ? initial.reason : null;
+  let rows = initial.state === "ok" ? initial.rows.map((row) => ({ ...row })) : [];
+  let mutationTail = Promise.resolve();
+  let pendingMutations = 0;
+  const view = (source = rows) => {
+    if (unreadable !== null) {
+      throw new Error(`browser registry is unreadable: ${unreadable}`);
+    }
+    if (!opts.forbiddenTokenHash) return { rows: [...source], quarantined: [] };
+    const quarantined = source.filter(
+      (row) => timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
+    );
+    return {
+      rows: source.filter(
+        (row) => !timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
+      ),
+      quarantined
+    };
+  };
+  const current = () => view().rows;
+  const serialize = (work) => {
+    pendingMutations += 1;
+    const result = mutationTail.then(work, work);
+    mutationTail = result.then(
+      () => {
+        pendingMutations -= 1;
+      },
+      () => {
+        pendingMutations -= 1;
+      }
+    );
+    return result;
+  };
+  const transact = (propose) => {
+    if (unreadable !== null) {
+      return Promise.reject(
+        new Error(`browser registry is unreadable: ${unreadable}`)
+      );
+    }
+    return serialize(async () => {
+      const proposal = propose(rows.map((row) => ({ ...row })));
+      await writeLedger(opts.path, proposal.next);
+      rows = proposal.next;
+      proposal.commit?.();
+      return proposal.result;
+    });
+  };
   return {
-    async begin(req) {
-      const key = keyOf(req);
-      const row = await readRow(key);
-      if (row === "unreadable") {
-        return refuse("uploads_unproven", true, "\uC791\uC5C5 \uC0C1\uD0DC\uB97C \uC77D\uC9C0 \uBABB\uD588\uC5B4\uC694.");
+    async add(label) {
+      const token = mintToken();
+      const claim = {
+        browserId: null,
+        tokenHash: digestToken(token),
+        label,
+        createdAt: now().toISOString()
+      };
+      return transact((snapshot) => ({
+        next: [...snapshot, claim],
+        result: { handle: handleOf(claim), token }
+      }));
+    },
+    async list() {
+      return current().map((claim) => ({
+        handle: handleOf(claim),
+        label: claim.label,
+        browserId: claim.browserId,
+        createdAt: claim.createdAt
+      }));
+    },
+    claim(browserId, tokenHash) {
+      if (pendingMutations > 0) return false;
+      if (opts.claimed.has(browserId)) return false;
+      for (const held of opts.claimed.values()) {
+        if (timingSafeEqual(held, tokenHash)) return false;
       }
-      if (row) {
-        if (req.fence < row.fence) {
-          return refuse(
-            "stale_fence",
-            false,
-            "\uB354 \uC0C8\uB85C\uC6B4 \uC2DC\uB3C4\uAC00 \uC774\uBBF8 \uC9C4\uD589\uB410\uC5B4\uC694."
-          );
-        }
-        if (row.state === "SEALED") {
-          return refuse("already_sealed", false, "\uC774\uBBF8 \uBD09\uC778\uB41C \uC790\uC0B0\uC774\uC5D0\uC694.");
-        }
-        if (row.state === "OPEN") {
-          for (const [token2, held] of tokens) {
-            if (held.key === key && held.expiresAt > now()) {
-              return {
-                state: "OPEN",
-                jobId: req.jobId,
+      let claims;
+      try {
+        claims = current();
+      } catch {
+        return false;
+      }
+      const row = claims.find(
+        (claim) => claim.browserId === null && timingSafeEqual(claim.tokenHash, tokenHash)
+      );
+      if (!row) return false;
+      const stored = rows.find((claim) => claim.tokenHash === row.tokenHash);
+      if (!stored) return false;
+      stored.browserId = browserId;
+      opts.claimed.set(browserId, row.tokenHash);
+      opts.onClaim?.(browserId, stored.label);
+      const snapshot = rows.map((entry) => ({ ...entry }));
+      void serialize(async () => {
+        try {
+          await writeLedger(opts.path, snapshot);
+        } catch (error51) {
+          if (stored.browserId === browserId) stored.browserId = null;
+          if (opts.claimed.get(browserId) === row.tokenHash) {
+            opts.claimed.delete(browserId);
+            opts.onRevoke?.(browserId);
+          }
+          throw error51;
+        }
+      }).catch(() => void 0);
+      return true;
+    },
+    async revoke(handle) {
+      return transact((snapshot) => {
+        const claims = view(snapshot).rows;
+        const removed = claims.filter((claim) => matches(claim, handle));
+        if (removed.length === 0) {
+          return { next: snapshot, result: false };
+        }
+        const removedHashes = new Set(removed.map((claim) => claim.tokenHash));
+        return {
+          next: snapshot.filter((claim) => !removedHashes.has(claim.tokenHash)),
+          result: true,
+          commit: () => {
+            for (const claim of removed) {
+              revoked.add(claim.tokenHash);
+              if (claim.browserId !== null) {
+                opts.claimed.delete(claim.browserId);
+                opts.onRevoke?.(claim.browserId);
+              }
+            }
+          }
+        };
+      });
+    },
+    async repair() {
+      return transact((snapshot) => {
+        const currentView = view(snapshot);
+        const removed = currentView.quarantined.map(handleOf);
+        const removedHashes = new Set(
+          currentView.quarantined.map((row) => row.tokenHash)
+        );
+        return {
+          next: snapshot.filter((row) => !removedHashes.has(row.tokenHash)),
+          result: { removed }
+        };
+      });
+    },
+    async repairRegistration(browserId, requestedLabel) {
+      if (browserId.length === 0) {
+        throw new BrowserRegistryError("registration_not_found");
+      }
+      return transact((snapshot) => {
+        const currentView = view(snapshot);
+        if (currentView.rows.some((row) => row.browserId === browserId)) {
+          throw new BrowserRegistryError("registration_already_valid");
+        }
+        const quarantined = currentView.quarantined.filter(
+          (row) => row.browserId === browserId
+        );
+        if (quarantined.length === 0) {
+          throw new BrowserRegistryError(
+            currentView.quarantined.length > 0 ? "registration_not_quarantined" : "registration_not_found"
+          );
+        }
+        const token = mintToken();
+        const tokenHash = digestToken(token);
+        const label = requestedLabel?.trim() || quarantined[0]?.label || "\uC774 \uBE0C\uB77C\uC6B0\uC800";
+        const removedHashes = new Set(quarantined.map((row) => row.tokenHash));
+        const next = {
+          browserId: null,
+          tokenHash,
+          label,
+          createdAt: now().toISOString()
+        };
+        return {
+          next: [
+            ...snapshot.filter((row) => !removedHashes.has(row.tokenHash)),
+            next
+          ],
+          result: {
+            outcome: "repaired",
+            removed: quarantined.map(handleOf),
+            registration: { handle: handleOf(next), label, token }
+          },
+          commit: () => {
+            for (const row of quarantined) {
+              revoked.add(row.tokenHash);
+              if (row.browserId !== null && opts.claimed.get(row.browserId) === row.tokenHash) {
+                opts.claimed.delete(row.browserId);
+                opts.onRevoke?.(row.browserId);
+              }
+            }
+          }
+        };
+      });
+    },
+    status() {
+      if (unreadable !== null) {
+        return {
+          state: "disabled",
+          error: "browser_registry_unreadable",
+          detail: unreadable
+        };
+      }
+      if (opts.forbiddenTokenHash && ledgerOverlapsToken(rows, opts.forbiddenTokenHash)) {
+        return {
+          state: "degraded",
+          error: "browser_registry_root_authority_overlap",
+          quarantinedHandles: rows.filter(
+            (row) => timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
+          ).map(handleOf),
+          quarantined: rows.filter(
+            (row) => timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
+          ).map((row) => ({
+            handle: handleOf(row),
+            label: row.label,
+            browserId: row.browserId,
+            createdAt: row.createdAt
+          })),
+          recovery: "repair_registration"
+        };
+      }
+      return { state: "ready" };
+    },
+    wasRevoked(tokenHash) {
+      return revoked.has(tokenHash);
+    }
+  };
+}
+var MAX_STAGE_BYTES = 10 * 1024 * 1024;
+var DEFAULT_TOKEN_TTL_MS = 30 * 60 * 1e3;
+var STAGE_CAPABILITY = "datalab-mcp-stage-v1";
+function refuse(reason, retryable, message) {
+  return { state: "REFUSED", reason, retryable, message };
+}
+function segment(...parts) {
+  return createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
+}
+function createMediaStage(opts) {
+  const now = opts.now ?? Date.now;
+  const ttl = opts.tokenTtlMs ?? DEFAULT_TOKEN_TTL_MS;
+  const ledgerDir = join3(opts.root, "ledger");
+  const blobDir = join3(opts.root, "blob");
+  const tokens = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Map();
+  const keyOf = (j) => segment(j.blogId, j.runId, j.actionId, j.jobId);
+  const ledgerPath2 = (key) => join3(ledgerDir, `${key}.json`);
+  const blobPath = (key) => join3(blobDir, key);
+  async function readRow(key) {
+    try {
+      const raw = await readFile(ledgerPath2(key), "utf8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return "unreadable";
+    }
+  }
+  async function writeRow(key, row) {
+    await mkdir2(ledgerDir, { recursive: true });
+    await writeFile2(ledgerPath2(key), JSON.stringify(row), "utf8");
+  }
+  return {
+    async begin(req) {
+      const key = keyOf(req);
+      const row = await readRow(key);
+      if (row === "unreadable") {
+        return refuse("uploads_unproven", true, "\uC791\uC5C5 \uC0C1\uD0DC\uB97C \uC77D\uC9C0 \uBABB\uD588\uC5B4\uC694.");
+      }
+      if (row) {
+        if (req.fence < row.fence) {
+          return refuse(
+            "stale_fence",
+            false,
+            "\uB354 \uC0C8\uB85C\uC6B4 \uC2DC\uB3C4\uAC00 \uC774\uBBF8 \uC9C4\uD589\uB410\uC5B4\uC694."
+          );
+        }
+        if (row.state === "SEALED") {
+          return refuse("already_sealed", false, "\uC774\uBBF8 \uBD09\uC778\uB41C \uC790\uC0B0\uC774\uC5D0\uC694.");
+        }
+        if (row.state === "OPEN") {
+          for (const [token2, held] of tokens) {
+            if (held.key === key && held.expiresAt > now()) {
+              return {
+                state: "OPEN",
+                jobId: req.jobId,
                 uploadToken: token2,
                 expiresAt: held.expiresAt,
                 capabilityVersion: STAGE_CAPABILITY
@@ -16424,7 +16781,7 @@ function createMediaStage(opts) {
       }
       active.set(held.key, (active.get(held.key) ?? 0) + 1);
       try {
-        await mkdir(blobDir, { recursive: true });
+        await mkdir2(blobDir, { recursive: true });
         const chunks = [];
         let total = 0;
         for await (const chunk of body) {
@@ -16435,7 +16792,7 @@ function createMediaStage(opts) {
           }
           chunks.push(buf);
         }
-        await writeFile(blobPath(held.key), Buffer.concat(chunks));
+        await writeFile2(blobPath(held.key), Buffer.concat(chunks));
         return { ok: true, bytes: total };
       } finally {
         const left = (active.get(held.key) ?? 1) - 1;
@@ -16568,7 +16925,7 @@ function createMediaStage(opts) {
       const out = [];
       for (const dir of [ledgerDir, blobDir]) {
         try {
-          for (const name of await readdir(dir)) out.push(join(dir, name));
+          for (const name of await readdir(dir)) out.push(join3(dir, name));
         } catch {
         }
       }
@@ -16838,7 +17195,15 @@ async function handleMcpRequest(bridge, body, accept, stage) {
     }
     if (params.name === BROWSERS_TOOL) {
       const registryStatus = bridge.browserRegistryStatus();
-      const { state: registryState, ...registryDetail } = registryStatus;
+      const { state: registryState } = registryStatus;
+      const registryDetail = registryStatus.state === "degraded" ? {
+        error: registryStatus.error,
+        quarantinedHandles: registryStatus.quarantinedHandles,
+        recovery: registryStatus.recovery
+      } : registryStatus.state === "disabled" ? {
+        error: registryStatus.error,
+        detail: registryStatus.detail
+      } : {};
       const payload = {
         browsers: bridge.connectedBrowsers(),
         registryStatus: registryState,
@@ -17018,6 +17383,11 @@ async function openLocalImage(path) {
     };
   }
 }
+var MCP_SERVER_HEALTH_NAME = "datalab-extension-mcp-server";
+var MCP_SERVER_HEALTH_SCHEMA = "datalab-extension-mcp-health-v1";
+var MCP_MANAGEMENT_CAPABILITIES = Object.freeze([
+  "browser-registration-repair-v1"
+]);
 var MAX_BODY_BYTES = 64 * 1024;
 var DEFAULT_TOOLS_CHANGED_DEBOUNCE_MS = 600;
 var MAX_MCP_BODY_BYTES2 = 256 * 1024;
@@ -17188,8 +17558,9 @@ function createHttpBridge(opts) {
     }
     if (req.method === "GET" && url2.pathname === "/bridge/health") {
       json2(res, 200, {
-        name: opts.identity.name,
-        version: opts.identity.version
+        name: MCP_SERVER_HEALTH_NAME,
+        version: opts.identity.version,
+        schema: MCP_SERVER_HEALTH_SCHEMA
       });
       return;
     }
@@ -17284,6 +17655,7 @@ function createHttpBridge(opts) {
         json2(res, 404, { error: "not found" });
         return;
       }
+      res.setHeader("cache-control", "no-store");
       void readJson(req, MAX_BODY_BYTES).then(async (body) => {
         const b = body;
         if (!opts.bridge.verifyRootToken(
@@ -17304,7 +17676,8 @@ function createHttpBridge(opts) {
           json2(res, 200, {
             ok: true,
             browsers,
-            registryStatus: registry2.status()
+            registryStatus: registry2.status(),
+            capabilities: [...MCP_MANAGEMENT_CAPABILITIES]
           });
           return;
         }
@@ -17325,10 +17698,33 @@ function createHttpBridge(opts) {
           json2(res, 200, { ok: true, ...await registry2.repair() });
           return;
         }
+        if (action === "repair_registration") {
+          const browserId = typeof b?.["browserId"] === "string" ? b["browserId"] : "";
+          const label = typeof b?.["label"] === "string" ? b["label"] : void 0;
+          const repaired = await registry2.repairRegistration(
+            browserId,
+            label
+          );
+          json2(res, 200, {
+            ok: true,
+            ...repaired,
+            registryStatus: registry2.status(),
+            capabilities: [...MCP_MANAGEMENT_CAPABILITIES]
+          });
+          return;
+        }
         json2(res, 400, { error: "unknown action" });
       }).catch((err) => {
         const why = err instanceof Error ? err.message : String(err);
         opts.log?.(`browsers route failed: ${why}`);
+        if (err instanceof BrowserRegistryError) {
+          json2(res, err.code === "registration_not_found" ? 404 : 409, {
+            error: err.code,
+            detail: err.code,
+            capabilities: [...MCP_MANAGEMENT_CAPABILITIES]
+          });
+          return;
+        }
         json2(res, 400, { error: "bad request", detail: why });
       });
       return;
@@ -17630,37 +18026,6 @@ function parsePort(raw) {
   if (!Number.isInteger(n) || n < 1 || n > 65535) return null;
   return n;
 }
-var LOG_MAX_BYTES = 1024 * 1024;
-var DIR_NAME = ".datalab-mcp";
-var FILE_NAME = "connector.log";
-function logDir(home = homedir()) {
-  return join2(home, DIR_NAME);
-}
-function logPath(home = homedir()) {
-  return join2(logDir(home), FILE_NAME);
-}
-function rolledLogPath(home = homedir()) {
-  return `${logPath(home)}.1`;
-}
-function rollIfLarge(home = homedir(), maxBytes = LOG_MAX_BYTES) {
-  try {
-    const size = statSync(logPath(home)).size;
-    if (size < maxBytes) return false;
-    renameSync(logPath(home), rolledLogPath(home));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function openLogFd(home = homedir()) {
-  try {
-    mkdirSync(logDir(home), { recursive: true });
-    rollIfLarge(home);
-    return openSync(logPath(home), "a");
-  } catch {
-    return null;
-  }
-}
 function tryConnect(host, port, timeoutMs, deps = {}) {
   const connect = deps.createConnection ?? createConnection;
   return new Promise((resolve) => {
@@ -17775,268 +18140,7 @@ var Lifecycle = class {
     }
   }
 };
-var FILE_NAME2 = "browsers.json";
-function ledgerPath(home) {
-  return join3(logDir(home), FILE_NAME2);
-}
-function isRegistration(row) {
-  if (typeof row !== "object" || row === null) return false;
-  const r = row;
-  const id = r["browserId"];
-  const hash2 = r["tokenHash"];
-  return (id === null || typeof id === "string" && id.length > 0) && typeof hash2 === "string" && /^[a-f0-9]{64}$/.test(hash2) && typeof r["label"] === "string" && typeof r["createdAt"] === "string";
-}
-function readLedger(path) {
-  let raw;
-  try {
-    raw = readFileSync(path, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return { state: "absent" };
-    }
-    return { state: "unreadable", reason: describe3(err) };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    return { state: "unreadable", reason: describe3(err) };
-  }
-  if (!Array.isArray(parsed)) {
-    return { state: "unreadable", reason: "not a list of browsers" };
-  }
-  if (!parsed.every(isRegistration)) {
-    return { state: "unreadable", reason: "a row is not a browser" };
-  }
-  const browserIds = /* @__PURE__ */ new Set();
-  const tokenHashes = /* @__PURE__ */ new Set();
-  for (const row of parsed) {
-    if (tokenHashes.has(row.tokenHash) || row.browserId !== null && browserIds.has(row.browserId)) {
-      return { state: "unreadable", reason: "duplicate browser authority" };
-    }
-    tokenHashes.add(row.tokenHash);
-    if (row.browserId !== null) browserIds.add(row.browserId);
-  }
-  return { state: "ok", rows: parsed };
-}
-function ledgerOverlapsToken(rows, tokenHash) {
-  return rows.some((row) => row.tokenHash === tokenHash);
-}
-async function writeLedger(path, claims) {
-  const queued = (writing.get(path) ?? Promise.resolve()).then(
-    () => writeOnce(path, claims),
-    () => writeOnce(path, claims)
-  );
-  writing.set(path, queued);
-  try {
-    await queued;
-  } finally {
-    if (writing.get(path) === queued) writing.delete(path);
-  }
-}
-var writing = /* @__PURE__ */ new Map();
-async function writeOnce(path, claims) {
-  const tmp = `${path}.${process.pid}.tmp`;
-  await mkdir2(dirname(path), { recursive: true, mode: 448 });
-  await writeFile2(tmp, `${JSON.stringify(claims, null, 2)}
-`, {
-    mode: 384
-  });
-  await rename(tmp, path);
-}
-function claimedDigestsFrom(claims) {
-  const pairs = [];
-  for (const claim of claims) {
-    if (claim.browserId !== null && claim.browserId.length > 0) {
-      pairs.push([claim.browserId, claim.tokenHash]);
-    }
-  }
-  return pairs;
-}
-function describe3(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-var HANDLE_LENGTH = 8;
-function mintToken() {
-  return randomBytes(32).toString("hex");
-}
-function handleOf(claim) {
-  return claim.tokenHash.slice(0, HANDLE_LENGTH);
-}
-function matches(claim, handle) {
-  return handleOf(claim) === handle || claim.browserId === handle;
-}
-function createBrowserRegistry(opts) {
-  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
-  const revoked = /* @__PURE__ */ new Set();
-  const initial = readLedger(opts.path);
-  const unreadable = initial.state === "unreadable" ? initial.reason : null;
-  let rows = initial.state === "ok" ? initial.rows.map((row) => ({ ...row })) : [];
-  let mutationTail = Promise.resolve();
-  let pendingMutations = 0;
-  const view = (source = rows) => {
-    if (unreadable !== null) {
-      throw new Error(`browser registry is unreadable: ${unreadable}`);
-    }
-    if (!opts.forbiddenTokenHash) return { rows: [...source], quarantined: [] };
-    const quarantined = source.filter(
-      (row) => timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
-    );
-    return {
-      rows: source.filter(
-        (row) => !timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
-      ),
-      quarantined
-    };
-  };
-  const current = () => view().rows;
-  const serialize = (work) => {
-    pendingMutations += 1;
-    const result = mutationTail.then(work, work);
-    mutationTail = result.then(
-      () => {
-        pendingMutations -= 1;
-      },
-      () => {
-        pendingMutations -= 1;
-      }
-    );
-    return result;
-  };
-  const transact = (propose) => {
-    if (unreadable !== null) {
-      return Promise.reject(
-        new Error(`browser registry is unreadable: ${unreadable}`)
-      );
-    }
-    return serialize(async () => {
-      const proposal = propose(rows.map((row) => ({ ...row })));
-      await writeLedger(opts.path, proposal.next);
-      rows = proposal.next;
-      proposal.commit?.();
-      return proposal.result;
-    });
-  };
-  return {
-    async add(label) {
-      const token = mintToken();
-      const claim = {
-        browserId: null,
-        tokenHash: digestToken(token),
-        label,
-        createdAt: now().toISOString()
-      };
-      return transact((snapshot) => ({
-        next: [...snapshot, claim],
-        result: { handle: handleOf(claim), token }
-      }));
-    },
-    async list() {
-      return current().map((claim) => ({
-        handle: handleOf(claim),
-        label: claim.label,
-        browserId: claim.browserId,
-        createdAt: claim.createdAt
-      }));
-    },
-    claim(browserId, tokenHash) {
-      if (pendingMutations > 0) return false;
-      if (opts.claimed.has(browserId)) return false;
-      for (const held of opts.claimed.values()) {
-        if (timingSafeEqual(held, tokenHash)) return false;
-      }
-      let claims;
-      try {
-        claims = current();
-      } catch {
-        return false;
-      }
-      const row = claims.find(
-        (claim) => claim.browserId === null && timingSafeEqual(claim.tokenHash, tokenHash)
-      );
-      if (!row) return false;
-      const stored = rows.find((claim) => claim.tokenHash === row.tokenHash);
-      if (!stored) return false;
-      stored.browserId = browserId;
-      opts.claimed.set(browserId, row.tokenHash);
-      opts.onClaim?.(browserId, stored.label);
-      const snapshot = rows.map((entry) => ({ ...entry }));
-      void serialize(async () => {
-        try {
-          await writeLedger(opts.path, snapshot);
-        } catch (error51) {
-          if (stored.browserId === browserId) stored.browserId = null;
-          if (opts.claimed.get(browserId) === row.tokenHash) {
-            opts.claimed.delete(browserId);
-            opts.onRevoke?.(browserId);
-          }
-          throw error51;
-        }
-      }).catch(() => void 0);
-      return true;
-    },
-    async revoke(handle) {
-      return transact((snapshot) => {
-        const claims = view(snapshot).rows;
-        const removed = claims.filter((claim) => matches(claim, handle));
-        if (removed.length === 0) {
-          return { next: snapshot, result: false };
-        }
-        const removedHashes = new Set(removed.map((claim) => claim.tokenHash));
-        return {
-          next: snapshot.filter((claim) => !removedHashes.has(claim.tokenHash)),
-          result: true,
-          commit: () => {
-            for (const claim of removed) {
-              revoked.add(claim.tokenHash);
-              if (claim.browserId !== null) {
-                opts.claimed.delete(claim.browserId);
-                opts.onRevoke?.(claim.browserId);
-              }
-            }
-          }
-        };
-      });
-    },
-    async repair() {
-      return transact((snapshot) => {
-        const currentView = view(snapshot);
-        const removed = currentView.quarantined.map(handleOf);
-        const removedHashes = new Set(
-          currentView.quarantined.map((row) => row.tokenHash)
-        );
-        return {
-          next: snapshot.filter((row) => !removedHashes.has(row.tokenHash)),
-          result: { removed }
-        };
-      });
-    },
-    status() {
-      if (unreadable !== null) {
-        return {
-          state: "disabled",
-          error: "browser_registry_unreadable",
-          detail: unreadable
-        };
-      }
-      if (opts.forbiddenTokenHash && ledgerOverlapsToken(rows, opts.forbiddenTokenHash)) {
-        return {
-          state: "degraded",
-          error: "browser_registry_root_authority_overlap",
-          quarantinedHandles: rows.filter(
-            (row) => timingSafeEqual(row.tokenHash, opts.forbiddenTokenHash)
-          ).map(handleOf),
-          recovery: "browsers repair"
-        };
-      }
-      return { state: "ready" };
-    },
-    wasRevoked(tokenHash) {
-      return revoked.has(tokenHash);
-    }
-  };
-}
-var NAME = "datalab-extension-mcp-server";
+var NAME = MCP_SERVER_HEALTH_NAME;
 function readVersion() {
   return createRequire(import.meta.url)("../package.json").version;
 }