jamdesk 1.1.223 → 1.1.225

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jamdesk",
-  "version": "1.1.223",
+  "version": "1.1.225",
   "description": "CLI for Jamdesk — build, preview, and deploy documentation sites from MDX. Dev server with hot reload, 50+ components, OpenAPI support, AI search, and Mintlify migration",
   "keywords": [
     "jamdesk",

package/vendored/lib/mdx-eval-guard.ts

@@ -37,6 +37,8 @@
  * live documentation sites.
  */
 
+import { transform } from '@babel/standalone';
+
 /** Name the runtime key guard is bound to inside the generated function. */
 export const KEY_GUARD_NAME = '__jdKey';
 
@@ -222,7 +224,11 @@ export function mdxEvalGuardPlugin({ types: t }: { types: any }) {
         // getBinding() — not hasBinding() — because hasBinding also reports
         // true for names merely *collected* as program globals, which is
         // exactly the case we need to reject.
-        if (path.scope.getBinding(name)) return;
+        //
+        // An import binding does not count: the snippet compiler strips import
+        // lines after transpile, so at runtime the name is the host global.
+        const binding = path.scope.getBinding(name);
+        if (binding && binding.kind !== 'module') return;
         reject(`"${name}"`);
       },
 
@@ -322,3 +328,183 @@ export function mdxEvalGuardPlugin({ types: t }: { types: any }) {
     },
   };
 }
