camelmind 0.1.0

package/dist/index.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/commands/init.ts
+import path from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import fs from "fs-extra";
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_DIR = path.join(__dirname, "../template");
+var BANNER = `
+  ${chalk.hex("#D8A15B").bold("\u{1F42A} CamelMind")}  ${chalk.hex("#F4D6A7")("Doc site spun up in minutes.")}
+`;
+function validateProjectName(name) {
+  if (!/^[a-z0-9][a-z0-9-_]*$/.test(name)) {
+    return "Use lowercase letters, numbers, hyphens, or underscores (must start with a letter or digit)";
+  }
+  return true;
+}
+async function init(projectName, options) {
+  console.log(BANNER);
+  if (!projectName) {
+    const response = await prompts(
+      {
+        type: "text",
+        name: "name",
+        message: "What do you want to call your doc site?",
+        initial: "my-docs",
+        validate: validateProjectName
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    projectName = response.name;
+  } else {
+    const valid = validateProjectName(projectName);
+    if (valid !== true) {
+      console.error(chalk.red(`  Error: ${valid}`));
+      process.exit(1);
+    }
+  }
+  const targetDir = path.resolve(process.cwd(), projectName);
+  const displayDir = `./${path.relative(process.cwd(), targetDir)}`;
+  if (await fs.pathExists(targetDir)) {
+    const { overwrite } = await prompts(
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `${chalk.yellow(displayDir)} already exists \u2014 clear it and start fresh?`,
+        initial: false
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    if (!overwrite) {
+      console.log(chalk.gray("\n  Safe travels. Come back when you're ready.\n"));
+      process.exit(0);
+    }
+    await fs.remove(targetDir);
+  }
+  console.log(
+    `  Packing your caravan in ${chalk.cyan(displayDir)}
+`
+  );
+  const copySpinner = ora("Loading up the camel...").start();
+  try {
+    if (!await fs.pathExists(TEMPLATE_DIR)) {
+      copySpinner.fail(
+        "Template directory not found. Run `npm run sync-template` from the monorepo root first."
+      );
+      process.exit(1);
+    }
+    await fs.copy(TEMPLATE_DIR, targetDir, {
+      filter: (src) => !src.includes("node_modules") && !src.includes(".next") && !src.includes(".git")
+    });
+    const pkgSrc = path.join(targetDir, "_package.json");
+    const pkgDest = path.join(targetDir, "package.json");
+    if (await fs.pathExists(pkgSrc)) {
+      let content = await fs.readFile(pkgSrc, "utf-8");
+      content = content.replace(/\{\{projectName\}\}/g, projectName);
+      await fs.writeFile(pkgDest, content, "utf-8");
+      await fs.remove(pkgSrc);
+    }
+    const gitignoreSrc = path.join(targetDir, "_gitignore");
+    if (await fs.pathExists(gitignoreSrc)) {
+      await fs.move(gitignoreSrc, path.join(targetDir, ".gitignore"));
+    }
+    const envSrc = path.join(targetDir, "_env.example");
+    if (await fs.pathExists(envSrc)) {
+      await fs.move(envSrc, path.join(targetDir, ".env.example"));
+    }
+    copySpinner.succeed("Caravan loaded");
+  } catch (err) {
+    copySpinner.fail("Failed to load the caravan");
+    console.error(chalk.red(`
+  ${String(err)}
+`));
+    process.exit(1);
+  }
+  if (options.install) {
+    const installSpinner = ora("Gathering supplies...").start();
+    try {
+      execSync("npm install", {
+        cwd: targetDir,
+        stdio: "ignore"
+      });
+      installSpinner.succeed("Supplies ready");
+    } catch {
+      installSpinner.warn(
+        "Supply run failed \u2014 try npm install inside your project"
+      );
+    }
+  }
+  const cdCmd = chalk.cyan(`cd ${displayDir}`);
+  const installCmd = options.install ? "" : `
+    ${chalk.cyan("npm install")}`;
+  const devCmd = chalk.cyan("npm run dev");
+  console.log(`
+  ${chalk.hex("#D8A15B")("Your documentation journey starts here.")}
+
+  ${chalk.bold("Next steps:")}
+    ${cdCmd}${installCmd}
+    ${devCmd}
+
+  Then open ${chalk.underline("http://localhost:3000")} in your browser.
+`);
+}
+
+// src/index.ts
+var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
+var pkgPath = path2.join(__dirname2, "../package.json");
+var pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+var program = new Command();
+program.name("camelmind").description("CamelMind CLI \u2014 scaffold and manage documentation sites").version(pkg.version);
+program.command("init [project-name]").description("Create a new CamelMind documentation site").option("--no-install", "Skip installing npm dependencies").action(init);
+program.parse();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "camelmind",
+  "version": "0.1.0",
+  "description": "Create and manage CamelMind documentation sites",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "camelmind": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "documentation",
+    "docs",
+    "mdx",
+    "nextjs",
+    "camelmind"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/conniehnguyen/camelmind"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/template/_env.example

@@ -0,0 +1,16 @@
+# Site URL (used for absolute links; defaults to http://localhost:3000)
+CAMELMIND_URL=http://localhost:3000
+
+# Auth — disabled by default. Set to "true" to enable.
+CAMELMIND_AUTH_ENABLED=false
+CAMELMIND_AUTH_REQUIRE_LOGIN=false
+CAMELMIND_AUTH_PROVIDER=dev-mock
+
+# OIDC / SSO (required when CAMELMIND_AUTH_PROVIDER=oidc)
+# OIDC_ISSUER=https://your-idp.example.com/realms/your-realm
+# OIDC_CLIENT_ID=your-client-id
+# OIDC_CLIENT_SECRET=your-client-secret
+# OIDC_ROLES_CLAIM=realm_access.roles
+
+# Session secret (required when auth is enabled)
+# SESSION_SECRET=change-me-to-a-random-32-char-string

package/template/_gitignore

@@ -0,0 +1,32 @@
+# Dependencies
+node_modules/
+
+# Next.js
+.next/
+out/
+
+# Build outputs
+offline-builds/
+public/search-index.json
+
+# Environment variables
+.env.local
+.env.*.local
+
+# Editor
+.vscode/
+.idea/
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

package/template/_package.json

@@ -0,0 +1,39 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@tailwindcss/typography": "^0.5.20",
+    "gray-matter": "^4.0.3",
+    "jose": "^6.2.3",
+    "js-yaml": "^4.2.0",
+    "lucide-react": "^1.18.0",
+    "next": "16.2.9",
+    "next-mdx-remote": "^6.0.0",
+    "next-themes": "^0.4.6",
+    "pdf-lib": "^1.17.1",
+    "playwright": "^1.61.0",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "rehype-autolink-headings": "^7.1.0",
+    "rehype-slug": "^6.0.0",
+    "remark-gfm": "^4.0.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.9",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}

package/template/app/[...slug]/page.tsx

@@ -0,0 +1,150 @@
+import { notFound, redirect } from "next/navigation"
+import { MDXRemote } from "next-mdx-remote/rsc"
+import remarkGfm from "remark-gfm"
+import rehypeSlug from "rehype-slug"
+import rehypeAutolinkHeadings from "rehype-autolink-headings"
+import {
+  getAllSlugs,
+  getSlugsFromConfig,
+  getEntryBySlugFromConfig,
+  getGroupForSlugFromConfig,
+  getSectionForSlugFromConfig,
+} from "@/lib/nav"
+import { loadMdxFile } from "@/lib/mdx"
+import { getSession, hasAccess, pageRequiresAuth, shouldRedirectToLogin } from "@/lib/auth"
+import { isAuthEnabled } from "@/lib/config"
+import { loadVersions, getVersionFromSlug, getNavForVersion } from "@/lib/versions"
+import { TopNav } from "@/components/Nav/TopNav"
+import { Sidebar } from "@/components/Sidebar/Sidebar"
+import { Toc } from "@/components/Toc/Toc"
+import { Breadcrumbs } from "@/components/Breadcrumbs/Breadcrumbs"
+import { PageNav } from "@/components/PageNav/PageNav"
+import { SectionCards } from "@/components/SectionCards/SectionCards"
+import { DocActions } from "@/components/DocActions/DocActions"
+import { ZoomImages } from "@/components/ZoomImages/ZoomImages"
+import { mdxComponents } from "@/components/mdx"
+import type { NavGroup, NavEntry } from "@/lib/nav-types"
+
+type Props = {
+  params: Promise<{ slug: string[] }>
+}
+
+export async function generateStaticParams() {
+  // Default (unversioned) slugs — full depth
+  const defaultSlugs = getAllSlugs().map((slug) => ({
+    slug: slug.replace(/^\//, "").split("/"),
+  }))
+
+  // Versioned slugs — full depth from each version's nav
+  const { versions } = loadVersions()
+  const versionedSlugs = versions.flatMap((v) => {
+    const nav = getNavForVersion(v.id)
+    return getSlugsFromConfig(nav).map((slug) => ({
+      slug: slug.replace(/^\//, "").split("/"),
+    }))
+  })
+
+  return [...defaultSlugs, ...versionedSlugs]
+}
+
+export default async function DocPage({ params }: Props) {
+  const { slug } = await params
+  const fullSlug = "/" + slug.join("/")
+
+  const versionId = getVersionFromSlug(fullSlug)
+  const nav = getNavForVersion(versionId)   // correct nav for this version (or default)
+  const { versions } = loadVersions()
+
+  const versionSlugs: Record<string, string[]> = Object.fromEntries(
+    versions.map((v) => [v.id, getSlugsFromConfig(getNavForVersion(v.id))])
+  )
+
+  // All lookups use the version-appropriate nav
+  const navEntry = getEntryBySlugFromConfig(nav, fullSlug)
+  if (!navEntry) return notFound()
+
+  const session = await getSession()
+  const authEnabled = isAuthEnabled()
+
+  if (shouldRedirectToLogin(navEntry.roles, session)) {
+    redirect(`/login?returnTo=${encodeURIComponent(fullSlug)}`)
+  }
+
+  if (pageRequiresAuth(navEntry.roles) && session && !hasAccess(navEntry.roles, session.roles)) {
+    return (
+      <div className="flex flex-col h-screen">
+        <TopNav nav={nav.nav} userRoles={session.roles} userName={session.name} authEnabled={authEnabled} versions={versions} currentVersionId={versionId} currentSlug={fullSlug} versionSlugs={versionSlugs} />
+        <div className="flex flex-1 items-center justify-center bg-[var(--cm-bg-primary)]">
+          <div className="text-center">
+            <h1 className="text-2xl font-bold text-[var(--cm-text-primary)] mb-2">Access Restricted</h1>
+            <p className="text-[var(--cm-text-secondary)]">You don&apos;t have permission to view this page.</p>
+            <p className="text-xs text-[var(--cm-text-muted)] mt-2">
+              Required roles: {navEntry.roles.join(", ")} · Your roles: {session.roles.join(", ") || "none"}
+            </p>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  const activeGroup = getGroupForSlugFromConfig(nav, fullSlug) as NavGroup | null
+  const sectionEntry = getSectionForSlugFromConfig(nav, fullSlug) as NavEntry | null
+  const { frontmatter, source, toc } = loadMdxFile(navEntry.file)
+  const isSectionRoot = sectionEntry?.slug === fullSlug
+
+  return (
+    <div className="flex flex-col h-screen">
+      <TopNav nav={nav.nav} userRoles={session?.roles ?? []} userName={session?.name ?? null} authEnabled={authEnabled} versions={versions} currentVersionId={versionId} currentSlug={fullSlug} versionSlugs={versionSlugs} />
+      <div className="flex flex-1 overflow-hidden">
+        <Sidebar activeGroup={activeGroup} currentSlug={fullSlug} userRoles={session?.roles ?? []} authEnabled={authEnabled} />
+        <main className="flex-1 overflow-y-auto bg-white dark:bg-gray-950">
+          <div className="flex max-w-5xl mx-auto">
+            <article className="flex-1 px-4 md:px-10 py-6 md:py-8 min-w-0">
+              <div data-print="hide">
+                <Breadcrumbs
+                  activeGroup={activeGroup}
+                  sectionEntry={sectionEntry}
+                  currentEntry={navEntry as NavEntry}
+                />
+              </div>
+              <h1 className="text-3xl font-bold mb-2 text-gray-900 dark:text-gray-50">{frontmatter.title}</h1>
+              {frontmatter.description && (
+                <p className="text-gray-500 dark:text-gray-400 text-lg mb-6 leading-relaxed">{frontmatter.description}</p>
+              )}
+              <div data-print="hide">
+                <DocActions file={navEntry.file} downloadPdf={frontmatter.download_pdf} offline={process.env.OFFLINE_MODE === "true"} />
+              </div>
+              <ZoomImages />
+              <div className="prose prose-gray mt-6">
+                <MDXRemote
+                  source={source}
+                  components={mdxComponents}
+                  options={{
+                    // blockJS must be false so JSX prop expressions like n={1} are not stripped
+                    blockJS: false,
+                    mdxOptions: {
+                      remarkPlugins: [remarkGfm],
+                      rehypePlugins: [
+                        rehypeSlug,
+                        [rehypeAutolinkHeadings, { behavior: "wrap" }],
+                      ],
+                    },
+                  }}
+                />
+              </div>
+              {isSectionRoot && sectionEntry && (
+                <div data-print="hide">
+                  <SectionCards entry={sectionEntry} />
+                </div>
+              )}
+              <div data-print="hide">
+                <PageNav activeGroup={activeGroup} currentSlug={fullSlug} />
+              </div>
+            </article>
+            <Toc entries={toc} />
+          </div>
+        </main>
+      </div>
+    </div>
+  )
+}

package/template/app/api/auth/callback/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from "next/server"
+import { createSession, COOKIE_NAME } from "@/lib/auth"
+import { getAuthConfig, isAuthEnabled } from "@/lib/config"
+import { exchangeCodeForSession } from "@/lib/auth-providers/oidc"
+
+export async function GET(req: NextRequest) {
+  if (!isAuthEnabled()) {
+    return NextResponse.redirect("/home")
+  }
+
+  const { provider } = getAuthConfig()
+  if (provider !== "oidc") {
+    return NextResponse.redirect("/login")
+  }
+
+  const code = req.nextUrl.searchParams.get("code")
+  const stateParam = req.nextUrl.searchParams.get("state") ?? ""
+  const storedState = req.cookies.get("oidc_state")?.value
+
+  if (!code) {
+    return NextResponse.redirect("/login?error=missing_code")
+  }
+
+  const [state, encodedReturnTo] = stateParam.split(":")
+  if (!storedState || state !== storedState) {
+    return NextResponse.redirect("/login?error=invalid_state")
+  }
+
+  try {
+    const user = await exchangeCodeForSession(code)
+    const token = await createSession(user)
+    const returnTo = encodedReturnTo ? decodeURIComponent(encodedReturnTo) : "/home"
+    const redirect = returnTo.startsWith("/") ? returnTo : "/home"
+
+    const res = NextResponse.redirect(redirect)
+    res.cookies.set(COOKIE_NAME, token, {
+      httpOnly: true,
+      sameSite: "lax",
+      path: "/",
+      maxAge: 60 * 60 * 8,
+    })
+    res.cookies.set("oidc_state", "", { maxAge: 0, path: "/" })
+    return res
+  } catch {
+    return NextResponse.redirect("/login?error=oidc_failed")
+  }
+}

package/template/app/api/auth/login/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from "next/server"
+import { createSession, COOKIE_NAME } from "@/lib/auth"
+import { getAuthConfig, isAuthEnabled } from "@/lib/config"
+import { getDemoUser } from "@/lib/auth-providers/dev-mock"
+
+function sanitizeReturnTo(returnTo: unknown): string {
+  const sanitized = typeof returnTo === "string" ? returnTo.replace(/^\/\/+/, "/") : ""
+  return sanitized.startsWith("/") ? sanitized : "/home"
+}
+
+/** Legacy dev-mock login endpoint — kept for backwards compatibility. */
+export async function POST(req: NextRequest) {
+  if (!isAuthEnabled()) {
+    return NextResponse.json({ error: "Auth is not enabled" }, { status: 404 })
+  }
+
+  const { provider } = getAuthConfig()
+  if (provider !== "dev-mock") {
+    return NextResponse.json({ error: "Use GET /api/auth/signin for OIDC login" }, { status: 400 })
+  }
+
+  const { persona, returnTo } = await req.json()
+  const user = getDemoUser(persona)
+  if (!user) {
+    return NextResponse.json({ error: "Unknown persona" }, { status: 400 })
+  }
+
+  const token = await createSession(user)
+  const redirect = sanitizeReturnTo(returnTo)
+
+  const res = NextResponse.json({ ok: true, redirectTo: redirect })
+  res.cookies.set(COOKIE_NAME, token, {
+    httpOnly: true,
+    sameSite: "lax",
+    path: "/",
+    maxAge: 60 * 60 * 8,
+  })
+  return res
+}

package/template/app/api/auth/logout/route.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from "next/server"
+import { COOKIE_NAME } from "@/lib/auth"
+
+export async function POST() {
+  const res = NextResponse.json({ ok: true })
+  res.cookies.set(COOKIE_NAME, "", { maxAge: 0, path: "/" })
+  return res
+}

package/template/app/api/auth/signin/route.ts

@@ -0,0 +1,64 @@
+import { NextRequest, NextResponse } from "next/server"
+import { createSession, COOKIE_NAME } from "@/lib/auth"
+import { getAuthConfig, isAuthEnabled } from "@/lib/config"
+import { getDemoUser } from "@/lib/auth-providers/dev-mock"
+import { getOidcAuthorizationUrl, isOidcConfigured } from "@/lib/auth-providers/oidc"
+import crypto from "crypto"
+
+function sanitizeReturnTo(returnTo: unknown): string {
+  const sanitized = typeof returnTo === "string" ? returnTo.replace(/^\/\/+/, "/") : ""
+  return sanitized.startsWith("/") ? sanitized : "/home"
+}
+
+/** Initiate sign-in — OIDC redirect or dev-mock instructions. */
+export async function GET(req: NextRequest) {
+  if (!isAuthEnabled()) {
+    return NextResponse.json({ error: "Auth is not enabled" }, { status: 404 })
+  }
+
+  const returnTo = sanitizeReturnTo(req.nextUrl.searchParams.get("returnTo"))
+  const { provider } = getAuthConfig()
+
+  if (provider === "oidc") {
+    if (!isOidcConfigured()) {
+      return NextResponse.json({ error: "OIDC is not configured" }, { status: 500 })
+    }
+    const state = crypto.randomBytes(16).toString("hex")
+    const url = await getOidcAuthorizationUrl(returnTo, state)
+    const res = NextResponse.redirect(url)
+    res.cookies.set("oidc_state", state, { httpOnly: true, sameSite: "lax", path: "/", maxAge: 600 })
+    return res
+  }
+
+  return NextResponse.redirect(`/login?returnTo=${encodeURIComponent(returnTo)}`)
+}
+
+/** Dev-mock sign-in via persona selection. */
+export async function POST(req: NextRequest) {
+  if (!isAuthEnabled()) {
+    return NextResponse.json({ error: "Auth is not enabled" }, { status: 404 })
+  }
+
+  const { provider } = getAuthConfig()
+  if (provider !== "dev-mock") {
+    return NextResponse.json({ error: "Use GET /api/auth/signin for OIDC login" }, { status: 400 })
+  }
+
+  const { persona, returnTo } = await req.json()
+  const user = getDemoUser(persona)
+  if (!user) {
+    return NextResponse.json({ error: "Unknown persona" }, { status: 400 })
+  }
+
+  const token = await createSession(user)
+  const redirect = sanitizeReturnTo(returnTo)
+
+  const res = NextResponse.json({ ok: true, redirectTo: redirect })
+  res.cookies.set(COOKIE_NAME, token, {
+    httpOnly: true,
+    sameSite: "lax",
+    path: "/",
+    maxAge: 60 * 60 * 8,
+  })
+  return res
+}

package/template/app/api/download/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from "next/server"
+import fs from "fs"
+import path from "path"
+import { getSession } from "@/lib/auth"
+import { isAuthEnabled } from "@/lib/config"
+import { loadVersions } from "@/lib/versions"
+
+export async function GET(req: NextRequest) {
+  const session = await getSession()
+  if (isAuthEnabled() && !session) {
+    return new NextResponse("Unauthorized", { status: 401 })
+  }
+
+  const versionId = req.nextUrl.searchParams.get("version")
+  const rawType = req.nextUrl.searchParams.get("type") ?? "zip"
+  if (rawType !== "zip" && rawType !== "pdf") {
+    return new NextResponse("Invalid type parameter", { status: 400 })
+  }
+  const type = rawType
+
+  if (!versionId) {
+    return new NextResponse("Missing version parameter", { status: 400 })
+  }
+
+  // Validate against known versions
+  const { versions } = loadVersions()
+  const version = versions.find((v) => v.id === versionId)
+  if (!version) {
+    return new NextResponse("Unknown version", { status: 404 })
+  }
+
+  // Only stable versions are available for download
+  if (!version.stable) {
+    return new NextResponse("Download not available for pre-release versions", { status: 403 })
+  }
+
+  if (type === "pdf") {
+    const pdfPath = path.join(process.cwd(), "offline-builds", `camelmind-${versionId}.pdf`)
+    if (!fs.existsSync(pdfPath)) {
+      return new NextResponse("PDF not yet built for this version", { status: 404 })
+    }
+    const stat = fs.statSync(pdfPath)
+    const buffer = fs.readFileSync(pdfPath)
+    return new NextResponse(buffer, {
+      headers: {
+        "Content-Type": "application/pdf",
+        "Content-Disposition": `attachment; filename="camelmind-${versionId}.pdf"`,
+        "Content-Length": stat.size.toString(),
+      },
+    })
+  }
+
+  // Default: ZIP
+  const zipPath = path.join(process.cwd(), "offline-builds", `camelmind-${versionId}-offline.zip`)
+  if (!fs.existsSync(zipPath)) {
+    return new NextResponse("Offline package not yet built for this version", { status: 404 })
+  }
+  const stat = fs.statSync(zipPath)
+  const buffer = fs.readFileSync(zipPath)
+  return new NextResponse(buffer, {
+    headers: {
+      "Content-Type": "application/zip",
+      "Content-Disposition": `attachment; filename="camelmind-${versionId}-offline.zip"`,
+      "Content-Length": stat.size.toString(),
+    },
+  })
+}