@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/publish/targets/deploy-hook.d.ts

@@ -0,0 +1,13 @@
+import type { PublishContext, PublishOutcome, PublishTarget } from "../publish-target.ts";
+/**
+ * Publish by POSTing to a raw Vercel deploy hook URL. Useful when the
+ * orchestrator runs outside the git repo (e.g. in a managed environment) and
+ * cannot commit + push on its own.
+ *
+ * Selected when no `siteOrigin` is supplied and `PUBLISH_MODE=deploy_hook`.
+ * Requires `VERCEL_DEPLOY_HOOK_URL` to be set.
+ */
+export declare class DeployHookPublishTarget implements PublishTarget {
+    readonly name = "deploy-hook";
+    publish(ctx: PublishContext): Promise<PublishOutcome>;
+}

package/dist/publish/targets/deploy-hook.js

@@ -0,0 +1,123 @@
+import { toErrorDetail } from "../../ops/ops-engine.js";
+import { firstUrlFromText } from "../../chat/chat-pipeline.js";
+import { parseJsonMaybe } from "../../chat/variation-pipeline.js";
+import { deploymentIdFromAny } from "../publish-helpers.js";
+/**
+ * Publish by POSTing to a raw Vercel deploy hook URL. Useful when the
+ * orchestrator runs outside the git repo (e.g. in a managed environment) and
+ * cannot commit + push on its own.
+ *
+ * Selected when no `siteOrigin` is supplied and `PUBLISH_MODE=deploy_hook`.
+ * Requires `VERCEL_DEPLOY_HOOK_URL` to be set.
+ */
+export class DeployHookPublishTarget {
+    name = "deploy-hook";
+    async publish(ctx) {
+        const { session, scopedSession, slugs } = ctx;
+        const deployHookUrl = process.env.VERCEL_DEPLOY_HOOK_URL?.trim();
+        if (!deployHookUrl) {
+            const now = new Date().toISOString();
+            return {
+                ok: false,
+                httpStatus: 400,
+                tracker: {
+                    session,
+                    status: "failed",
+                    startedAt: now,
+                    updatedAt: now,
+                    slugs,
+                    vercelState: "ERROR"
+                },
+                response: { error: "VERCEL_DEPLOY_HOOK_URL is not configured" }
+            };
+        }
+        try {
+            const hookResponse = await fetch(deployHookUrl, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    source: "orchestrator",
+                    session: scopedSession,
+                    slugs,
+                    publishedAt: new Date().toISOString()
+                })
+            });
+            const responseText = await hookResponse.text();
+            const responseJson = parseJsonMaybe(responseText);
+            const inspectUrl = findStringByKeys(responseJson, new Set(["inspectorUrl", "inspectUrl", "url"])) ?? firstUrlFromText(responseText);
+            const deploymentId = findStringByKeys(responseJson, new Set(["deploymentId", "id"])) ??
+                (inspectUrl ? deploymentIdFromAny(inspectUrl) : undefined) ??
+                deploymentIdFromAny(responseText);
+            const vercelStateRaw = findStringByKeys(responseJson, new Set(["state", "readyState", "status"])) ??
+                (hookResponse.ok ? "TRIGGERED" : "FAILED");
+            const vercelState = typeof vercelStateRaw === "string" ? vercelStateRaw.toUpperCase() : undefined;
+            const now = new Date().toISOString();
+            const tracker = {
+                session,
+                status: hookResponse.ok ? "triggered" : "failed",
+                startedAt: now,
+                updatedAt: now,
+                slugs,
+                deployStatus: hookResponse.status,
+                deployResponse: responseText.slice(0, 500),
+                inspectUrl,
+                deploymentId,
+                vercelState
+            };
+            return {
+                ok: hookResponse.ok,
+                httpStatus: 200,
+                tracker,
+                response: {
+                    status: hookResponse.ok ? "triggered" : "failed",
+                    session,
+                    slugs,
+                    deployStatus: hookResponse.status,
+                    deployResponse: responseText.slice(0, 500),
+                    inspectUrl,
+                    deploymentId,
+                    vercelState
+                }
+            };
+        }
+        catch (error) {
+            const now = new Date().toISOString();
+            return {
+                ok: false,
+                httpStatus: 502,
+                tracker: {
+                    session,
+                    status: "failed",
+                    startedAt: now,
+                    updatedAt: now,
+                    slugs,
+                    vercelState: "ERROR"
+                },
+                response: { error: toErrorDetail(error) }
+            };
+        }
+    }
+}
+function findStringByKeys(root, wanted) {
+    if (!root || typeof root !== "object")
+        return undefined;
+    if (Array.isArray(root)) {
+        for (const item of root) {
+            const found = findStringByKeys(item, wanted);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    const obj = root;
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === "string" && wanted.has(key))
+            return value;
+        if (value && typeof value === "object") {
+            const found = findStringByKeys(value, wanted);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}

package/dist/publish/targets/git.d.ts

@@ -0,0 +1,13 @@
+import type { PublishContext, PublishOutcome, PublishTarget } from "../publish-target.ts";
+/**
+ * Publish by committing `apps/site/lib/published-content.json` and pushing
+ * to the configured remote branch. Works standalone or with a Vercel project
+ * wired to that branch for auto-deploy.
+ *
+ * Selected when no `siteOrigin` is supplied and `PUBLISH_MODE=git` (the
+ * default). Honors `PUBLISH_GIT_BRANCH` and `PUBLISH_GIT_STRICT` env vars.
+ */
+export declare class GitPublishTarget implements PublishTarget {
+    readonly name = "git";
+    publish(ctx: PublishContext): Promise<PublishOutcome>;
+}

package/dist/publish/targets/git.js

@@ -0,0 +1,55 @@
+import { publishViaGit } from "../publish-helpers.js";
+/**
+ * Publish by committing `apps/site/lib/published-content.json` and pushing
+ * to the configured remote branch. Works standalone or with a Vercel project
+ * wired to that branch for auto-deploy.
+ *
+ * Selected when no `siteOrigin` is supplied and `PUBLISH_MODE=git` (the
+ * default). Honors `PUBLISH_GIT_BRANCH` and `PUBLISH_GIT_STRICT` env vars.
+ */
+export class GitPublishTarget {
+    name = "git";
+    async publish(ctx) {
+        const { session, scopedSession, slugs } = ctx;
+        const result = await publishViaGit(scopedSession);
+        const now = new Date().toISOString();
+        const tracker = {
+            session,
+            status: result.status === "failed" ? "failed" : "triggered",
+            startedAt: now,
+            updatedAt: now,
+            slugs: result.slugs,
+            vercelState: result.status === "failed" ? "ERROR" : "READY",
+            deployResponse: "git_publish",
+            deployStatus: result.status === "failed" ? 500 : 200
+        };
+        if (result.status === "failed") {
+            return {
+                ok: false,
+                httpStatus: 400,
+                tracker,
+                response: {
+                    status: "failed",
+                    session,
+                    slugs: result.slugs,
+                    reason: result.reason,
+                    details: result.details
+                }
+            };
+        }
+        return {
+            ok: true,
+            httpStatus: 200,
+            tracker,
+            response: {
+                status: result.status,
+                session,
+                slugs: result.slugs,
+                branch: result.branch,
+                commitSha: "commitSha" in result ? result.commitSha : undefined,
+                message: "message" in result ? result.message : undefined,
+                vercelState: "vercelState" in result ? result.vercelState ?? "READY" : "READY"
+            }
+        };
+    }
+}

package/dist/publish/targets/site-contract.d.ts

@@ -0,0 +1,19 @@
+import type { PublishContext, PublishOutcome, PublishTarget } from "../publish-target.ts";
+/**
+ * Publish by POSTing to the site's `/api/editor/publish` contract endpoint.
+ *
+ * This is the primary production flow: the remote site implements the publish
+ * contract from `@avocadostudio-ai/site-sdk`, receives pages + siteConfig +
+ * inline image assets, and writes them wherever it stores content (CMS, json
+ * file, database, etc.). The orchestrator does not touch the site's storage.
+ *
+ * For the legacy `avocado-stories` siteId this target also records a git
+ * snapshot into `apps/site/lib/published-content.json` so version history can
+ * find it. Non-legacy sites skip the snapshot — their publish handler owns
+ * durability.
+ */
+export declare class SiteContractPublishTarget implements PublishTarget {
+    readonly name = "site-contract";
+    canHandle(ctx: PublishContext): boolean;
+    publish(ctx: PublishContext): Promise<PublishOutcome>;
+}

package/dist/publish/targets/site-contract.js

@@ -0,0 +1,124 @@
+import { normalizeSiteId, isLegacySiteId } from "../../state/session-state.js";
+import { collectInlineAssets, recordPublishSnapshot } from "../publish-helpers.js";
+/**
+ * Publish by POSTing to the site's `/api/editor/publish` contract endpoint.
+ *
+ * This is the primary production flow: the remote site implements the publish
+ * contract from `@avocadostudio-ai/site-sdk`, receives pages + siteConfig +
+ * inline image assets, and writes them wherever it stores content (CMS, json
+ * file, database, etc.). The orchestrator does not touch the site's storage.
+ *
+ * For the legacy `avocado-stories` siteId this target also records a git
+ * snapshot into `apps/site/lib/published-content.json` so version history can
+ * find it. Non-legacy sites skip the snapshot — their publish handler owns
+ * durability.
+ */
+export class SiteContractPublishTarget {
+    name = "site-contract";
+    canHandle(ctx) {
+        return typeof ctx.siteOrigin === "string" && ctx.siteOrigin.length > 0;
+    }
+    async publish(ctx) {
+        const { session, scopedSession, siteId, siteOrigin, pages, slugs, siteConfig, generatedImageDir, logger } = ctx;
+        if (!siteOrigin) {
+            return failed(session, slugs, 400, "siteOrigin is required for site-contract target");
+        }
+        const assets = await collectInlineAssets(pages, generatedImageDir);
+        const publishTokenValue = process.env.PUBLISH_TOKEN?.trim();
+        let siteRes;
+        try {
+            siteRes = await fetch(`${siteOrigin}/api/editor/publish`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...(publishTokenValue ? { "x-publish-token": publishTokenValue } : {})
+                },
+                body: JSON.stringify({
+                    pages,
+                    siteConfig,
+                    session: scopedSession,
+                    publishedAt: new Date().toISOString(),
+                    ...(Object.keys(assets).length > 0 ? { assets } : {})
+                })
+            });
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : "fetch failed";
+            return failed(session, slugs, 502, `Site unreachable at ${siteOrigin}/api/editor/publish: ${detail}`);
+        }
+        if (siteRes.status === 404) {
+            return failed(session, slugs, 400, `Site does not implement the publish contract. POST ${siteOrigin}/api/editor/publish returned 404.`);
+        }
+        const siteResult = (await siteRes.json());
+        const ok = siteRes.ok && siteResult.ok !== false;
+        const now = new Date().toISOString();
+        const tracker = {
+            session,
+            status: ok ? "triggered" : "failed",
+            startedAt: now,
+            updatedAt: now,
+            slugs,
+            vercelState: ok ? "READY" : "ERROR",
+            deployResponse: "site_contract",
+            deployStatus: siteRes.status
+        };
+        if (!ok) {
+            return {
+                ok: false,
+                httpStatus: 400,
+                tracker,
+                response: {
+                    status: "failed",
+                    session,
+                    slugs,
+                    reason: siteResult.error ?? "site publish failed"
+                }
+            };
+        }
+        // Record snapshot in git only for the default site (json-file based).
+        // CMS sites (sanity, contentful, strapi) publish to their CMS directly;
+        // writing their pages to apps/site/lib/published-content.json would
+        // overwrite the avocado-stories content.
+        const snapshotCommit = isLegacySiteId(normalizeSiteId(siteId))
+            ? await recordPublishSnapshot(scopedSession, pages, logger, siteConfig)
+            : undefined;
+        const publishedSlugs = siteResult.slugs ?? slugs;
+        const pageNames = publishedSlugs.map((s) => (s === "/" ? "Home" : s.replace(/^\//, "")));
+        return {
+            ok: true,
+            httpStatus: 200,
+            tracker,
+            response: {
+                status: "ready",
+                session,
+                slugs: publishedSlugs,
+                vercelState: "READY",
+                commitSha: snapshotCommit?.slice(0, 12),
+                message: `Published ${pageNames.join(", ")} to site.`
+            }
+        };
+    }
+}
+function failed(session, slugs, httpStatus, reason) {
+    const now = new Date().toISOString();
+    return {
+        ok: false,
+        httpStatus,
+        tracker: {
+            session,
+            status: "failed",
+            startedAt: now,
+            updatedAt: now,
+            slugs,
+            vercelState: "ERROR",
+            deployResponse: "site_contract",
+            deployStatus: httpStatus
+        },
+        response: {
+            status: "failed",
+            session,
+            slugs,
+            reason
+        }
+    };
+}

package/dist/state/content-source.d.ts

@@ -0,0 +1,17 @@
+import type { PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
+export interface ContentSource {
+    getPage(session: string, slug: string): Promise<PageDoc | null>;
+    getSessionPages(session: string): Promise<PageDoc[]>;
+    getSlugs(session: string): Promise<string[]>;
+    getSiteConfig(session: string): Promise<SiteConfig>;
+    setPage(session: string, page: PageDoc): Promise<void>;
+    removePage(session: string, slug: string): Promise<void>;
+    setSiteConfig(session: string, config: SiteConfig): Promise<void>;
+    getVersion(session: string): Promise<number>;
+    bumpVersion(session: string): Promise<number>;
+    pushUndo(session: string, slug: string, snapshot: PageDoc | null): Promise<void>;
+    popUndo(session: string, slug: string): Promise<PageDoc | null | undefined>;
+    pushRedo(session: string, slug: string, snapshot: PageDoc | null): Promise<void>;
+    popRedo(session: string, slug: string): Promise<PageDoc | null | undefined>;
+    clearRedo(session: string, slug: string): Promise<void>;
+}

package/dist/state/content-source.js

@@ -0,0 +1 @@
+export {};

package/dist/state/in-memory-content-source.d.ts

@@ -0,0 +1,27 @@
+import type { PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
+import type { ContentSource } from "./content-source.ts";
+export declare class InMemoryContentSource implements ContentSource {
+    getPage(session: string, slug: string): Promise<PageDoc | null>;
+    getSessionPages(session: string): Promise<PageDoc[]>;
+    getSlugs(session: string): Promise<string[]>;
+    getSiteConfig(session: string): Promise<{
+        name?: string | undefined;
+        logo?: string | undefined;
+        purpose?: string | undefined;
+        tone?: string | undefined;
+        constraints?: string[] | undefined;
+        navLabels?: Record<string, string> | undefined;
+        navGroups?: Record<string, string[]> | undefined;
+        themeOverrides?: Record<string, string> | undefined;
+    }>;
+    setPage(session: string, page: PageDoc): Promise<void>;
+    removePage(session: string, slug: string): Promise<void>;
+    setSiteConfig(session: string, config: SiteConfig): Promise<void>;
+    getVersion(session: string): Promise<number>;
+    bumpVersion(session: string): Promise<number>;
+    pushUndo(session: string, slug: string, snapshot: PageDoc | null): Promise<void>;
+    popUndo(session: string, slug: string): Promise<PageDoc | null | undefined>;
+    pushRedo(session: string, slug: string, snapshot: PageDoc | null): Promise<void>;
+    popRedo(session: string, slug: string): Promise<PageDoc | null | undefined>;
+    clearRedo(session: string, slug: string): Promise<void>;
+}

package/dist/state/in-memory-content-source.js

@@ -0,0 +1,51 @@
+import { getSessionDraft, getPage as _getPage, getSessionPages as _getSessionPages, setPage as _setPage, removePage as _removePage, getSiteConfig as _getSiteConfig, setSiteConfig as _setSiteConfig, bumpVersion as _bumpVersion, pushUndo as _pushUndo, pushCappedHistory, orderSlugsHomeFirst, versions, historyUndo, historyRedo, getHistoryMap } from "./session-state.js";
+export class InMemoryContentSource {
+    async getPage(session, slug) {
+        return _getPage(session, slug);
+    }
+    async getSessionPages(session) {
+        return _getSessionPages(session);
+    }
+    async getSlugs(session) {
+        return orderSlugsHomeFirst(Array.from(getSessionDraft(session).keys()));
+    }
+    async getSiteConfig(session) {
+        return _getSiteConfig(session);
+    }
+    async setPage(session, page) {
+        _setPage(session, page);
+    }
+    async removePage(session, slug) {
+        _removePage(session, slug);
+    }
+    async setSiteConfig(session, config) {
+        _setSiteConfig(session, config);
+    }
+    async getVersion(session) {
+        return versions.get(session) ?? 0;
+    }
+    async bumpVersion(session) {
+        return _bumpVersion(session);
+    }
+    async pushUndo(session, slug, snapshot) {
+        _pushUndo(session, slug, snapshot);
+    }
+    async popUndo(session, slug) {
+        const undoMap = getHistoryMap(historyUndo, session);
+        return undoMap.get(slug)?.pop();
+    }
+    async pushRedo(session, slug, snapshot) {
+        const redoMap = getHistoryMap(historyRedo, session);
+        const list = redoMap.get(slug) ?? [];
+        pushCappedHistory(list, snapshot);
+        redoMap.set(slug, list);
+    }
+    async popRedo(session, slug) {
+        const redoMap = getHistoryMap(historyRedo, session);
+        return redoMap.get(slug)?.pop();
+    }
+    async clearRedo(session, slug) {
+        const redoMap = getHistoryMap(historyRedo, session);
+        redoMap.set(slug, []);
+    }
+}

package/dist/state/session-lock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Acquire an exclusive lock for `session`. The returned release function
+ * MUST be called when done — wrap the critical section in try/finally.
+ *
+ * Usage:
+ *   const release = await acquireSessionLock(session)
+ *   try { … } finally { release() }
+ */
+export declare function acquireSessionLock(session: string): Promise<() => void>;
+/**
+ * Remove stale lock entries (e.g. on session cleanup).
+ */
+export declare function clearSessionLock(session: string): void;

package/dist/state/session-lock.js

@@ -0,0 +1,29 @@
+// ---------------------------------------------------------------------------
+// Lightweight per-session async mutex using promise chains.
+// Serializes applyOpsAtomically() calls within a session to prevent
+// concurrent read-modify-write races (e.g. multi-tab, fast typing).
+// ---------------------------------------------------------------------------
+const locks = new Map();
+/**
+ * Acquire an exclusive lock for `session`. The returned release function
+ * MUST be called when done — wrap the critical section in try/finally.
+ *
+ * Usage:
+ *   const release = await acquireSessionLock(session)
+ *   try { … } finally { release() }
+ */
+export function acquireSessionLock(session) {
+    const prev = locks.get(session) ?? Promise.resolve();
+    let release;
+    const next = new Promise((resolve) => {
+        release = resolve;
+    });
+    locks.set(session, next);
+    return prev.then(() => release);
+}
+/**
+ * Remove stale lock entries (e.g. on session cleanup).
+ */
+export function clearSessionLock(session) {
+    locks.delete(session);
+}