@aeptus/aexeo-emdash 0.1.0

package/dist/sandbox-entry.js

@@ -0,0 +1,846 @@
+// src/adapter.ts
+function contentItemToEmdashDocument(content) {
+  const route = deriveRoute(content);
+  const title = stringOrEmpty(
+    content.seo?.title ?? content.data["title"] ?? content.slug ?? content.id
+  );
+  const document = {
+    route,
+    title
+  };
+  const description = content.seo?.description ?? content.data["description"];
+  if (typeof description === "string" && description.length > 0) {
+    document.description = description;
+  }
+  const canonical = content.seo?.canonical;
+  if (typeof canonical === "string" && canonical.length > 0) {
+    document.canonical = canonical;
+  }
+  if (content.locale !== null) {
+    document.lang = content.locale;
+  }
+  const body = extractPortableText(content.data);
+  if (body !== null) {
+    document.body = body;
+  }
+  return document;
+}
+function deriveRoute(content) {
+  if (typeof content.slug === "string" && content.slug.length > 0) {
+    return content.slug.startsWith("/") ? content.slug : `/${content.slug}`;
+  }
+  return `/${content.type}/${content.id}`;
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function extractPortableText(data) {
+  const candidates = ["body", "content"];
+  for (const slug of candidates) {
+    const value = data[slug];
+    if (isPortableTextArray(value)) {
+      return value;
+    }
+  }
+  for (const value of Object.values(data)) {
+    if (isPortableTextArray(value)) {
+      return value;
+    }
+  }
+  return null;
+}
+function isPortableTextArray(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return false;
+  }
+  const first = value[0];
+  return typeof first === "object" && first !== null && "_type" in first && typeof first._type === "string";
+}
+
+// src/plugin.ts
+var CONFIG_URL_KEY = "config:evaluator_url";
+var CONFIG_TOKEN_KEY = "config:eval_token";
+async function readSidecarConfig(kv) {
+  const url = await kv.get(CONFIG_URL_KEY);
+  const token = await kv.get(CONFIG_TOKEN_KEY);
+  if (typeof url !== "string" || typeof token !== "string") {
+    return null;
+  }
+  if (url.length === 0 || token.length === 0) {
+    return null;
+  }
+  return { url, token };
+}
+async function writeSidecarConfig(kv, config) {
+  await kv.set(CONFIG_URL_KEY, config.url);
+  await kv.set(CONFIG_TOKEN_KEY, config.token);
+}
+async function handleAfterSave(_event, _ctx) {
+}
+var DEFAULT_COLLECTIONS = ["posts", "pages"];
+async function evaluateAndPersistAll(ctx, options) {
+  const collections = options.collections ?? DEFAULT_COLLECTIONS;
+  const { kv, log } = ctx;
+  const summary = {
+    documentsScanned: 0,
+    routesUpdated: 0,
+    totalFindings: 0,
+    errors: []
+  };
+  const documents = [];
+  const documentRoutes = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    let cursor;
+    do {
+      try {
+        const page = await ctx.content.list(collection, {
+          limit: 100,
+          ...cursor === void 0 ? {} : { cursor }
+        });
+        for (const item of page.items) {
+          const document = contentItemToEmdashDocument(item);
+          documents.push(document);
+          documentRoutes.add(document.route);
+        }
+        cursor = page.hasMore ? page.cursor : void 0;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        summary.errors.push(`${collection}: ${message}`);
+        cursor = void 0;
+      }
+    } while (cursor !== void 0);
+  }
+  summary.documentsScanned = documents.length;
+  for (const document of documents) {
+    await kv.set(documentKey(document.route), document);
+  }
+  const result = await options.evaluator(documents);
+  if (!result.ok) {
+    log?.error?.(`seogeo evaluator failure (${result.reason})`, {
+      detail: result.detail
+    });
+    summary.errors.push(`${result.reason}: ${result.detail}`);
+    return summary;
+  }
+  const findingsByRoute2 = /* @__PURE__ */ new Map();
+  for (const route of documentRoutes) {
+    findingsByRoute2.set(route, []);
+  }
+  for (const finding of result.findings) {
+    const bucket = finding.scope === "page" ? finding.path : "*";
+    const list = findingsByRoute2.get(bucket) ?? [];
+    list.push(finding);
+    findingsByRoute2.set(bucket, list);
+  }
+  for (const [route, findings] of findingsByRoute2) {
+    await kv.set(findingsKey(route), { route, findings });
+    summary.routesUpdated += 1;
+  }
+  summary.totalFindings = result.findings.length;
+  return summary;
+}
+function findingsKey(route) {
+  const normalized = route === "" || route === "/" ? "/" : route;
+  return `findings:${normalized}`;
+}
+function documentKey(route) {
+  const normalized = route === "" || route === "/" ? "/" : route;
+  return `document:${normalized}`;
+}
+async function readAllDocuments(kv) {
+  const entries = await kv.list("document:");
+  return entries.map((entry) => entry.value).filter((value) => value !== null);
+}
+async function readFindings(kv, route) {
+  const stored = await kv.get(findingsKey(route));
+  if (stored === null) {
+    return [];
+  }
+  return stored.findings;
+}
+
+// src/sidecar.ts
+async function evaluateViaSidecar(http, config, documents) {
+  const body = {
+    documents
+  };
+  if (config.configJson !== void 0) {
+    body.configJson = config.configJson;
+  }
+  let response;
+  try {
+    response = await http.fetch(`${trimTrailingSlash(config.url)}/evaluate`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${config.authToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: "network_error", detail };
+  }
+  if (response.status === 401 || response.status === 403) {
+    return {
+      ok: false,
+      reason: "auth_error",
+      detail: `sidecar rejected token (HTTP ${response.status})`
+    };
+  }
+  if (!response.ok) {
+    let detail = `sidecar HTTP ${response.status}`;
+    try {
+      detail = `${detail}: ${await response.text()}`;
+    } catch {
+    }
+    return { ok: false, reason: "server_error", detail };
+  }
+  let raw;
+  try {
+    raw = await response.text();
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: "invalid_response", detail };
+  }
+  try {
+    const findings = JSON.parse(raw);
+    if (!Array.isArray(findings)) {
+      return {
+        ok: false,
+        reason: "invalid_response",
+        detail: "sidecar returned non-array body"
+      };
+    }
+    return { ok: true, findings };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: "invalid_response", detail };
+  }
+}
+function trimTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+
+// src/evaluator-sandbox.ts
+async function evaluate(_documents) {
+  return [];
+}
+async function scoreSite(_documents) {
+  return {
+    overall_score: 0,
+    citation_readiness_score: 0,
+    truth_consistency_score: 0,
+    answer_pack_score: 0,
+    external_trust_alignment_score: null,
+    route_scores: [],
+    blockers: []
+  };
+}
+function errorFindings(findings) {
+  return findings.filter((finding) => finding.severity === "error");
+}
+function findingsByRoute(findings) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const bucket = grouped.get(finding.path);
+    if (bucket) {
+      bucket.push(finding);
+    } else {
+      grouped.set(finding.path, [finding]);
+    }
+  }
+  return grouped;
+}
+
+// src/indexnow.ts
+var INDEXNOW_ENDPOINT = "https://api.indexnow.org/indexnow";
+async function submitIndexNow(config, urls) {
+  const host = hostOf(config.siteUrl);
+  if (host === null) {
+    return failure("siteUrl is not a valid URL", []);
+  }
+  const keyLocation = config.keyLocation ?? defaultKeyLocation(config);
+  const { submitted, rejected } = partitionByHost(urls, host);
+  if (submitted.length === 0) {
+    return failure("no submittable URLs after host check", rejected);
+  }
+  const payload = {
+    host,
+    key: config.key,
+    keyLocation,
+    urlList: submitted
+  };
+  const response = await fetch(INDEXNOW_ENDPOINT, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  return {
+    ok: response.ok,
+    status: response.status,
+    endpoint: INDEXNOW_ENDPOINT,
+    submitted,
+    rejected
+  };
+}
+function hostOf(rawUrl) {
+  try {
+    return new URL(rawUrl).host;
+  } catch {
+    return null;
+  }
+}
+function defaultKeyLocation(config) {
+  const siteUrl = config.siteUrl.endsWith("/") ? config.siteUrl.slice(0, -1) : config.siteUrl;
+  return `${siteUrl}/${config.key}.txt`;
+}
+function partitionByHost(urls, expectedHost) {
+  const submitted = [];
+  const rejected = [];
+  for (const candidate of urls) {
+    const host = hostOf(candidate);
+    if (host === expectedHost) {
+      submitted.push(candidate);
+    } else {
+      rejected.push(candidate);
+    }
+  }
+  return { submitted, rejected };
+}
+function failure(reason, rejected) {
+  return {
+    ok: false,
+    status: 0,
+    endpoint: INDEXNOW_ENDPOINT,
+    submitted: [],
+    rejected,
+    reason
+  };
+}
+
+// src/mcp.ts
+var checkTool = {
+  name: "seogeo.check",
+  description: "Evaluate a list of EmdashDocument values against the seogeo rule engine and return the stable Finding contract. Mirrors the CLI's `seogeo-cli check` surface so agents, the admin UI, and the CI gate all see the same rule ids.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      documents: {
+        type: "array",
+        description: "Array of EmdashDocument values to evaluate. Each entry carries route, title, optional description/canonical/lang, alternates, meta map, schema, and Portable Text body."
+      },
+      configJson: {
+        type: "string",
+        description: "Optional JSON-serialized seogeo Config. When absent the evaluator uses Config::default(), matching a cold CLI run."
+      }
+    },
+    required: ["documents"]
+  },
+  handler: async ({ documents, configJson }) => {
+    const options = configJson === void 0 ? {} : { configJson };
+    const findings = await evaluate(documents, options);
+    const errors = errorFindings(findings);
+    const grouped = findingsByRoute(findings);
+    const byRoute = {};
+    for (const [route, items] of grouped.entries()) {
+      byRoute[route] = items;
+    }
+    return {
+      findings,
+      errors,
+      byRoute,
+      totals: {
+        findings: findings.length,
+        errors: errors.length,
+        warnings: findings.length - errors.length
+      }
+    };
+  }
+};
+var indexNowSubmitTool = {
+  name: "seogeo.indexnow.submit",
+  description: "Submit a list of URLs to the IndexNow freshness endpoint. Mirrors the seogeo-cli `indexnow submit` contract: the IndexNow protocol requires every submitted URL to belong to the configured site host. URLs that do not match the host are returned in `rejected` and never sent over the wire.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      config: {
+        type: "object",
+        description: "IndexNow configuration: siteUrl, key, and optional keyLocation override.",
+        properties: {
+          siteUrl: { type: "string" },
+          key: { type: "string" },
+          keyLocation: { type: "string" }
+        },
+        required: ["siteUrl", "key"]
+      },
+      urls: {
+        type: "array",
+        items: { type: "string" },
+        description: "Absolute URLs to submit. Must share siteUrl's host."
+      }
+    },
+    required: ["config", "urls"]
+  },
+  handler: async ({ config, urls }) => submitIndexNow(config, urls)
+};
+var tools = [checkTool, indexNowSubmitTool];
+
+// src/sandbox-entry.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+async function handleAdminRoute(input, ctx) {
+  ctx.log?.info?.(
+    `seogeo route: type=${input.input?.type} page=${input.input?.page ?? ""}`
+  );
+  const dispatch = { body: input.input, kv: ctx.kv, ctx };
+  if (dispatch.body.type === "page_load") {
+    return handlePageLoad(dispatch, dispatch.body.page);
+  }
+  if (dispatch.body.type === "block_action") {
+    return handleBlockAction(
+      dispatch,
+      dispatch.body.action_id,
+      dispatch.body.value
+    );
+  }
+  if (dispatch.body.type === "form_submit") {
+    return handleFormSubmit(
+      dispatch,
+      dispatch.body.action_id,
+      dispatch.body.values
+    );
+  }
+  return handlePageLoad(dispatch, "findings");
+}
+async function handleFormSubmit(ctx, actionId, values) {
+  if (actionId === "save_setup") {
+    return handleSetupSubmit(ctx, values);
+  }
+  if (actionId === "view_document") {
+    const picked = values["route_picker"];
+    if (typeof picked === "string" && picked.length > 0) {
+      return renderDocumentPanel(ctx, picked);
+    }
+  }
+  return handlePageLoad(ctx, "findings");
+}
+async function handlePageLoad(ctx, page) {
+  const normalized = page.startsWith("/") ? page.slice(1) : page;
+  if (normalized === "findings") {
+    return renderFindingsPage(ctx);
+  }
+  if (normalized === "widget:seogeo-score") {
+    return renderScoreWidget(ctx);
+  }
+  if (normalized === "document") {
+    return renderDocumentPanel(ctx);
+  }
+  if (normalized === "setup") {
+    return renderSetupPage(ctx);
+  }
+  return notFound(page);
+}
+async function handleBlockAction(ctx, actionId, value) {
+  if (actionId === "view_document" && typeof value === "string") {
+    return renderDocumentPanel(ctx, value);
+  }
+  if (actionId === "refresh_findings") {
+    return handleRefresh(ctx);
+  }
+  if (actionId.startsWith("filter:")) {
+    return renderFindingsPage(ctx);
+  }
+  return notFound(actionId);
+}
+async function handleRefresh(ctx) {
+  const sandboxEvaluator = async (documents) => {
+    const runtime = await readSidecarConfig(ctx.kv);
+    if (runtime === null) {
+      return {
+        ok: false,
+        reason: "config_missing",
+        detail: "sidecar not configured \u2014 open the seogeo Setup page and enter your evaluator URL and token"
+      };
+    }
+    return evaluateViaSidecar(
+      ctx.ctx.http,
+      { url: runtime.url, authToken: runtime.token },
+      documents
+    );
+  };
+  let summary;
+  try {
+    summary = await evaluateAndPersistAll(ctx.ctx, {
+      evaluator: sandboxEvaluator
+    });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      blocks: [
+        { type: "header", text: "SEO findings" },
+        {
+          type: "banner",
+          title: `Refresh failed: ${detail}`,
+          variant: "alert"
+        }
+      ],
+      toast: { message: `Refresh failed: ${detail}`, type: "error" }
+    };
+  }
+  const refreshed = await renderFindingsPage(ctx);
+  const toastMessage = summary.errors.length === 0 ? `Refreshed ${summary.routesUpdated} routes (${summary.totalFindings} findings across ${summary.documentsScanned} documents)` : `Refresh completed with ${summary.errors.length} errors \u2014 see banner`;
+  if (summary.errors.length > 0) {
+    refreshed.blocks.unshift({
+      type: "banner",
+      title: `Refresh issues: ${summary.errors.join(" \u2022 ")}`,
+      variant: "alert"
+    });
+  }
+  return {
+    ...refreshed,
+    toast: {
+      message: toastMessage,
+      type: summary.errors.length === 0 ? "success" : "info"
+    }
+  };
+}
+async function renderFindingsPage(ctx) {
+  const findings = await readAllFindings(ctx.kv);
+  const errors = findings.filter((finding) => finding.severity === "error");
+  const warnings = findings.filter((finding) => finding.severity === "warning");
+  const sorted = [...findings].sort(severityFirst);
+  const routes = uniqueRoutes(findings);
+  const blocks = [
+    { type: "header", text: "SEO findings" },
+    {
+      type: "context",
+      text: findings.length === 0 ? "No findings yet \u2014 click Refresh to evaluate the site." : `${findings.length} findings across ${routes.length} routes \u2014 ${errors.length} errors, ${warnings.length} warnings.`
+    },
+    { type: "divider" },
+    {
+      type: "actions",
+      elements: [
+        // Refresh is the primary action: emdash 0.7.0's afterSave hook
+        // can't reliably do I/O (post-response bridge invalidation), so
+        // re-evaluation is admin-triggered rather than save-triggered.
+        // Pressing this lists all content via the live in-request bridge,
+        // calls the sidecar /evaluate, and writes findings back to KV.
+        {
+          type: "button",
+          label: "Refresh",
+          action_id: "refresh_findings",
+          style: "primary"
+        },
+        { type: "button", label: "All", action_id: "filter:all" },
+        { type: "button", label: "Errors only", action_id: "filter:errors" },
+        {
+          type: "button",
+          label: "Warnings only",
+          action_id: "filter:warnings"
+        }
+      ]
+    },
+    sorted.length === 0 ? {
+      type: "context",
+      text: "Once a document publishes, its rule findings list here."
+    } : findingsTable(sorted)
+  ];
+  if (routes.length > 0) {
+    blocks.push({
+      type: "form",
+      fields: [
+        {
+          type: "select",
+          action_id: "route_picker",
+          label: "Document to inspect",
+          options: routes.map((route) => ({ label: route, value: route }))
+        }
+      ],
+      submit: { label: "View document SEO", action_id: "view_document" }
+    });
+  }
+  return { blocks };
+}
+async function readAllFindings(kv) {
+  const entries = await kv.list(
+    "findings:"
+  );
+  const out = [];
+  for (const entry of entries) {
+    if (entry.value === null) {
+      continue;
+    }
+    const route = entry.key.replace(/^findings:/, "");
+    for (const finding of entry.value.findings) {
+      out.push({ ...finding, document_route: route });
+    }
+  }
+  return out;
+}
+function uniqueRoutes(rows) {
+  const routes = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    routes.add(row.document_route);
+  }
+  return [...routes].sort();
+}
+function severityFirst(a, b) {
+  const rank = (severity) => severity === "error" ? 0 : 1;
+  const diff = rank(a.severity) - rank(b.severity);
+  if (diff !== 0) {
+    return diff;
+  }
+  return a.rule_id.localeCompare(b.rule_id);
+}
+function findingsTable(rows) {
+  return {
+    type: "table",
+    columns: [
+      { key: "route", label: "Route" },
+      { key: "rule", label: "Rule", format: "code" },
+      { key: "severity", label: "Severity", format: "badge" },
+      { key: "message", label: "Message" }
+    ],
+    rows: rows.map((row) => ({
+      route: row.document_route,
+      rule: row.rule_id,
+      severity: row.severity,
+      message: row.message
+    }))
+  };
+}
+async function renderScoreWidget(ctx) {
+  const documents = await readAllDocuments(ctx.kv);
+  if (documents.length === 0) {
+    return {
+      blocks: [
+        { type: "header", text: "SEO score" },
+        {
+          type: "context",
+          text: "No documents saved yet \u2014 score appears after the first emdash save."
+        }
+      ]
+    };
+  }
+  const score = await scoreSite(documents);
+  const blocks = [
+    {
+      type: "stats",
+      items: [
+        {
+          label: "Overall",
+          value: `${score.overall_score}`
+        },
+        {
+          label: "Citation",
+          value: `${score.citation_readiness_score}`
+        },
+        {
+          label: "Truth",
+          value: `${score.truth_consistency_score}`
+        },
+        {
+          label: "Answers",
+          value: `${score.answer_pack_score}`
+        }
+      ]
+    }
+  ];
+  if (score.overall_score < 60) {
+    blocks.unshift({
+      type: "banner",
+      title: `Site score is ${score.overall_score} \u2014 below the 60 quality threshold`,
+      variant: "alert"
+    });
+  }
+  if (score.blockers.length > 0) {
+    blocks.push({
+      type: "context",
+      text: topBlockersLine(score)
+    });
+  }
+  return { blocks };
+}
+function topBlockersLine(score) {
+  const top = score.blockers.slice(0, 3).map((blocker) => blocker.message);
+  if (top.length === 0) {
+    return "No blockers identified.";
+  }
+  return `Top blockers: ${top.join(" \u2022 ")}`;
+}
+async function renderDocumentPanel(ctx, route) {
+  if (route === void 0) {
+    return {
+      blocks: [
+        { type: "header", text: "Document SEO" },
+        {
+          type: "context",
+          text: "Pick a document from the SEO findings list to see its rule findings here."
+        }
+      ]
+    };
+  }
+  const findings = await readFindings(ctx.kv, route);
+  const errors = findings.filter((finding) => finding.severity === "error");
+  const warnings = findings.filter((finding) => finding.severity === "warning");
+  const sorted = [...findings].sort(severityFirst);
+  return {
+    blocks: [
+      { type: "header", text: `Document SEO \u2014 ${route}` },
+      {
+        type: "context",
+        text: findings.length === 0 ? `No findings for ${route} \u2014 the document is currently clean.` : `${findings.length} findings \u2014 ${errors.length} errors, ${warnings.length} warnings.`
+      },
+      ...findings.length === 0 ? [] : [{ type: "divider" }, documentFindingsTable(sorted)]
+    ]
+  };
+}
+function documentFindingsTable(findings) {
+  return {
+    type: "table",
+    columns: [
+      { key: "rule", label: "Rule", format: "code" },
+      { key: "severity", label: "Severity", format: "badge" },
+      { key: "message", label: "Message" },
+      { key: "block", label: "Block", format: "code" }
+    ],
+    rows: findings.map((finding) => ({
+      rule: finding.rule_id,
+      severity: finding.severity,
+      message: finding.message,
+      // The bridge stamps every Portable Text block with id + data-pt-key
+      // when rendering; surfacing the path:line locator here lets authors
+      // locate the failing block via the editor's ⌘-F.
+      block: `${finding.path}:${finding.line}`
+    }))
+  };
+}
+async function renderSetupPage(ctx, options = {}) {
+  const existing = await readSidecarConfig(ctx.kv);
+  const blocks = [
+    { type: "header", text: "seogeo setup" },
+    {
+      type: "context",
+      text: "Paste the URL and auth token of your deployed seogeo-crawl-worker. These are stored in plugin KV and read at runtime \u2014 no rebuild required after a change. Rotate the token here whenever you redeploy the sidecar with a new secret."
+    }
+  ];
+  if (options.bannerError !== void 0) {
+    blocks.push({
+      type: "banner",
+      title: options.bannerError,
+      variant: "error"
+    });
+  } else if (options.bannerSuccess !== void 0) {
+    blocks.push({
+      type: "banner",
+      title: options.bannerSuccess,
+      variant: "default"
+    });
+  }
+  blocks.push(
+    {
+      type: "form",
+      fields: [
+        {
+          type: "text_input",
+          action_id: "evaluator_url",
+          label: "Sidecar URL",
+          placeholder: "https://seogeo-crawl-worker.<subdomain>.workers.dev",
+          initial_value: options.initialUrl ?? existing?.url ?? ""
+        },
+        {
+          type: "secret_input",
+          action_id: "eval_token",
+          label: "EVAL_TOKEN",
+          placeholder: existing === null ? "Generate with: openssl rand -hex 32" : "Leave blank to keep the existing token",
+          has_value: existing !== null
+        }
+      ],
+      submit: {
+        label: "Save",
+        action_id: "save_setup"
+      }
+    },
+    { type: "divider" },
+    {
+      type: "context",
+      text: existing === null ? "Status: not configured. Refresh on the findings page will fail until both fields are saved." : `Status: configured. Sidecar at ${existing.url}. Token stored \u2014 paste a new one above to rotate.`
+    }
+  );
+  return { blocks };
+}
+async function handleSetupSubmit(ctx, values) {
+  const rawUrl = values["evaluator_url"];
+  const rawToken = values["eval_token"];
+  const url = typeof rawUrl === "string" ? rawUrl.trim() : "";
+  const token = typeof rawToken === "string" ? rawToken.trim() : "";
+  if (url.length === 0) {
+    return renderSetupPage(ctx, {
+      bannerError: "Sidecar URL is required.",
+      initialUrl: url
+    });
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return renderSetupPage(ctx, {
+      bannerError: `Sidecar URL is not a valid URL: ${url}`,
+      initialUrl: url
+    });
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    return renderSetupPage(ctx, {
+      bannerError: `Sidecar URL must be http(s): got ${parsed.protocol}`,
+      initialUrl: url
+    });
+  }
+  if (parsed.hostname === "localhost" || parsed.hostname.endsWith(".localhost") || /^127\./.test(parsed.hostname)) {
+    return renderSetupPage(ctx, {
+      bannerError: "emdash's sandbox blocks fetches to localhost (anti-SSRF). Use the deployed *.workers.dev URL.",
+      initialUrl: url
+    });
+  }
+  const existing = await readSidecarConfig(ctx.kv);
+  let resolvedToken;
+  if (token.length > 0) {
+    resolvedToken = token;
+  } else if (existing !== null) {
+    resolvedToken = existing.token;
+  } else {
+    return renderSetupPage(ctx, {
+      bannerError: "EVAL_TOKEN is required on first setup.",
+      initialUrl: url
+    });
+  }
+  const next = { url, token: resolvedToken };
+  await writeSidecarConfig(ctx.kv, next);
+  return renderSetupPage(ctx, {
+    bannerSuccess: "Configuration saved. Click Refresh on the findings page to evaluate."
+  });
+}
+function notFound(page) {
+  return {
+    blocks: [
+      { type: "header", text: "Not found" },
+      { type: "context", text: `unknown page: ${page}` }
+    ]
+  };
+}
+var sandbox_entry_default = definePlugin({
+  hooks: {
+    "content:afterSave": handleAfterSave
+  },
+  routes: {
+    admin: { handler: handleAdminRoute }
+  },
+  // emdash's MCP server picks tools up from this field. The exact
+  // host-side spec for plugin-contributed tools is still being mapped;
+  // the field is harmless if unrecognized.
+  mcpTools: tools
+});
+export {
+  sandbox_entry_default as default
+};