jamdesk 1.0.0

package/vendored/lib/redirect-matcher.ts

@@ -0,0 +1,296 @@
+/**
+ * Redirect Handling Module
+ *
+ * Fetches and matches redirects from _redirects.json in R2.
+ * Uses Upstash Redis for caching with 5-minute TTL.
+ */
+
+import { redis } from './redis';
+import { getFileBufferFromR2 } from './r2';
+
+// Cache TTL in seconds (5 minutes)
+const CACHE_TTL = 300;
+
+// Redis cache key prefix
+const CACHE_PREFIX = 'redirects:';
+
+/**
+ * Redirect rule as stored in _redirects.json
+ */
+export interface RedirectRule {
+  source: string;
+  destination: string;
+  permanent: boolean;
+  pattern: string;
+  hasWildcard: boolean;
+  // Pre-compiled regex for performance (added at runtime, not stored in JSON)
+  _compiledRegex?: RegExp;
+}
+
+/**
+ * Redirects file structure
+ */
+interface RedirectsFile {
+  version: number;
+  generatedAt?: string;
+  redirects: RedirectRule[];
+}
+
+/**
+ * Match result with resolved destination
+ */
+export interface RedirectMatch {
+  destination: string;
+  permanent: boolean;
+}
+
+/**
+ * Pre-compile regex patterns for wildcard rules.
+ * Mutates the rules array in place for performance.
+ */
+function compileRedirectPatterns(rules: RedirectRule[]): void {
+  for (const rule of rules) {
+    if (!rule.hasWildcard || !rule.pattern || rule._compiledRegex) continue;
+
+    try {
+      rule._compiledRegex = new RegExp(rule.pattern);
+    } catch (e) {
+      console.error('[Redirects] Invalid regex pattern:', rule.pattern, e);
+    }
+  }
+}
+
+/**
+ * Fetch redirects for a project from R2 with Redis caching
+ * Returns null if no redirects file or error (fail open)
+ */
+export async function getRedirects(projectName: string): Promise<RedirectRule[] | null> {
+  const cacheKey = `${CACHE_PREFIX}${projectName}`;
+
+  // Try cache first (if Redis is available)
+  if (redis) {
+    try {
+      const cached = await redis.get<RedirectsFile>(cacheKey);
+      if (cached && cached.redirects) {
+        // Pre-compile regex patterns (not serialized in Redis)
+        compileRedirectPatterns(cached.redirects);
+        return cached.redirects;
+      }
+    } catch (error) {
+      console.error('[Redirects] Redis cache read failed:', error);
+      // Continue to fetch from R2
+    }
+  }
+
+  // Fetch from R2
+  try {
+    const buffer = await getFileBufferFromR2(projectName, '_redirects.json');
+    if (!buffer) {
+      // No redirects file - cache the "no redirects" state to avoid repeated R2 lookups
+      if (redis) {
+        try {
+          await redis.set(cacheKey, { version: 1, redirects: [] }, { ex: CACHE_TTL });
+        } catch {
+          // Ignore cache write errors
+        }
+      }
+      return null;
+    }
+
+    const content = buffer.toString('utf-8');
+    const data: RedirectsFile = JSON.parse(content);
+
+    if (!data.redirects || !Array.isArray(data.redirects)) {
+      return null;
+    }
+
+    // Pre-compile regex patterns for wildcard rules
+    compileRedirectPatterns(data.redirects);
+
+    // Cache in Redis
+    if (redis) {
+      try {
+        await redis.set(cacheKey, data, { ex: CACHE_TTL });
+      } catch {
+        // Ignore cache write errors
+      }
+    }
+
+    return data.redirects;
+  } catch (error) {
+    console.error('[Redirects] Failed to fetch redirects for', projectName, error);
+    return null; // Fail open
+  }
+}
+
+/**
+ * Normalize a path by stripping trailing slash (except for root)
+ */
+function normalizePath(pathname: string): string {
+  if (pathname === '/') return pathname;
+  return pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;
+}
+
+/**
+ * Paths that should never be redirected (system paths).
+ * These are protected to prevent redirect loops and system breakage.
+ */
+const PROTECTED_PATHS = [
+  '/api/',
+  '/_next/',
+  '/.well-known/',
+];
+
+/**
+ * Check if a redirect destination is invalid.
+ * Invalid destinations include system paths and malformed patterns.
+ */
+export function isInvalidDestination(destination: string): boolean {
+  // Destinations to system paths are invalid (would break the site)
+  for (const protected_path of PROTECTED_PATHS) {
+    if (destination.startsWith(protected_path)) {
+      return true;
+    }
+  }
+  // Destinations with unresolved wildcards are likely misconfigured
+  if (destination.includes('*')) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Match a pathname against redirect rules
+ * Returns the matched redirect with resolved destination, or null if no match
+ */
+// Max path length to process (limits ReDoS attack surface)
+const MAX_PATH_LENGTH = 2048;
+
+export function matchRedirect(
+  pathname: string,
+  redirects: RedirectRule[]
+): RedirectMatch | null {
+  // Never redirect protected system paths
+  for (const protected_path of PROTECTED_PATHS) {
+    if (pathname.startsWith(protected_path)) {
+      return null;
+    }
+  }
+
+  // Limit path length to reduce ReDoS attack surface
+  if (pathname.length > MAX_PATH_LENGTH) {
+    console.warn('[Redirects] Path too long, skipping redirect matching:', pathname.length);
+    return null;
+  }
+
+  // Normalize incoming path (strip trailing slash for matching)
+  const normalizedPath = normalizePath(pathname);
+
+  for (const rule of redirects) {
+    // Normalize rule source for matching
+    const normalizedSource = normalizePath(rule.source);
+
+    // Try exact match first (fast path)
+    if (!rule.hasWildcard && normalizedPath === normalizedSource) {
+      // Skip redirects with invalid destinations
+      if (isInvalidDestination(rule.destination)) {
+        console.warn('[Redirects] Skipping invalid destination:', normalizedPath, '->', rule.destination);
+        continue;
+      }
+      // Detect circular redirect (destination same as source)
+      const normalizedDest = normalizePath(rule.destination);
+      if (normalizedDest === normalizedPath) {
+        console.warn('[Redirects] Skipping circular redirect:', normalizedPath, '->', rule.destination);
+        continue;
+      }
+      return {
+        destination: rule.destination,
+        permanent: rule.permanent,
+      };
+    }
+
+    // Try pattern match for wildcards
+    if (rule.hasWildcard) {
+      // Use pre-compiled regex, skip rule if compilation failed
+      if (!rule._compiledRegex) continue;
+
+      // Safety: wrap regex match in try-catch to handle malformed patterns
+      // Note: This doesn't protect against ReDoS (catastrophic backtracking).
+      // Patterns should be validated at build time for production safety.
+      let match: RegExpMatchArray | null = null;
+      try {
+        match = normalizedPath.match(rule._compiledRegex);
+      } catch (error) {
+        console.error('[Redirects] Regex match failed:', rule.pattern, error);
+        continue; // Skip this rule
+      }
+
+      if (match) {
+        // Replace captured groups in destination
+        let destination = rule.destination;
+
+        // Handle :slug* style replacements
+        // The pattern captures groups, and destination uses :slug* placeholders
+        if (match.length > 1) {
+          // Replace :slug* in destination with captured value
+          const captured = match[1] || '';
+          destination = destination.replace(/:(\w+)\*/g, captured);
+
+          // Also handle trailing * in destination
+          if (destination.endsWith('/*')) {
+            destination = destination.slice(0, -2) + '/' + captured;
+          } else if (destination.endsWith('*')) {
+            destination = destination.slice(0, -1) + captured;
+          }
+        }
+
+        // Skip redirects with invalid destinations
+        if (isInvalidDestination(destination)) {
+          console.warn('[Redirects] Skipping invalid destination:', normalizedPath, '->', destination);
+          continue;
+        }
+
+        // Detect circular redirect (destination same as source after substitution)
+        const normalizedDest = normalizePath(destination);
+        if (normalizedDest === normalizedPath) {
+          console.warn('[Redirects] Skipping circular redirect:', normalizedPath, '->', destination);
+          continue;
+        }
+
+        return {
+          destination,
+          permanent: rule.permanent,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Merge query strings from source URL with destination
+ * Source query params take precedence on conflicts
+ */
+export function mergeQueryStrings(
+  sourceSearch: string,
+  destinationPath: string
+): string {
+  // Parse source query string
+  const sourceParams = new URLSearchParams(sourceSearch);
+  if (sourceParams.toString() === '') {
+    return destinationPath; // No source params to merge
+  }
+
+  // Check if destination has query string
+  const [destPath, destSearch] = destinationPath.split('?');
+  const destParams = new URLSearchParams(destSearch || '');
+
+  // Merge: source params override destination params
+  for (const [key, value] of sourceParams) {
+    destParams.set(key, value);
+  }
+
+  const mergedSearch = destParams.toString();
+  return mergedSearch ? `${destPath}?${mergedSearch}` : destPath;
+}

package/vendored/lib/redis.ts

@@ -0,0 +1,23 @@
+// DO NOT EDIT — this file is auto-synced from shared/. Edit the source in shared/ and run ./scripts/sync-shared.sh
+
+/**
+ * Shared Redis Client Module
+ *
+ * Provides a singleton Upstash Redis client.
+ * Supports both UPSTASH_REDIS_* and KV_* environment variable naming conventions.
+ *
+ * SYNC TARGET: This file is the source of truth.
+ * Synced to: builder/build-service/lib, proxy/lib
+ */
+import { Redis } from '@upstash/redis';
+
+const redisUrl = process.env.UPSTASH_REDIS_REST_URL || process.env.KV_REST_API_URL;
+const redisToken = process.env.UPSTASH_REDIS_REST_TOKEN || process.env.KV_REST_API_TOKEN;
+
+export const redis = redisUrl && redisToken && redisUrl.startsWith('https://')
+  ? new Redis({ url: redisUrl, token: redisToken })
+  : null;
+
+export function isRedisConfigured(): boolean {
+  return redis !== null;
+}

package/vendored/lib/rehype-class-to-classname.ts

@@ -0,0 +1,31 @@
+import { visit } from 'unist-util-visit';
+import type { Root, Element } from 'hast';
+
+/**
+ * Rehype plugin to convert HTML `class` attributes to React `className`
+ * 
+ * This fixes the React warning: "Invalid DOM property `class`. Did you mean `className`?"
+ * when MDX content contains raw HTML elements with class attributes.
+ */
+export function rehypeClassToClassName() {
+  return (tree: Root) => {
+    visit(tree, 'element', (node: Element) => {
+      if (node.properties) {
+        // Check for both 'class' and 'className' as MDX might pass either
+        if ('class' in node.properties) {
+          const classValue = node.properties.class;
+          // Merge with existing className if present
+          if (node.properties.className) {
+            const existing = Array.isArray(node.properties.className) 
+              ? node.properties.className.join(' ') 
+              : node.properties.className;
+            node.properties.className = `${existing} ${classValue}`;
+          } else {
+            node.properties.className = classValue;
+          }
+          delete node.properties.class;
+        }
+      }
+    });
+  };
+}

package/vendored/lib/rehype-code-meta.ts

@@ -0,0 +1,275 @@
+import { visit } from 'unist-util-visit';
+import type { Root, Element } from 'hast';
+import type { Plugin } from 'unified';
+
+/**
+ * Parsed code fence metadata
+ */
+export interface CodeMeta {
+  /** Custom icon class (e.g., "fa-solid fa-terminal") */
+  icon?: string;
+  /** Title/filename to display in header (e.g., "utils.js") */
+  title?: string;
+  /** Line numbers to highlight (e.g., [1, 3, 4, 5, 10]) */
+  highlightLines?: number[];
+  /** Whether to show line numbers */
+  showLineNumbers?: boolean;
+  /** Starting line number (default: 1) */
+  startLine?: number;
+  /** Remaining meta string (status codes, etc.) */
+  meta?: string;
+}
+
+/**
+ * Parse icon attribute from meta string
+ * Supports: icon="fa-solid fa-terminal" or icon='custom-icon'
+ */
+function parseIcon(meta: string): string | undefined {
+  const match = meta.match(/icon=["']([^"']+)["']/);
+  return match ? match[1] : undefined;
+}
+
+/**
+ * Parse title attribute from meta string
+ * Supports: title="filename.js" or title='utils.ts'
+ */
+function parseTitle(meta: string): string | undefined {
+  const match = meta.match(/title=["']([^"']+)["']/);
+  return match ? match[1] : undefined;
+}
+
+/**
+ * Parse line highlight ranges from meta string
+ * Supports: {1}, {1,3}, {1-5}, {1,3-5,10}
+ * Returns array of individual line numbers
+ */
+function parseHighlightLines(meta: string): number[] | undefined {
+  const match = meta.match(/\{([^}]+)\}/);
+  if (!match) return undefined;
+
+  const lines: number[] = [];
+  const parts = match[1].split(',');
+
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed.includes('-')) {
+      // Range: "3-5" -> [3, 4, 5]
+      const [start, end] = trimmed.split('-').map(Number);
+      if (!isNaN(start) && !isNaN(end)) {
+        for (let i = start; i <= end; i++) {
+          lines.push(i);
+        }
+      }
+    } else {
+      // Single number: "3" -> [3]
+      const num = Number(trimmed);
+      if (!isNaN(num)) {
+        lines.push(num);
+      }
+    }
+  }
+
+  return lines.length > 0 ? lines : undefined;
+}
+
+/**
+ * Parse showLineNumbers flag from meta string
+ */
+function parseShowLineNumbers(meta: string): boolean {
+  return /\bshowLineNumbers\b/.test(meta);
+}
+
+/**
+ * Parse startLine attribute from meta string
+ * Supports: startLine=10 or startLine="10"
+ */
+function parseStartLine(meta: string): number | undefined {
+  const match = meta.match(/startLine=["']?(\d+)["']?/);
+  if (match) {
+    const num = Number(match[1]);
+    return !isNaN(num) ? num : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Remove parsed attributes from meta string
+ */
+function cleanMeta(meta: string): string {
+  return meta
+    .replace(/\s*icon=["'][^"']+["']\s*/g, ' ')
+    .replace(/\s*title=["'][^"']+["']\s*/g, ' ')
+    .replace(/\s*\{[^}]+\}\s*/g, ' ')
+    .replace(/\s*showLineNumbers\s*/g, ' ')
+    .replace(/\s*startLine=["']?\d+["']?\s*/g, ' ')
+    .trim();
+}
+
+/**
+ * Parse all code fence metadata from meta string
+ */
+export function parseCodeMeta(meta: string): CodeMeta {
+  const explicitTitle = parseTitle(meta);
+  const cleanedMeta = cleanMeta(meta);
+
+  // If no explicit title= attribute but there's remaining text after parsing,
+  // use that text as the title (e.g., "Header" in ```json Header)
+  const fallbackTitle = !explicitTitle && cleanedMeta ? cleanedMeta : undefined;
+
+  return {
+    icon: parseIcon(meta),
+    title: explicitTitle || fallbackTitle,
+    highlightLines: parseHighlightLines(meta),
+    showLineNumbers: parseShowLineNumbers(meta),
+    startLine: parseStartLine(meta),
+    // Only include meta if we didn't use it as the title
+    meta: explicitTitle ? cleanedMeta || undefined : undefined,
+  };
+}
+
+/**
+ * Rehype plugin to pass code fence meta strings as data attributes
+ *
+ * Parses:
+ * - icon="fa-solid fa-terminal" → data-icon
+ * - title="filename.js" → data-title
+ * - {1,3-5} → data-highlight-lines (JSON array)
+ * - showLineNumbers → data-show-line-numbers
+ * - startLine=10 → data-start-line
+ * - Remaining text → data-meta (e.g., "200: Success")
+ *
+ * Attributes are added to both the code element and parent pre element
+ * so they're accessible from both React component mappings.
+ */
+export function rehypeCodeMeta() {
+  return (tree: Root) => {
+    visit(tree, 'element', (node: Element, _index, parent) => {
+      if (node.tagName === 'code' && node.data?.meta) {
+        const meta = node.data.meta as string;
+        const parsed = parseCodeMeta(meta);
+
+        // DEBUG: Log what we're parsing
+
+        node.properties = node.properties || {};
+
+        // Store parsed data in node.data so Shiki transformers can access it
+        node.data = node.data || {};
+        (node.data as any).parsedMeta = parsed;
+
+        if (parsed.icon) {
+          node.properties['data-icon'] = parsed.icon;
+        }
+        if (parsed.title) {
+          node.properties['data-title'] = parsed.title;
+        }
+        if (parsed.highlightLines) {
+          node.properties['data-highlight-lines'] = JSON.stringify(parsed.highlightLines);
+        }
+        if (parsed.showLineNumbers) {
+          node.properties['data-show-line-numbers'] = 'true';
+        }
+        if (parsed.startLine !== undefined) {
+          node.properties['data-start-line'] = String(parsed.startLine);
+        }
+        if (parsed.meta) {
+          node.properties['data-meta'] = parsed.meta;
+        }
+
+        // Also add title to parent pre element for easier access in MDX components
+        if (parsed.title && parent && (parent as Element).tagName === 'pre') {
+          const preNode = parent as Element;
+          preNode.properties = preNode.properties || {};
+          preNode.properties['data-title'] = parsed.title;
+          // Store in parent data as well
+          preNode.data = preNode.data || {};
+          (preNode.data as any).parsedTitle = parsed.title;
+        }
+      }
+    });
+  };
+}
+
+/**
+ * Common language names and their variants used in CodeGroup tabs
+ * These should NOT be converted to titles
+ */
+const LANGUAGE_LABELS = new Set([
+  // Language names
+  'javascript', 'typescript', 'python', 'java', 'ruby', 'php', 'go', 'rust',
+  'c', 'cpp', 'csharp', 'c#', 'swift', 'kotlin', 'scala', 'r', 'perl',
+  'bash', 'shell', 'sh', 'powershell', 'cmd',
+  'html', 'css', 'scss', 'sass', 'less',
+  'json', 'xml', 'yaml', 'yml', 'toml', 'ini', 'csv',
+  'sql', 'graphql', 'markdown', 'md',
+  // Short forms and variants
+  'js', 'ts', 'py', 'rb', 'cs', 'rs', 'kt',
+  // Tool names often used as labels
+  'curl', 'wget', 'npm', 'yarn', 'pip', 'gem', 'cargo', 'gradle', 'maven',
+  'docker', 'git', 'node', 'deno', 'bun',
+]);
+
+/**
+ * Check if a meta string looks like a language/tool label vs. a title
+ */
+function isLanguageLabel(meta: string, language?: string): boolean {
+  const normalized = meta.toLowerCase().trim();
+
+  // Check if it's in our language labels set
+  if (LANGUAGE_LABELS.has(normalized)) {
+    return true;
+  }
+
+  // Check if it matches the language (e.g., "JavaScript" for lang="javascript")
+  if (language && normalized === language.toLowerCase()) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Rehype plugin that restores data-title attributes after Shiki processing
+ *
+ * This plugin runs AFTER Shiki and converts data-meta to data-title for standalone code blocks.
+ *
+ * IMPORTANT: Preserves data-meta as tab labels for CodeGroup by detecting when data-meta
+ * contains language/tool names (e.g., "JavaScript", "cURL", "Python") vs. actual titles
+ * (e.g., "Header", "Request Headers", "Configuration").
+ */
+/**
+ * Check if meta string is a code fence feature (not a title)
+ * Features like showLineNumbers, {1,3-5}, startLine=N should not become titles
+ */
+function isCodeFenceFeature(meta: string): boolean {
+  const trimmed = meta.trim();
+  // Line highlighting: {1}, {1,3-5}, etc.
+  if (/^\{[\d,\-\s]+\}$/.test(trimmed)) return true;
+  // showLineNumbers flag
+  if (/^showLineNumbers(\s|$)/.test(trimmed)) return true;
+  // startLine=N
+  if (/^startLine=/.test(trimmed)) return true;
+  // Multiple features combined (no actual title)
+  if (/^(showLineNumbers|\{[\d,\-\s]+\}|startLine=\d+)(\s+(showLineNumbers|\{[\d,\-\s]+\}|startLine=\d+))*$/.test(trimmed)) return true;
+  return false;
+}
+
+export const rehypeRestoreDataTitle: Plugin<[], Root> = () => {
+  return (tree: Root) => {
+    visit(tree, 'element', (node: Element) => {
+      if (node.tagName === 'pre' && node.properties) {
+        const dataMeta = node.properties['data-meta'] as string | undefined;
+        const dataLanguage = node.properties['data-language'] as string | undefined;
+
+        // Only convert data-meta to data-title if:
+        // 1. data-meta exists
+        // 2. It doesn't look like a status code (no colon)
+        // 3. It's not a language/tool label (which CodeGroup uses for tabs)
+        // 4. It's not just code fence features (showLineNumbers, {1,3-5}, startLine=N)
+        if (dataMeta && !dataMeta.includes(':') && !isLanguageLabel(dataMeta, dataLanguage) && !isCodeFenceFeature(dataMeta)) {
+          node.properties['data-title'] = dataMeta;
+        }
+      }
+    });
+  };
+};
+

package/vendored/lib/rehype-nozoom-to-data.ts

@@ -0,0 +1,45 @@
+import { visit } from 'unist-util-visit';
+import type { Root, Element } from 'hast';
+
+/**
+ * Rehype plugin to convert custom image attributes to data attributes.
+ *
+ * Converts:
+ * - `noZoom` → `data-no-zoom` (disables image zoom on click)
+ * - `noStyle` → `data-no-style` (disables default image styling)
+ *
+ * Fixes React warning: "React does not recognize the `noZoom` prop on a DOM element"
+ * when MDX content uses <img noZoom ... /> or <img noStyle ... /> syntax.
+ *
+ * Note: This is a backup mechanism. The primary conversion happens in
+ * preprocess-mdx.ts at the text level before MDX parsing.
+ */
+export function rehypeNoZoomToData() {
+  return (tree: Root) => {
+    visit(tree, 'element', (node: Element) => {
+      if (node.properties) {
+        // Convert noZoom to data-no-zoom
+        // Check both camelCase (JSX) and lowercase (HTML) versions
+        if ('noZoom' in node.properties) {
+          node.properties['data-no-zoom'] = node.properties.noZoom;
+          delete node.properties.noZoom;
+        }
+        if ('nozoom' in node.properties) {
+          node.properties['data-no-zoom'] = node.properties.nozoom;
+          delete node.properties.nozoom;
+        }
+
+        // Convert noStyle to data-no-style
+        // Check both camelCase (JSX) and lowercase (HTML) versions
+        if ('noStyle' in node.properties) {
+          node.properties['data-no-style'] = node.properties.noStyle;
+          delete node.properties.noStyle;
+        }
+        if ('nostyle' in node.properties) {
+          node.properties['data-no-style'] = node.properties.nostyle;
+          delete node.properties.nostyle;
+        }
+      }
+    });
+  };
+}