infinitecampus-mcp 2.3.5 → 2.4.0

package/dist/bundle.js

@@ -34704,6 +34704,9 @@ var API_KEY_RE = new RegExp([
   "whsec_[A-Za-z0-9]{16,}\\b"
   // webhook signing secret (Stripe-style)
 ].map((p) => `\\b${p}`).join("|"), "g");
+var JSON_SECRET_KEYS = "access_token|refresh_token|client_secret|api_?key|password|passwd|secret|token";
+var JSON_SECRET_DQ_RE = new RegExp(`("(?:${JSON_SECRET_KEYS})"\\s*:\\s*")[^"]*(")`, "gi");
+var JSON_SECRET_SQ_RE = new RegExp(`('(?:${JSON_SECRET_KEYS})'\\s*:\\s*')[^']*(')`, "gi");
 
 // node_modules/@chrischall/mcp-utils/dist/response/index.js
 function textResult(data) {
@@ -34842,6 +34845,7 @@ var KNOWN_CAPABILITIES = /* @__PURE__ */ new Set([
   "capture_request_header",
   "capture_redirect",
   "read_indexed_db",
+  "read_dom",
   "download"
 ]);
 
@@ -35143,6 +35147,44 @@ function assertIndexedDbScopesArray(value, label) {
     }
   }
 }
+var DOM_SELECTOR_RE = /^[^-]{1,512}$/;
+var DOM_ATTRIBUTE_RE = /^[A-Za-z_:][A-Za-z0-9_:.\-]{0,127}$/;
+function assertDomSelectorsArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new ProtocolError(`${label}: expected array, got ${typeof value}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < value.length; i++) {
+    const entry = value[i];
+    assertObject(entry, `${label}[${i}]`);
+    if (entry.name === void 0) {
+      throw new ProtocolError(`${label}[${i}].name: missing`);
+    }
+    if (entry.selector === void 0) {
+      throw new ProtocolError(`${label}[${i}].selector: missing`);
+    }
+    if (typeof entry.name !== "string" || !SCOPE_KEY_RE.test(entry.name)) {
+      throw new ProtocolError(`${label}[${i}].name: invalid ${JSON.stringify(entry.name)}`);
+    }
+    if (typeof entry.selector !== "string" || !DOM_SELECTOR_RE.test(entry.selector)) {
+      throw new ProtocolError(`${label}[${i}].selector: invalid ${JSON.stringify(entry.selector)}`);
+    }
+    if (entry.attribute !== void 0) {
+      if (typeof entry.attribute !== "string" || !DOM_ATTRIBUTE_RE.test(entry.attribute)) {
+        throw new ProtocolError(`${label}[${i}].attribute: invalid ${JSON.stringify(entry.attribute)}`);
+      }
+    }
+    if (seen.has(entry.name)) {
+      throw new ProtocolError(`${label}: duplicate name ${JSON.stringify(entry.name)}`);
+    }
+    seen.add(entry.name);
+    for (const k of Object.keys(entry)) {
+      if (k !== "name" && k !== "selector" && k !== "attribute") {
+        throw new ProtocolError(`${label}[${i}]: unexpected field ${JSON.stringify(k)}`);
+      }
+    }
+  }
+}
 function validateFrame(raw) {
   assertObject(raw, "frame");
   const t = raw.type;
@@ -35218,6 +35260,9 @@ function validateHello(raw) {
     if (raw.sessionStoragePointers !== void 0) {
       assertStoragePointersArray(raw.sessionStoragePointers, "hello.sessionStoragePointers", raw.sessionStorageKeys);
     }
+    if (raw.domSelectors !== void 0) {
+      assertDomSelectorsArray(raw.domSelectors, "hello.domSelectors");
+    }
     assertBase64(raw.identityX25519Pub, "hello.identityX25519Pub");
     assertBase64(raw.identityEd25519Pub, "hello.identityEd25519Pub");
     assertBase64(raw.sessionNonce, "hello.sessionNonce");
@@ -35452,6 +35497,21 @@ function validateInnerRequest(raw) {
     }
     return raw;
   }
+  if (raw.op === "read_dom") {
+    assertObject(raw.init, "inner.init");
+    if (raw.init.origin === void 0)
+      throw new ProtocolError("inner.init.origin: missing");
+    if (raw.init.names === void 0)
+      throw new ProtocolError("inner.init.names: missing");
+    assertHttpsOriginOnly(raw.init.origin, "inner.init.origin");
+    assertNonEmptyKeyArray(raw.init.names, "inner.init.names");
+    for (const k of Object.keys(raw.init)) {
+      if (k !== "origin" && k !== "names") {
+        throw new ProtocolError(`inner.init: unexpected field ${JSON.stringify(k)} on read_dom`);
+      }
+    }
+    return raw;
+  }
   if (raw.op === "download") {
     assertObject(raw.init, "inner.init");
     if (raw.init.url === void 0) {
@@ -35477,7 +35537,7 @@ 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", "capture_redirect", "read_indexed_db", "download"; got ${JSON.stringify(raw.op)}`);
+  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", "read_dom", "download"; got ${JSON.stringify(raw.op)}`);
 }
 function assertNonEmptyKeyArray(value, label) {
   if (!Array.isArray(value)) {
@@ -35562,6 +35622,13 @@ function validateInnerResponse(raw) {
       assertObject(raw.values, "inner.values");
       return raw;
     }
+    if (op === "read_dom") {
+      if (raw.values === void 0) {
+        throw new ProtocolError("inner.values: missing on read_dom response");
+      }
+      assertStringMap(raw.values, "inner.values");
+      return raw;
+    }
     if (op === "download") {
       assertObject(raw.value, "inner.value");
       assertString(raw.value.path, "inner.value.path");
@@ -35901,6 +35968,13 @@ async function buildServerHello(opts) {
       jsonPointer: d.jsonPointer
     }));
   }