+
+const PARAM_NAME = /^[A-Za-z_$][\w$]*$/;
+
+/**
+ * The ONLY place tenant code becomes a function. It checks the exact source
+ * it is about to compile, then compiles that same string.
+ *
+ * Why a second check on top of mdxEvalGuardPlugin: the plugin runs on the
+ * author's source, and later steps change that code before it runs (the
+ * TypeScript preset erases `declare` statements, the snippet compiler strips
+ * import lines and rewrites exports). Scope facts from the earlier pass, like
+ * "this name is declared locally", need not hold for the code that runs.
+ * This check parses the final JavaScript, applies no transforms, and trusts
+ * nothing from the earlier pass. It rejects instead of rewriting, so the
+ * runtime key guard must already wrap every dynamic key.
+ */
+export function compileGuardedFunction(
+  paramNames: string[],
+  body: string
+): (...args: unknown[]) => unknown {
+  const source = `${STRICT_MODE_PROLOGUE}\n${body}`;
+  assertExecutedCodeIsGuarded(paramNames, source);
+  // NOTE: new Function() is intentionally used here to compile tenant MDX
+  // components and snippets; `source` is exactly what was checked above.
+  return new Function(...paramNames, source) as (...args: unknown[]) => unknown;
+}
+
+function assertExecutedCodeIsGuarded(paramNames: string[], source: string): void {
+  for (const name of paramNames) {
+    if (!PARAM_NAME.test(name)) reject(`Parameter name "${name}"`);
+  }
+  if (!paramNames.includes(KEY_GUARD_NAME)) reject('Code without the key guard');
+
+  const wrapped = `(function (${paramNames.join(', ')}) {\n${source}\n});`;
+  try {
+    transform(wrapped, {
+      babelrc: false,
+      configFile: false,
+      code: false,
+      ast: false,
+      sourceType: 'script',
+      plugins: [executedCodeCheckPlugin(paramNames.length)],
+    });
+  } catch (error) {
+    if (error instanceof MdxEvalGuardError) throw error;
+    // Babel could not parse what new Function is about to compile. Refuse it
+    // rather than run code nothing has checked.
+    reject('Code that could not be checked');
+  }
+}
+
+/**
+ * Check-only twin of mdxEvalGuardPlugin, for the final JavaScript. Same deny
+ * lists, but every rule that rewrote there rejects here.
+ */
+function executedCodeCheckPlugin(paramCount: number) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function plugin(): any {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let wrapper: any = null;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const isGuardCall = (node: any) =>
+      node?.type === 'CallExpression' &&
+      node.callee?.type === 'Identifier' &&
+      node.callee.name === KEY_GUARD_NAME &&
+      node.arguments?.length === 1 &&
+      node.arguments[0].type !== 'SpreadElement';
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const checkComputedKey = (key: any) => {
+      if (key?.type === 'StringLiteral') {
+        if (FORBIDDEN_PROPERTIES.has(key.value)) reject(`Property "${key.value}"`);
+        return;
+      }
+      if (key?.type === 'NumericLiteral') return;
+      if (isGuardCall(key)) return;
+      reject('Unguarded dynamic property access');
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const checkMember = (path: any) => {
+      const { node } = path;
+      if (!node.computed) {
+        if (node.property?.type === 'Identifier' &&
+            FORBIDDEN_PROPERTIES.has(node.property.name)) {
+          reject(`Property "${node.property.name}"`);
+        }
+        return;
+      }
+      checkComputedKey(node.property);
+    };
+
+    return {
+      visitor: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Program(path: any) {
+          // The source must parse as exactly the one wrapper function, so
+          // text that closes the wrapper early is refused, not checked as
+          // something new Function would never see.
+          const body = path.node.body;
+          const expr = body.length === 1 && body[0].type === 'ExpressionStatement'
+            ? body[0].expression : null;
+          if (expr?.type !== 'FunctionExpression' ||
+              expr.params.length !== paramCount ||
+              (path.node.directives?.length ?? 0) > 0) {
+            reject('Code that could not be checked');
+          }
+          wrapper = expr;
+        },
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Identifier(path: any) {
+          const name = path.node.name;
+
+          if (name === KEY_GUARD_NAME) {
+            if (path.parentPath?.node === wrapper && path.listKey === 'params') return;
+            const call = path.parentPath;
+            if (call?.isCallExpression() && call.node.callee === path.node &&
+                isGuardCall(call.node)) {
+              const owner = call.parentPath;
+              const asMemberKey =
+                (owner?.isMemberExpression() || owner?.isOptionalMemberExpression()) &&
+                owner.node.computed && owner.node.property === call.node;
+              const asPatternKey =
+                owner?.isObjectProperty() && owner.node.computed &&
+                owner.node.key === call.node && owner.parentPath?.isObjectPattern();
+              const binding = path.scope.getBinding(name);
+              if ((asMemberKey || asPatternKey) && binding?.kind === 'param' &&
+                  binding.scope.block === wrapper) {
+                return;
+              }
+            }
+            reject(`"${KEY_GUARD_NAME}" outside a guarded key`);
+          }
+
+          if (!FORBIDDEN_GLOBALS.has(name)) return;
+          if (!path.isReferencedIdentifier() && !path.isBindingIdentifier()) return;
+          const binding = path.scope.getBinding(name);
+          if (binding && binding.kind !== 'module') return;
+          reject(`"${name}"`);
+        },
+
+        MemberExpression: checkMember,
+        OptionalMemberExpression: checkMember,
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ObjectProperty(path: any) {
+          const { node } = path;
+          const isPattern = path.parentPath?.isObjectPattern() === true;
+          if (node.computed) {
+            if (isPattern) checkComputedKey(node.key);
+            return;
+          }
+          const name = node.key?.type === 'Identifier' ? node.key.name :
+            node.key?.type === 'StringLiteral' ? node.key.value : null;
+          if (name === null) return;
+          if (isPattern ? FORBIDDEN_PROPERTIES.has(name) : name === '__proto__') {
+            reject(`Property "${name}"`);
+          }
+        },
+
+        ImportExpression() {
+          reject('Dynamic import()');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        CallExpression(path: any) {
+          if (path.node.callee?.type === 'Import') reject('Dynamic import()');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        MetaProperty(path: any) {
+          if (path.node.meta?.name === 'import') reject('import.meta');
+        },
+        WithStatement() {
+          reject('with statements');
+        },
+      },
+    };
+  };
+}

package/vendored/lib/mdx-inline-components.ts

@@ -30,7 +30,7 @@ import {
   mdxEvalGuardPlugin,
   guardPropertyKey,
   KEY_GUARD_NAME,
-  STRICT_MODE_PROLOGUE,
+  compileGuardedFunction,
 } from './mdx-eval-guard';
 
 interface InlineExports {
@@ -130,24 +130,17 @@ export function compileInlineComponents(
 
       // Step 3: Create and evaluate the component
       // The component has access to React, jsx runtime, AND built-in MDX components
-      // NOTE: new Function() is intentionally used here to compile user-provided MDX
-      // This is similar to how MDX itself works - user content becomes executable code
+      // compileGuardedFunction checks the final JavaScript, then compiles it with
+      // new Function. This is similar to how MDX itself works - user content becomes executable code
       // Babel's automatic runtime uses _jsx/_jsxs as variable names (with underscore)
       //
       // IMPORTANT: React hooks are intentionally NOT provided here. Inline components
       // are server-rendered during Next.js static export, and hooks only work client-side.
       // Users who need hooks should use snippet files with 'use client' directive instead.
 
-      const createComponent = new Function(
-        'React',
-        '_jsx',
-        '_jsxs',
-        '_Fragment',
-        KEY_GUARD_NAME, // runtime half of mdxEvalGuardPlugin — see mdx-eval-guard.ts
-        ...builtInNames, // Note, Card, Icon, Tip, Warning, etc.
-        // STRICT_MODE_PROLOGUE is load-bearing, not hygiene: without it this
-        // body is sloppy-mode and `this` is globalThis. See mdx-eval-guard.ts.
-        `${STRICT_MODE_PROLOGUE}\nreturn ${jsFunctionBody}`
+      const createComponent = compileGuardedFunction(
+        ['React', '_jsx', '_jsxs', '_Fragment', KEY_GUARD_NAME, ...builtInNames],
+        `return ${jsFunctionBody}`
       );
 
       const component = createComponent(
@@ -159,7 +152,7 @@ export function compileInlineComponents(
         ...builtInNames.map((n) => builtInComponents[n]) // Pass actual components
       );
 
-      components[name] = component;
+      components[name] = component as AnyComponent;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       errors.push(`Failed to compile inline component "${name}": ${errorMessage}`);

package/vendored/lib/snippet-loader-isr.ts

@@ -24,8 +24,8 @@ import {
   mdxEvalGuardPlugin,
   guardPropertyKey,
   KEY_GUARD_NAME,
-  STRICT_MODE_PROLOGUE,
   MdxEvalGuardError,
+  compileGuardedFunction,
 } from './mdx-eval-guard';
 import { extractUtilityCandidates, MAX_UTILITY_CANDIDATES } from './user-utility-css';
 import { logger } from '../shared/logger';
@@ -355,17 +355,9 @@ function evaluateSnippetCode(
   builtInNames: string[],
   builtInValues: AnyComponent[]
 ): unknown {
-  // NOTE: new Function() is intentionally used here to compile user-provided snippets
-  const fn = new Function(
-    'React',
-    '_jsx',
-    '_jsxs',
-    '_Fragment',
-    KEY_GUARD_NAME, // runtime half of mdxEvalGuardPlugin — see mdx-eval-guard.ts
-    ...builtInNames,
-    // STRICT_MODE_PROLOGUE is load-bearing, not hygiene: without it this
-    // body is sloppy-mode and `this` is globalThis. See mdx-eval-guard.ts.
-    `${STRICT_MODE_PROLOGUE}\n${code}`
+  const fn = compileGuardedFunction(
+    ['React', '_jsx', '_jsxs', '_Fragment', KEY_GUARD_NAME, ...builtInNames],
+    code
   );
   return fn(React, jsxRuntime.jsx, jsxRuntime.jsxs, jsxRuntime.Fragment, guardPropertyKey, ...builtInValues);
 }