@webmaster-droid/server 0.1.0-alpha.0

package/dist/agent/index.d.ts

@@ -0,0 +1,37 @@
+import { SelectedElementContext, CmsDocument } from '@webmaster-droid/contracts';
+import { C as CmsService } from '../service-BYwdlvCI.js';
+import '../types-OKJgq7Oo.js';
+
+interface AgentRunnerInput {
+    prompt: string;
+    actor?: string;
+    includeThinking?: boolean;
+    modelId?: string;
+    currentPath?: string;
+    selectedElement?: SelectedElementContext;
+    history?: Array<{
+        role: "user" | "assistant";
+        text: string;
+    }>;
+    onThinkingEvent?: (note: string) => void;
+    onToolEvent?: (event: {
+        tool: string;
+        summary: string;
+    }) => void;
+}
+interface AgentRunnerResult {
+    text: string;
+    thinking: string[];
+    toolEvents: Array<{
+        tool: string;
+        summary: string;
+    }>;
+    updatedDraft: CmsDocument;
+    mutationsApplied: boolean;
+}
+declare const STATIC_TOOL_NAMES: readonly ["patch_content", "patch_theme_tokens", "get_page", "get_section", "search_content", "generate_image"];
+type StaticToolName = (typeof STATIC_TOOL_NAMES)[number];
+declare function listStaticToolNames(): StaticToolName[];
+declare function runAgentTurn(service: CmsService, input: AgentRunnerInput): Promise<AgentRunnerResult>;
+
+export { type AgentRunnerInput, type AgentRunnerResult, type StaticToolName, listStaticToolNames, runAgentTurn };

package/dist/agent/index.js

@@ -0,0 +1,9 @@
+import {
+  listStaticToolNames,
+  runAgentTurn
+} from "../chunk-X6TU47KZ.js";
+import "../chunk-2LAI3MY2.js";
+export {
+  listStaticToolNames,
+  runAgentTurn
+};

package/dist/api-aws/index.d.ts