+  if (opts.domSelectors && opts.domSelectors.length > 0) {
+    hello.domSelectors = opts.domSelectors.map((d) => ({
+      name: d.name,
+      selector: d.selector,
+      ...d.attribute !== void 0 ? { attribute: d.attribute } : {}
+    }));
+  }
   return hello;
 }
 
@@ -35990,7 +36064,8 @@ async function startHost(opts) {
     captureHeaders: opts.ownCaptureHeaders,
     indexedDbScopes: opts.ownIndexedDbScopes,
     localStoragePointers: opts.ownLocalStoragePointers,
-    sessionStoragePointers: opts.ownSessionStoragePointers
+    sessionStoragePointers: opts.ownSessionStoragePointers,
+    domSelectors: opts.ownDomSelectors
   });
   const ownSessionNonce = fromB64(ownHello.sessionNonce);
   let extensionWs = null;
@@ -36225,6 +36300,7 @@ async function startPeer(opts) {
     sessionStorageKeys: opts.sessionStorageKeys,
     captureHeaders: opts.captureHeaders,
     indexedDbScopes: opts.indexedDbScopes,
+    domSelectors: opts.domSelectors,
     localStoragePointers: opts.localStoragePointers,
     sessionStoragePointers: opts.sessionStoragePointers
   });
@@ -36632,6 +36708,11 @@ var FetchproxyServer = class {
         key: d.key,
         jsonPointer: d.jsonPointer
       })),
+      domSelectors: (opts.domSelectors ?? []).map((d) => ({
+        name: d.name,
+        selector: d.selector,
+        ...d.attribute !== void 0 ? { attribute: d.attribute } : {}
+      })),
       // 0.8.0+: timer + lazy-revive default to ON. Every realty MCP
       // adapter was about to set these to the same numbers anyway; the
       // back-door is `0` (explicit opt-out) if a caller genuinely wants
@@ -36752,6 +36833,7 @@ var FetchproxyServer = class {
         ownIndexedDbScopes: this.opts.indexedDbScopes,
         ownLocalStoragePointers: this.opts.localStoragePointers,
         ownSessionStoragePointers: this.opts.sessionStoragePointers,
+        ownDomSelectors: this.opts.domSelectors,
         onPairCode: this.opts.onPairCode
       });
       this.hostHandle.onOwnInner((inner) => this.onInner(inner));
