@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/safe-bash-mcp/index.js

@@ -1921,7 +1921,7 @@ async function requestTokens(input) {
   if (method === "client_secret_basic") {
     const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
     const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
-    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+    headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
   } else {
     body.set("client_id", input.clientId);
     if (method === "client_secret_post")
@@ -2111,10 +2111,10 @@ function createDefaultOAuthClientProvider(options) {
   if (resourceIdentity !== void 0 && selectedSessionStore !== void 0)
     throw new Error("OAuth resourceIdentity requires native-owned persistence; custom stores own their resource trust policy");
   const now = () => {
-    const timestamp = clock();
-    if (!Number.isSafeInteger(timestamp) || Math.abs(timestamp) > MAX_JS_DATE_MS3)
+    const timestamp2 = clock();
+    if (!Number.isSafeInteger(timestamp2) || Math.abs(timestamp2) > MAX_JS_DATE_MS3)
       throw new Error("OAuth clock must return valid epoch milliseconds");
-    return timestamp;
+    return timestamp2;
   };
   const registeredClients = /* @__PURE__ */ new Map();
   const resourceStores = resourceIdentity === void 0 ? void 0 : createResourceBoundOAuthStores(authStore ?? {}, persistenceNamespace, resourceIdentity);
@@ -2901,6 +2901,155 @@ function shouldReRegisterStoredDynamicClient(error, client, alreadyAttempted) {
   return client.registrationOwnership !== "caller";
 }
 
+// ../mcp-oauth/dist/client/resumable.js
+var responseParameters = ["code", "state", "iss", "error", "error_description", "error_uri"];
+function httpsUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" || url.username || url.password || url.href.includes("#"))
+    throw new Error();
+  return url;
+}
+function base64url(bytes) {
+  return btoa(String.fromCharCode(...bytes)).split("+").join("-").split("/").join("_").split("=").join("");
+}
+function timestamp(now) {
+  const value = now();
+  if (!Number.isSafeInteger(value) || value < 0 || value > 864e13 - 6e5)
+    throw new Error();
+  return value;
+}
+async function beginRemoteMcpAuthorization(options) {
+  try {
+    const { store, signal, discover } = options;
+    const now = options.now?.bind(options) ?? Date.now;
+    const resource = httpsUrl(options.resource).href;
+    const redirect = httpsUrl(options.redirectUri);
+    if (responseParameters.some((key2) => redirect.searchParams.has(key2)))
+      throw new Error();
+    const client = structuredClone(options.client);
+    if (typeof client.clientId !== "string" || !client.clientId.trim())
+      throw new Error();
+    const method = normalizeOAuthTokenEndpointAuthMethod(client.tokenEndpointAuthMethod) ?? (client.clientSecret === void 0 ? "none" : "client_secret_post");
+    if (client.clientSecret !== void 0 && (typeof client.clientSecret !== "string" || !client.clientSecret.trim()))
+      throw new Error();
+    if (method !== "none" && client.clientSecret === void 0)
+      throw new Error();
+    if (client.registration !== void 0 && (client.registration.client_id !== client.clientId || client.registration.client_secret != null && client.registration.client_secret !== client.clientSecret || client.registration.token_endpoint_auth_method != null && client.registration.token_endpoint_auth_method !== method))
+      throw new Error();
+    client.tokenEndpointAuthMethod = method;
+    if (client.requestedRedirectUri !== void 0 && client.requestedRedirectUri !== redirect.href)
+      throw new Error();
+    if (client.registration?.redirect_uris != null && !client.registration.redirect_uris.includes(redirect.href))
+      throw new Error();
+    const scope = normalizeOAuthScope(options.scope);
+    const ttl = options.ttlMs ?? 6e5;
+    if (!Number.isSafeInteger(ttl) || ttl < 1 || ttl > 6e5)
+      throw new Error();
+    signal?.throwIfAborted();
+    const metadata = structuredClone(await discover(resource, signal));
+    signal?.throwIfAborted();
+    const server = metadata.authorizationServerMetadata;
+    if (httpsUrl(metadata.resource).href !== resource || httpsUrl(metadata.resourceMetadata.resource).href !== resource || server.issuer !== metadata.authorizationServer || !metadata.resourceMetadata.authorization_servers.includes(server.issuer) || !server.response_types_supported.includes("code") || !server.code_challenge_methods_supported.includes("S256"))
+      throw new Error();
+    httpsUrl(server.issuer);
+    httpsUrl(server.token_endpoint);
+    const authorization = httpsUrl(server.authorization_endpoint);
+    const state = base64url(crypto.getRandomValues(new Uint8Array(32)));
+    const codeVerifier = base64url(crypto.getRandomValues(new Uint8Array(32)));
+    const challenge = base64url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier))));
+    const expiresAt = timestamp(now) + ttl;
+    const session = {
+      resource,
+      authorizationServer: server.issuer,
+      client: { ...client, registrationOwnership: "caller", requestedRedirectUri: redirect.href },
+      ...scope === void 0 ? {} : { requestedScope: scope },
+      discovery: { resourceMetadataUrl: metadata.resourceMetadataUrl, resourceMetadata: metadata.resourceMetadata, authorizationServerMetadata: server }
+    };
+    for (const [key2, value] of Object.entries({
+      response_type: "code",
+      client_id: client.clientId,
+      redirect_uri: redirect.href,
+      resource,
+      state,
+      code_challenge: challenge,
+      code_challenge_method: "S256"
+    }))
+      authorization.searchParams.set(key2, value);
+    authorization.searchParams.delete("scope");
+    if (scope !== void 0)
+      authorization.searchParams.set("scope", scope);
+    signal?.throwIfAborted();
+    await store.create({
+      state,
+      expiresAt,
+      redirectUri: redirect.href,
+      codeVerifier,
+      requireIssuer: server.authorization_response_iss_parameter_supported === true,
+      session
+    });
+    signal?.throwIfAborted();
+    return { authorizationUrl: authorization.href, expiresAt };
+  } catch {
+    throw new Error("Unable to begin MCP authorization");
+  }
+}
+async function completeRemoteMcpAuthorization(options) {
+  try {
+    const { store, fetch: fetch2, signal } = options;
+    const now = options.now?.bind(options) ?? Date.now;
+    const callback = httpsUrl(options.callbackUrl);
+    for (const key2 of responseParameters)
+      if (callback.searchParams.getAll(key2).length > 1)
+        throw new Error();
+    const state = callback.searchParams.get("state");
+    if (!state || state.length > 256)
+      throw new Error();
+    signal?.throwIfAborted();
+    const stored = await store.consume(state);
+    if (stored === null)
+      throw new Error();
+    const transaction = structuredClone(stored);
+    if (transaction.state !== state || !Number.isSafeInteger(transaction.expiresAt) || transaction.expiresAt <= timestamp(now))
+      throw new Error();
+    const expected = httpsUrl(transaction.redirectUri);
+    const issuer = callback.searchParams.get("iss");
+    if (transaction.requireIssuer && issuer === null || issuer !== null && issuer !== transaction.session.authorizationServer)
+      throw new Error();
+    const code = callback.searchParams.get("code");
+    if (!code || callback.searchParams.has("error"))
+      throw new Error();
+    for (const key2 of responseParameters)
+      callback.searchParams.delete(key2);
+    const actualPairs = [...callback.searchParams].sort(), expectedPairs = [...expected.searchParams].sort();
+    if (callback.origin !== expected.origin || callback.pathname !== expected.pathname || JSON.stringify(actualPairs) !== JSON.stringify(expectedPairs))
+      throw new Error();
+    const session = structuredClone(transaction.session);
+    const tokenEndpoint = httpsUrl(String(session.discovery.authorizationServerMetadata.token_endpoint)).href;
+    signal?.throwIfAborted();
+    session.tokens = await exchangeAuthorizationCode({
+      tokenEndpoint,
+      clientId: session.client.clientId,
+      clientSecret: session.client.clientSecret,
+      tokenEndpointAuthMethod: session.client.tokenEndpointAuthMethod,
+      code,
+      codeVerifier: transaction.codeVerifier,
+      redirectUri: transaction.redirectUri,
+      resource: session.resource,
+      fetch: fetch2,
+      signal,
+      now
+    });
+    if (session.tokens.scope === void 0 && session.requestedScope !== void 0)
+      session.tokens.scope = session.requestedScope;
+    signal?.throwIfAborted();
+    if (transaction.expiresAt <= timestamp(now) || !await store.commit(transaction, session))
+      throw new Error();
+    return { resource: session.resource };
+  } catch {
+    throw new Error("Unable to complete MCP authorization");
+  }
+}
+
 // src/oauth-policy.ts
 function snapshotOAuthBindingOptions(oauth) {
   return {
@@ -2932,8 +3081,8 @@ function snapshotOAuthBrowserOptions(browser) {
 // ../tiny-mcp-client/dist/index.js
 import { PassThrough } from "node:stream";
 import http2 from "node:http";
-import crypto5 from "node:crypto";
 import crypto22 from "node:crypto";
+import crypto32 from "node:crypto";
 import path42 from "node:path";
 import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes2, randomUUID as randomUUID22, scrypt as scrypt2 } from "node:crypto";
 import { promises as fs2 } from "node:fs";
@@ -2948,7 +3097,7 @@ import { homedir as homedir22 } from "node:os";
 import path32 from "node:path";
 import { isIP as isIP2 } from "node:net";
 import { URL as URL22 } from "node:url";
-import crypto32 from "node:crypto";
+import crypto42 from "node:crypto";
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res, err) => function __init() {
@@ -6473,7 +6622,7 @@ function copyBoundedOAuthJson2(value, message) {
 function createAuthorizationState2(input) {
   const payload = {
     v: 1,
-    n: crypto5.randomBytes(16).toString("base64url"),
+    n: crypto22.randomBytes(16).toString("base64url"),
     i: input.issuer,
     r: input.requireIssuer
   };
@@ -7731,7 +7880,7 @@ function snapshotPersistenceOptions2(options) {
 }
 function createNamedSecretStore2(key2, options, defaults, namespace) {
   options = snapshotOAuthPersistenceOptions2(options);
-  const hash = crypto22.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
+  const hash = crypto32.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
   const configuredFilePath = options.fileStore?.filePath;
   const parsedFilePath = configuredFilePath === void 0 ? null : path42.parse(configuredFilePath);
   const fileStore = {
@@ -8033,10 +8182,10 @@ async function fetchMcpResponse2(fetchImplementation, input, init = {}) {
   });
 }
 function generateCodeVerifier2() {
-  return crypto32.randomBytes(32).toString("base64url");
+  return crypto42.randomBytes(32).toString("base64url");
 }
 function generateCodeChallenge2(verifier) {
-  return crypto32.createHash("sha256").update(verifier).digest("base64url");
+  return crypto42.createHash("sha256").update(verifier).digest("base64url");
 }
 async function readBoundedResponseText2(response, maxBytes, readers, signal) {
   if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 1))
@@ -8165,7 +8314,7 @@ async function requestTokens2(input) {
   if (method === "client_secret_basic") {
     const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
     const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
-    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+    headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
   } else {
     body.set("client_id", input.clientId);
     if (method === "client_secret_post")
@@ -8357,10 +8506,10 @@ function createDefaultOAuthClientProvider2(options) {
   if (resourceIdentity !== void 0 && selectedSessionStore !== void 0)
     throw new Error("OAuth resourceIdentity requires native-owned persistence; custom stores own their resource trust policy");
   const now = () => {
-    const timestamp = clock();
-    if (!Number.isSafeInteger(timestamp) || Math.abs(timestamp) > MAX_JS_DATE_MS32)
+    const timestamp2 = clock();
+    if (!Number.isSafeInteger(timestamp2) || Math.abs(timestamp2) > MAX_JS_DATE_MS32)
       throw new Error("OAuth clock must return valid epoch milliseconds");
-    return timestamp;
+    return timestamp2;
   };
   const registeredClients = /* @__PURE__ */ new Map();
   const resourceStores = resourceIdentity === void 0 ? void 0 : createResourceBoundOAuthStores2(authStore ?? {}, persistenceNamespace, resourceIdentity);
@@ -14863,16 +15012,31 @@ async function openFileDescriptor(path6, options, capabilities, acquire) {
 }
 
 // ../safe-fs/dist/contracts/virtual-path.js
-var MAX_PATH_BYTES = 65536;
-var MAX_PATH_COMPONENTS = 2048;
-function validatePath(path6, maxComponents = MAX_PATH_COMPONENTS) {
+function pathByteLength(path6) {
+  let bytes = 0;
+  for (const point of path6) {
+    const code = point.codePointAt(0);
+    bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function validatePath(path6, limits = {}) {
+  const maxBytes = typeof limits === "number" ? Infinity : limits.maxPathBytes ?? Infinity;
+  const maxComponents = typeof limits === "number" ? limits : limits.maxPathComponents ?? Infinity;
+  for (const value of [maxBytes, maxComponents]) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
+      throw new RangeError("Path limits must be nonnegative safe integers or Infinity");
+    }
+  }
   if (typeof path6 !== "string" || path6.includes("\0")) {
     throw new FsError("EINVAL", { syscall: "resolve", message: "paths must be strings without NUL bytes" });
   }
-  if (path6.length > MAX_PATH_BYTES) {
+  if (maxBytes !== Infinity && pathByteLength(path6) > maxBytes) {
     throw new FsError("ENAMETOOLONG", { syscall: "resolve", path: path6 });
   }
-  const limit = Math.min(maxComponents, MAX_PATH_COMPONENTS);
+  if (maxComponents === Infinity)
+    return;
+  const limit = maxComponents;
   let components2 = 0;
   let inComponent = false;
   for (let i = 0; i < path6.length; i++) {
@@ -15536,11 +15700,14 @@ function components(path6, signal) {
   }
   return result;
 }
-function resolveMissingTarget(root, path6, signal) {
+function resolveMissingTarget(root, path6, signal, limits = {}) {
+  validatePath(path6, limits);
   const fail3 = (code, failedPath = path6) => {
     throw new FsError(code, { syscall: "realpath", path: failedPath });
   };
   const origin = components(path6, signal);
+  let remainingBytes = (limits.maxPathBytes ?? Infinity) - pathByteLength(path6);
+  let remainingComponents = (limits.maxPathComponents ?? Infinity) - origin.length;
   const initial = { node: root, name: "" };
   let position = initial;
   let links = 0;
@@ -15593,7 +15760,10 @@ function resolveMissingTarget(root, path6, signal) {
       if (node.type === "symlink") {
         if (++links > 40)
           return fail3("ELOOP");
+        validatePath(node.target, { maxPathBytes: remainingBytes, maxPathComponents: remainingComponents });
         const names2 = components(node.target, signal);
+        remainingBytes -= pathByteLength(node.target);
+        remainingComponents -= names2.length;
         if (node.target.endsWith("/"))
           names2.push({ name: ".", start: node.target.length });
         if (node.target.startsWith("/"))
@@ -15797,26 +15967,22 @@ function readConfigRecord(value, label, keys) {
 
 // ../safe-fs/dist/fs/memory/limits.js
 var defaultMemoryFileSystemLimits = Object.freeze({
+  maxPathBytes: Infinity,
+  maxPathComponents: Infinity,
   maxFileBytes: Infinity,
   maxRetainedBytes: Infinity,
   maxMetadataUnits: Infinity
 });
 function normalizeMemoryFileSystemLimits(options) {
-  const keys = ["maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
+  const keys = ["maxPathBytes", "maxPathComponents", "maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
   const record3 = readConfigRecord(options, "memory option", [...keys, "maxBytes"]);
   const limits = { ...defaultMemoryFileSystemLimits };
-  if (Object.hasOwn(record3, "maxBytes") && record3.maxBytes !== void 0) {
-    if (typeof record3.maxBytes !== "number" || !Number.isSafeInteger(record3.maxBytes) || record3.maxBytes < 0) {
-      throw new RangeError("maxBytes must be a nonnegative safe integer");
-    }
-    limits.maxBytes = record3.maxBytes;
-  }
-  for (const key2 of keys) {
-    if (!Object.hasOwn(record3, key2))
-      continue;
+  for (const key2 of [...keys, "maxBytes"]) {
     const value = record3[key2];
+    if (value === void 0 || value === Infinity)
+      continue;
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key2 === "maxMetadataUnits" ? 1 : 0)) {
-      throw new RangeError(`${key2} must be a ${key2 === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer`);
+      throw new RangeError(`${key2} must be a ${key2 === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer or Infinity`);
     }
     limits[key2] = value;
   }
@@ -15865,12 +16031,10 @@ var DUMMY_POOL_FILE_NODE = new MemoryFileNode(0, 0, null, 0, DUMMY_POOL_ALLOCATI
 DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NODE.ctimeMs = DUMMY_POOL_FILE_NODE.birthtimeMs = 17e11;
 var defaultDateNow = Date.now;
 var fastWriteCachedNow = Date.now();
-var lastFastMapMiss = {
-  map: void 0,
-  key: "",
-  slot: -1
-};
 var FastDirectoryEntriesMap = class {
+  // Keep speculative slots local so a failed write cannot pin a tenant globally.
+  _missKey = "";
+  _missSlot = -1;
   _table = new Int16Array(128).fill(-1);
   _mask = 127;
   _keys = new Array(64).fill("");
@@ -15907,9 +16071,8 @@ var FastDirectoryEntriesMap = class {
   getForWriteWithHash(k, h) {
     let slot = h & this._mask;
     if (this.size === 0) {
-      lastFastMapMiss.map = this;
-      lastFastMapMiss.key = k;
-      lastFastMapMiss.slot = slot;
+      this._missKey = k;
+      this._missSlot = slot;
       return void 0;
     }
     const mask = this._mask;
@@ -15919,9 +16082,8 @@ var FastDirectoryEntriesMap = class {
     while (true) {
       const idx = table[slot];
       if (idx === -1) {
-        lastFastMapMiss.map = this;
-        lastFastMapMiss.key = k;
-        lastFastMapMiss.slot = firstDeleted !== -1 ? firstDeleted : slot;
+        this._missKey = k;
+        this._missSlot = firstDeleted !== -1 ? firstDeleted : slot;
         return void 0;
       }
       if (idx === -2) {
@@ -15970,6 +16132,7 @@ var FastDirectoryEntriesMap = class {
     return this.get(k) !== void 0;
   }
   _rebuild(newCap) {
+    this._missKey = "";
     const newTableLen = newCap * 2;
     const newMask = newTableLen - 1;
     const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
@@ -16009,15 +16172,16 @@ var FastDirectoryEntriesMap = class {
     this._next = writeIdx;
   }
   set(k, v) {
-    if (this === lastFastMapMiss.map && k === lastFastMapMiss.key && this._next < this._keys.length) {
+    if (k === this._missKey && this._next < this._keys.length) {
       const entryIdx = this._next++;
-      this._table[lastFastMapMiss.slot] = entryIdx;
+      this._table[this._missSlot] = entryIdx;
       this._keys[entryIdx] = k;
       this._vals[entryIdx] = v;
       this.size++;
-      lastFastMapMiss.map = void 0;
+      this._missKey = "";
       return this;
     }
+    this._missKey = "";
     if (this._next >= this._keys.length) {
       this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
     }
@@ -16048,6 +16212,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   delete(k) {
+    this._missKey = "";
     if (this.size === 0)
       return false;
     let slot = this._hash(k);
@@ -16073,6 +16238,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   clear() {
+    this._missKey = "";
     if (this._next > 0) {
       this._table.fill(-1);
       for (let i = 0; i < this._next; i++) {
@@ -16525,7 +16691,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const owner = ownedStores.get(this);
     if (path6 !== "")
       this.validatePath(path6, "realpath");
-    return resolveMissingTarget(owner.root, path6 || ".", options.signal);
+    return resolveMissingTarget(owner.root, path6 || ".", options.signal, this.ledger.limits);
   }
   async confineExtraction(roots, options = {}) {
     options.signal?.throwIfAborted();
@@ -16746,6 +16912,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
   }
   replaceData(node, allocation, length = allocation.data.byteLength) {
     const previous = node.allocation;
+    node.sourceRef = void 0;
     this.totalBytes += length - node.byteLength;
     node.byteLength = length;
     node.view = length === allocation.data.byteLength ? allocation.data : void 0;
@@ -16778,6 +16945,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
       this.fail("EINVAL", syscall, path6);
     if (path6.length === 0)
       this.fail("ENOENT", syscall, path6);
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
   }
   permission(node, mask, syscall, path6) {
     if ((node.mode >> 6 & mask) !== mask)
@@ -16799,6 +16968,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     node.mtimeMs = node.ctimeMs = now;
   }
   resolveNode(path6, syscall, followFinal = true) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     if (this.symlinkCount === 0 && isCleanAbsolutePath(path6)) {
       const fastDir = cache.lastFastDirNode;
@@ -16883,7 +17054,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         start = slash + 1;
       }
     }
-    let remainingPathUnits = 65536 - path6.length;
+    let remainingPathUnits = this.ledger.limits.maxPathBytes - pathByteLength(path6);
     if (remainingPathUnits < 0)
       this.fail("ENAMETOOLONG", syscall, path6);
     let initialComponents = 0;
@@ -16893,12 +17064,12 @@ var MemoryFileSystem = class _MemoryFileSystem {
         inComp = false;
       else if (!inComp) {
         inComp = true;
-        if (++initialComponents > 256)
+        if (++initialComponents > this.ledger.limits.maxPathComponents)
           this.fail("ENAMETOOLONG", syscall, path6);
       }
     }
-    const pending = path6.split("/").filter(Boolean);
-    let remainingComponents = 256 - pending.length;
+    let pending = path6.split("/").filter(Boolean);
+    let remainingComponents = this.ledger.limits.maxPathComponents - pending.length;
     if (path6.endsWith("/"))
       pending.push("");
     const stack = [{ node: this.root, name: "" }];
@@ -16948,9 +17119,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (node.type === "symlink" && (options.followFinal !== false || pending.length > 0)) {
         if (++links > 40)
           this.fail("ELOOP", syscall, path6);
-        if (node.target.length > remainingPathUnits)
+        if (pathByteLength(node.target) > remainingPathUnits)
           this.fail("ENAMETOOLONG", syscall, path6);
-        remainingPathUnits -= node.target.length;
+        remainingPathUnits -= pathByteLength(node.target);
         const target = node.target.split("/").filter(Boolean);
         if (target.length > remainingComponents)
           this.fail("ENAMETOOLONG", syscall, path6);
@@ -16959,7 +17130,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           target.push("");
         if (options.resizeCreate !== void 0 && target.at(-1) === "" && pending[0] === "")
           target.pop();
-        pending.unshift(...target);
+        pending = target.concat(pending);
         if (node.target.startsWith("/"))
           stack.splice(1);
         continue;
@@ -16975,6 +17146,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     };
   }
   file(path6, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     if (this.symlinkCount === 0 && path6.charCodeAt(0) === 47 && path6.length > 1 && path6.indexOf("/", 1) === -1 && !path6.includes("\0")) {
       const name = path6 === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path6, _lastFileSlice1Name = path6.slice(1));
       if (name !== "." && name !== "..") {
@@ -17249,6 +17422,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }, syscall, path6);
   }
   writeData(path6, data, options, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     if (!(data instanceof Uint8Array))
       throw new TypeError("Memory files require Uint8Array data");
     const target = this.prepareWrite(path6, options, syscall);
@@ -17362,12 +17537,15 @@ var MemoryFileSystem = class _MemoryFileSystem {
       node.byteLength = length;
       node.view = length === allocation.data.byteLength ? allocation.data : void 0;
     }
+    node.sourceRef = void 0;
     this.changed(node, now);
   }
   writeMemoryFileFast(path6, data, append, mode) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     const syscall = append ? "appendFile" : "writeFile";
-    if (append && path6 === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+    if (append && path6 === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
       const current2 = cache.lastFastFileNode;
       const length2 = current2.byteLength + data.byteLength;
       this.admitSize(current2, length2, syscall, path6);
@@ -17381,7 +17559,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     let name = "";
     const cachedPrefix = cache.lastFastDirPrefix;
     const cachedDir = cache.lastFastDirNode;
-    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && cachedPrefix.length > 1 && path6.startsWith(cachedPrefix) && path6.indexOf("/", cachedPrefix.length) === -1) {
+    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && cachedPrefix.length > 1 && path6.startsWith(cachedPrefix) && path6.indexOf("/", cachedPrefix.length) === -1) {
       parent = cachedDir;
       name = path6.slice(cachedPrefix.length);
       if (exceedsComponentByteLimit2(name))
@@ -17394,7 +17572,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           name = path6.slice(start);
           if (exceedsComponentByteLimit2(name))
             this.fail("ENAMETOOLONG", syscall, path6);
-          if (start > 1 && (parent.mode & 1) !== 0) {
+          if (start > 1 && (parent.mode & 64) !== 0) {
             cache.lastFastDirPrefix = path6.slice(0, start);
             cache.lastFastDirNode = parent;
           }
@@ -17514,6 +17692,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         let ino = this.nextInode;
         this.nextInode = ino + batchCount;
         let nextIdx = 1;
+        entries2._missKey = "";
         entries2._next = 1 + batchCount;
         entries2.size = 1 + batchCount;
         const table = entries2._table;
@@ -17563,12 +17742,15 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
   }
   writeMemoryFileInDirFast(dirPrefix, name, data, append, mode, nameHash) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(dirPrefix + name, this.ledger.limits);
     const cache = this._cache;
     if (!append && dirPrefix === cache.lastFastDirPrefix && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 192) === 192 && name.length <= 85 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === void 0 && sharedFileNodePoolLen > 0) {
       const parent = cache.lastFastDirNode;
       const entries2 = parent.entries;
       const existing = nameHash !== void 0 ? entries2.getForWriteWithHash(name, nameHash) : entries2.getForWrite(name);
       if (existing === void 0 && entries2._next < entries2._keys.length) {
+        this.ledger.reserve(name.length * 2, 2, "writeFile", name);
         const now = fastWriteCachedNow;
         const length = data.byteLength;
         const node = sharedFileNodePool[--sharedFileNodePoolLen];
@@ -17590,13 +17772,11 @@ var MemoryFileSystem = class _MemoryFileSystem {
         node.allocation = DUMMY_POOL_ALLOCATION;
         node.sourceRef = node.data.subarray(0);
         const entryIdx = entries2._next++;
-        entries2._table[lastFastMapMiss.slot] = entryIdx;
+        entries2._table[entries2._missSlot] = entryIdx;
         entries2._keys[entryIdx] = name;
         entries2._vals[entryIdx] = node;
         entries2.size++;
-        lastFastMapMiss.map = void 0;
-        lastFastMapMiss.key = "";
-        this.ledger.reserve(name.length * 2, 2, "writeFile", name);
+        entries2._missKey = "";
         this.totalBytes += length;
         this.mutationTick = this.mutationTick + 1 | 0;
         parent.revision = parent.revision < 1073741823 ? parent.revision + 1 | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
@@ -17609,7 +17789,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
     const syscall = append ? "appendFile" : "writeFile";
     try {
-      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
         const current2 = cache.lastFastFileNode;
         const length2 = current2.byteLength + data.byteLength;
         this.admitSize(current2, length2, syscall, name);
@@ -17620,7 +17800,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       }
       let parent = this.root;
       const cachedDir = cache.lastFastDirNode;
-      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
+      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
         parent = cachedDir;
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
@@ -17645,7 +17825,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         this.permission(parent, 1, syscall, name);
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
-        if (dirPrefix.length > 1 && (parent.mode & 1) !== 0) {
+        if (dirPrefix.length > 1 && (parent.mode & 64) !== 0) {
           cache.lastFastDirPrefix = dirPrefix;
           cache.lastFastDirNode = parent;
         }
@@ -17721,11 +17901,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
             cache.lastFastFilePath = "";
             cache.lastFastFileName = name;
             cache.lastFastFileNode = node;
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
           } catch (error) {
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
             this.ledger.release(nameBytes, 2);
             throw error;
           }
@@ -19719,27 +19895,42 @@ function* parseXmlSteps(input, limits = {}) {
       throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
   };
   let pendingWork = 0;
-  const skipWhitespace = () => {
+  const skipWhitespace = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     return offset - start2;
   };
-  const scanName = () => {
+  const scanName = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     const name = source.slice(start2, offset);
+    pendingWork += offset - start2;
+    while (pendingWork >= 512) {
+      yield 512;
+      pendingWork -= 512;
+    }
     const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
-    return [name, prefix, localName, (offset - start2) * 2];
+    return [name, prefix, localName];
   };
   while (offset < source.length) {
     pendingWork += 1;
@@ -19776,11 +19967,15 @@ function* parseXmlSteps(input, limits = {}) {
         }
       } else {
         for (let index = 0; index < resolved.length; index++) {
+          pendingWork++;
+          if (pendingWork >= 512) {
+            yield 512;
+            pendingWork -= 512;
+          }
           const c = resolved.charCodeAt(index);
           if (c !== 32 && c !== 9 && c !== 13 && c !== 10)
             invalid("text outside the root");
         }
-        pendingWork += resolved.length;
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -19822,8 +20017,7 @@ function* parseXmlSteps(input, limits = {}) {
     } else if (source.startsWith("<?", offset)) {
       const start2 = offset;
       offset += 2;
-      const [target, , , wName] = scanName();
-      pendingWork += wName;
+      const [target] = yield* scanName();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -19862,8 +20056,8 @@ function* parseXmlSteps(input, limits = {}) {
       invalid("DTD and entity declarations are forbidden");
     } else if (source.charCodeAt(offset + 1) === 47) {
       offset += 2;
-      const [name, , , wName] = scanName();
-      pendingWork += wName + skipWhitespace();
+      const [name] = yield* scanName();
+      yield* skipWhitespace();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -19876,10 +20070,11 @@ function* parseXmlSteps(input, limits = {}) {
     } else {
       offset++;
       const repeated = previousEmpty && source.startsWith(previousEmpty.suffix, offset) ? previousEmpty : void 0;
-      const [name, prefix, localName, wName] = repeated ? [repeated.name, repeated.prefix, repeated.localName, repeated.name.length * 2] : scanName();
+      const [name, prefix, localName] = repeated ? [repeated.name, repeated.prefix, repeated.localName] : yield* scanName();
       if (repeated)
         offset += name.length;
-      pendingWork += wName;
+      if (repeated)
+        pendingWork += name.length * 2;
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -19889,8 +20084,7 @@ function* parseXmlSteps(input, limits = {}) {
       let namespaces = stack.at(-1)?.namespaces ?? /* @__PURE__ */ new Map([["xml", xmlNamespace]]);
       let ownsNamespaces = stack.length === 0;
       while (!repeated) {
-        const ws = skipWhitespace();
-        pendingWork += ws;
+        const ws = yield* skipWhitespace();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -19900,8 +20094,7 @@ function* parseXmlSteps(input, limits = {}) {
           break;
         if (ws === 0)
           invalid("attributes require whitespace");
-        const [attribute, attrPrefix, attrLocal, wAttr] = scanName();
-        pendingWork += wAttr;
+        const [attribute, attrPrefix, attrLocal] = yield* scanName();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -19912,10 +20105,10 @@ function* parseXmlSteps(input, limits = {}) {
           throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
         if ((attributes?.size ?? 0) >= maxAttributesPerElement)
           throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         if (source[offset++] !== "=")
           invalid("missing attribute equals");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         const quote = source[offset++];
         if (quote !== '"' && quote !== "'")
           invalid("unquoted attribute");
@@ -20102,14 +20295,13 @@ function scalar(element) {
 
 // ../safe-fs/dist/fs/webdav/webdav.js
 var timestampNamespace = "urn:virtual-bash:metadata";
-var maxTimestampPropertyBytes = 4096;
-function preflightTimestamps(property) {
+function preflightTimestamps(property, maxTimestampPropertyBytes) {
   let bytes = 0;
   for (const point of property.text) {
     const code = point.codePointAt(0);
     bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
     if (bytes > maxTimestampPropertyBytes)
-      throw new Error("timestamp property exceeds 4KiB limit");
+      throw new Error("timestamp property exceeds byte limit");
   }
   const text = scalar(property);
   let offset = 0;
@@ -20350,6 +20542,7 @@ var WebDavFileSystem = class {
   headers;
   maxResponseBytes;
   maxXmlBytes;
+  maxTimestampPropertyBytes;
   maxEntries;
   xmlLimits;
   timeoutMs;
@@ -20419,6 +20612,7 @@ var WebDavFileSystem = class {
       streamingAppend: this.requestStreamSupport !== false
     });
     this.maxResponseBytes = options.maxResponseBytes === void 0 ? Infinity : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
+    this.maxTimestampPropertyBytes = positive(options.maxTimestampPropertyBytes ?? Infinity, "maxTimestampPropertyBytes", true, true);
     this.maxXmlBytes = options.maxXmlBytes === void 0 ? Infinity : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
     this.xmlLimits = Object.freeze({ ...options.xmlLimits });
     for (const [name, value] of Object.entries(this.xmlLimits))
@@ -20854,7 +21048,7 @@ var WebDavFileSystem = class {
     let mtimeMs = date("getlastmodified") ?? 0;
     let atimeMs = 0;
     if (timestampProperty) {
-      const timestamps = JSON.parse(preflightTimestamps(timestampProperty));
+      const timestamps = JSON.parse(preflightTimestamps(timestampProperty, this.maxTimestampPropertyBytes));
       if (typeof timestamps !== "object" || timestamps === null || !("version" in timestamps) || timestamps.version !== 1 || !("etag" in timestamps) || typeof timestamps.etag !== "string" || !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(timestamps.etag) || !("type" in timestamps) || timestamps.type !== "file" && timestamps.type !== "directory" || !("atimeMs" in timestamps) || typeof timestamps.atimeMs !== "number" || !Number.isFinite(timestamps.atimeMs) || Math.abs(timestamps.atimeMs) > 864e13 || !("mtimeMs" in timestamps) || typeof timestamps.mtimeMs !== "number" || !Number.isFinite(timestamps.mtimeMs) || Math.abs(timestamps.mtimeMs) > 864e13)
         throw new Error("invalid timestamp property");
       if (timestamps.etag === validator && timestamps.type === (directory ? "directory" : "file")) {
@@ -21857,7 +22051,7 @@ var S3FileSystem = class {
     const modified = metadata?.LastModified?.getTime() ?? 0;
     if (!Number.isFinite(modified))
       fail2("EIO", "stat", "", "transport returned an invalid LastModified");
-    const timestamp = (key2, fallback) => {
+    const timestamp2 = (key2, fallback) => {
       const value = metadata?.Metadata?.[key2];
       if (value === void 0)
         return fallback;
@@ -21874,8 +22068,8 @@ var S3FileSystem = class {
       type,
       size,
       mode: (type === "directory" ? 16384 : 32768) | mode,
-      mtimeMs: timestamp("virtual-bash-mtime", modified),
-      atimeMs: timestamp("virtual-bash-atime", 0),
+      mtimeMs: timestamp2("virtual-bash-mtime", modified),
+      atimeMs: timestamp2("virtual-bash-atime", 0),
       ctimeMs: modified
     };
   }
@@ -23780,8 +23974,10 @@ Redirect URI: ${textLine(request.redirectUri)}
 export {
   accessRemoteMcpResources,
   authenticateRemoteMcpServer,
+  beginRemoteMcpAuthorization,
   bindRemoteMcpConfiguration,
   compileToolArguments,
+  completeRemoteMcpAuthorization,
   createRemoteMcpCommands,
   createRemoteMcpManagementCommand,
   fetchRemoteMcpSchema,