honeybook-mcp 0.3.2 → 0.3.3

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "HoneyBook client-portal tools for Claude Code",
-    "version": "0.3.2"
+    "version": "0.3.3"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "HoneyBook",
       "source": "./",
       "description": "HoneyBook client-portal MCP for Claude — view wedding-vendor contracts and invoices via MCP",
-      "version": "0.3.2",
+      "version": "0.3.3",
       "author": {
         "name": "Chris Chall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "honeybook",
   "displayName": "HoneyBook",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "HoneyBook client-portal MCP for Claude — view wedding-vendor contracts and invoices via MCP",
   "author": {
     "name": "Chris Chall",

package/dist/auth.js

@@ -57,15 +57,12 @@
 //     verify the captured session round-trips through sessionStore.get.
 import { bootstrap } from '@fetchproxy/bootstrap';
 import { bridgeErrorInfo } from '@chrischall/mcp-utils/fetchproxy';
-import { readEnvVar } from '@chrischall/mcp-utils';
+import { parseBoolEnv } from '@chrischall/mcp-utils';
 import pkg from '../package.json' with { type: 'json' };
 import { sessionStore, normalizeOrigin } from './sessions.js';
 /** True if the user has explicitly disabled the fetchproxy capture path. */
 function fetchproxyDisabled() {
-    const raw = readEnvVar('HONEYBOOK_DISABLE_FETCHPROXY');
-    if (raw === undefined)
-        return false;
-    return ['1', 'true', 'yes', 'on'].includes(raw.toLowerCase());
+    return parseBoolEnv('HONEYBOOK_DISABLE_FETCHPROXY');
 }
 /**
  * Capture a HoneyBook portal session by reading the user's signed-in

package/dist/bundle.js

@@ -34684,22 +34684,30 @@ async function runMcp(opts) {
   return server;
 }
 
-// node_modules/@chrischall/mcp-utils/dist/response/index.js
-function textResult(data) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-  };
-}
-function rawTextResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-
 // node_modules/@chrischall/mcp-utils/dist/errors/index.js
 var DEFAULT_ERROR_MESSAGE_MAX = 500;
 var BEARER_RE = /(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
 var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{8,}\b/g;
+var BASIC_AUTH_RE = /(authorization\s*:\s*basic\s+)[A-Za-z0-9+/=_-]{6,}/gi;
+var SET_COOKIE_RE = /(\bset-cookie\s*:\s*)([^=;,\s]+)=[^;,\s]*/gi;
+var COOKIE_HEADER_RE = /((?<!set-)\bcookie\s*:\s*)((?:[^=;,\s]+=[^;,\s]*)(?:;\s*[^=;,\s]+=[^;,\s]*)*)/gi;
+var API_KEY_RE = new RegExp([
+  "sk-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])",
+  // OpenAI / Anthropic (incl. sk-ant-…)
+  "gh[pousr]_[A-Za-z0-9]{36,}\\b",
+  // GitHub ghp_/gho_/ghu_/ghs_/ghr_
+  "xox[baprs]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])",
+  // Slack
+  "AIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])",
+  // Google API key (39 chars total)
+  "AKIA[0-9A-Z]{16}\\b",
+  // AWS access key id (20 chars total)
+  "whsec_[A-Za-z0-9]{16,}\\b"
+  // webhook signing secret (Stripe-style)
+].map((p) => `\\b${p}`).join("|"), "g");
+var QUERY_SECRET_RE = /([?&](?:access_token|refresh_token|client_secret|api_?key|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
 function redactSecrets(text) {
-  return text.replace(BEARER_RE, "$1[REDACTED]").replace(JWT_RE, "[REDACTED]");
+  return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(JWT_RE, "[REDACTED]");
 }
 function truncateErrorMessage(text, max = DEFAULT_ERROR_MESSAGE_MAX) {
   const str = text === null || text === void 0 ? "" : String(text);
@@ -34714,6 +34722,16 @@ function messageOf(err) {
   return String(err);
 }
 
+// node_modules/@chrischall/mcp-utils/dist/response/index.js
+function textResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function rawTextResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+
 // node_modules/@chrischall/mcp-utils/dist/config/index.js
 var PLACEHOLDER_RE = /^\$\{[^}]*\}$/;
 function readEnvVar(key, opts = {}) {
@@ -34727,6 +34745,20 @@ function readEnvVar(key, opts = {}) {
   }
   return opts.default;
 }
+var TRUE_TOKENS = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var FALSE_TOKENS = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+function parseBoolEnv(key, opts = {}) {
+  const fallback = opts.default ?? false;
+  const raw = readEnvVar(key, { env: opts.env });
+  if (raw === void 0)
+    return fallback;
+  const token = raw.toLowerCase();
+  if (TRUE_TOKENS.has(token))
+    return true;
+  if (FALSE_TOKENS.has(token))
+    return false;
+  return fallback;
+}
 async function loadDotenvSafely(opts = {}) {
   try {
     const mod = await import(
@@ -34770,107 +34802,155 @@ var pageSchema = {
 };
 
 // src/sessions.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
+
+// node_modules/@chrischall/mcp-utils/dist/session/index.js
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, renameSync } from "node:fs";
+import { dirname } from "node:path";
 function normalizeOrigin(input) {
   try {
-    const url2 = new URL(input);
-    return url2.origin.replace(/\/$/, "");
+    return new URL(input).origin.replace(/\/$/, "");
   } catch {
     return input.replace(/\/$/, "");
   }
 }
-function serializeSessions(sessions) {
-  return JSON.stringify(Array.from(sessions.values()), null, 2);
-}
-function deserializeSessions(body) {
-  try {
-    const arr = JSON.parse(body);
-    if (!Array.isArray(arr)) return /* @__PURE__ */ new Map();
-    const map2 = /* @__PURE__ */ new Map();
-    for (const s of arr) {
-      if (s && typeof s.portalOrigin === "string") {
-        map2.set(s.portalOrigin, s);
-      }
-    }
-    return map2;
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-}
 var SessionStore = class {
-  sessions;
-  mostRecentOrigin;
-  diskPath;
-  constructor(diskPath) {
-    this.diskPath = diskPath ?? join(homedir(), ".honeybook-mcp", "sessions.json");
-    this.sessions = /* @__PURE__ */ new Map();
-    this.mostRecentOrigin = null;
+  sessions = /* @__PURE__ */ new Map();
+  mostRecentKey = null;
+  filePath;
+  keyOf;
+  normalizeKey;
+  constructor(opts) {
+    this.filePath = opts.filePath;
+    this.keyOf = opts.keyOf;
+    this.normalizeKey = opts.normalizeKey ?? normalizeOrigin;
     this.loadFromDisk();
   }
   loadFromDisk() {
-    if (!existsSync(this.diskPath)) return;
+    if (!existsSync(this.filePath))
+      return;
     try {
-      const body = readFileSync(this.diskPath, "utf8");
-      this.sessions = deserializeSessions(body);
-      const last = Array.from(this.sessions.keys()).pop();
-      this.mostRecentOrigin = last ?? null;
-    } catch {
+      this.sessions = this.deserialize(readFileSync(this.filePath, "utf8"));
+      const keys = Array.from(this.sessions.keys());
+      this.mostRecentKey = keys[keys.length - 1] ?? null;
+    } catch (err) {
+      const backupPath = this.preserveCorruptFile();
+      const detail = err instanceof Error ? err.message : String(err);
+      console.error(`[mcp-utils] SessionStore: failed to parse ${this.filePath} (${detail}); ` + (backupPath !== null ? `preserved the corrupt file at ${backupPath}; ` : "could not preserve the corrupt file; ") + "starting with an empty store.");
       this.sessions = /* @__PURE__ */ new Map();
-      this.mostRecentOrigin = null;
+      this.mostRecentKey = null;
+    }
+  }
+  /**
+   * Move a corrupt store file to `<filePath>.corrupt` (or `.corrupt-<n>` if a
+   * previous backup exists) so a subsequent save cannot overwrite the only
+   * copy of the prior credentials. Best-effort: returns the backup path, or
+   * `null` if the rename failed.
+   */
+  preserveCorruptFile() {
+    try {
+      let candidate = `${this.filePath}.corrupt`;
+      for (let n = 1; existsSync(candidate) && n <= 100; n++) {
+        candidate = `${this.filePath}.corrupt-${n}`;
+      }
+      if (existsSync(candidate))
+        return null;
+      renameSync(this.filePath, candidate);
+      return candidate;
+    } catch {
+      return null;
+    }
+  }
+  /** Serialize the store to its on-disk JSON form (array, insertion order). */
+  serialize() {
+    return JSON.stringify(Array.from(this.sessions.values()), null, 2);
+  }
+  /** Parse on-disk JSON back into a keyed `Map`; empty map on invalid input. */
+  deserialize(body) {
+    const map2 = /* @__PURE__ */ new Map();
+    const arr = JSON.parse(body);
+    if (!Array.isArray(arr))
+      return map2;
+    for (const raw of arr) {
+      if (raw && typeof raw === "object") {
+        const s = raw;
+        const key = this.normalizeKey(this.keyOf(s));
+        map2.set(key, s);
+      }
     }
+    return map2;
   }
   saveToDisk() {
-    mkdirSync(dirname(this.diskPath), { recursive: true });
-    writeFileSync(this.diskPath, serializeSessions(this.sessions), { mode: 384 });
+    const dir = dirname(this.filePath);
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    if (existsSync(this.filePath)) {
+      try {
+        chmodSync(this.filePath, 384);
+      } catch {
+      }
+    }
+    writeFileSync(this.filePath, this.serialize(), { mode: 384 });
     try {
-      chmodSync(dirname(this.diskPath), 448);
+      chmodSync(this.filePath, 384);
+      chmodSync(dir, 448);
     } catch {
     }
   }
-  /**
-   * Insert (or replace) a fully-constructed CapturedSession. Used by
-   * `src/auth.ts` after `@fetchproxy/bootstrap` has supplied the
-   * jStorage + fingerprint values from the user's browser tab.
-   *
-   * Marks the session as most-recent so the next tool call that doesn't
-   * pass `origin` picks it up automatically.
-   */
+  /** Insert or replace a record, normalizing its key and marking it active. */
   add(session) {
-    const normalized = normalizeOrigin(session.portalOrigin);
-    const stored = { ...session, portalOrigin: normalized };
-    this.sessions.set(normalized, stored);
-    this.mostRecentOrigin = normalized;
+    const key = this.normalizeKey(this.keyOf(session));
+    this.sessions.set(key, session);
+    this.mostRecentKey = key;
     this.saveToDisk();
   }
-  get(origin) {
-    if (origin) return this.sessions.get(normalizeOrigin(origin)) ?? null;
-    if (this.mostRecentOrigin) return this.sessions.get(this.mostRecentOrigin) ?? null;
+  /** Look up by key; with no key, returns the active (most-recent) session. */
+  get(key) {
+    if (key !== void 0)
+      return this.sessions.get(this.normalizeKey(key)) ?? null;
+    if (this.mostRecentKey !== null)
+      return this.sessions.get(this.mostRecentKey) ?? null;
     return null;
   }
+  /** The most-recently-added session, or `null`. */
+  getActiveSession() {
+    return this.get();
+  }
+  /** All sessions in insertion order. */
   list() {
     return Array.from(this.sessions.values());
   }
-  deactivate(origin) {
-    const normalized = normalizeOrigin(origin);
+  /** Remove a session; fixes up the active pointer. Returns whether it existed. */
+  remove(key) {
+    const normalized = this.normalizeKey(key);
     const had = this.sessions.delete(normalized);
     if (had) {
-      if (this.mostRecentOrigin === normalized) {
-        const remaining = Array.from(this.sessions.keys());
-        this.mostRecentOrigin = remaining[remaining.length - 1] ?? null;
+      if (this.mostRecentKey === normalized) {
+        const keys = Array.from(this.sessions.keys());
+        this.mostRecentKey = keys[keys.length - 1] ?? null;
       }
       this.saveToDisk();
     }
     return had;
   }
-  /** Test-only — clears in-memory state without touching disk. */
+  /** Clear in-memory state without touching disk. Test helper. */
   resetForTest() {
     this.sessions.clear();
-    this.mostRecentOrigin = null;
+    this.mostRecentKey = null;
   }
 };
-var sessionStore = new SessionStore();
+var TOKEN_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+
+// src/sessions.ts
+var sessionsDir = readEnvVar("HONEYBOOK_SESSIONS_DIR", {
+  default: join(homedir(), ".honeybook-mcp")
+});
+var sessionsFilePath = join(sessionsDir, "sessions.json");
+var sessionStore = new SessionStore({
+  filePath: sessionsFilePath,
+  keyOf: (session) => session.portalOrigin,
+  normalizeKey: normalizeOrigin
+});
 
 // src/client.ts
 var API_BASE = "https://api.honeybook.com";
@@ -34958,7 +35038,12 @@ async function getActiveClient(origin) {
   }
   const cached2 = clientCache.get(session.portalOrigin);
   if (cached2) return cached2;
-  if (!moduleState.apiVersionPromise) moduleState.apiVersionPromise = fetchApiVersion();
+  if (!moduleState.apiVersionPromise) {
+    moduleState.apiVersionPromise = fetchApiVersion().catch((err) => {
+      moduleState.apiVersionPromise = null;
+      throw err;
+    });
+  }
   const apiVersion = await moduleState.apiVersionPromise;
   const client = new HoneyBookClient(session, apiVersion);
   clientCache.set(session.portalOrigin, client);
@@ -34974,7 +35059,9 @@ var KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "read_local_storage",
   "read_session_storage",
   "capture_request_header",
-  "read_indexed_db"
+  "capture_redirect",
+  "read_indexed_db",
+  "download"
 ]);
 
 // node_modules/@fetchproxy/protocol/dist/mcp-id.js
@@ -35534,6 +35621,31 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
+  if (raw.op === "capture_redirect") {
+    assertObject(raw.init, "inner.init");
+    if (raw.init.host === void 0) {
+      throw new ProtocolError("inner.init.host: missing");
+    }
+    assertString(raw.init.host, "inner.init.host");
+    if (!HOSTNAME_RE.test(raw.init.host)) {
+      throw new ProtocolError(`inner.init.host: invalid hostname ${JSON.stringify(raw.init.host)}`);
+    }
+    if (raw.init.path !== void 0) {
+      assertString(raw.init.path, "inner.init.path");
+      if (!CAPTURE_PATH_RE.test(raw.init.path)) {
+        throw new ProtocolError(`inner.init.path: must start with '/' ${JSON.stringify(raw.init.path)}`);
+      }
+    }
+    if (raw.init.timeoutMs !== void 0) {
+      assertPositiveInt(raw.init.timeoutMs, "inner.init.timeoutMs");
+    }
+    for (const k of Object.keys(raw.init)) {
+      if (k !== "host" && k !== "path" && k !== "timeoutMs") {
+        throw new ProtocolError(`inner.init: unexpected field ${JSON.stringify(k)} on capture_redirect`);
+      }
+    }
+    return raw;
+  }
   if (raw.op === "read_indexed_db") {
     assertObject(raw.init, "inner.init");
     if (raw.init.origin === void 0)
@@ -35559,7 +35671,32 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
-  throw new ProtocolError(`inner.op: must be one of "fetch", "read_cookies", "read_local_storage", "read_session_storage", "capture_request_header", "read_indexed_db"; got ${JSON.stringify(raw.op)}`);
+  if (raw.op === "download") {
+    assertObject(raw.init, "inner.init");
+    if (raw.init.url === void 0) {
+      throw new ProtocolError("inner.init.url: missing");
+    }
+    assertHttpUrl(raw.init.url, "inner.init.url");
+    if (raw.init.filename !== void 0) {
+      assertString(raw.init.filename, "inner.init.filename");
+      if (/^([/\\]|[A-Za-z]:)/.test(raw.init.filename)) {
+        throw new ProtocolError(`inner.init.filename: must be relative ${JSON.stringify(raw.init.filename)}`);
+      }
+      if (raw.init.filename.split(/[/\\]/).includes("..")) {
+        throw new ProtocolError(`inner.init.filename: must not contain '..' ${JSON.stringify(raw.init.filename)}`);
+      }
+    }
+    if (raw.init.timeoutMs !== void 0) {
+      assertPositiveInt(raw.init.timeoutMs, "inner.init.timeoutMs");
+    }
+    for (const k of Object.keys(raw.init)) {
+      if (k !== "url" && k !== "filename" && k !== "timeoutMs") {
+        throw new ProtocolError(`inner.init: unexpected field ${JSON.stringify(k)} on download`);
+      }
+    }
+    return raw;
+  }
+  throw new ProtocolError(`inner.op: must be one of "fetch", "read_cookies", "read_local_storage", "read_session_storage", "capture_request_header", "capture_redirect", "read_indexed_db", "download"; got ${JSON.stringify(raw.op)}`);
 }
 function assertNonEmptyKeyArray(value, label) {
   if (!Array.isArray(value)) {
@@ -35630,6 +35767,13 @@ function validateInnerResponse(raw) {
       assertString(raw.value, "inner.value");
       return raw;
     }
+    if (op === "capture_redirect") {
+      if (raw.value === void 0) {
+        throw new ProtocolError("inner.value: missing on capture_redirect response");
+      }
+      assertString(raw.value, "inner.value");
+      return raw;
+    }
     if (op === "read_indexed_db") {
       if (raw.values === void 0) {
         throw new ProtocolError("inner.values: missing on read_indexed_db response");
@@ -35637,6 +35781,25 @@ function validateInnerResponse(raw) {
       assertObject(raw.values, "inner.values");
       return raw;
     }
+    if (op === "download") {
+      assertObject(raw.value, "inner.value");
+      assertString(raw.value.path, "inner.value.path");
+      if (typeof raw.value.bytes !== "number" || !Number.isInteger(raw.value.bytes) || raw.value.bytes < 0) {
+        throw new ProtocolError("inner.value.bytes: expected non-negative integer");
+      }
+      if (raw.value.mime !== void 0) {
+        assertString(raw.value.mime, "inner.value.mime");
+      }
+      if (raw.value.finalUrl !== void 0) {
+        assertString(raw.value.finalUrl, "inner.value.finalUrl");
+      }
+      for (const k of Object.keys(raw.value)) {
+        if (k !== "path" && k !== "bytes" && k !== "mime" && k !== "finalUrl") {
+          throw new ProtocolError(`inner.value: unexpected field ${JSON.stringify(k)} on download response`);
+        }
+      }
+      return raw;
+    }
     throw new ProtocolError(`inner.op: unknown success-response op ${JSON.stringify(raw.op)}`);
   }
   if (raw.ok === false) {
@@ -36507,8 +36670,12 @@ var FetchproxyServer = class {
   pendingStorage = /* @__PURE__ */ new Map();
   // 0.3.0+: capture-header awaiters resolve a single string.
   pendingCapture = /* @__PURE__ */ new Map();
+  // capture_redirect awaiters resolve the captured redirect URL string.
+  pendingRedirect = /* @__PURE__ */ new Map();
   // 0.4.0+: read_indexed_db awaiters resolve a JSON-typed values map.
   pendingIdb = /* @__PURE__ */ new Map();
+  // download awaiters resolve the saved-file metadata (path + size + mime).
+  pendingDownload = /* @__PURE__ */ new Map();
   mcpId = null;
   identity = null;
   // 0.5.3+: in-flight role-election / handle-start promise. Set the
@@ -37440,6 +37607,181 @@ var FetchproxyServer = class {
     }
     return pending;
   }
+  /**
+   * Snapshot the redirect target URL of the next request the browser
+   * makes to `(host, path?)`. Single-shot: the extension registers a
+   * one-time `chrome.webRequest.onBeforeRedirect` listener filtered on
+   * `https://${host}${path ?? '/*'}`, captures `details.redirectUrl` on
+   * the first match, removes itself, and resolves with the URL. Times out
+   * after `timeoutMs` (default 30s on the extension).
+   *
+   * Use case: a Cloudflare-walled endpoint that 302-redirects cross-origin
+   * to a presigned URL — a page-level fetch sees only an opaque redirect,
+   * but `onBeforeRedirect` exposes the target. Capture is limited to the
+   * MCP's own declared `domains`; no per-entry declared scope is required.
+   */
+  async captureRedirect(opts) {
+    if (!this.opts.capabilities.includes("capture_redirect")) {
+      throw new Error('FetchproxyServer.captureRedirect(): MCP did not declare "capture_redirect" in capabilities');
+    }
+    await this.ensureConnected();
+    this.throwIfPendingPair();
+    try {
+      const result = await this._captureRedirectOnce(opts);
+      this.recordSuccess();
+      return result;
+    } catch (err) {
+      const swDown = err instanceof FetchproxyProtocolError && classifyFetchError(err.message) === "content_script_unreachable";
+      if (!swDown) {
+        this.recordFailure(`capture_redirect: ${err.message ?? String(err)}`);
+        throw err;
+      }
+      this.lastEvictionDetectedAt = Date.now();
+      const reviveMs = this.opts.bridgeReviveDelayMs ?? 0;
+      if (reviveMs > 0) {
+        this.lazyReviveAttempts += 1;
+        await new Promise((r) => setTimeout(r, reviveMs));
+        try {
+          const result = await this._captureRedirectOnce(opts);
+          this.lazyReviveSuccesses += 1;
+          this.recordSuccess();
+          return result;
+        } catch (retryErr) {
+          const stillDown = retryErr instanceof FetchproxyProtocolError && classifyFetchError(retryErr.message) === "content_script_unreachable";
+          if (!stillDown) {
+            this.recordFailure(`capture_redirect: ${retryErr.message ?? String(retryErr)}`);
+            throw retryErr;
+          }
+          this.recordFailure(`capture_redirect bridge-down: ${retryErr.message}`);
+          throw new FetchproxyBridgeDownError({
+            originalError: retryErr.message,
+            retryAttempted: true,
+            op: "capture_redirect",
+            url: `https://${opts.host}${opts.path ?? "/*"}`,
+            role: this.role,
+            port: this.opts.port
+          });
+        }
+      }
+      this.recordFailure(`capture_redirect bridge-down: ${err.message}`);
+      throw new FetchproxyBridgeDownError({
+        originalError: err.message,
+        retryAttempted: false,
+        op: "capture_redirect",
+        url: `https://${opts.host}${opts.path ?? "/*"}`,
+        role: this.role,
+        port: this.opts.port
+      });
+    }
+  }
+  async _captureRedirectOnce(opts) {
+    const id = this.nextRequestId++;
+    const inner = {
+      type: "request",
+      id,
+      op: "capture_redirect",
+      init: {
+        host: opts.host,
+        ...opts.path !== void 0 ? { path: opts.path } : {},
+        ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
+      }
+    };
+    const pending = new Promise((resolve, reject) => {
+      this.pendingRedirect.set(id, { resolve, reject });
+    });
+    if (this.hostHandle) {
+      await this.hostHandle.sendOwnInner(inner);
+    } else if (this.peerHandle) {
+      await this.peerHandle.sendInner(inner);
+    }
+    return pending;
+  }
+  /**
+   * Download `url` through the BROWSER's own network stack via
+   * `chrome.downloads` (real cookies + TLS/JA3 fingerprint). Unlike a
+   * page-level `fetch()` (cors mode), this clears a Cloudflare bot-challenge
+   * on the endpoint and follows the cross-origin redirect to the final file.
+   * Resolves the saved local file path + size; the bridge is loopback-only /
+   * single-host, so the MCP reads the bytes from the same disk. Requires
+   * `'download'` in capabilities and the `url` host to be a declared `domain`.
+   */
+  async download(opts) {
+    if (!this.opts.capabilities.includes("download")) {
+      throw new Error('FetchproxyServer.download(): MCP did not declare "download" in capabilities');
+    }
+    assertUrlInDomains("download url", opts.url, this.opts.domains);
+    await this.ensureConnected();
+    this.throwIfPendingPair();
+    try {
+      const result = await this._downloadOnce(opts);
+      this.recordSuccess();
+      return result;
+    } catch (err) {
+      const swDown = err instanceof FetchproxyProtocolError && classifyFetchError(err.message) === "content_script_unreachable";
+      if (!swDown) {
+        this.recordFailure(`download: ${err.message ?? String(err)}`);
+        throw err;
+      }
+      this.lastEvictionDetectedAt = Date.now();
+      const reviveMs = this.opts.bridgeReviveDelayMs ?? 0;
+      if (reviveMs > 0) {
+        this.lazyReviveAttempts += 1;
+        await new Promise((r) => setTimeout(r, reviveMs));
+        try {
+          const result = await this._downloadOnce(opts);
+          this.lazyReviveSuccesses += 1;
+          this.recordSuccess();
+          return result;
+        } catch (retryErr) {
+          const stillDown = retryErr instanceof FetchproxyProtocolError && classifyFetchError(retryErr.message) === "content_script_unreachable";
+          if (!stillDown) {
+            this.recordFailure(`download: ${retryErr.message ?? String(retryErr)}`);
+            throw retryErr;
+          }
+          this.recordFailure(`download bridge-down: ${retryErr.message}`);
+          throw new FetchproxyBridgeDownError({
+            originalError: retryErr.message,
+            retryAttempted: true,
+            op: "download",
+            url: opts.url,
+            role: this.role,
+            port: this.opts.port
+          });
+        }
+      }
+      this.recordFailure(`download bridge-down: ${err.message}`);
+      throw new FetchproxyBridgeDownError({
+        originalError: err.message,
+        retryAttempted: false,
+        op: "download",
+        url: opts.url,
+        role: this.role,
+        port: this.opts.port
+      });
+    }
+  }
+  async _downloadOnce(opts) {
+    const id = this.nextRequestId++;
+    const inner = {
+      type: "request",
+      id,
+      op: "download",
+      init: {
+        url: opts.url,
+        ...opts.filename !== void 0 ? { filename: opts.filename } : {},
+        ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
+      }
+    };
+    const pending = new Promise((resolve, reject) => {
+      this.pendingDownload.set(id, { resolve, reject });
+    });
+    if (this.hostHandle) {
+      await this.hostHandle.sendOwnInner(inner);
+    } else if (this.peerHandle) {
+      await this.peerHandle.sendInner(inner);
+    }
+    return pending;
+  }
   /**
    * 0.4.0+: read declared IndexedDB keys from the user's signed-in
    * tab. Requires `'read_indexed_db'` in capabilities AND the
@@ -37587,6 +37929,20 @@ var FetchproxyServer = class {
       }
       return;
     }
+    const redirectCb = this.pendingRedirect.get(inner.id);
+    if (redirectCb) {
+      this.pendingRedirect.delete(inner.id);
+      if (inner.ok) {
+        if (inner.op === "capture_redirect" && typeof inner.value === "string") {
+          redirectCb.resolve(inner.value);
+        } else {
+          redirectCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on capture_redirect awaiter`));
+        }
+      } else {
+        redirectCb.reject(new FetchproxyProtocolError(inner.error));
+      }
+      return;
+    }
     const idbCb = this.pendingIdb.get(inner.id);
     if (idbCb) {
       this.pendingIdb.delete(inner.id);
@@ -37601,6 +37957,20 @@ var FetchproxyServer = class {
       }
       return;
     }
+    const downloadCb = this.pendingDownload.get(inner.id);
+    if (downloadCb) {
+      this.pendingDownload.delete(inner.id);
+      if (inner.ok) {
+        if (inner.op === "download" && inner.value && typeof inner.value === "object") {
+          downloadCb.resolve({ ...inner.value });
+        } else {
+          downloadCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on download awaiter`));
+        }
+      } else {
+        downloadCb.reject(new FetchproxyProtocolError(inner.error));
+      }
+      return;
+    }
     const cookiesCb = this.pendingReadCookies.get(inner.id);
     if (cookiesCb) {
       this.pendingReadCookies.delete(inner.id);
@@ -37643,9 +38013,15 @@ var FetchproxyServer = class {
     for (const { reject } of this.pendingCapture.values())
       reject(err);
     this.pendingCapture.clear();
+    for (const { reject } of this.pendingRedirect.values())
+      reject(err);
+    this.pendingRedirect.clear();
     for (const { reject } of this.pendingIdb.values())
       reject(err);
     this.pendingIdb.clear();
+    for (const { reject } of this.pendingDownload.values())
+      reject(err);
+    this.pendingDownload.clear();
   }
   /**
    * 0.5.2+: read the current pair-pending pair code from whichever handle
@@ -37887,7 +38263,7 @@ function bridgeErrorInfo(err) {
 // package.json
 var package_default = {
   name: "honeybook-mcp",
-  version: "0.3.2",
+  version: "0.3.3",
   mcpName: "io.github.chrischall/honeybook-mcp",
   description: "HoneyBook client-portal MCP server for Claude",
   author: "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -37927,7 +38303,7 @@ var package_default = {
     "test:watch": "vitest"
   },
   dependencies: {
-    "@chrischall/mcp-utils": "^0.5.0",
+    "@chrischall/mcp-utils": "^0.7.0",
     "@fetchproxy/bootstrap": "^1.0.0",
     "@fetchproxy/server": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -37945,9 +38321,7 @@ var package_default = {
 
 // src/auth.ts
 function fetchproxyDisabled() {
-  const raw = readEnvVar("HONEYBOOK_DISABLE_FETCHPROXY");
-  if (raw === void 0) return false;
-  return ["1", "true", "yes", "on"].includes(raw.toLowerCase());
+  return parseBoolEnv("HONEYBOOK_DISABLE_FETCHPROXY");
 }
 async function captureSessionViaFetchproxy(opts) {
   if (fetchproxyDisabled()) {
@@ -38521,7 +38895,7 @@ var __dirname = dirname2(fileURLToPath(import.meta.url));
 await loadDotenvSafely({ path: join3(__dirname, "..", ".env"), override: false });
 await runMcp({
   name: "honeybook-mcp",
-  version: "0.3.2",
+  version: "0.3.3",
   // x-release-please-version
   tools: [
     registerSessionTools,

package/dist/client.js

@@ -90,8 +90,15 @@ export async function getActiveClient(origin) {
     const cached = clientCache.get(session.portalOrigin);
     if (cached)
         return cached;
-    if (!moduleState.apiVersionPromise)
-        moduleState.apiVersionPromise = fetchApiVersion();
+    if (!moduleState.apiVersionPromise) {
+        // Memoize the one-time fetch, but only on success — if it rejects, clear
+        // the cache so the next call retries instead of re-awaiting the same
+        // rejection until process restart.
+        moduleState.apiVersionPromise = fetchApiVersion().catch((err) => {
+            moduleState.apiVersionPromise = null;
+            throw err;
+        });
+    }
     const apiVersion = await moduleState.apiVersionPromise;
     const client = new HoneyBookClient(session, apiVersion);
     clientCache.set(session.portalOrigin, client);

package/dist/index.js

@@ -11,7 +11,7 @@ import { registerContractTools } from './tools/contracts.js';
 import { registerInvoiceTools } from './tools/invoices.js';
 await runMcp({
     name: 'honeybook-mcp',
-    version: '0.3.2', // x-release-please-version
+    version: '0.3.3', // x-release-please-version
     tools: [
         registerSessionTools,
         registerWorkspaceFileTools,

package/dist/sessions.js

@@ -1,127 +1,28 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs';
+// Disk-persisted session cache — thin adapter over the shared SessionStore in
+// @chrischall/mcp-utils/session (this repo was the donor that store was
+// extracted from). The shared store keeps the same semantics (keyed by
+// normalized portalOrigin, most-recently-added is active, JSON array on disk
+// in insertion order) and adds two hardening upgrades the local copy lacked:
+//   - file perms are re-asserted 0600 (dir 0700) on EVERY save, so a loose
+//     pre-existing sessions.json gets tightened before secrets are written;
+//   - a corrupt sessions.json is preserved as `<path>.corrupt` instead of
+//     being silently overwritten on the next save.
 import { homedir } from 'node:os';
-import { join, dirname } from 'node:path';
-// ---------------------------------------------------------------------------
-// Pure helpers — testable without a browser
-// ---------------------------------------------------------------------------
-/**
- * Given a full URL or just an origin, return the origin without trailing slash.
- * e.g. normalizeOrigin('https://x.hbportal.co/app/workspace_file/123') → 'https://x.hbportal.co'
- *      normalizeOrigin('https://x.hbportal.co/') → 'https://x.hbportal.co'
- */
-export function normalizeOrigin(input) {
-    try {
-        const url = new URL(input);
-        return url.origin.replace(/\/$/, '');
-    }
-    catch {
-        return input.replace(/\/$/, '');
-    }
-}
-/**
- * JSON stringify — sessions as an array in insertion order.
- */
-export function serializeSessions(sessions) {
-    return JSON.stringify(Array.from(sessions.values()), null, 2);
-}
-/**
- * Parse JSON array back into a Map keyed by portalOrigin; return empty map on invalid input.
- */
-export function deserializeSessions(body) {
-    try {
-        const arr = JSON.parse(body);
-        if (!Array.isArray(arr))
-            return new Map();
-        const map = new Map();
-        for (const s of arr) {
-            if (s && typeof s.portalOrigin === 'string') {
-                map.set(s.portalOrigin, s);
-            }
-        }
-        return map;
-    }
-    catch {
-        return new Map();
-    }
-}
-// ---------------------------------------------------------------------------
-// SessionStore — manages in-memory + disk-persisted sessions
-// ---------------------------------------------------------------------------
-class SessionStore {
-    sessions;
-    mostRecentOrigin;
-    diskPath;
-    constructor(diskPath) {
-        this.diskPath = diskPath ?? join(homedir(), '.honeybook-mcp', 'sessions.json');
-        this.sessions = new Map();
-        this.mostRecentOrigin = null;
-        this.loadFromDisk();
-    }
-    loadFromDisk() {
-        if (!existsSync(this.diskPath))
-            return;
-        try {
-            const body = readFileSync(this.diskPath, 'utf8');
-            this.sessions = deserializeSessions(body);
-            const last = Array.from(this.sessions.keys()).pop();
-            this.mostRecentOrigin = last ?? null;
-        }
-        catch {
-            this.sessions = new Map();
-            this.mostRecentOrigin = null;
-        }
-    }
-    saveToDisk() {
-        mkdirSync(dirname(this.diskPath), { recursive: true });
-        writeFileSync(this.diskPath, serializeSessions(this.sessions), { mode: 0o600 });
-        try {
-            chmodSync(dirname(this.diskPath), 0o700);
-        }
-        catch {
-            // best-effort
-        }
-    }
-    /**
-     * Insert (or replace) a fully-constructed CapturedSession. Used by
-     * `src/auth.ts` after `@fetchproxy/bootstrap` has supplied the
-     * jStorage + fingerprint values from the user's browser tab.
-     *
-     * Marks the session as most-recent so the next tool call that doesn't
-     * pass `origin` picks it up automatically.
-     */
-    add(session) {
-        const normalized = normalizeOrigin(session.portalOrigin);
-        const stored = { ...session, portalOrigin: normalized };
-        this.sessions.set(normalized, stored);
-        this.mostRecentOrigin = normalized;
-        this.saveToDisk();
-    }
-    get(origin) {
-        if (origin)
-            return this.sessions.get(normalizeOrigin(origin)) ?? null;
-        if (this.mostRecentOrigin)
-            return this.sessions.get(this.mostRecentOrigin) ?? null;
-        return null;
-    }
-    list() {
-        return Array.from(this.sessions.values());
-    }
-    deactivate(origin) {
-        const normalized = normalizeOrigin(origin);
-        const had = this.sessions.delete(normalized);
-        if (had) {
-            if (this.mostRecentOrigin === normalized) {
-                const remaining = Array.from(this.sessions.keys());
-                this.mostRecentOrigin = remaining[remaining.length - 1] ?? null;
-            }
-            this.saveToDisk();
-        }
-        return had;
-    }
-    /** Test-only — clears in-memory state without touching disk. */
-    resetForTest() {
-        this.sessions.clear();
-        this.mostRecentOrigin = null;
-    }
-}
-export const sessionStore = new SessionStore();
+import { join } from 'node:path';
+import { SessionStore, normalizeOrigin } from '@chrischall/mcp-utils/session';
+import { readEnvVar } from '@chrischall/mcp-utils';
+export { normalizeOrigin };
+// Base directory holding `sessions.json`. Defaults to the real per-user store
+// (`~/.honeybook-mcp`). Overridable via `HONEYBOOK_SESSIONS_DIR` so the test
+// suite can redirect persistence into an isolated temp dir and never touch the
+// developer's real captured-session credentials. Production never sets the env
+// var, so the default is unchanged.
+export const sessionsDir = readEnvVar('HONEYBOOK_SESSIONS_DIR', {
+    default: join(homedir(), '.honeybook-mcp'),
+});
+export const sessionsFilePath = join(sessionsDir, 'sessions.json');
+export const sessionStore = new SessionStore({
+    filePath: sessionsFilePath,
+    keyOf: (session) => session.portalOrigin,
+    normalizeKey: normalizeOrigin,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeybook-mcp",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "mcpName": "io.github.chrischall/honeybook-mcp",
   "description": "HoneyBook client-portal MCP server for Claude",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -40,7 +40,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^0.5.0",
+    "@chrischall/mcp-utils": "^0.7.0",
     "@fetchproxy/bootstrap": "^1.0.0",
     "@fetchproxy/server": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/honeybook-mcp",
     "source": "github"
   },
-  "version": "0.3.2",
+  "version": "0.3.3",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "honeybook-mcp",
-      "version": "0.3.2",
+      "version": "0.3.3",
       "transport": {
         "type": "stdio"
       },