@@ -36779,7 +36861,8 @@ var FetchproxyServer = class {
         captureHeaders: this.opts.captureHeaders,
         indexedDbScopes: this.opts.indexedDbScopes,
         localStoragePointers: this.opts.localStoragePointers,
-        sessionStoragePointers: this.opts.sessionStoragePointers
+        sessionStoragePointers: this.opts.sessionStoragePointers,
+        domSelectors: this.opts.domSelectors
       });
       this.peerHandle.onInner((inner) => this.onInner(inner));
       this.peerHandle.onRenegotiate(() => {
@@ -37754,6 +37837,46 @@ var FetchproxyServer = class {
     await this.sendInnerFrame(inner);
     return this._withVerbTimeout(pending, this.pendingIdb, id, origin);
   }
+  /**
+   * 1.4.0+: read declared DOM values from the user's signed-in tab.
+   * Requires `'read_dom'` in capabilities AND every requested `name` to
+   * match a declared `domSelectors` entry. The extension reads each
+   * declared selector from the matched tab's DOM (isolated-world
+   * `querySelector`, value or attribute) — no page-JS execution.
+   *
+   * Returns a `Record<string, string>` of `name → value`, with names
+   * whose element (or attribute) was absent omitted. Throws
+   * `FetchproxyProtocolError` on bridge failures and a plain `Error` on
+   * developer mistakes (undeclared capability, undeclared name).
+   */
+  async readDom(opts) {
+    if (!this.opts.capabilities.includes("read_dom")) {
+      throw new Error('FetchproxyServer.readDom(): MCP did not declare "read_dom" in capabilities');
+    }
+    await this.ensureConnected();
+    this.throwIfPendingPair();
+    if (!Array.isArray(opts.names) || opts.names.length === 0) {
+      throw new Error("FetchproxyServer.readDom: opts.names must be a non-empty array");
+    }
+    this.assertScopeSubset(opts.names, this.opts.domSelectors.map((d) => d.name), "domSelectors");
+    if (opts.subdomain !== void 0)
+      assertSubdomainLabel(opts.subdomain);
+    const baseDomain = this.resolveBaseDomain(opts.domain);
+    const host = opts.subdomain ? `${opts.subdomain}.${baseDomain}` : baseDomain;
+    const origin = `https://${host}`;
+    const id = this.nextRequestId++;
+    const inner = {
+      type: "request",
+      id,
+      op: "read_dom",
+      init: { origin, names: [...opts.names] }
+    };
+    const pending = new Promise((resolve, reject) => {
+      this.pendingStorage.set(id, { resolve, reject });
+    });
+    await this.sendInnerFrame(inner);
+    return this._withVerbTimeout(pending, this.pendingStorage, id, origin);
+  }
   assertScopeSubset(requested, declared, label) {
     const undeclared = undeclaredKeys(requested, declared);
     if (undeclared.length > 0) {
@@ -37825,7 +37948,7 @@ var FetchproxyServer = class {
     if (storageCb) {
       this.pendingStorage.delete(inner.id);
       if (inner.ok) {
-        if ((inner.op === "read_local_storage" || inner.op === "read_session_storage") && inner.values) {
+        if ((inner.op === "read_local_storage" || inner.op === "read_session_storage" || inner.op === "read_dom") && inner.values) {
           storageCb.resolve({ ...inner.values });
         } else {
           storageCb.reject(new FetchproxyProtocolError(`unexpected ${String(inner.op)} response on storage awaiter`));
@@ -38188,7 +38311,7 @@ function loadAccount(env = process.env) {
 // package.json
 var package_default = {
   name: "infinitecampus-mcp",
-  version: "2.3.5",
+  version: "2.4.0",
   mcpName: "io.github.chrischall/infinitecampus-mcp",
   description: "Infinite Campus (Campus Parent) MCP server \u2014 multi-district read + message/document write",
   author: "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -38230,19 +38353,19 @@ var package_default = {
     "test:watch": "vitest"
   },
   dependencies: {
-    "@chrischall/mcp-utils": "^0.10.3",
+    "@chrischall/mcp-utils": "^0.13.0",
     "@fetchproxy/bootstrap": "^1.0.0",
     "@fetchproxy/server": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     dotenv: "^17.4.2",
-    "node-html-parser": "^8.0.2",
+    "node-html-parser": "^9.0.0",
     zod: "^4.4.3"
   },
   devDependencies: {
     "@types/node": "^26.0.0",
     "@vitest/coverage-v8": "^4.1.7",
     esbuild: "^0.28.0",
-    typescript: "^6.0.3",
+    typescript: "^7.0.2",
     vitest: "^4.1.7"
   }
 };
@@ -38318,10 +38441,163 @@ async function resolveAuth() {
 // src/client.ts
 import { writeFile as writeFile2, stat } from "fs/promises";
 import { dirname } from "path";
+
+// node_modules/@chrischall/mcp-utils/dist/session/index.js
+var TOKEN_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+var CookieSessionManager = class {
+  session;
+  inFlight;
+  /** A cached *permanent* config error: once set, every `ensure` rethrows it. */
+  permanentError;
+  /** When the current session was minted (login) or installed (seed) — for maxAgeMs. */
+  sessionAt = 0;
+  loginFn;
+  isExpiredFn;
+  isPermanentErrorFn;
+  maxAgeMs;
+  now;
+  onReplayLoginErrorFn;
+  constructor(opts) {
+    this.loginFn = opts.login;
+    this.isExpiredFn = opts.isExpired ?? (() => false);
+    this.isPermanentErrorFn = opts.isPermanentError ?? (() => false);
+    this.maxAgeMs = opts.maxAgeMs;
+    this.now = opts.now ?? Date.now;
+    this.onReplayLoginErrorFn = opts.onReplayLoginError;
+  }
+  /** The current session, or `undefined` before the first successful login. */
+  get current() {
+    return this.session;
+  }
+  /** True when {@link CookieSessionManagerOptions.maxAgeMs} says the session is too old. */
+  isStale() {
+    return this.maxAgeMs !== void 0 && this.now() - this.sessionAt >= this.maxAgeMs;
+  }
+  /**
+   * Return the current session, or single-flight a login if there is none.
+   *
+   * Concurrent callers share one in-flight login; the in-flight promise is
+   * cleared on settle (success OR failure) so a rejected login never sticks and
+   * the next call retries. A login error classified permanent by
+   * {@link CookieSessionManagerOptions.isPermanentError} is cached and rethrown
+   * on every later call; a transient error is not cached (next call retries).
+   * With {@link CookieSessionManagerOptions.maxAgeMs} set, a session past its
+   * TTL is invalidated first, so the call falls through to a (single-flight)
+   * re-login.
+   */
+  async ensure() {
+    if (this.session !== void 0) {
+      if (!this.isStale())
+        return this.session;
+      this.invalidate();
+    }
+    if (this.permanentError !== void 0)
+      throw this.permanentError;
+    if (this.inFlight === void 0) {
+      this.inFlight = this.runLogin();
+    }
+    return this.inFlight;
+  }
+  /**
+   * Install an externally-minted session (e.g. infinitecampus's CUPS linked-
+   * district discovery, which mints sessions outside {@link
+   * CookieSessionManagerOptions.login}). The seed becomes the current session
+   * with a fresh {@link CookieSessionManagerOptions.maxAgeMs} clock, and any
+   * in-flight login is DETACHED: its waiters still receive its result, but a
+   * late resolution will not overwrite the seed. A cached permanent config
+   * error is left intact — the login path is still misconfigured, and the next
+   * post-seed re-login should keep saying so.
+   */
+  seed(session) {
+    this.session = session;
+    this.sessionAt = this.now();
+    this.inFlight = void 0;
+  }
+  /**
+   * One login attempt. Self-clears `inFlight` on settle so a rejected login
+   * never sticks, and stamps the resulting session only while it's still the
+   * live attempt (an `invalidate()` mid-flight cleared `inFlight` — a stale
+   * resolution must not re-stamp the dropped session over the new state).
+   */
+  runLogin() {
+    const holder = {};
+    holder.p = (async () => {
+      try {
+        const session = await this.loginFn();
+        if (this.inFlight === holder.p) {
+          this.session = session;
+          this.sessionAt = this.now();
+        }
+        return session;
+      } catch (err) {
+        if (this.isPermanentErrorFn(err))
+          this.permanentError = err;
+        throw err;
+      } finally {
+        if (this.inFlight === holder.p)
+          this.inFlight = void 0;
+      }
+    })();
+    return holder.p;
+  }
+  /**
+   * Drop the current session (and any in-flight login) so the next
+   * {@link ensure} re-runs {@link CookieSessionManagerOptions.login}. Does NOT
+   * clear a cached permanent config error — that only clears on a fresh process
+   * (new config). Used to recover from a detected session expiry.
+   */
+  invalidate() {
+    this.session = void 0;
+    this.inFlight = void 0;
+  }
+  /**
+   * Run an authenticated `call` with the current session and reactive
+   * expiry-replay. `call` receives the session and returns a `Response`. If
+   * {@link CookieSessionManagerOptions.isExpired} flags the response, the
+   * session is invalidated, a single-flight re-login runs, and `call` is
+   * replayed EXACTLY once. A persistent expiry surfaces the (second) response
+   * rather than looping. If the re-login itself fails, the original
+   * (expired-looking) response is returned so the caller can surface a clean
+   * sign-in error rather than the login failure.
+   *
+   * `call` resolves to `R` (the generic response type, default {@link Response});
+   * the manager passes it untouched to {@link CookieSessionManagerOptions.isExpired}
+   * and returns it untouched, so a custom transport type flows through cleanly.
+   */
+  async withSession(call) {
+    const session = await this.ensure();
+    const res = await call(session);
+    if (!await this.isExpiredFn(res))
+      return res;
+    if (this.current === session)
+      this.invalidate();
+    let fresh;
+    try {
+      fresh = await this.ensure();
+    } catch (err) {
+      this.onReplayLoginErrorFn?.(err);
+      return res;
+    }
+    return call(fresh);
+  }
+};
+function createCookieSessionManager(opts) {
+  return new CookieSessionManager(opts);
+}
+
+// src/client.ts
 var SESSION_TTL_MS = 5 * 60 * 60 * 1e3;
 var ICClient = class {
   accounts = /* @__PURE__ */ new Map();
-  sessions = /* @__PURE__ */ new Map();
+  /**
+   * One CookieSessionManager per district (primary + each discovered linked
+   * district). The manager owns the session lifecycle: single-flight login,
+   * `withSession` exactly-one 401 replay, `invalidate()`, permanent-error
+   * caching, proactive `maxAgeMs` (SESSION_TTL_MS) expiry, and — for linked
+   * districts — the CUPS-minted session installed via `seed()` during
+   * discovery.
+   */
+  managers = /* @__PURE__ */ new Map();
   linkedTo = /* @__PURE__ */ new Map();
   // linkedDistrictName → primaryDistrictName
   primaryName;
@@ -38335,6 +38611,8 @@ var ICClient = class {
    */
   fetchproxyMode = false;
   fetchproxyDiscoveryRan = false;
+  /** fetchproxy cookies, consumed by the primary manager's first login. */
+  preloaded = null;
   /**
    * `preloaded` is the fetchproxy escape hatch: when set, the client treats
    * the supplied cookies as a freshly-completed login on the primary account.
@@ -38347,21 +38625,66 @@ var ICClient = class {
   constructor(account2, opts = {}) {
     this.accounts.set(account2.name, account2);
     this.primaryName = account2.name;
+    this.managers.set(account2.name, this.makeManager(account2));
     if (opts.preloaded) {
-      this.sessions.set(account2.name, {
-        cookie: opts.preloaded.cookieHeader,
-        xsrfToken: opts.preloaded.xsrfToken,
-        loggedInAt: Date.now(),
-        loginInFlight: null
-      });
+      this.preloaded = opts.preloaded;
       this.fetchproxyMode = true;
     }
   }
+  /**
+   * Build the per-district CookieSessionManager.
+   *
+   * - `maxAgeMs: SESSION_TTL_MS` makes `ensure()` proactively invalidate and
+   *   re-login a session older than 5h (single-flight), replacing IC's old
+   *   hand-rolled `ensureFresh` wrapper. `now` reads `Date.now` at call time so
+   *   the clock stays mockable in tests.
+   * - `isPermanentError` caches the one config error the process can never
+   *   recover from (fetchproxy no-creds) so `ensure()` fails fast instead of
+   *   pointlessly retrying a login that can never succeed.
+   * - `onReplayLoginError` rethrows the re-login failure from `withSession`'s
+   *   expiry-replay path. By default that failure is swallowed and the stale
+   *   401 returned; rethrowing surfaces the actionable error (e.g. fetchproxy's
+   *   "sign back into your IC portal in the browser") to the caller instead of
+   *   a generic SessionExpiredError — the behavior IC's `lastLoginError`
+   *   bookkeeping used to provide.
+   */
+  makeManager(account2) {
+    return createCookieSessionManager({
+      login: () => this.login(account2),
+      isExpired: (res) => this.detectExpiredSession(account2.name, res),
+      isPermanentError: (e) => e instanceof AuthFailedError && e.permanent,
+      maxAgeMs: SESSION_TTL_MS,
+      now: () => Date.now(),
+      onReplayLoginError: (err) => {
+        throw err;
+      }
+    });
+  }
+  /**
+   * `isExpired` predicate for `withSession`: a 401 means the session died.
+   * Side effect for linked districts: the shared CUPS SSO umbrella died with
+   * it, so drop the primary and every *sibling* linked session too — the
+   * linked district's re-login (via `login()`'s linked branch) then re-logs
+   * the primary in, whose discovery re-establishes all of them. `withSession`
+   * invalidates the requesting district itself. Mirrors the old hand-rolled
+   * doRequest 401 handling.
+   */
+  detectExpiredSession(district, res) {
+    if (res.status !== 401) return false;
+    const primaryName = this.linkedTo.get(district);
+    if (primaryName) {
+      this.managers.get(primaryName).invalidate();
+      for (const linked of this.linkedTo.keys()) {
+        if (linked !== district) this.managers.get(linked).invalidate();
+      }
+    }
+    return true;
+  }
   async ensureDiscovery() {
-    await this.ensureSession(this.accounts.get(this.primaryName));
+    const session = await this.managers.get(this.primaryName).ensure();
     if (this.fetchproxyMode && !this.fetchproxyDiscoveryRan) {
       this.fetchproxyDiscoveryRan = true;
-      await this.discoverLinkedDistricts(this.accounts.get(this.primaryName));
+      await this.discoverLinkedDistricts(this.accounts.get(this.primaryName), session);
     }
   }
   listDistricts() {
@@ -38394,50 +38717,37 @@ var ICClient = class {
       account2 = this.accounts.get(district);
       if (!account2) throw new UnknownDistrictError(district, [...this.accounts.keys()]);
     }
-    await this.ensureSession(account2);
+    const session = await this.managers.get(account2.name).ensure();
     if (this.fetchproxyMode && !this.fetchproxyDiscoveryRan && account2.name === this.primaryName) {
       this.fetchproxyDiscoveryRan = true;
-      await this.discoverLinkedDistricts(account2);
-    }
-    return this.doRequest(account2, path, opts, false);
-  }
-  async ensureSession(account2) {
-    let s = this.sessions.get(account2.name);
-    if (s && Date.now() - s.loggedInAt < SESSION_TTL_MS) return;
-    if (s?.loginInFlight) {
-      await s.loginInFlight;
-      return;
-    }
-    if (!s) {
-      s = { cookie: "", xsrfToken: "", loggedInAt: 0, loginInFlight: null };
-      this.sessions.set(account2.name, s);
-    }
-    s.loginInFlight = this.login(account2);
-    try {
-      await s.loginInFlight;
-    } finally {
-      s.loginInFlight = null;
+      await this.discoverLinkedDistricts(account2, session);
     }
+    return this.doRequest(account2, path, opts);
   }
   async login(account2) {
     const primaryName = this.linkedTo.get(account2.name);
     if (primaryName) {
-      this.sessions.delete(account2.name);
-      const primaryAccount = this.accounts.get(primaryName);
-      await this.ensureSession(primaryAccount);
-      if (!this.sessions.has(account2.name)) {
+      await this.managers.get(primaryName).ensure();
+      const restored = this.managers.get(account2.name).current;
+      if (!restored) {
         throw new AuthFailedError(
           account2.name,
           "linked-district session could not be re-established via the primary district",
           { credentialHint: false }
         );
       }
-      return;
+      return restored;
+    }
+    if (this.preloaded) {
+      const { cookieHeader, xsrfToken } = this.preloaded;
+      this.preloaded = null;
+      return { cookieHeader, xsrfToken };
     }
     if (!account2.username || !account2.password) {
       throw new AuthFailedError(
         account2.name,
-        "session expired and no IC_USERNAME/IC_PASSWORD set \u2014 sign back into your IC portal in the browser and restart the MCP"
+        "session expired and no IC_USERNAME/IC_PASSWORD set \u2014 sign back into your IC portal in the browser and restart the MCP",
+        { permanent: true }
       );
     }
     const postRes = await fetch(
@@ -38470,17 +38780,17 @@ var ICClient = class {
     if (!cookies.cookieHeader) {
       throw new AuthFailedError(account2.name, "login response missing session cookies");
     }
-    const session = this.sessions.get(account2.name);
-    session.cookie = cookies.cookieHeader;
-    session.xsrfToken = cookies.xsrfToken;
-    session.loggedInAt = Date.now();
-    await this.discoverLinkedDistricts(account2);
+    const session = {
+      cookieHeader: cookies.cookieHeader,
+      xsrfToken: cookies.xsrfToken
+    };
+    await this.discoverLinkedDistricts(account2, session);
+    return session;
   }
-  async discoverLinkedDistricts(account2) {
+  async discoverLinkedDistricts(account2, session) {
     try {
-      const session = this.sessions.get(account2.name);
       const baseHeaders = {
-        Cookie: session.cookie,
+        Cookie: session.cookieHeader,
         Accept: "application/json",
         "Content-Type": "application/json",
         Referer: `${account2.baseUrl}/campus/nav-wrapper/`,
@@ -38548,13 +38858,14 @@ var ICClient = class {
             password: "(linked)"
           };
           this.accounts.set(linked.districtName, syntheticAccount);
-          this.sessions.set(linked.districtName, {
-            cookie: switchCookies.cookieHeader,
-            xsrfToken: switchCookies.xsrfToken,
-            loggedInAt: Date.now(),
-            loginInFlight: null
-          });
           this.linkedTo.set(linked.districtName, account2.name);
+          if (!this.managers.has(linked.districtName)) {
+            this.managers.set(linked.districtName, this.makeManager(syntheticAccount));
+          }
+          this.managers.get(linked.districtName).seed({
+            cookieHeader: switchCookies.cookieHeader,
+            xsrfToken: switchCookies.xsrfToken
+          });
           console.error(`[ic] Linked district discovered: ${linked.districtName} (${linked.appName})`);
         } catch (e) {
           console.error(`[ic] CUPS flow failed for ${linked.districtName}: ${e instanceof Error ? e.message : e}`);
@@ -38580,12 +38891,11 @@ var ICClient = class {
     }
     const account2 = this.accounts.get(district);
     if (!account2) throw new UnknownDistrictError(district, [...this.accounts.keys()]);
-    await this.ensureSession(account2);
-    const session = this.sessions.get(account2.name);
+    const session = await this.managers.get(account2.name).ensure();
     const url2 = /^https?:\/\//i.test(path) ? path : `${account2.baseUrl}${path}`;
     const res = await fetch(url2, {
       headers: {
-        Cookie: session.cookie,
+        Cookie: session.cookieHeader,
         ...session.xsrfToken ? { "X-XSRF-TOKEN": session.xsrfToken } : {}
       }
     });
@@ -38598,34 +38908,23 @@ var ICClient = class {
       contentType: res.headers.get("content-type") ?? "application/octet-stream"
     };
   }
-  async doRequest(account2, path, opts, isRetry) {
-    const session = this.sessions.get(account2.name);
+  async doRequest(account2, path, opts) {
+    const mgr = this.managers.get(account2.name);
     const accept = opts.responseType === "text" ? "text/html, text/plain, */*" : "application/json";
-    const res = await fetch(`${account2.baseUrl}${path}`, {
-      method: opts.method ?? "GET",
-      headers: {
-        Cookie: session.cookie,
-        Accept: accept,
-        ...session.xsrfToken ? { "X-XSRF-TOKEN": session.xsrfToken } : {},
-        ...opts.headers ?? {}
-      },
-      body: opts.body
-    });
+    const res = await mgr.withSession(
+      async (session) => fetch(`${account2.baseUrl}${path}`, {
+        method: opts.method ?? "GET",
+        headers: {
+          Cookie: session.cookieHeader,
+          Accept: accept,
+          ...session.xsrfToken ? { "X-XSRF-TOKEN": session.xsrfToken } : {},
+          ...opts.headers ?? {}
+        },
+        body: opts.body
+      })
+    );
     if (res.status === 401) {
-      if (isRetry) throw new SessionExpiredError(account2.name);
-      this.sessions.delete(account2.name);
-      const primaryName = this.linkedTo.get(account2.name);
-      if (primaryName) {
-        this.sessions.delete(primaryName);
-        for (const [linked] of this.linkedTo) {
-          this.sessions.delete(linked);
-        }
-        const primaryAccount = this.accounts.get(primaryName);
-        await this.ensureSession(primaryAccount);
-      } else {
-        await this.ensureSession(account2);
-      }
-      return this.doRequest(account2, path, opts, true);
+      throw new SessionExpiredError(account2.name);
     }
     if (res.status >= 500) throw new PortalUnreachableError(account2.name, res.status);
     if (!res.ok) throw new Error(`IC ${res.status} ${res.statusText} for ${path}`);
@@ -38638,14 +38937,11 @@ var ICClient = class {
 };
 function parseSetCookies(headers) {
   const raw = headers.getSetCookie?.() ?? [];
-  const entries = raw.length > 0 ? raw : splitFallback(headers.get("set-cookie"));
-  const { cookies, cookieHeader } = parseCookieJar(entries);
+  const { cookies, cookieHeader } = parseCookieJar(
+    raw.length > 0 ? raw : headers.get("set-cookie")
+  );
   return { cookieHeader, xsrfToken: cookies["XSRF-TOKEN"] ?? "" };
 }
-function splitFallback(header) {
-  if (!header) return [];
-  return header.split(",").map((s) => s.trim());
-}
 var UnknownDistrictError = class extends Error {
   constructor(district, available) {
     super(`Unknown district '${district}'. Configured: [${available.join(", ")}]`);
@@ -38662,6 +38958,7 @@ var AuthFailedError = class extends Error {
    *   "Check IC_USERNAME and IC_PASSWORD" suffix — used for failures where the
    *   credentials are known-good (e.g. a linked-district CUPS/SSO re-discovery
    *   failure) and pointing the user at their creds would be misleading.
+   * @param opts.permanent See {@link AuthFailedError.permanent}.
    */
   constructor(district, reason, opts) {
     const detail = reason ? ` (${reason})` : "";
@@ -38670,9 +38967,17 @@ var AuthFailedError = class extends Error {
     this.district = district;
     this.reason = reason;
     this.name = "AuthFailedError";
+    this.permanent = opts?.permanent ?? false;
   }
   district;
   reason;
+  /**
+   * A *permanent* configuration failure: retrying the login inside this
+   * process can never succeed (e.g. fetchproxy mode with no creds — the user
+   * must re-sign-in in the browser and restart). CookieSessionManager caches
+   * and rethrows permanent errors instead of retrying.
+   */
+  permanent;
 };
 var PortalUnreachableError = class extends Error {
   constructor(district, status) {
@@ -38717,40 +39022,6 @@ var FileExistsError = class extends Error {
   path;
 };
 
-// src/tools/_shared.ts
-function textContent(data) {
-  return textResult(data);
-}
-function is404(e) {
-  return e instanceof Error && e.message.startsWith("IC 404 ");
-}
-function featureDisabled(feature, district, data = []) {
-  return textContent({ warning: "FeatureDisabled", feature, district, data });
-}
-async function findStudent(client, district, studentId) {
-  const students = await client.request(district, "/campus/api/portal/students");
-  return students.find((s) => String(s.personID) === studentId) ?? null;
-}
-function studentNotFound(studentId) {
-  return textContent({ error: "StudentNotFound", studentId });
-}
-async function checkFeatureDisabled(client, district, studentId, student, flag, toolName, emptyData = []) {
-  const structureID = student.enrollments?.[0]?.structureID;
-  if (!structureID) return null;
-  try {
-    const features = await client.getFeatures(district, structureID, studentId);
-    if (features[flag] === false) return featureDisabled(toolName, district, emptyData);
-    return null;
-  } catch (e) {
-    console.error(`[ic] displayOptions check failed for ${district}/${flag}: ${e instanceof Error ? e.message : e}`);
-    return null;
-  }
-}
-function toArray(value) {
-  if (value === null || value === void 0) return [];
-  return Array.isArray(value) ? value : [value];
-}
-
 // src/tools/districts.ts
 function registerDistrictTools(server, client) {
   server.registerTool("ic_list_districts", {
@@ -38759,7 +39030,7 @@ function registerDistrictTools(server, client) {
   }, async () => {
     await client.ensureDiscovery();
     const data = client.listDistricts();
-    return textContent(data);
+    return textResult(data);
   });
 }
 
@@ -38775,7 +39046,7 @@ function registerStudentTools(server, client) {
   }, async (rawArgs) => {
     const args = argsSchema.parse(rawArgs);
     const data = await client.request(args.district, "/campus/api/portal/students");
-    return textContent(data);
+    return textResult(data);
   });
 }
 
@@ -38795,7 +39066,7 @@ function registerScheduleTools(server, client) {
     const args = argsSchema2.parse(rawArgs);
     const params = new URLSearchParams({ personID: args.studentId });
     const data = await client.request(args.district, `/campus/resources/portal/roster?${params}`);
-    return textContent(data);
+    return textResult(data);
   });
 }
 
@@ -38833,7 +39104,7 @@ function registerAssignmentTools(server, client) {
     if (args.missingOnly) {
       data = data.filter((a) => a.missing);
     }
-    return textContent(data);
+    return textResult(data);
   });
 }
 
@@ -38853,10 +39124,41 @@ function registerGradeTools(server, client) {
     const params = new URLSearchParams({ personID: args.studentId });
     if (args.termId) params.set("termID", args.termId);
     const data = await client.request(args.district, `/campus/resources/portal/grades?${params}`);
-    return textContent(data);
+    return textResult(data);
   });
 }
 
+// src/tools/_shared.ts
+function is404(e) {
+  return e instanceof Error && e.message.startsWith("IC 404 ");
+}
+function featureDisabled(feature, district, data = []) {
+  return textResult({ warning: "FeatureDisabled", feature, district, data });
+}
+async function findStudent(client, district, studentId) {
+  const students = await client.request(district, "/campus/api/portal/students");
+  return students.find((s) => String(s.personID) === studentId) ?? null;
+}
+function studentNotFound(studentId) {
+  return textResult({ error: "StudentNotFound", studentId });
+}
+async function checkFeatureDisabled(client, district, studentId, student, flag, toolName, emptyData = []) {
+  const structureID = student.enrollments?.[0]?.structureID;
+  if (!structureID) return null;
+  try {
+    const features = await client.getFeatures(district, structureID, studentId);
+    if (features[flag] === false) return featureDisabled(toolName, district, emptyData);
+    return null;
+  } catch (e) {
+    console.error(`[ic] displayOptions check failed for ${district}/${flag}: ${e instanceof Error ? e.message : e}`);
+    return null;
+  }
+}
+function toArray(value) {
+  if (value === null || value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
 // src/tools/attendance.ts
 var argsSchema5 = external_exports.object({
   district: external_exports.string(),
@@ -38921,7 +39223,7 @@ function registerAttendanceTools(server, client) {
           results.push({ ...entry, terms: trimmedTerms });
         }
       }
-      return textContent(results);
+      return textResult(results);
     } catch (e) {
       if (is404(e)) return featureDisabled("attendance", args.district);
       throw e;
@@ -38952,7 +39254,7 @@ function registerBehaviorTools(server, client) {
     if (args.until) params.set("endDate", args.until);
     try {
       const data = await client.request(args.district, `/campus/resources/portal/behavior?${params}`);
-      return textContent(data);
+      return textResult(data);
     } catch (e) {
       if (is404(e)) return featureDisabled("behavior", args.district);
       throw e;
@@ -38992,7 +39294,7 @@ function registerFoodServiceTools(server, client) {
     if (args.until) params.set("endDate", args.until);
     try {
       const data = await client.request(args.district, `/campus/resources/portal/foodService?${params}`);
-      return textContent(data);
+      return textResult(data);
     } catch (e) {
       if (is404(e)) return featureDisabled("foodService", args.district, EMPTY_FOOD);
       throw e;
@@ -39012,16 +39314,50 @@ var NAMED_ENTITIES = {
 function extractPlainTextFromHtml(html) {
   if (!html)
     return "";
-  let text = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ");
+  let text = stripElementContent(stripElementContent(html, "script"), "style");
   text = text.replace(/<[^>]+>/g, " ");
-  text = text.replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)));
-  text = text.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)));
+  text = text.replace(/&#(\d+);/g, (whole, d) => codePointOr(Number(d), whole));
+  text = text.replace(/&#x([0-9a-fA-F]+);/g, (whole, h) => codePointOr(parseInt(h, 16), whole));
   text = text.replace(/&([a-zA-Z]+);/g, (whole, name) => {
     const decoded = NAMED_ENTITIES[name.toLowerCase()];
     return decoded ?? whole;
   });
   return text.replace(/\s+/g, " ").trim();
 }
+function stripElementContent(html, tag) {
+  const lower = html.toLowerCase();
+  const open = `<${tag}`;
+  const close = `</${tag}>`;
+  let out = "";
+  let i = 0;
+  for (; ; ) {
+    const start = lower.indexOf(open, i);
+    if (start < 0) {
+      out += html.slice(i);
+      return out;
+    }
+    const after = lower[start + open.length];
+    if (after !== void 0 && after !== ">" && after !== " " && after !== "	" && after !== "\n" && after !== "\r" && after !== "\f" && after !== "/") {
+      out += html.slice(i, start + open.length);
+      i = start + open.length;
+      continue;
+    }
+    out += html.slice(i, start) + " ";
+    const closeAt = lower.indexOf(close, start + open.length);
+    if (closeAt < 0)
+      return out;
+    i = closeAt + close.length;
+  }
+}
+function codePointOr(code, raw) {
+  if (!Number.isInteger(code) || code < 0 || code > 1114111)
+    return raw;
+  try {
+    return String.fromCodePoint(code);
+  } catch {
+    return raw;
+  }
+}
 
 // src/tools/messages.ts
 var listArgs = external_exports.object({
@@ -39116,7 +39452,7 @@ function registerMessageTools(server, client) {
       return { count: 0, items: [], error: e instanceof Error ? e.message : String(e) };
     });
     const [notifications, inbox, announcements] = await Promise.all([prismPromise, inboxPromise, noticePromise]);
-    return textContent({ notifications, inbox, announcements });
+    return textResult({ notifications, inbox, announcements });
   });
   server.registerTool("ic_get_message", {
     description: "Fetch the HTML body of an inbox message and return it parsed into { subject, date, body, url }. Takes a `messageUrl` which is the `url` field from an item returned by ic_list_messages' inbox section (e.g. 'portal/messageView.xsl?x=messenger.MessengerEngine-getMessageRecipientView&messageID=...'). Relative and /campus/-prefixed URLs are both accepted. Note: fetching the HTML body may mark the message as read on some district configurations; probe against an empty inbox could not confirm the side effect.",
@@ -39127,7 +39463,7 @@ function registerMessageTools(server, client) {
     const path = normalizeMessageUrl(args.messageUrl);
     const html = await client.request(args.district, path, { responseType: "text" });
     const parsed = parseMessageHtml(html ?? "", path);
-    return textContent(parsed);
+    return textResult(parsed);
   });
 }
 
@@ -39167,7 +39503,7 @@ function registerDocumentTools(server, client) {
         if (d.endYear !== void 0) out.endYear = d.endYear;
         return out;
       });
-      return textContent(trimmed);
+      return textResult(trimmed);
     } catch (e) {
       if (is404(e)) return featureDisabled("documents", args.district);
       throw e;
@@ -39183,10 +39519,10 @@ function registerDocumentTools(server, client) {
       const meta3 = await client.download(args.district, args.documentId, args.destinationPath, {
         overwrite: args.overwrite ?? false
       });
-      return textContent(meta3);
+      return textResult(meta3);
     } catch (e) {
       if (e instanceof Error && e.message.startsWith("IC download 404")) {
-        return textContent({ warning: "FeatureDisabled", feature: "documents", district: args.district });
+        return textResult({ warning: "FeatureDisabled", feature: "documents", district: args.district });
       }
       throw e;
     }
@@ -39242,7 +39578,7 @@ function registerCalendarTools(server, client) {
         terms: trimmedTerms
       });
     }
-    return textContent(result);
+    return textResult(result);
   });
 }
 
@@ -39333,7 +39669,7 @@ function registerAttendanceEventsTools(server, client) {
           results.push(trimmed);
         }
       }
-      return textContent(results);
+      return textResult(results);
     } catch (e) {
       if (is404(e)) return featureDisabled("attendance_events", args.district);
       throw e;
@@ -39389,7 +39725,7 @@ function registerRecentGradesTools(server, client) {
       }
       return out;
     });
-    return textContent(trimmed);
+    return textResult(trimmed);
   });
 }
 
@@ -39444,7 +39780,7 @@ function registerTeacherTools(server, client) {
     const [teachersRaw, counselorsRaw] = await Promise.all([teachersPromise, counselorsPromise]);
     const teachers = toArray(teachersRaw).map((t) => trimRecord(t));
     const counselors = toArray(counselorsRaw).map((c) => trimRecord(c));
-    return textContent({ counselors, teachers });
+    return textResult({ counselors, teachers });
   });
 }
 
@@ -39495,7 +39831,7 @@ function registerAssessmentTools(server, client) {
     if (feature404 && result.length === 0) {
       return featureDisabled("assessments", args.district);
     }
-    return textContent(result);
+    return textResult(result);
   });
 }
 
@@ -39539,7 +39875,7 @@ function registerFeeTools(server, client) {
       feeAssignments: assignments.ok ? assignments.value : [],
       ...issues.length > 0 ? { issues } : {}
     };
-    return textContent(response);
+    return textResult(response);
   });
 }
 
@@ -39567,7 +39903,7 @@ function registerFeaturesTools(server, client) {
         features
       });
     }
-    return textContent(result);
+    return textResult(result);
   });
 }
 
@@ -39591,7 +39927,7 @@ try {
 }
 var COMMON = {
   name: "infinitecampus",
-  version: "2.3.5"
+  version: "2.4.0"
   // x-release-please-version
 };
 if (account) {