@@ -0,0 +1,6 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+
+declare function handler(event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult>;
+declare const streamHandler: (event: unknown, responseStream: unknown, context: unknown) => Promise<void>;
+
+export { handler, streamHandler };

package/dist/api-aws/index.js

@@ -0,0 +1,11 @@
+import {
+  handler,
+  streamHandler
+} from "../chunk-5CVLHGGO.js";
+import "../chunk-X6TU47KZ.js";
+import "../chunk-2LAI3MY2.js";
+import "../chunk-MLID7STX.js";
+export {
+  handler,
+  streamHandler
+};

package/dist/chunk-2LAI3MY2.js

@@ -0,0 +1,620 @@
+// src/core/patch.ts
+import {
+  isEditablePath,
+  isHttpsUrl,
+  requiresStrictImageValidation
+} from "@webmaster-droid/contracts";
+function cloneDocument(doc) {
+  return JSON.parse(JSON.stringify(doc));
+}
+function splitPath(path) {
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+var RESTRICTED_LINK_ROOTS = [
+  ["layout", "header", "primaryLinks"],
+  ["layout", "footer", "navigationLinks"],
+  ["layout", "footer", "legalLinks"]
+];
+function classifyRestrictedLinkPath(path) {
+  const segments = splitPath(path);
+  for (const root of RESTRICTED_LINK_ROOTS) {
+    const isRootMatch = root.every((segment, index) => segments[index] === segment);
+    if (!isRootMatch) {
+      continue;
+    }
+    if (segments.length === root.length) {
+      return "restricted";
+    }
+    const indexSegment = segments[root.length];
+    const leafSegment = segments[root.length + 1];
+    const hasValidIndex = /^\d+$/.test(indexSegment ?? "");
+    if (hasValidIndex && segments.length === root.length + 2 && (leafSegment === "label" || leafSegment === "href")) {
+      return "allowed_leaf";
+    }
+    return "restricted";
+  }
+  return "none";
+}
+function normalizeInternalPath(path) {
+  const trimmed = path.trim();
+  if (!trimmed.startsWith("/")) {
+    return null;
+  }
+  const [withoutQuery] = trimmed.split(/[?#]/, 1);
+  if (!withoutQuery) {
+    return null;
+  }
+  if (withoutQuery === "/") {
+    return "/";
+  }
+  const normalized = withoutQuery.replace(/\/+$/, "");
+  if (!normalized) {
+    return null;
+  }
+  return `${normalized}/`;
+}
+function readByPath(input, path) {
+  const segments = splitPath(path);
+  let current = input;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (Number.isNaN(index)) {
+        return void 0;
+      }
+      current = current[index];
+      continue;
+    }
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function writeByPath(input, path, value) {
+  const segments = splitPath(path);
+  if (segments.length === 0) {
+    return false;
+  }
+  let current = input;
+  for (let idx = 0; idx < segments.length - 1; idx += 1) {
+    const segment = segments[idx];
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (Number.isNaN(index)) {
+        return false;
+      }
+      if (current[index] === void 0) {
+        const next = segments[idx + 1];
+        current[index] = /^\d+$/.test(next) ? [] : {};
+      }
+      current = current[index];
+      continue;
+    }
+    if (typeof current !== "object" || current === null) {
+      return false;
+    }
+    const record = current;
+    if (record[segment] === void 0) {
+      const next = segments[idx + 1];
+      record[segment] = /^\d+$/.test(next) ? [] : {};
+    }
+    current = record[segment];
+  }
+  const finalSegment = segments.at(-1);
+  if (!finalSegment) {
+    return false;
+  }
+  if (Array.isArray(current)) {
+    const index = Number(finalSegment);
+    if (Number.isNaN(index)) {
+      return false;
+    }
+    current[index] = value;
+    return true;
+  }
+  if (typeof current !== "object" || current === null) {
+    return false;
+  }
+  current[finalSegment] = value;
+  return true;
+}
+function validatePatch(patch, source, options) {
+  const warnings = [];
+  const errors = [];
+  const allowedInternalPaths = new Set(options.allowedInternalPaths);
+  if (patch.operations.length > options.maxOperationsPerPatch) {
+    errors.push(
+      `Patch contains ${patch.operations.length} operations; limit is ${options.maxOperationsPerPatch}.`
+    );
+  }
+  for (const operation of patch.operations) {
+    if (operation.op !== "set") {
+      errors.push(`Unsupported operation type: ${operation.op}`);
+      continue;
+    }
+    if (!isEditablePath(operation.path)) {
+      errors.push(`Path is out of editable scope: ${operation.path}`);
+      continue;
+    }
+    const linkPathClassification = classifyRestrictedLinkPath(operation.path);
+    if (linkPathClassification === "restricted") {
+      errors.push(
+        `Only link label and href leaf fields are editable for header/footer links: ${operation.path}`
+      );
+      continue;
+    }
+    const currentValue = readByPath(source, operation.path);
+    if (currentValue === void 0) {
+      errors.push(
+        `Path does not exist and cannot be created by patch_content: ${operation.path}`
+      );
+      continue;
+    }
+    if (requiresStrictImageValidation(operation.path) && !isHttpsUrl(operation.value)) {
+      errors.push(`Image path requires HTTPS URL: ${operation.path}`);
+    }
+    if (linkPathClassification === "allowed_leaf" && operation.path.endsWith(".href")) {
+      if (typeof operation.value !== "string") {
+        errors.push(`Link href must be a string: ${operation.path}`);
+        continue;
+      }
+      const normalizedHref = normalizeInternalPath(operation.value);
+      if (!normalizedHref || !allowedInternalPaths.has(normalizedHref)) {
+        errors.push(
+          `Link href is outside allowed internal routes: ${operation.path} (${operation.value})`
+        );
+      }
+    }
+    if (typeof currentValue === "number" && typeof operation.value !== "number" && operation.value !== null) {
+      warnings.push(
+        `Numeric field ${operation.path} received non-number value; value will still be applied.`
+      );
+    }
+    if (typeof currentValue === "boolean" && typeof operation.value !== "boolean" && operation.value !== null) {
+      warnings.push(
+        `Boolean field ${operation.path} received non-boolean value; value will still be applied.`
+      );
+    }
+    if (typeof currentValue === "string" && typeof operation.value === "string") {
+      const before = currentValue.trim();
+      const after = operation.value.trim();
+      if (before.length >= 80 && after.length < Math.floor(before.length * 0.85) && before.startsWith(after)) {
+        errors.push(
+          `Refusing potentially truncated update at ${operation.path}; fetch full section and retry with complete value.`
+        );
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    warnings,
+    errors
+  };
+}
+function applyPatch(source, patch, options) {
+  const validation = validatePatch(patch, source, options);
+  if (!validation.valid) {
+    throw new Error(validation.errors.join("\n"));
+  }
+  const document = cloneDocument(source);
+  for (const operation of patch.operations) {
+    const ok = writeByPath(document, operation.path, operation.value);
+    if (!ok) {
+      throw new Error(`Failed to apply operation at path ${operation.path}`);
+    }
+  }
+  return {
+    document,
+    warnings: validation.warnings
+  };
+}
+function applyThemeTokenPatch(source, patch) {
+  const document = cloneDocument(source);
+  const warnings = [];
+  for (const [tokenKey, tokenValue] of Object.entries(
+    patch
+  )) {
+    if (typeof tokenValue !== "string") {
+      warnings.push(`Theme token ${tokenKey} ignored because value is not a string.`);
+      continue;
+    }
+    if (!tokenValue.trim()) {
+      warnings.push(`Theme token ${tokenKey} ignored because value is empty.`);
+      continue;
+    }
+    document.themeTokens[tokenKey] = tokenValue;
+  }
+  return { document, warnings };
+}
+
+// src/core/service.ts
+import {
+  REQUIRED_PUBLISH_CONFIRMATION,
+  isEditablePath as isEditablePath2
+} from "@webmaster-droid/contracts";
+var DEFAULT_MAX_OPERATIONS = 25;
+var DEFAULT_ALLOWED_INTERNAL_PATHS = ["/"];
+var DEFAULT_PUBLIC_ASSET_PREFIX = "assets/generated";
+var DEFAULT_GENERATED_IMAGE_CACHE_CONTROL = "public,max-age=31536000,immutable";
+function createId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeInternalPath2(path) {
+  const trimmed = path.trim();
+  if (!trimmed.startsWith("/")) {
+    return null;
+  }
+  const [withoutQuery] = trimmed.split(/[?#]/, 1);
+  if (!withoutQuery) {
+    return null;
+  }
+  if (withoutQuery === "/") {
+    return "/";
+  }
+  const normalized = withoutQuery.replace(/\/+$/, "");
+  if (!normalized) {
+    return null;
+  }
+  return `${normalized}/`;
+}
+function normalizeAllowedInternalPaths(paths) {
+  const out = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const normalized = normalizeInternalPath2(path);
+    if (normalized) {
+      out.add(normalized);
+    }
+  }
+  return Array.from(out);
+}
+function comparableContentSnapshot(document) {
+  return JSON.stringify({
+    themeTokens: document.themeTokens,
+    layout: document.layout,
+    pages: document.pages,
+    seo: document.seo
+  });
+}
+function normalizePublicAssetBaseUrl(value) {
+  const raw = value?.trim();
+  if (!raw) {
+    return null;
+  }
+  try {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "https:") {
+      return null;
+    }
+    return parsed.toString().replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+function normalizePublicAssetPrefix(value) {
+  const normalized = (value ?? DEFAULT_PUBLIC_ASSET_PREFIX).trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  return normalized || DEFAULT_PUBLIC_ASSET_PREFIX;
+}
+function sanitizeTargetPathForKey(value) {
+  const normalized = value.replace(/\[(\d+)\]/g, "-$1-").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").toLowerCase();
+  return normalized.slice(0, 80) || "image";
+}
+function extensionFromMimeType(contentType) {
+  const normalized = contentType.trim().toLowerCase().split(";", 1)[0];
+  if (normalized === "image/jpeg") {
+    return "jpg";
+  }
+  if (normalized === "image/png") {
+    return "png";
+  }
+  if (normalized === "image/webp") {
+    return "webp";
+  }
+  if (normalized === "image/gif") {
+    return "gif";
+  }
+  return "png";
+}
+function buildGeneratedAssetKey(targetPath, publicAssetPrefix, contentType, now = /* @__PURE__ */ new Date()) {
+  const year = String(now.getUTCFullYear());
+  const month = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(now.getUTCDate()).padStart(2, "0");
+  const timestamp = now.getTime();
+  const random = Math.random().toString(36).slice(2, 10);
+  const safePath = sanitizeTargetPathForKey(targetPath);
+  const ext = extensionFromMimeType(contentType);
+  return `${publicAssetPrefix}/${year}/${month}/${day}/${safePath}-${timestamp}-${random}.${ext}`;
+}
+var CmsService = class {
+  storage;
+  modelConfig;
+  maxOperationsPerPatch;
+  allowedInternalPaths;
+  publicAssetBaseUrl;
+  publicAssetPrefix;
+  constructor(storage, config) {
+    this.storage = storage;
+    this.modelConfig = config.modelConfig;
+    this.maxOperationsPerPatch = config.maxOperationsPerPatch ?? DEFAULT_MAX_OPERATIONS;
+    this.allowedInternalPaths = normalizeAllowedInternalPaths(
+      config.allowedInternalPaths ?? DEFAULT_ALLOWED_INTERNAL_PATHS
+    );
+    this.publicAssetBaseUrl = normalizePublicAssetBaseUrl(config.publicAssetBaseUrl);
+    this.publicAssetPrefix = normalizePublicAssetPrefix(config.publicAssetPrefix);
+  }
+  async ensureInitialized(seed) {
+    await this.storage.ensureInitialized(seed);
+  }
+  async getContent(stage) {
+    return this.storage.getContent(stage);
+  }
+  getModelConfig() {
+    return this.modelConfig;
+  }
+  getPublicAssetBaseUrl() {
+    return this.publicAssetBaseUrl;
+  }
+  async saveGeneratedImage(input) {
+    const targetPath = input.targetPath.trim();
+    if (!targetPath) {
+      throw new Error("Generated image target path is required.");
+    }
+    if (!(input.data instanceof Uint8Array) || input.data.length === 0) {
+      throw new Error("Generated image bytes are required.");
+    }
+    const contentType = input.contentType.trim().toLowerCase().split(";", 1)[0];
+    if (!contentType.startsWith("image/")) {
+      throw new Error(`Generated content type is not an image: ${input.contentType}`);
+    }
+    if (!this.publicAssetBaseUrl) {
+      throw new Error(
+        "CMS public asset base URL is not configured. Set CMS_PUBLIC_BASE_URL to enable generated image URLs."
+      );
+    }
+    const key = buildGeneratedAssetKey(targetPath, this.publicAssetPrefix, contentType);
+    await this.storage.putPublicAsset({
+      key,
+      body: input.data,
+      contentType,
+      cacheControl: input.cacheControl ?? DEFAULT_GENERATED_IMAGE_CACHE_CONTROL
+    });
+    return {
+      key,
+      url: `${this.publicAssetBaseUrl}/${key}`
+    };
+  }
+  async mutateDraft(input) {
+    const currentDraft = await this.storage.getContent("draft");
+    const checkpoint = await this.storage.createCheckpoint(currentDraft, {
+      createdBy: input.actor,
+      reason: input.reason
+    });
+    const { document, warnings } = applyPatch(currentDraft, input.patch, {
+      maxOperationsPerPatch: this.maxOperationsPerPatch,
+      allowedInternalPaths: this.allowedInternalPaths
+    });
+    document.meta.updatedAt = nowIso();
+    document.meta.updatedBy = input.actor;
+    document.meta.contentVersion = createId("draft");
+    document.meta.sourceCheckpointId = checkpoint.id;
+    await this.storage.saveDraft(document);
+    await this.storage.appendEvent(this.createEvent("chat_mutation", input.actor, {
+      checkpointId: checkpoint.id,
+      reason: input.reason,
+      operations: input.patch.operations,
+      warnings
+    }));
+    return {
+      document,
+      checkpoint,
+      warnings
+    };
+  }
+  async mutateDraftBatch(input) {
+    const hasContentPatch = Boolean(input.patch && input.patch.operations.length > 0);
+    const hasThemePatch = Boolean(input.themePatch && Object.keys(input.themePatch).length > 0);
+    if (!hasContentPatch && !hasThemePatch) {
+      throw new Error("No draft mutations provided.");
+    }
+    const currentDraft = await this.storage.getContent("draft");
+    const checkpoint = await this.storage.createCheckpoint(currentDraft, {
+      createdBy: input.actor,
+      reason: input.reason
+    });
+    let workingDocument = currentDraft;
+    const warnings = [];
+    if (hasContentPatch) {
+      const contentResult = applyPatch(workingDocument, input.patch, {
+        maxOperationsPerPatch: this.maxOperationsPerPatch,
+        allowedInternalPaths: this.allowedInternalPaths
+      });
+      workingDocument = contentResult.document;
+      warnings.push(...contentResult.warnings);
+    }
+    if (hasThemePatch) {
+      const themeResult = applyThemeTokenPatch(
+        workingDocument,
+        input.themePatch
+      );
+      workingDocument = themeResult.document;
+      warnings.push(...themeResult.warnings);
+    }
+    const document = {
+      ...workingDocument,
+      meta: {
+        ...workingDocument.meta,
+        updatedAt: nowIso(),
+        updatedBy: input.actor,
+        contentVersion: createId("draft"),
+        sourceCheckpointId: checkpoint.id
+      }
+    };
+    await this.storage.saveDraft(document);
+    await this.storage.appendEvent(
+      this.createEvent("chat_mutation", input.actor, {
+        checkpointId: checkpoint.id,
+        reason: input.reason,
+        operations: input.patch?.operations,
+        themePatch: input.themePatch,
+        warnings
+      })
+    );
+    return {
+      document,
+      checkpoint,
+      warnings
+    };
+  }
+  async mutateThemeTokens(input) {
+    const currentDraft = await this.storage.getContent("draft");
+    const checkpoint = await this.storage.createCheckpoint(currentDraft, {
+      createdBy: input.actor,
+      reason: input.reason
+    });
+    const { document, warnings } = applyThemeTokenPatch(currentDraft, input.patch);
+    document.meta.updatedAt = nowIso();
+    document.meta.updatedBy = input.actor;
+    document.meta.contentVersion = createId("draft");
+    document.meta.sourceCheckpointId = checkpoint.id;
+    await this.storage.saveDraft(document);
+    await this.storage.appendEvent(this.createEvent("chat_mutation", input.actor, {
+      checkpointId: checkpoint.id,
+      reason: input.reason,
+      themePatch: input.patch,
+      warnings
+    }));
+    return {
+      document,
+      checkpoint,
+      warnings
+    };
+  }
+  async publishDraft(input, actor) {
+    if (input.confirmationText !== REQUIRED_PUBLISH_CONFIRMATION) {
+      throw new Error(
+        `Invalid publish confirmation text. Use exactly: ${REQUIRED_PUBLISH_CONFIRMATION}`
+      );
+    }
+    const currentDraft = await this.storage.getContent("draft");
+    const version = await this.storage.publishDraft({
+      content: currentDraft,
+      createdBy: actor
+    });
+    const publishedLive = {
+      ...currentDraft,
+      meta: {
+        ...currentDraft.meta,
+        updatedAt: nowIso(),
+        updatedBy: actor,
+        contentVersion: version.id
+      }
+    };
+    await this.storage.saveLive(publishedLive);
+    await this.storage.saveDraft(publishedLive);
+    await this.storage.appendEvent(this.createEvent("publish", actor, {
+      version
+    }));
+    return version;
+  }
+  async rollbackDraft(input, actor) {
+    const currentDraft = await this.storage.getContent("draft");
+    const targetSnapshot = await this.storage.getSnapshot(input);
+    if (!targetSnapshot) {
+      throw new Error(`Rollback source not found: ${input.sourceType}/${input.sourceId}`);
+    }
+    const currentComparable = comparableContentSnapshot(currentDraft);
+    const targetComparable = comparableContentSnapshot(targetSnapshot);
+    if (currentComparable === targetComparable) {
+      await this.storage.appendEvent(this.createEvent("rollback", actor, {
+        sourceType: input.sourceType,
+        sourceId: input.sourceId,
+        newDraftVersion: currentDraft.meta.contentVersion,
+        skipped: true,
+        reason: "already-at-target"
+      }));
+      return currentDraft;
+    }
+    const newDraft = {
+      ...targetSnapshot,
+      meta: {
+        ...targetSnapshot.meta,
+        updatedAt: nowIso(),
+        updatedBy: actor,
+        contentVersion: createId("draft"),
+        sourceCheckpointId: `${input.sourceType}:${input.sourceId}`
+      }
+    };
+    await this.storage.saveDraft(newDraft);
+    await this.storage.appendEvent(this.createEvent("rollback", actor, {
+      sourceType: input.sourceType,
+      sourceId: input.sourceId,
+      newDraftVersion: newDraft.meta.contentVersion
+    }));
+    return newDraft;
+  }
+  async listHistory() {
+    const [checkpoints, published] = await Promise.all([
+      this.storage.listCheckpoints(),
+      this.storage.listPublishedVersions()
+    ]);
+    return {
+      checkpoints,
+      published
+    };
+  }
+  async deleteCheckpoint(checkpointId) {
+    const normalizedId = checkpointId.trim();
+    if (!normalizedId) {
+      throw new Error("Checkpoint id is required.");
+    }
+    const deleted = await this.storage.deleteCheckpoint(normalizedId);
+    if (!deleted) {
+      throw new Error(`Checkpoint not found: ${normalizedId}`);
+    }
+  }
+  createEvent(type, actor, detail) {
+    return {
+      id: createId("evt"),
+      type,
+      actor,
+      createdAt: nowIso(),
+      detail
+    };
+  }
+};
+function createPatchFromAgentOperations(operations) {
+  const patchOperations = [];
+  for (const operation of operations) {
+    if (!isEditablePath2(operation.path)) {
+      throw new Error(`Path is out of editable scope: ${operation.path}`);
+    }
+    patchOperations.push({
+      op: "set",
+      path: operation.path,
+      value: operation.value
+    });
+  }
+  return {
+    operations: patchOperations
+  };
+}
+function createThemePatchFromAgentOperations(operations) {
+  const out = {};
+  for (const operation of operations) {
+    out[operation.token] = operation.value;
+  }
+  return out;
+}
+
+export {
+  validatePatch,
+  applyPatch,
+  applyThemeTokenPatch,
+  CmsService,
+  createPatchFromAgentOperations,
+  createThemePatchFromAgentOperations
+};