@avocadostudio-ai/site-sdk 0.1.0

package/dist/cli/register.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * `avocado-register` — register a Next.js site with an Avocado Studio
+ * orchestrator without going through the editor UI.
+ *
+ * Designed to be the final step of the "bring your own coding agent" path:
+ * after Codex / Claude Code / Cursor / etc. has wired the @avocadostudio-ai/site-sdk
+ * into the user's Next.js project, this CLI is what makes the site appear in
+ * the editor's dashboard.
+ *
+ * What it does:
+ *   1. Parses CLI args.
+ *   2. Reads `.env.local` in the target project, looks for an existing
+ *      DRAFT_MODE_SECRET. If missing, generates a cryptographically random
+ *      secret (32 random bytes, hex-encoded) and writes it to `.env.local`.
+ *      Also fills in ORCHESTRATOR_URL and the NEXT_PUBLIC_* vars if absent.
+ *   3. POSTs the site config to `<ORCHESTRATOR_URL>/sites/register`.
+ *   4. Prints next steps (and any warnings the orchestrator returned about
+ *      secret mismatches with the editor's build-time config).
+ *
+ * Usage:
+ *   npx @avocadostudio-ai/site-sdk register --name "My Site"
+ *   npx @avocadostudio-ai/site-sdk register --id my-site --name "My Site" --port 3000
+ *   npx @avocadostudio-ai/site-sdk register --help
+ *
+ * Defaults:
+ *   --id            kebab-case of --name (or the project's package.json `name`)
+ *   --port          parsed from `scripts.dev` in package.json, falls back to 3000
+ *   --orchestrator  $ORCHESTRATOR_URL or http://localhost:4200
+ *   --session       dev
+ *   --cwd           process.cwd()
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = () => argv[++i];
+        switch (a) {
+            case "--id":
+                out.id = next();
+                break;
+            case "--name":
+                out.name = next();
+                break;
+            case "--port":
+                out.port = Number(next());
+                break;
+            case "--orchestrator":
+            case "--orchestrator-url":
+                out.orchestrator = next();
+                break;
+            case "--secret":
+                out.secret = next();
+                break;
+            case "--session":
+                out.session = next();
+                break;
+            case "--cwd":
+                out.cwd = next();
+                break;
+            case "--purpose":
+                out.purpose = next();
+                break;
+            case "--preview-url":
+                out.previewUrl = next();
+                break;
+            case "-h":
+            case "--help":
+                out.help = true;
+                break;
+            default:
+                if (a.startsWith("--")) {
+                    process.stderr.write(`Unknown flag: ${a}\n`);
+                    process.exit(2);
+                }
+        }
+    }
+    return out;
+}
+function printHelp() {
+    process.stdout.write(`
+avocado-register — register a Next.js site with an Avocado Studio orchestrator
+
+USAGE
+  npx @avocadostudio-ai/site-sdk register [options]
+
+REQUIRED
+  --name <string>           Human-readable site name (or read from package.json name)
+
+OPTIONAL
+  --id <kebab-case>         Site ID (default: kebab-case of name or package.json name)
+  --port <number>           Dev server port (default: parsed from package.json scripts.dev, or 3000)
+  --orchestrator <url>      Orchestrator URL (default: $ORCHESTRATOR_URL or http://localhost:4200)
+  --secret <string>         DRAFT_MODE_SECRET (default: read from .env.local, or generate random)
+  --session <string>        Orchestrator session (default: dev)
+  --purpose <string>        One-line site description for AI context
+  --preview-url <url>       Preview URL (default: http://localhost:<port>)
+  --cwd <path>              Project directory (default: current working directory)
+  -h, --help                Show this help
+
+EXAMPLES
+  # Register the site in the current directory, auto-detect everything
+  npx @avocadostudio-ai/site-sdk register --name "Marketing Site"
+
+  # Register a site with explicit values
+  npx @avocadostudio-ai/site-sdk register \\
+    --id marketing-site \\
+    --name "Marketing Site" \\
+    --port 3000 \\
+    --orchestrator http://localhost:4200
+
+NEXT STEPS
+  After running this command, refresh the editor at http://localhost:4100
+  and the site will appear in the dashboard.
+`);
+}
+function kebabCase(s) {
+    return s
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .replace(/[^a-zA-Z0-9-]/g, "")
+        .toLowerCase()
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function readPackageJson(cwd) {
+    const path = join(cwd, "package.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function detectPortFromPackageJson(pkg) {
+    const dev = pkg?.scripts?.dev;
+    if (!dev)
+        return null;
+    // Look for `-p <port>` or `--port <port>` or `--port=<port>`
+    const m = dev.match(/(?:-p|--port)[\s=](\d+)/);
+    if (m)
+        return Number(m[1]);
+    return null;
+}
+function parseEnvFile(content) {
+    const out = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        const k = trimmed.slice(0, eq).trim();
+        let v = trimmed.slice(eq + 1).trim();
+        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+            v = v.slice(1, -1);
+        }
+        out[k] = v;
+    }
+    return out;
+}
+/**
+ * Append-only env merge: read the file as raw text, append `KEY=value` lines
+ * for any keys not already present, and write back. Preserves the user's
+ * original formatting (comments, key order, blank lines, hand-tuned values).
+ *
+ * The previous round-trip approach (parse → merge → serialize) silently
+ * dropped comments and reordered keys, which is real data loss for users
+ * with hand-curated `.env.local` files.
+ */
+function mergeEnvFile(envPath, existing, additions) {
+    const added = [];
+    const newLines = [];
+    for (const [k, v] of Object.entries(additions)) {
+        if (existing[k] === undefined) {
+            newLines.push(`${k}=${v}`);
+            added.push(k);
+        }
+    }
+    if (newLines.length === 0)
+        return added;
+    let original = "";
+    if (existsSync(envPath)) {
+        original = readFileSync(envPath, "utf-8");
+        if (original.length > 0 && !original.endsWith("\n"))
+            original += "\n";
+    }
+    writeFileSync(envPath, original + newLines.join("\n") + "\n", "utf-8");
+    return added;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    const cwd = resolve(args.cwd ?? process.cwd());
+    const pkg = readPackageJson(cwd);
+    // Resolve name
+    const name = args.name ?? (pkg?.name ? humanize(pkg.name) : null);
+    if (!name) {
+        process.stderr.write("Error: --name is required (or run from a directory with a package.json that has a `name` field).\n");
+        process.exit(1);
+    }
+    // Resolve siteId
+    const siteId = args.id ?? kebabCase(pkg?.name ?? name);
+    if (!siteId) {
+        process.stderr.write("Error: could not derive a site ID from --id, --name, or package.json. Pass --id explicitly.\n");
+        process.exit(1);
+    }
+    // Resolve port
+    const port = args.port ?? detectPortFromPackageJson(pkg) ?? 3000;
+    // Resolve orchestrator URL
+    const orchestrator = (args.orchestrator ?? process.env.ORCHESTRATOR_URL ?? "http://localhost:4200").replace(/\/+$/, "");
+    // Resolve / generate the draft secret
+    const envPath = join(cwd, ".env.local");
+    const existingEnv = existsSync(envPath) ? parseEnvFile(readFileSync(envPath, "utf-8")) : {};
+    let secret = args.secret ?? existingEnv.DRAFT_MODE_SECRET;
+    let secretGenerated = false;
+    if (!secret) {
+        secret = randomBytes(32).toString("hex");
+        secretGenerated = true;
+    }
+    // Append-only merge — only add keys that aren't already present, preserving
+    // the user's existing file formatting and comments.
+    const added = mergeEnvFile(envPath, existingEnv, {
+        ORCHESTRATOR_URL: orchestrator,
+        DRAFT_MODE_SECRET: secret,
+        NEXT_PUBLIC_DEFAULT_SITE_ID: siteId,
+        NEXT_PUBLIC_SITE_NAME: name,
+        NEXT_PUBLIC_EDITOR_ORIGIN: "http://localhost:4100",
+    });
+    // POST to the orchestrator with a 10s timeout — without it, a hung
+    // orchestrator (mid-handler stall, not just connection-refused) would freeze
+    // the CLI indefinitely with no feedback.
+    const previewUrl = args.previewUrl ?? `http://localhost:${port}`;
+    const ac = new AbortController();
+    const timeoutId = setTimeout(() => ac.abort(), 10_000);
+    let response;
+    try {
+        response = await fetch(`${orchestrator}/sites/register`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                siteId,
+                name,
+                port,
+                previewUrl,
+                purpose: args.purpose,
+                secret,
+                session: args.session ?? "dev",
+            }),
+            signal: ac.signal,
+        });
+    }
+    catch (err) {
+        const aborted = err.name === "AbortError";
+        process.stderr.write(`\nError: could not reach the orchestrator at ${orchestrator}\n`);
+        process.stderr.write(`  ${aborted ? "Request timed out after 10 seconds." : err.message}\n`);
+        process.stderr.write(`\nMake sure the orchestrator is running:\n  pnpm dev:orchestrator\n`);
+        process.exit(1);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        process.stderr.write(`\nOrchestrator responded ${response.status}:\n  ${text}\n`);
+        process.exit(1);
+    }
+    const result = (await response.json());
+    // Friendly output
+    process.stdout.write(`\nRegistered "${name}" with the orchestrator.\n`);
+    process.stdout.write(`  Site ID:      ${siteId}\n`);
+    process.stdout.write(`  Preview URL:  ${previewUrl}\n`);
+    process.stdout.write(`  Orchestrator: ${orchestrator}\n`);
+    if (secretGenerated) {
+        process.stdout.write(`  Secret:       generated (${secret.slice(0, 8)}…)\n`);
+    }
+    else {
+        process.stdout.write(`  Secret:       reused from .env.local\n`);
+    }
+    if (added.length > 0) {
+        process.stdout.write(`\n.env.local updated. Added: ${added.join(", ")}\n`);
+    }
+    else {
+        process.stdout.write(`\n.env.local unchanged (all keys already present).\n`);
+    }
+    if (Array.isArray(result.warnings) && result.warnings.length > 0) {
+        process.stdout.write(`\nWarnings:\n`);
+        for (const w of result.warnings) {
+            process.stdout.write(`  - ${w}\n`);
+        }
+    }
+    process.stdout.write(`\nNext steps:\n`);
+    process.stdout.write(`  1. Start your site:    pnpm dev   (in this directory)\n`);
+    process.stdout.write(`  2. Open the editor:    http://localhost:4100\n`);
+    process.stdout.write(`  3. The site should appear in the dashboard. If not, refresh the page.\n\n`);
+}
+function humanize(s) {
+    return s
+        .replace(/[-_]/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase())
+        .trim();
+}
+main().catch((err) => {
+    process.stderr.write(`\nUnexpected error: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/create-site-page.d.ts

@@ -0,0 +1,95 @@
+import type { JSX } from "react";
+import type { BlockInstance } from "./types.ts";
+import type { SiteConfig } from "@avocadostudio-ai/shared";
+import type { PageDoc } from "@avocadostudio-ai/shared";
+/**
+ * Configuration for creating a site page component.
+ *
+ * Provide your CMS-specific data fetchers and the factory handles:
+ * - Draft/editor mode detection and switching
+ * - Navigation header and footer chrome
+ * - Editor overlay for live editing
+ * - Static params generation for build-time rendering
+ * - 404 and draft-unavailable fallbacks
+ *
+ * @example Single-route ("auto") setup — everything in one [[...slug]] route
+ * ```ts
+ * // app/[[...slug]]/page.tsx
+ * import { createSitePage } from "@avocadostudio-ai/site-sdk/page"
+ * import { getPage, getSlugs, getSiteConfig } from "../../lib/my-cms"
+ *
+ * const { Page, generateStaticParams } = createSitePage({
+ *   siteId: "my-site",
+ *   getPage,
+ *   getSlugs,
+ *   getSiteConfig,
+ * })
+ *
+ * export default Page
+ * export { generateStaticParams }
+ * ```
+ *
+ * @example Split-route setup — fully static published path + dynamic preview path
+ * ```ts
+ * // middleware.ts
+ * import { createEditorMiddleware } from "@avocadostudio-ai/site-sdk/middleware"
+ * export const { middleware, config } = createEditorMiddleware()
+ *
+ * // app/[[...slug]]/page.tsx (statically generated)
+ * const { Page, generateStaticParams } = createSitePage({ mode: "static", ... })
+ * export default Page
+ * export { generateStaticParams }
+ *
+ * // app/preview-draft/[[...slug]]/page.tsx (dynamic editor route)
+ * export const dynamic = "force-dynamic"
+ * const { Page } = createSitePage({ mode: "preview", ... })
+ * export default Page
+ * ```
+ */
+export type SitePageConfig = {
+    /** Unique site identifier (used for session scoping) */
+    siteId: string;
+    /** Default session name. Defaults to "dev". */
+    session?: string;
+    /** Fetch a single page by slug from your CMS */
+    getPage: (slug: string) => Promise<PageDoc | null>;
+    /** Fetch all page slugs from your CMS (for static generation) */
+    getSlugs: () => Promise<string[]>;
+    /** Fetch site-wide config (name, logo, nav labels) from your CMS */
+    getSiteConfig?: () => Promise<SiteConfig>;
+    /** Default logo path. Defaults to "/logo.svg". */
+    defaultLogo?: string;
+    /** Footer block to render below content. Omit to hide footer. */
+    footer?: BlockInstance;
+    /** Render site header/footer chrome. Set false when the host layout provides its own. Defaults to true. */
+    chrome?: boolean;
+    /**
+     * Rendering mode. Defaults to `"auto"`.
+     *
+     * - `"auto"`: single-route — handles published and editor modes in one file. Works without middleware.
+     * - `"static"`: published-only — no searchParams, no editor logic, fully static. Pair with `createEditorMiddleware()` and a separate `mode: "preview"` route.
+     * - `"preview"`: editor-only — always reads searchParams + draft content. Set `export const dynamic = "force-dynamic"` on the route file.
+     */
+    mode?: "auto" | "static" | "preview";
+};
+type StaticPageProps = {
+    params: Promise<{
+        slug?: string[];
+    }>;
+};
+type DynamicPageProps = StaticPageProps & {
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+};
+/**
+ * Create a Next.js page component with full editor integration.
+ *
+ * Returns `{ Page, generateStaticParams }` — export them from your route file.
+ * See {@link SitePageConfig.mode} for the three rendering modes.
+ */
+export declare function createSitePage(config: SitePageConfig): {
+    Page: ({ params, searchParams }: DynamicPageProps) => Promise<JSX.Element>;
+    generateStaticParams: () => Promise<{
+        slug: string[] | undefined;
+    }[]>;
+};
+export {};

package/dist/create-site-page.js

@@ -0,0 +1,127 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { unstable_noStore as noStore } from "next/cache";
+import { draftMode } from "next/headers";
+import { SharedBlockRenderer, BlocksHydrator } from "@avocadostudio-ai/blocks";
+import { buildSlug } from "./index.js";
+import { resolveEditorContext, fetchEditorPage, fetchEditorSlugs } from "./draft.js";
+import { renderBlocks, EditorOverlay } from "./editor.js";
+import { buildNavItems, buildSiteHeaderBlock } from "./navigation.js";
+function resolve(config) {
+    return {
+        siteId: config.siteId,
+        defaultSession: config.session ?? "dev",
+        cmsGetPage: config.getPage,
+        cmsGetSlugs: config.getSlugs,
+        cmsGetSiteConfig: config.getSiteConfig,
+        defaultLogo: config.defaultLogo ?? "/logo.svg",
+        footer: config.footer,
+        chrome: config.chrome ?? true,
+    };
+}
+function makeGenerateStaticParams(cmsGetSlugs) {
+    return async function generateStaticParams() {
+        const slugs = await cmsGetSlugs();
+        return slugs.map((slug) => ({
+            slug: slug === "/" ? undefined : slug.replace(/^\//, "").split("/"),
+        }));
+    };
+}
+async function renderStatic(slug, c) {
+    const [page, navSlugs, siteConfig] = await Promise.all([
+        c.cmsGetPage(slug),
+        c.cmsGetSlugs(),
+        c.cmsGetSiteConfig ? c.cmsGetSiteConfig() : Promise.resolve({}),
+    ]);
+    const { navItems, siteName, siteLogo } = buildNavItems({
+        navSlugs,
+        currentSlug: slug,
+        siteConfig,
+        siteId: c.siteId,
+        editorQuery: "",
+        defaultLogo: c.defaultLogo,
+    });
+    const chromeHeader = buildSiteHeaderBlock({ navItems, siteName, siteLogo, activePath: slug });
+    if (!page) {
+        return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsxs("main", { style: { padding: "4rem", textAlign: "center" }, children: [_jsx("h1", { children: "404" }), _jsx("p", { children: "Page not found." })] }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null] }));
+    }
+    return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsxs("main", { children: [renderBlocks(page.blocks), _jsx(BlocksHydrator, {})] }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null] }));
+}
+async function renderPreview(slug, search, c) {
+    noStore();
+    const editorCtx = await resolveEditorContext(search, {
+        defaultSession: c.defaultSession,
+        defaultSiteId: c.siteId,
+    });
+    const session = editorCtx?.session ?? c.defaultSession;
+    const currentSiteId = editorCtx?.siteId ?? c.siteId;
+    const [page, navSlugs, siteConfig] = await Promise.all([
+        fetchEditorPage(slug, session, currentSiteId).then((p) => p ?? c.cmsGetPage(slug)),
+        fetchEditorSlugs(session, currentSiteId).then((s) => (s.length > 0 ? s : c.cmsGetSlugs())),
+        c.cmsGetSiteConfig ? c.cmsGetSiteConfig() : Promise.resolve({}),
+    ]);
+    const editorOrigin = editorCtx?.editorOrigin ?? "";
+    const editorQuery = (() => {
+        const p = new URLSearchParams({ session, siteId: currentSiteId });
+        if (editorOrigin)
+            p.set("editorOrigin", editorOrigin);
+        return `?${p.toString()}`;
+    })();
+    const { navItems, siteName, siteLogo } = buildNavItems({
+        navSlugs,
+        currentSlug: slug,
+        siteConfig,
+        siteId: c.siteId,
+        editorQuery,
+        defaultLogo: c.defaultLogo,
+    });
+    const chromeHeader = buildSiteHeaderBlock({ navItems, siteName, siteLogo, activePath: slug });
+    if (!page) {
+        return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsxs("main", { style: { padding: "4rem", textAlign: "center" }, children: [_jsx("h1", { children: "Draft unavailable" }), _jsxs("p", { children: ["Could not load draft content for ", slug, "."] })] }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null] }));
+    }
+    return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsx("main", { className: "editor-mode", children: renderBlocks(page.blocks, { editable: true }) }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null, _jsx(EditorOverlay, { slug: slug, editorOrigin: editorOrigin })] }));
+}
+async function renderAuto(slug, search, c) {
+    const editorCtx = await resolveEditorContext(search, {
+        defaultSession: c.defaultSession,
+        defaultSiteId: c.siteId,
+    });
+    const draft = await draftMode();
+    const editorMode = draft.isEnabled || !!editorCtx;
+    if (editorMode) {
+        return renderPreview(slug, search, c);
+    }
+    return renderStatic(slug, c);
+}
+/**
+ * Create a Next.js page component with full editor integration.
+ *
+ * Returns `{ Page, generateStaticParams }` — export them from your route file.
+ * See {@link SitePageConfig.mode} for the three rendering modes.
+ */
+export function createSitePage(config) {
+    const c = resolve(config);
+    const mode = config.mode ?? "auto";
+    const generateStaticParams = makeGenerateStaticParams(c.cmsGetSlugs);
+    if (mode === "static") {
+        async function Page({ params }) {
+            const { slug: slugParts } = await params;
+            const slug = buildSlug(slugParts);
+            return renderStatic(slug, c);
+        }
+        return { Page, generateStaticParams };
+    }
+    if (mode === "preview") {
+        async function Page({ params, searchParams }) {
+            const [{ slug: slugParts }, search] = await Promise.all([params, searchParams]);
+            const slug = buildSlug(slugParts);
+            return renderPreview(slug, search, c);
+        }
+        return { Page, generateStaticParams };
+    }
+    async function Page({ params, searchParams }) {
+        const [{ slug: slugParts }, search] = await Promise.all([params, searchParams]);
+        const slug = buildSlug(slugParts);
+        return renderAuto(slug, search, c);
+    }
+    return { Page, generateStaticParams };
+}

package/dist/draft-common.d.ts

@@ -0,0 +1,4 @@
+export declare const DRAFT_SESSION_COOKIE = "editor_draft_session";
+export declare const DRAFT_SITE_COOKIE = "editor_draft_site_id";
+export declare const EDITOR_ORIGIN_COOKIE = "editor_origin";
+export declare function normalizeOrigin(value: string | null | undefined): string | undefined;

package/dist/draft-common.js

@@ -0,0 +1,17 @@
+export const DRAFT_SESSION_COOKIE = "editor_draft_session";
+export const DRAFT_SITE_COOKIE = "editor_draft_site_id";
+export const EDITOR_ORIGIN_COOKIE = "editor_origin";
+export function normalizeOrigin(value) {
+    const raw = value?.trim();
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = new URL(decodeURIComponent(raw));
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            return undefined;
+        return parsed.origin;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/draft-context-core.d.ts

@@ -0,0 +1,11 @@
+import type { DraftContext, SearchParamsRecord } from "./types.ts";
+export { single } from "./draft-context.ts";
+export type DraftModeAdapter = {
+    isDraftMode: boolean;
+    getCookie: (name: string) => string | undefined;
+};
+export declare function resolveDraftContextCore(searchParams: SearchParamsRecord, adapter: DraftModeAdapter, options?: {
+    defaultSession?: string;
+    defaultSiteId?: string;
+    defaultEditorOrigin?: string;
+}): Promise<DraftContext | null>;

package/dist/draft-context-core.js

@@ -0,0 +1,26 @@
+import { DRAFT_SESSION_COOKIE, DRAFT_SITE_COOKIE, EDITOR_ORIGIN_COOKIE, normalizeOrigin } from "./draft-common.js";
+import { single } from "./draft-context.js";
+export { single } from "./draft-context.js";
+export async function resolveDraftContextCore(searchParams, adapter, options) {
+    const isDev = process.env.NODE_ENV !== "production";
+    const isEditorParam = single(searchParams.__editor) === "1";
+    const isContentStoreEnabled = isDev || adapter.isDraftMode || isEditorParam;
+    if (!isContentStoreEnabled)
+        return null;
+    const defaultSession = options?.defaultSession ?? process.env.DRAFT_DEFAULT_SESSION?.trim() ?? "dev";
+    const defaultSiteId = options?.defaultSiteId ?? process.env.DRAFT_DEFAULT_SITE_ID?.trim() ?? "";
+    const defaultEditorOrigin = options?.defaultEditorOrigin
+        ?? process.env.NEXT_PUBLIC_EDITOR_ORIGIN?.replace(/\/+$/, "")
+        ?? (isDev ? "http://localhost:4100" : "");
+    // Query param (from editor iframe) wins, then the site's own configured siteId,
+    // then cookie fallback. This prevents stale cookies from a different site
+    // overriding the current site's identity when accessed directly.
+    const siteId = single(searchParams.siteId) ?? (defaultSiteId || adapter.getCookie(DRAFT_SITE_COOKIE)?.trim()) ?? "";
+    if (!siteId)
+        return null;
+    const session = single(searchParams.session) ?? adapter.getCookie(DRAFT_SESSION_COOKIE)?.trim() ?? defaultSession;
+    const editorOrigin = normalizeOrigin(single(searchParams.editorOrigin))
+        ?? normalizeOrigin(adapter.getCookie(EDITOR_ORIGIN_COOKIE))
+        ?? defaultEditorOrigin;
+    return { session, siteId, editorOrigin };
+}

package/dist/draft-context.d.ts

@@ -0,0 +1,8 @@
+import type { SearchParamsRecord } from "./types.ts";
+import type { DraftContext } from "./types.ts";
+export declare function single(value: string | string[] | undefined): string | undefined;
+export declare function resolveEditorContext(searchParams: SearchParamsRecord, options?: {
+    defaultSession?: string;
+    defaultSiteId?: string;
+    defaultEditorOrigin?: string;
+}): Promise<DraftContext | null>;

package/dist/draft-context.js

@@ -0,0 +1,14 @@
+import { draftMode, cookies } from "next/headers";
+import { resolveDraftContextCore } from "./draft-context-core.js";
+export function single(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export async function resolveEditorContext(searchParams, options) {
+    const jar = await cookies();
+    const draft = await draftMode();
+    const adapter = {
+        isDraftMode: draft.isEnabled,
+        getCookie: (name) => jar.get(name)?.value,
+    };
+    return resolveDraftContextCore(searchParams, adapter, options);
+}

package/dist/draft-fetch.d.ts

@@ -0,0 +1,14 @@
+import type { PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
+export declare function getOrchestratorUrl(): string | null;
+export declare function fetchEditorPage(slug: string, session: string, siteId: string, options?: {
+    timeoutMs?: number;
+    orchestratorUrl?: string;
+}): Promise<PageDoc | null>;
+export declare function fetchEditorSlugs(session: string, siteId: string, options?: {
+    timeoutMs?: number;
+    orchestratorUrl?: string;
+}): Promise<string[]>;
+export declare function fetchEditorSiteConfig(session: string, siteId: string, options?: {
+    timeoutMs?: number;
+    orchestratorUrl?: string;
+}): Promise<SiteConfig>;