jamdesk 1.1.221 → 1.1.222

package/vendored/scripts/openapi-safe-ref-resolvers.cjs

@@ -0,0 +1,354 @@
+// builder/build-service/scripts/openapi-safe-ref-resolvers.cjs
+//
+// CommonJS twin of lib/openapi/safe-ref-resolvers.ts for the build scripts,
+// which run in plain node and are vendored into the CLI, so they cannot
+// import TypeScript (same pairing as lib/visibility-filter.ts /
+// scripts/visibility-filter.cjs). The policy and its reasoning live in the
+// TS file's header. Keep the two identical:
+// __tests__/openapi/safe-ref-resolvers.test.ts runs the same cases on both.
+
+const dns = require('node:dns');
+const fs = require('node:fs');
+const http = require('node:http');
+const https = require('node:https');
+const net = require('node:net');
+const path = require('node:path');
+const { fileURLToPath } = require('node:url');
+
+const REF_FETCH_TIMEOUT_MS = 10_000;
+const REF_FETCH_MAX_BYTES = 5_000_000;
+const REF_FETCH_MAX_REDIRECTS = 5;
+const SPEC_FETCH_TIMEOUT_MS = 15_000;
+const SPEC_FETCH_MAX_BYTES = 25_000_000;
+
+const BLOCKED_ADDRESSES = new net.BlockList();
+for (const [prefix, bits] of [
+  ['0.0.0.0', 8],
+  ['10.0.0.0', 8],
+  ['100.64.0.0', 10],
+  ['127.0.0.0', 8],
+  ['169.254.0.0', 16],
+  ['172.16.0.0', 12],
+  ['192.0.0.0', 24],
+  ['192.168.0.0', 16],
+  ['198.18.0.0', 15],
+  ['224.0.0.0', 3],
+]) {
+  BLOCKED_ADDRESSES.addSubnet(prefix, bits, 'ipv4');
+}
+for (const [prefix, bits] of [
+  ['::', 96],
+  ['64:ff9b::', 96],
+  ['64:ff9b:1::', 48],
+  ['2002::', 16],
+  ['fc00::', 7],
+  ['fe80::', 10],
+  ['fec0::', 10],
+  ['ff00::', 8],
+]) {
+  BLOCKED_ADDRESSES.addSubnet(prefix, bits, 'ipv6');
+}
+
+function isBlockedAddress(address) {
+  const family = net.isIP(address);
+  if (family === 0) return true;
+  return BLOCKED_ADDRESSES.check(address, family === 6 ? 'ipv6' : 'ipv4');
+}
+
+function bareHostname(url) {
+  return url.hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '').toLowerCase();
+}
+
+const LOOPBACK_ADDRESSES = new net.BlockList();
+LOOPBACK_ADDRESSES.addSubnet('127.0.0.0', 8, 'ipv4');
+LOOPBACK_ADDRESSES.addAddress('::1', 'ipv6');
+
+function isLoopbackAddress(address) {
+  const family = net.isIP(address);
+  return family !== 0 && LOOPBACK_ADDRESSES.check(address, family === 6 ? 'ipv6' : 'ipv4');
+}
+
+/** `localhost`, `*.localhost`, 127.0.0.0/8 and ::1 (IP literals arrive normalized). */
+function isLoopbackHost(host) {
+  return host === 'localhost' || host.endsWith('.localhost') || isLoopbackAddress(host);
+}
+
+function checkRefUrl(rawUrl, { allowHttp = false, allowLoopback = false } = {}) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return 'not a valid URL';
+  }
+  if (url.protocol !== 'https:' && !(allowHttp && url.protocol === 'http:')) {
+    return allowHttp ? 'only http:// and https:// URLs are allowed' : 'only https:// $refs are allowed';
+  }
+  const host = bareHostname(url);
+  if (allowLoopback && isLoopbackHost(host)) return null;
+  if (net.isIP(host) !== 0) return 'IP address hosts are not allowed';
+  if (
+    host === 'localhost' ||
+    host.endsWith('.localhost') ||
+    host.endsWith('.internal') ||
+    host.endsWith('.local') ||
+    !host.includes('.')
+  ) {
+    return 'internal hosts are not allowed';
+  }
+  return null;
+}
+
+function lookupPublicAddresses(hostname, signal, allowLoopback) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new Error(`DNS lookup for ${hostname} timed out`));
+    if (signal.aborted) return onAbort();
+    signal.addEventListener('abort', onAbort, { once: true });
+    dns.lookup(hostname, { all: true }, (err, addresses) => {
+      signal.removeEventListener('abort', onAbort);
+      if (err) return reject(err);
+      if (addresses.length === 0 || addresses.some((a) => !(allowLoopback && isLoopbackAddress(a.address)) && isBlockedAddress(a.address))) {
+        return reject(new Error(`${hostname} resolves to a non-public address`));
+      }
+      resolve(addresses);
+    });
+  });
+}
+
+// Hosts like api.github.com and some WAF bot rules 403 a request with no
+// User-Agent, and node:http adds none (the old runtime fetch sent undici's).
+// Identity encoding because this fetcher does not decode compressed bodies.
+const REQUEST_HEADERS = (accept) => ({
+  Accept: accept,
+  'User-Agent': 'Jamdesk-OpenAPI-Fetcher/1.0',
+  'Accept-Encoding': 'identity',
+});
+
+function requestOnce(url, addresses, signal, maxBytes, accept) {
+  return new Promise((resolve, reject) => {
+    const lookup = (_hostname, options, callback) => {
+      if (options.all) callback(null, addresses);
+      else callback(null, addresses[0].address, addresses[0].family);
+    };
+
+    const transport = url.protocol === 'http:' ? http : https;
+    const req = transport.request(
+      url,
+      { method: 'GET', agent: false, lookup, signal, headers: REQUEST_HEADERS(accept) },
+      (res) => {
+        const status = res.statusCode ?? 0;
+        if (status >= 300 && status < 400) {
+          res.resume();
+          resolve({ location: res.headers.location });
+          return;
+        }
+        if (status < 200 || status >= 300) {
+          res.resume();
+          reject(new Error(`HTTP ${status}`));
+          return;
+        }
+        if (Number(res.headers['content-length']) > maxBytes) {
+          res.destroy();
+          reject(new Error(`response exceeds ${maxBytes} bytes`));
+          return;
+        }
+        const chunks = [];
+        let size = 0;
+        res.on('data', (chunk) => {
+          size += chunk.length;
+          if (size > maxBytes) {
+            res.destroy();
+            reject(new Error(`response exceeds ${maxBytes} bytes`));
+            return;
+          }
+          chunks.push(chunk);
+        });
+        res.on('end', () => resolve({ body: Buffer.concat(chunks) }));
+        res.on('error', reject);
+      },
+    );
+    req.on('error', reject);
+    signal.addEventListener('abort', () => reject(new Error('timed out')), { once: true });
+    req.end();
+  });
+}
+
+function startsAtLoopback(rawUrl) {
+  try {
+    return isLoopbackHost(bareHostname(new URL(rawUrl)));
+  } catch {
+    return false;
+  }
+}
+
+async function fetchRefSafely(
+  rawUrl,
+  {
+    timeoutMs = REF_FETCH_TIMEOUT_MS,
+    maxBytes = REF_FETCH_MAX_BYTES,
+    allowHttp = false,
+    allowLoopback = false,
+    accept = '*/*',
+  } = {},
+) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  // Loopback is only for a spec the author pointed at their own machine. A
+  // public URL that redirects to localhost must not get there.
+  const loopbackOk = allowLoopback && startsAtLoopback(rawUrl);
+  let current = rawUrl;
+  for (let hop = 0; hop <= REF_FETCH_MAX_REDIRECTS; hop++) {
+    const reason = checkRefUrl(current, { allowHttp, allowLoopback: loopbackOk });
+    if (reason) throw new Error(`Refusing $ref ${current}: ${reason}`);
+    const url = new URL(current);
+    const addresses = await lookupPublicAddresses(bareHostname(url), signal, loopbackOk);
+    const result = await requestOnce(url, addresses, signal, maxBytes, accept);
+    if (result.body) return result.body;
+    if (!result.location) throw new Error(`Redirect from ${current} has no location`);
+    current = new URL(result.location, url).href;
+  }
+  throw new Error(`Too many redirects resolving $ref ${rawUrl}`);
+}
+
+function fetchSpecUrlSafely(rawUrl) {
+  return fetchRefSafely(rawUrl, {
+    timeoutMs: SPEC_FETCH_TIMEOUT_MS,
+    maxBytes: SPEC_FETCH_MAX_BYTES,
+    allowHttp: true,
+    // `jamdesk dev` only: an author previewing against their own local API.
+    // Never true for a $ref, and the CLI is the only thing that sets the env.
+    allowLoopback: process.env.JAMDESK_LOCAL_DEV === '1',
+    accept: 'application/json',
+  });
+}
+
+function isFileRef(url) {
+  const match = /^(\w{2,}):\/\//.exec(url);
+  return !match || match[1].toLowerCase() === 'file';
+}
+
+function toFileSystemPath(url) {
+  return /^file:\/\//i.test(url) ? fileURLToPath(url) : decodeURIComponent(url);
+}
+
+/**
+ * Whether `target` is strictly inside `dir` (both absolute; pass realpaths to
+ * stop symlink hops). Same helper as copy-files.cjs. The TS file uses
+ * shared/path-security.ts isPathWithinProject, which this CJS file cannot
+ * import.
+ */
+function isRealPathInside(dir, target) {
+  const rel = path.relative(dir, target);
+  return rel !== '' && rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+
+function hasGitSegment(relativePath) {
+  return relativePath.split(/[\\/]/).some((segment) => segment.toLowerCase() === '.git');
+}
+
+// Same lexical rules as shared/path-security.ts isPathWithinProject (which
+// this file cannot import), but strict: the boundary itself is not a file.
+function isLexicallyInside(target, boundaryDir) {
+  if (target.includes('\0') || target.includes('%00')) return false;
+  if (/%2f/i.test(target) || /%5c/i.test(target)) return false;
+  const lexicalBoundary = path.resolve(boundaryDir);
+  return isRealPathInside(lexicalBoundary, path.resolve(lexicalBoundary, target.replace(/\\/g, '/')));
+}
+
+function isReadableProjectFile(target, boundaryDir) {
+  if (!isLexicallyInside(target, boundaryDir)) return false;
+  const lexicalBoundary = path.resolve(boundaryDir);
+  const lexicalTarget = path.resolve(lexicalBoundary, target.replace(/\\/g, '/'));
+  if (hasGitSegment(path.relative(lexicalBoundary, lexicalTarget))) return false;
+  let realTarget;
+  let realBoundary;
+  try {
+    realTarget = fs.realpathSync(target);
+    realBoundary = fs.realpathSync(boundaryDir);
+  } catch {
+    return false;
+  }
+  return isRealPathInside(realBoundary, realTarget) && !hasGitSegment(path.relative(realBoundary, realTarget));
+}
+
+function refusedFileRef(target, boundaryDir) {
+  const rel = path.relative(path.resolve(boundaryDir), path.resolve(target)).split(path.sep).join('/');
+  return new Error(`Cannot resolve $ref: "${rel}" (missing, outside the project, or inside .git)`);
+}
+
+function createProjectFileResolver(boundaryDir) {
+  return {
+    order: 100,
+    canRead: (file) => isFileRef(file.url),
+    read: async (file) => {
+      const target = toFileSystemPath(file.url);
+      if (!isReadableProjectFile(target, boundaryDir)) throw refusedFileRef(target, boundaryDir);
+      try {
+        return await fs.promises.readFile(fs.realpathSync(target));
+      } catch {
+        throw refusedFileRef(target, boundaryDir);
+      }
+    },
+  };
+}
+
+const RENDER_FILE_REF_MESSAGE = 'Cannot resolve $ref: file $refs are not resolved at render time';
+
+function createRefuseFileResolver() {
+  return {
+    order: 100,
+    canRead: (file) => isFileRef(file.url),
+    read: () => {
+      throw new Error(RENDER_FILE_REF_MESSAGE);
+    },
+  };
+}
+
+function sanitizeRefError(err, boundaryDir) {
+  if (!(err instanceof Error)) return err;
+  const match = /^(?:Error reading file|Unable to resolve \$ref pointer) "(.+)"$/.exec(err.message);
+  const url = match && match[1];
+  if (!url || !isFileRef(url)) return err;
+  if (!boundaryDir) return new Error(RENDER_FILE_REF_MESSAGE);
+  let target = url;
+  try {
+    target = toFileSystemPath(url);
+  } catch {
+    // Malformed percent-encoding: judge the raw string.
+  }
+  return refusedFileRef(target, boundaryDir);
+}
+
+function createSafeHttpResolver() {
+  return {
+    order: 200,
+    canRead: (file) => /^https?:\/\//i.test(file.url),
+    read: (file) => fetchRefSafely(file.url),
+  };
+}
+
+function safeRefParserOptions(boundaryDir) {
+  return {
+    resolve: {
+      file: false,
+      http: false,
+      ...(boundaryDir
+        ? { projectFile: createProjectFileResolver(boundaryDir) }
+        : { refuseFile: createRefuseFileResolver() }),
+      safeHttps: createSafeHttpResolver(),
+    },
+  };
+}
+
+module.exports = {
+  REF_FETCH_TIMEOUT_MS,
+  REF_FETCH_MAX_BYTES,
+  SPEC_FETCH_TIMEOUT_MS,
+  SPEC_FETCH_MAX_BYTES,
+  isBlockedAddress,
+  checkRefUrl,
+  fetchRefSafely,
+  fetchSpecUrlSafely,
+  isReadableProjectFile,
+  isRealPathInside,
+  safeRefParserOptions,
+  sanitizeRefError,
+};

package/vendored/scripts/openapi-spec-loader.cjs

@@ -7,8 +7,8 @@
 // as lib/visibility-filter.ts / scripts/visibility-filter.cjs.
 
 const path = require('path');
-const fs = require('fs');
 const SwaggerParser = require('@apidevtools/swagger-parser');
+const { isReadableProjectFile, safeRefParserOptions } = require('./openapi-safe-ref-resolvers.cjs');
 
 const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
 
@@ -22,10 +22,15 @@ function createSpecLoader(docsDir) {
     const promise = (async () => {
       try {
         const full = path.resolve(docsDir, key);
-        if (!fs.existsSync(full)) return null;
-        // dereference() inlines every $ref. NOTE: for recursive schemas this
-        // produces genuinely circular JS objects — consumers MUST guard.
-        return await SwaggerParser.dereference(full);
+        // Frontmatter spec paths are customer input: out of docsDir, into .git
+        // or missing all read as missing. docsDir, not a repo root: these
+        // scripts run under the CLI, which has no notion of one.
+        if (!isReadableProjectFile(full, docsDir)) return null;
+        // dereference() inlines every $ref (file refs only inside docsDir,
+        // external refs only via the SSRF-safe https resolver). NOTE: for
+        // recursive schemas this produces genuinely circular JS objects —
+        // consumers MUST guard.
+        return await SwaggerParser.dereference(full, safeRefParserOptions(docsDir));
       } catch {
         return null;
       }

package/vendored/themes/base.css

@@ -1182,6 +1182,54 @@ img.center {
   box-shadow: var(--shadow-2xl);
 }
 
+/* Mermaid zoom (MermaidZoomModal) reuses the image modal and backdrop above. */
+/* Scrollable panel: a wide diagram fits the width, a tall one keeps its
+   readable size and scrolls instead of shrinking to fit 90vh. */
+.mermaid-zoom-panel {
+  position: relative;
+  width: 90vw;
+  max-height: 90vh;
+  overflow: auto;
+  background: var(--color-bg-primary);
+  border-radius: var(--radius-md);
+  box-shadow: var(--shadow-2xl);
+  padding: 1.5rem;
+  cursor: auto;
+}
+
+/* MermaidZoomModal caps this inline at 1.5x the diagram's natural width. */
+.mermaid-zoom-content {
+  margin: 0 auto;
+}
+
+/* Beats mermaid's inline max-width so the viewBox scales to the content width. */
+.mermaid-zoom-panel svg {
+  display: block;
+  width: 100% !important;
+  height: auto !important;
+  max-width: none !important;
+  min-width: 0 !important;
+}
+
+.mermaid-zoom-close {
+  position: sticky;
+  top: 0;
+  float: right;
+  z-index: 1;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2rem;
+  height: 2rem;
+  border-radius: var(--radius-md);
+  background: var(--color-bg-primary);
+  color: var(--color-text-secondary);
+}
+
+.mermaid-zoom-close:hover {
+  color: var(--color-text-primary);
+}
+
 /* ===== IFRAME STYLES ===== */
 iframe {
   border: none !important;

package/vendored/workspace-package-lock.json

@@ -2153,9 +2153,9 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "26.6.4",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.6.4.tgz",
-      "integrity": "sha512-ldVPDCzj7fsaGZrLB0NuHuTvJcsNasysBAqMolr/cgxrLd1xbqxIr3XJiPnHHJUCxj5sNF1vnRj9aWnrVh5Jcg==",
+      "version": "26.6.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.6.5.tgz",
+      "integrity": "sha512-uMzsv9stDdofIZBx4UGh4Z9ZgXnGC9seRDscilBcTHAeOFk67MZg/k9bWVfO+bk4qZmG+l52hRnLwUiH2LnJTg==",
       "license": "MIT",
       "dependencies": {
         "undici-types": "~8.9.0"
@@ -2449,9 +2449,9 @@
       }
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.11.27",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.27.tgz",
-      "integrity": "sha512-ElY12DaROGuan+lMmZ8Cvo/ZUbXPe7Enc/9VU/b1T3Kp4dwytRcNdR8DoSJN5SNJT/CuvcCA0DHDVmMOCePdRQ==",
+      "version": "2.11.28",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.28.tgz",
+      "integrity": "sha512-br0LOmjJqr6Rt4AEkadbcNf67Zpo7EPwKsWbjnRrJIa1QYFHQBqM4C7F2WTbV8ahTEcg1Eo+Y0aWjjORInYFyA==",
       "license": "Apache-2.0",
       "bin": {
         "baseline-browser-mapping": "dist/cli.cjs"
@@ -3279,9 +3279,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.449",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.449.tgz",
-      "integrity": "sha512-dKeYk/3SFQz+nXi5whp3OuJzeWABEG4zCtkWJ9+Vby1E1iFM2y0gElRtQvNXRPJTsj8WAF4HMP7hvP790QtJ9g==",
+      "version": "1.5.452",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.452.tgz",
+      "integrity": "sha512-cVvk1YBSj6571VmV6hdJTqj94Y79xSu8cj6Y9t6ae4Y4431z8/7EJFvu3rVp90xhfuv9BpPKUmaLfTo4+FOGBg==",
       "license": "ISC"
     },
     "node_modules/elkjs": {
@@ -5968,9 +5968,9 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.57",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.57.tgz",
-      "integrity": "sha512-kQK9LGGFiHtrWiNhZtA7Qbw17AQz+dmsEKODRIVTXA9+e5MS/2gZEBhYJt13GrAz5/IOZKddH/0Z3TP/Zgo+yw==",
+      "version": "2.0.58",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.58.tgz",
+      "integrity": "sha512-BdiKAgbfRlvfMq/XzO/AF9NPmaA8a+YpLAyAFTVFBj3gARrAIfWvNq7Q7NE4se3KgFu0KkrvQMxTS0XVnsGzHg==",
       "license": "MIT",
       "engines": {
         "node": ">=18"
@@ -7186,9 +7186,9 @@
       }
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz",
-      "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz",
+      "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==",
       "funding": [
         {
           "type": "opencollective",
@@ -7222,9 +7222,9 @@
       "license": "MIT"
     },
     "node_modules/uuid": {
-      "version": "14.0.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-14.0.2.tgz",
-      "integrity": "sha512-xZe/16rV4aa+HGSOCiY2YeLT1OybRLrrkL/Rqaq7p7GMVXjFh+6wN4oMYgjFmnSnhY8t6Xpdl2l9qmnHYuMHwQ==",
+      "version": "14.0.3",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-14.0.3.tgz",
+      "integrity": "sha512-Sc5u1VVln93y1Xnz4R+CunOZc7R9LUcTmhj7Rc7Eg3HVcf7rVn2FOoa812fe0W8p3jD7xeoGSYbfqCGGH2B6xw==",
       "funding": [
         "https://github.com/sponsors/broofa",
         "https://github.com/sponsors/ctavan"

package/vendored/components/chat/ChatFAB.tsx

@@ -1,36 +0,0 @@
-'use client';
-
-interface ChatFABProps {
-  isOpen: boolean;
-  onClick: () => void;
-}
-
-/**
- * Floating action button that opens the AI chat panel.
- * Pill-shaped with accent color, slides down/fades when chat panel is open.
- * Positioned above common third-party chat widgets (Crisp, Intercom) which
- * sit at bottom-right with z-index ~1,000,000+. We use z-[1000003] to ensure
- * clickability and bottom-20 to avoid visual overlap.
- */
-export function ChatFAB({ isOpen, onClick }: ChatFABProps) {
-  return (
-    <button
-      onClick={onClick}
-      className={`
-        fixed bottom-20 right-6 z-[1000003]
-        flex items-center gap-2 px-4 py-2.5
-        bg-[var(--color-accent)] text-white
-        rounded-full shadow-lg
-        transition-all duration-200
-        hover:shadow-xl hover:scale-105 cursor-pointer
-        focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-[var(--color-accent)]
-        ${isOpen ? 'translate-y-16 opacity-0 pointer-events-none' : 'translate-y-0 opacity-100'}
-      `}
-      aria-label="Open AI chat"
-      title="Ask AI"
-    >
-      <i className="fa-solid fa-comment text-sm" aria-hidden="true" />
-      <span className="text-sm font-medium">Ask AI</span>
-    </button>
-  );
-}