@webmaster-droid/server 0.1.0 → 0.2.0

package/dist/chunk-JIGCFERP.js

@@ -0,0 +1,509 @@
+import {
+  getBearerToken,
+  normalizeEditablePath,
+  verifyAdminToken
+} from "./chunk-SIXK4BMG.js";
+import {
+  runAgentTurn
+} from "./chunk-PS4GESOZ.js";
+import {
+  CmsService
+} from "./chunk-EYY23AAK.js";
+import {
+  SupabaseCmsStorage
+} from "./chunk-OWXROQ4O.js";
+
+// src/api-supabase/http.ts
+var CORS_HEADERS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-headers": "content-type,authorization,accept,cache-control",
+  "access-control-allow-methods": "GET,POST,OPTIONS"
+};
+var SSE_BASE_HEADERS = {
+  ...CORS_HEADERS,
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache, no-transform",
+  connection: "keep-alive"
+};
+function jsonResponse(statusCode, body, headers) {
+  return new Response(JSON.stringify(body), {
+    status: statusCode,
+    headers: {
+      ...CORS_HEADERS,
+      "content-type": "application/json",
+      ...headers
+    }
+  });
+}
+function sseHeaders(headers) {
+  return {
+    ...SSE_BASE_HEADERS,
+    ...headers
+  };
+}
+function sseEvent(event, data) {
+  const payload = typeof data === "string" ? data : JSON.stringify(data);
+  return `event: ${event}
+data: ${payload}
+
+`;
+}
+async function parseJsonBody(request) {
+  const raw = await request.text();
+  if (!raw) {
+    throw new Error("Request body is required.");
+  }
+  return JSON.parse(raw);
+}
+function normalizePath(path) {
+  return path.replace(/\/+$/, "") || "/";
+}
+
+// src/api-supabase/service-factory.ts
+import {
+  createDefaultCmsDocument
+} from "@webmaster-droid/contracts";
+var DEFAULT_SUPABASE_BUCKET = "webmaster-droid-cms";
+var DEFAULT_STORAGE_PREFIX = "cms";
+var servicePromise = null;
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+function parseBooleanEnv(name, defaultValue) {
+  const raw = process.env[name];
+  if (!raw) {
+    return defaultValue;
+  }
+  return raw.toLowerCase() === "true";
+}
+function parseOptionalEnv(name) {
+  const raw = process.env[name];
+  if (!raw) {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed || void 0;
+}
+function buildModelConfig() {
+  return {
+    openaiEnabled: parseBooleanEnv("MODEL_OPENAI_ENABLED", true),
+    geminiEnabled: parseBooleanEnv("MODEL_GEMINI_ENABLED", true),
+    defaultModelId: process.env.DEFAULT_MODEL_ID ?? "openai:gpt-5.2"
+  };
+}
+function normalizeAllowedPath(path) {
+  const trimmed = path.trim();
+  if (!trimmed.startsWith("/")) {
+    return null;
+  }
+  if (trimmed === "/") {
+    return "/";
+  }
+  const normalized = trimmed.replace(/\/+$/, "");
+  if (!normalized) {
+    return null;
+  }
+  return `${normalized}/`;
+}
+function parseAllowedInternalPathsEnv() {
+  const raw = process.env.CMS_ALLOWED_INTERNAL_PATHS;
+  if (!raw) {
+    return ["/"];
+  }
+  const normalized = raw.split(",").map((item) => normalizeAllowedPath(item)).filter((value) => Boolean(value));
+  return normalized.length > 0 ? normalized : ["/"];
+}
+function resolveStorageBucket() {
+  return parseOptionalEnv("CMS_SUPABASE_BUCKET") ?? parseOptionalEnv("SUPABASE_STORAGE_BUCKET") ?? DEFAULT_SUPABASE_BUCKET;
+}
+function resolveStoragePrefix() {
+  return parseOptionalEnv("CMS_STORAGE_PREFIX") ?? DEFAULT_STORAGE_PREFIX;
+}
+function deriveSupabasePublicBaseUrl(bucket) {
+  const explicit = parseOptionalEnv("CMS_PUBLIC_BASE_URL");
+  if (explicit) {
+    return explicit;
+  }
+  const supabaseUrl = parseOptionalEnv("SUPABASE_URL");
+  if (!supabaseUrl) {
+    return void 0;
+  }
+  const normalized = supabaseUrl.replace(/\/+$/, "");
+  return `${normalized}/storage/v1/object/public/${bucket}`;
+}
+async function getCmsService() {
+  if (!servicePromise) {
+    servicePromise = (async () => {
+      const bucket = resolveStorageBucket();
+      const storage = new SupabaseCmsStorage({
+        supabaseUrl: requireEnv("SUPABASE_URL"),
+        serviceRoleKey: requireEnv("SUPABASE_SERVICE_ROLE_KEY"),
+        bucket,
+        prefix: resolveStoragePrefix()
+      });
+      const service = new CmsService(storage, {
+        modelConfig: buildModelConfig(),
+        allowedInternalPaths: parseAllowedInternalPathsEnv(),
+        publicAssetBaseUrl: deriveSupabasePublicBaseUrl(bucket),
+        publicAssetPrefix: parseOptionalEnv("CMS_GENERATED_ASSET_PREFIX")
+      });
+      await service.ensureInitialized(createDefaultCmsDocument());
+      return service;
+    })();
+  }
+  return servicePromise;
+}
+
+// src/api-supabase/index.ts
+var SELECTION_KIND_SET = /* @__PURE__ */ new Set([
+  "text",
+  "image",
+  "link",
+  "section"
+]);
+var DEFAULT_MODEL_OPTIONS = [
+  {
+    id: "openai:gpt-5.2",
+    label: "OpenAI GPT-5.2",
+    provider: "openai"
+  },
+  {
+    id: "gemini:gemini-3-flash-preview",
+    label: "Google Gemini 3 Flash (preview)",
+    provider: "gemini"
+  },
+  {
+    id: "gemini:gemini-3.1-pro-preview",
+    label: "Google Gemini 3.1 Pro (preview)",
+    provider: "gemini"
+  }
+];
+function buildAvailableModels(config) {
+  const enabledProviders = /* @__PURE__ */ new Set();
+  if (config.openaiEnabled) {
+    enabledProviders.add("openai");
+  }
+  if (config.geminiEnabled) {
+    enabledProviders.add("gemini");
+  }
+  const options = /* @__PURE__ */ new Map();
+  for (const candidate of DEFAULT_MODEL_OPTIONS) {
+    if (!enabledProviders.has(candidate.provider)) {
+      continue;
+    }
+    options.set(candidate.id, {
+      id: candidate.id,
+      label: candidate.label
+    });
+  }
+  return Array.from(options.values());
+}
+function buildModelCapabilities(input) {
+  const hasReadableModel = input.availableModels.length > 0;
+  const hasImagePipeline = input.config.geminiEnabled && input.hasPublicAssetBaseUrl;
+  return {
+    contentEdit: hasReadableModel,
+    themeTokenEdit: hasReadableModel,
+    imageGenerate: hasImagePipeline,
+    imageEdit: hasImagePipeline,
+    visionAssist: hasReadableModel
+  };
+}
+function resolveDefaultModelId(config, availableModels) {
+  const requestedDefault = config.defaultModelId.trim();
+  if (availableModels.some((model) => model.id === requestedDefault)) {
+    return requestedDefault;
+  }
+  return availableModels[0]?.id ?? requestedDefault;
+}
+function toHeaderRecord(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+async function requireAdminFromHeaders(headers) {
+  const token = getBearerToken(toHeaderRecord(headers));
+  if (!token) {
+    throw new Error("Missing bearer token.");
+  }
+  return verifyAdminToken(token);
+}
+function getStageFromQuery(url) {
+  const stage = url.searchParams.get("stage");
+  if (stage === "draft") {
+    return "draft";
+  }
+  return "live";
+}
+function normalizeText(value, maxLength) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const compact = value.replace(/\s+/g, " ").trim();
+  if (!compact) {
+    return null;
+  }
+  if (compact.length <= maxLength) {
+    return compact;
+  }
+  return `${compact.slice(0, maxLength - 3)}...`;
+}
+function normalizeSelectionKind(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  if (SELECTION_KIND_SET.has(value)) {
+    return value;
+  }
+  return null;
+}
+function normalizePagePath(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const [withoutQuery] = value.split(/[?#]/, 1);
+  const trimmed = withoutQuery?.trim() ?? "";
+  if (!trimmed || !trimmed.startsWith("/")) {
+    return null;
+  }
+  return trimmed;
+}
+function normalizeRelatedPaths(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    const normalized = normalizeEditablePath(item);
+    if (normalized) {
+      out.add(normalized);
+    }
+  }
+  return Array.from(out);
+}
+function normalizeSelectedElementContext(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  const path = normalizeEditablePath(record.path);
+  const label = normalizeText(record.label, 120);
+  const kind = normalizeSelectionKind(record.kind);
+  const pagePath = normalizePagePath(record.pagePath);
+  if (!path || !label || !kind || !pagePath) {
+    return void 0;
+  }
+  const selected = {
+    path,
+    label,
+    kind,
+    pagePath
+  };
+  const relatedPaths = normalizeRelatedPaths(record.relatedPaths);
+  if (relatedPaths.length > 0) {
+    selected.relatedPaths = relatedPaths;
+  }
+  const preview = normalizeText(record.preview, 140);
+  if (preview) {
+    selected.preview = preview;
+  }
+  return selected;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function createChatStreamResponse(input) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      let heartbeat = null;
+      let closed = false;
+      const close = () => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        if (heartbeat) {
+          clearInterval(heartbeat);
+        }
+        controller.close();
+      };
+      const write = (eventName, data) => {
+        if (closed) {
+          return;
+        }
+        controller.enqueue(encoder.encode(sseEvent(eventName, data)));
+      };
+      const abortHandler = () => {
+        close();
+      };
+      input.requestSignal.addEventListener("abort", abortHandler, { once: true });
+      void (async () => {
+        try {
+          const selectedElement = normalizeSelectedElementContext(input.body.selectedElement);
+          write("ready", { ok: true });
+          heartbeat = setInterval(() => {
+            write("ping", { ts: (/* @__PURE__ */ new Date()).toISOString() });
+          }, 15e3);
+          const result = await runAgentTurn(input.service, {
+            prompt: input.body.message,
+            modelId: input.body.modelId,
+            includeThinking: input.body.includeThinking,
+            actor: input.actor,
+            currentPath: input.body.currentPath,
+            selectedElement,
+            history: input.body.history,
+            onThinkingEvent: input.body.includeThinking ? (note) => {
+              write("thinking", { note });
+            } : void 0,
+            onToolEvent: (toolEvent) => {
+              write("tool", toolEvent);
+            }
+          });
+          write("message", { text: result.text });
+          if (result.mutationsApplied) {
+            write("draft-updated", {
+              contentVersion: result.updatedDraft.meta.contentVersion,
+              updatedAt: result.updatedDraft.meta.updatedAt,
+              summary: result.mutationSummary ?? {
+                contentOperations: 0,
+                themeTokenChanges: 0,
+                imageOperations: 0
+              }
+            });
+          }
+          write("done", { ok: true });
+        } catch (error) {
+          write("error", {
+            ok: false,
+            error: errorMessage(error)
+          });
+          write("done", { ok: false });
+        } finally {
+          input.requestSignal.removeEventListener("abort", abortHandler);
+          close();
+        }
+      })();
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: sseHeaders()
+  });
+}
+async function handler(request) {
+  try {
+    const method = request.method.toUpperCase();
+    if (method === "OPTIONS") {
+      return jsonResponse(200, { ok: true });
+    }
+    const url = new URL(request.url);
+    const path = normalizePath(url.pathname);
+    const service = await getCmsService();
+    if (method === "GET" && path.endsWith("/content")) {
+      const stage = getStageFromQuery(url);
+      if (stage === "draft") {
+        await requireAdminFromHeaders(request.headers);
+      }
+      const content = await service.getContent(stage);
+      return jsonResponse(200, { stage, content });
+    }
+    if (method === "GET" && path.endsWith("/models")) {
+      const config = service.getModelConfig();
+      const availableModels = buildAvailableModels(config);
+      const defaultModelId = resolveDefaultModelId(config, availableModels);
+      const capabilities = buildModelCapabilities({
+        config,
+        availableModels,
+        hasPublicAssetBaseUrl: Boolean(service.getPublicAssetBaseUrl())
+      });
+      return jsonResponse(200, {
+        providers: {
+          openai: config.openaiEnabled,
+          gemini: config.geminiEnabled
+        },
+        capabilities,
+        defaultModelId,
+        showModelPicker: availableModels.length > 1,
+        availableModels
+      });
+    }
+    if (method === "GET" && path.endsWith("/session")) {
+      const identity = await requireAdminFromHeaders(request.headers);
+      return jsonResponse(200, {
+        authenticated: true,
+        identity
+      });
+    }
+    if (method === "GET" && path.endsWith("/history")) {
+      await requireAdminFromHeaders(request.headers);
+      const history = await service.listHistory();
+      return jsonResponse(200, history);
+    }
+    if (method === "POST" && path.endsWith("/publish")) {
+      const identity = await requireAdminFromHeaders(request.headers);
+      const body = await parseJsonBody(request);
+      const result = await service.publishDraft(body, identity.email ?? identity.sub);
+      return jsonResponse(200, {
+        ok: true,
+        version: result
+      });
+    }
+    if (method === "POST" && path.endsWith("/rollback")) {
+      const identity = await requireAdminFromHeaders(request.headers);
+      const body = await parseJsonBody(request);
+      const document = await service.rollbackDraft(body, identity.email ?? identity.sub);
+      return jsonResponse(200, {
+        ok: true,
+        draftVersion: document.meta.contentVersion
+      });
+    }
+    if (method === "POST" && path.endsWith("/checkpoints/delete")) {
+      await requireAdminFromHeaders(request.headers);
+      const body = await parseJsonBody(request);
+      const checkpointId = typeof body.checkpointId === "string" ? body.checkpointId.trim() : "";
+      if (!checkpointId) {
+        throw new Error("checkpointId is required.");
+      }
+      await service.deleteCheckpoint(checkpointId);
+      return jsonResponse(200, {
+        ok: true,
+        checkpointId
+      });
+    }
+    if (method === "POST" && path.endsWith("/chat/stream")) {
+      const identity = await requireAdminFromHeaders(request.headers);
+      const body = await parseJsonBody(request);
+      return createChatStreamResponse({
+        service,
+        requestSignal: request.signal,
+        body,
+        actor: identity.email ?? identity.sub
+      });
+    }
+    return jsonResponse(404, {
+      error: "Not found",
+      path,
+      method
+    });
+  } catch (error) {
+    const message = errorMessage(error);
+    const statusCode = message.startsWith("Checkpoint not found:") ? 404 : 400;
+    return jsonResponse(statusCode, {
+      ok: false,
+      error: message
+    });
+  }
+}
+var api_supabase_default = handler;
+
+export {
+  handler,
+  api_supabase_default
+};