pagecast 0.1.1 → 0.1.2

package/src/server.js

@@ -26,6 +26,17 @@ export const DEFAULT_CLOUDFLARE_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 export const DEFAULT_CLOUDFLARE_LIST_TIMEOUT_MS = 60 * 1000;
 export const CLOUDFLARE_OAUTH_SCOPES = ["account:read", "user:read", "pages:write"];
 
+// Feedback provisioning deploys a Worker + KV, which the base publishing scopes
+// don't permit. These elevate the grant only when the user opts into feedback,
+// so publishing never has to request Workers/KV access up front.
+export const FEEDBACK_OAUTH_SCOPES = [
+  "account:read",
+  "user:read",
+  "pages:write",
+  "workers_scripts:write",
+  "workers_kv:write"
+];
+
 const MIME_TYPES = new Map([
   [".html", "text/html; charset=utf-8"],
   [".htm", "text/html; charset=utf-8"],
@@ -228,6 +239,62 @@ function cleanCommandOutput(output) {
     .trim();
 }
 
+// --- Feedback Worker provisioning: parse wrangler outputs --------------------
+
+// A KV namespace id is a 32-char hex string. `wrangler kv namespace create`
+// prints a TOML/JSON snippet containing `id = "<hex>"` / `"id": "<hex>"`.
+export function parseKvNamespaceId(output) {
+  const text = stripAnsi(output || "");
+  const match = text.match(/(?:id\s*=\s*|"id"\s*:\s*)"([0-9a-f]{32})"/i);
+  return match ? match[1].toLowerCase() : "";
+}
+
+// `wrangler kv namespace list` prints a JSON array of { id, title }. Reuse an
+// existing namespace by title so re-running setup is idempotent.
+export function findKvNamespaceId(output, title) {
+  const text = stripAnsi(output || "");
+  try {
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    if (start >= 0 && end > start) {
+      const list = JSON.parse(text.slice(start, end + 1));
+      const hit = list.find((entry) => entry && entry.title === title);
+      if (hit && /^[0-9a-f]{32}$/i.test(hit.id || "")) {
+        return String(hit.id).toLowerCase();
+      }
+    }
+  } catch {
+    // Non-JSON or unexpected shape — treat as "not found" and create one.
+  }
+  return "";
+}
+
+// The deployed Worker's public origin, e.g. https://name.sub.workers.dev.
+export function parseWorkerDevUrl(output) {
+  const text = stripAnsi(output || "");
+  const match = text.match(/https:\/\/[a-z0-9-]+\.[a-z0-9-]+\.workers\.dev/i);
+  return match ? match[0].toLowerCase() : "";
+}
+
+// Normalize the persisted feedback (reactions + analytics) settings. Returns
+// null until the feedback Worker has been provisioned, so callers can treat the
+// whole feature as off by checking for a truthy `feedback`.
+function normalizeFeedback(feedback) {
+  if (!feedback || typeof feedback !== "object") {
+    return null;
+  }
+  const url = String(feedback.url || "").trim().replace(/\/+$/, "");
+  if (!/^https:\/\/[^\s/]+/i.test(url)) {
+    return null;
+  }
+  return {
+    url,
+    statsToken: String(feedback.statsToken || ""),
+    workerName: String(feedback.workerName || ""),
+    kvId: String(feedback.kvId || "")
+  };
+}
+
 function normalizeConfig(config = {}) {
   const projectName = normalizePagesProjectName(
     config.pages?.projectName || DEFAULT_PAGES_PROJECT_NAME
@@ -242,7 +309,8 @@ function normalizeConfig(config = {}) {
       accountName,
       branch: DEFAULT_PAGES_BRANCH,
       baseUrl: pagesBaseUrl(projectName)
-    }
+    },
+    feedback: normalizeFeedback(config.feedback)
   };
 }
 
@@ -889,7 +957,19 @@ export function createConfigStore({ dataDir = path.join(PROJECT_ROOT, ".pagecast
         projectName: projectName === undefined ? config.pages.projectName : projectName,
         accountId: nextAccountId,
         accountName: nextAccountName
-      }
+      },
+      // Preserve feedback config — a pages update (e.g. persisting the account on
+      // publish) must not wipe an already-provisioned feedback Worker.
+      feedback: config.feedback
+    });
+    await save();
+    return get();
+  }
+
+  async function updateFeedback(feedback) {
+    config = normalizeConfig({
+      pages: config.pages,
+      feedback: feedback === null ? null : { ...(config.feedback || {}), ...feedback }
     });
     await save();
     return get();
@@ -899,6 +979,7 @@ export function createConfigStore({ dataDir = path.join(PROJECT_ROOT, ".pagecast
     init,
     get,
     updatePages,
+    updateFeedback,
     configPath
   };
 }
@@ -923,11 +1004,41 @@ export function createDeployQueue() {
   return { enqueue };
 }
 
+// Insert the feedback widget into a published HTML document. The widget (served
+// by the user's feedback Worker) beacons a view and renders the reactions bar.
+// Injected just before </body> so it loads after page content. `url` is the
+// Worker origin and `slug` keys this page's stats. Returns the HTML unchanged
+// when feedback is not configured. Pure + exported for testing.
+export function injectFeedbackWidget(html, { url, slug } = {}) {
+  const baseUrl = String(url || "").trim().replace(/\/+$/, "");
+  const pageSlug = String(slug || "").trim();
+  if (!baseUrl || !pageSlug) {
+    return html;
+  }
+  const esc = (value) =>
+    String(value)
+      .replace(/&/g, "&amp;")
+      .replace(/"/g, "&quot;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;");
+  const tag =
+    `<script src="${esc(`${baseUrl}/widget.js`)}" data-slug="${esc(pageSlug)}" defer></script>`;
+  // Avoid double-injecting if the document already carries the widget.
+  if (html.includes(`data-slug="${esc(pageSlug)}"`) && html.includes("/widget.js")) {
+    return html;
+  }
+  if (/<\/body>/i.test(html)) {
+    return html.replace(/<\/body>/i, `${tag}\n</body>`);
+  }
+  return `${html}\n${tag}\n`;
+}
+
 export function createCloudflarePagesPublisher({
   dataDir = path.join(PROJECT_ROOT, ".pagecast"),
   spawnImpl = spawn,
   timeoutMs = 180000,
-  getRedirects = () => []
+  getRedirects = () => [],
+  getFeedback = () => null
 } = {}) {
   const siteRoot = path.join(dataDir, "pages-site");
   const deployRoot = path.join(dataDir, "pages-deploy");
@@ -966,18 +1077,28 @@ export function createCloudflarePagesPublisher({
   }
 
   async function stagePublication(report, publication) {
-    const destinationRoot = publicationDir(publication.slug || publication.token);
+    const slug = publication.slug || publication.token;
+    const destinationRoot = publicationDir(slug);
     const sourceRoot = publishSourceFor(report);
     await copyPublicTree(sourceRoot, destinationRoot);
+
+    const indexPath = path.join(destinationRoot, "index.html");
+    let html;
     if (isMarkdownFileName(report.entryFile)) {
       // Render the raw markdown entry to real HTML so the published Cloudflare
       // site serves a proper document; sibling assets were copied above.
       const markdown = await fs.readFile(path.join(sourceRoot, report.entryFile), "utf8");
-      const html = markdownToHtml(markdown, { title: report.name });
-      await fs.writeFile(path.join(destinationRoot, "index.html"), html, "utf8");
+      html = markdownToHtml(markdown, { title: report.name });
     } else {
-      await fs.copyFile(path.join(sourceRoot, report.entryFile), path.join(destinationRoot, "index.html"));
+      html = await fs.readFile(path.join(sourceRoot, report.entryFile), "utf8");
     }
+
+    // Inject the reactions + analytics widget when feedback is provisioned.
+    const feedback = getFeedback();
+    if (feedback?.url) {
+      html = injectFeedbackWidget(html, { url: feedback.url, slug });
+    }
+    await fs.writeFile(indexPath, html, "utf8");
   }
 
   async function removePublication(slug) {
@@ -1258,8 +1379,8 @@ export function createCloudflareAuthManager({
   // connect/refresh time; the cache is invalidated whenever login state changes.
   let sessionCache = null;
 
-  async function login() {
-    const scopedArgs = CLOUDFLARE_OAUTH_SCOPES.flatMap((scope) => ["--scopes", scope]);
+  async function login(scopes = CLOUDFLARE_OAUTH_SCOPES) {
+    const scopedArgs = scopes.flatMap((scope) => ["--scopes", scope]);
     await runWrangler(["login", ...scopedArgs], loginTimeoutMs);
     sessionCache = null;
   }
@@ -1342,6 +1463,98 @@ export function createCloudflareAuthManager({
     return name;
   }
 
+  // Provision the feedback Worker: reuse-or-create a KV namespace, stage the
+  // worker + a generated wrangler.toml, and deploy it to the account's
+  // workers.dev. Returns { url, kvId, workerName, statsToken }. Side-effecting
+  // (creates real Cloudflare resources) — only run on explicit user action.
+  async function setupFeedback({
+    accountId = "",
+    workerName = "pagecast-feedback",
+    workerSource = "",
+    statsToken = "",
+    deployDir,
+    timeoutMs = 120000
+  } = {}) {
+    if (!workerSource) {
+      throw appError("Feedback Worker source was not found in the package.", 500);
+    }
+    if (!deployDir) {
+      throw appError("A deploy directory is required to set up feedback.", 500);
+    }
+    const env = accountId ? { CLOUDFLARE_ACCOUNT_ID: accountId } : {};
+    const kvTitle = `${workerName}-store`;
+
+    const provision = async () => {
+      // 1. Reuse or create the KV namespace.
+      let kvId = "";
+      try {
+        const listOut = await runWrangler(["kv", "namespace", "list"], timeoutMs, env);
+        kvId = findKvNamespaceId(listOut, kvTitle);
+      } catch {
+        // Listing isn't available/authorized — fall through to create.
+      }
+      if (!kvId) {
+        const createOut = await runWrangler(
+          ["kv", "namespace", "create", kvTitle],
+          timeoutMs,
+          env
+        );
+        kvId = parseKvNamespaceId(createOut);
+      }
+      if (!kvId) {
+        throw appError("Could not create the feedback KV namespace.", 502);
+      }
+
+      // 2. Stage worker.js + a generated wrangler.toml in a clean temp dir.
+      await fs.rm(deployDir, { recursive: true, force: true });
+      await fs.mkdir(deployDir, { recursive: true });
+      await fs.writeFile(path.join(deployDir, "worker.js"), workerSource, "utf8");
+      const toml = [
+        `name = "${workerName}"`,
+        `main = "worker.js"`,
+        `compatibility_date = "2024-09-01"`,
+        `workers_dev = true`,
+        ``,
+        `[[kv_namespaces]]`,
+        `binding = "PAGECAST_FEEDBACK"`,
+        `id = "${kvId}"`,
+        ``,
+        `[vars]`,
+        `PAGECAST_STATS_TOKEN = "${statsToken}"`,
+        ``
+      ].join("\n");
+      await fs.writeFile(path.join(deployDir, "wrangler.toml"), toml, "utf8");
+
+      // 3. Deploy. Wrangler resolves `main` relative to the config file's dir.
+      const deployOut = await runWrangler(
+        ["deploy", "--config", path.join(deployDir, "wrangler.toml")],
+        timeoutMs,
+        env
+      );
+      const url = parseWorkerDevUrl(deployOut);
+      if (!url) {
+        throw appError(
+          "Feedback Worker deployed but no workers.dev URL was returned. Enable a workers.dev subdomain in your Cloudflare dashboard, then retry.",
+          502
+        );
+      }
+      return { url, kvId, workerName, statsToken };
+    };
+
+    try {
+      return await provision();
+    } catch (error) {
+      // The base publishing OAuth lacks Workers/KV permission, surfacing as a
+      // Cloudflare "Authentication error [code: 10000]". Elevate the grant to the
+      // feedback scopes once, then retry. (No-op if a token is already broad.)
+      if (/code:\s*10000|authentication error/i.test(stripAnsi(error.message || ""))) {
+        await login(FEEDBACK_OAUTH_SCOPES);
+        return await provision();
+      }
+      throw error;
+    }
+  }
+
   function cachedSession() {
     return sessionCache ? sessionCache.value : { loggedIn: false, accounts: [] };
   }
@@ -1369,6 +1582,7 @@ export function createCloudflareAuthManager({
     loginAndListProjects,
     whoami,
     ensureProject,
+    setupFeedback,
     cachedSession,
     refreshSession,
     invalidateSession
@@ -3165,6 +3379,60 @@ async function handleApi(
     return;
   }
 
+  // Provision (or re-provision) the feedback Worker + KV on the user's account.
+  // Creates real Cloudflare resources, so it only runs on this explicit action.
+  if (url.pathname === "/api/feedback/setup" && req.method === "POST") {
+    const body = await readJsonBody(req);
+    const pages = configStore.get().pages;
+    const accountId = normalizeAccountId(body.accountId || pages.accountId || "");
+    const workerPath = path.join(PROJECT_ROOT, "feedback", "worker.js");
+    let workerSource;
+    try {
+      workerSource = await fs.readFile(workerPath, "utf8");
+    } catch {
+      sendError(res, appError("Feedback Worker source not found in the package.", 500));
+      return;
+    }
+    const existing = configStore.get().feedback;
+    const statsToken = existing?.statsToken || randomBytes(24).toString("hex");
+    const dataDir = path.dirname(configStore.configPath);
+    try {
+      const result = await cloudflareAuth.setupFeedback({
+        accountId,
+        workerSource,
+        statsToken,
+        deployDir: path.join(dataDir, "feedback-deploy")
+      });
+      const config = await configStore.updateFeedback(result);
+      sendJson(res, 200, { config, feedback: config.feedback });
+    } catch (error) {
+      sendError(res, error);
+    }
+    return;
+  }
+
+  // Read aggregate stats for a published page back from the feedback Worker.
+  // Proxied through the local server so the stats token never reaches the UI.
+  if (url.pathname === "/api/feedback/stats" && req.method === "GET") {
+    const feedback = configStore.get().feedback;
+    if (!feedback?.url) {
+      sendJson(res, 200, { ok: true, configured: false, stats: null });
+      return;
+    }
+    const slug = url.searchParams.get("slug") || "";
+    const statsUrl =
+      `${feedback.url}/api/v1/stats?slug=${encodeURIComponent(slug)}` +
+      `&token=${encodeURIComponent(feedback.statsToken)}`;
+    try {
+      const response = await fetch(statsUrl);
+      const data = await response.json().catch(() => ({}));
+      sendJson(res, 200, { ok: response.ok, configured: true, ...data });
+    } catch {
+      sendError(res, appError("Could not reach the feedback service.", 502));
+    }
+    return;
+  }
+
   if (url.pathname === "/api/cloudflare/login" && req.method === "POST") {
     await readJsonBody(req);
     await cloudflareAuth.login();
@@ -3593,7 +3861,8 @@ export async function startServers({
     dataDir,
     spawnImpl: pagesDeploySpawnImpl,
     timeoutMs: pagesDeployTimeoutMs,
-    getRedirects: () => store.listRedirects()
+    getRedirects: () => store.listRedirects(),
+    getFeedback: () => configStore.get().feedback
   });
   const deployQueue = createDeployQueue();
   const watchManager = createWatchManager({
@@ -3685,7 +3954,10 @@ async function createHeadlessCloudflareContext({
   const pagesPublisher = createCloudflarePagesPublisher({
     dataDir,
     spawnImpl: pagesDeploySpawnImpl,
-    timeoutMs: pagesDeployTimeoutMs
+    timeoutMs: pagesDeployTimeoutMs,
+    // Headless/CLI publishes (incl. the agent skill's `npx pagecast publish`)
+    // must inject the feedback widget too, not just the running app.
+    getFeedback: () => configStore.get().feedback
   });
   return { configStore, cloudflareAuth, pagesPublisher };
 }
@@ -3778,6 +4050,45 @@ export async function setupCloudflarePages({
   };
 }
 
+// Provision the feedback Worker + KV on the user's account and persist the
+// resulting config. Reuses an existing stats token/namespace on re-run.
+export async function setupCloudflareFeedback({
+  accountId,
+  dataDir = path.join(PROJECT_ROOT, ".pagecast"),
+  cloudflareAuthSpawnImpl = spawn,
+  cloudflareListTimeoutMs = DEFAULT_CLOUDFLARE_LIST_TIMEOUT_MS,
+  feedbackTimeoutMs = 120000
+} = {}) {
+  const { configStore, cloudflareAuth } = await createHeadlessCloudflareContext({
+    dataDir,
+    cloudflareAuthSpawnImpl,
+    cloudflareListTimeoutMs
+  });
+  const pages = configStore.get().pages;
+  const resolvedAccountId = normalizeAccountId(accountId || pages.accountId || "");
+
+  const workerPath = path.join(PROJECT_ROOT, "feedback", "worker.js");
+  let workerSource;
+  try {
+    workerSource = await fs.readFile(workerPath, "utf8");
+  } catch {
+    throw appError("Feedback Worker source not found in the package.", 500);
+  }
+
+  const existing = configStore.get().feedback;
+  const statsToken = existing?.statsToken || randomBytes(24).toString("hex");
+
+  const result = await cloudflareAuth.setupFeedback({
+    accountId: resolvedAccountId,
+    workerSource,
+    statsToken,
+    deployDir: path.join(dataDir, "feedback-deploy")
+  });
+
+  const config = await configStore.updateFeedback(result);
+  return { config, feedback: config.feedback };
+}
+
 export async function getCloudflarePagesStatus({
   dataDir = path.join(PROJECT_ROOT, ".pagecast"),
   cloudflareAuthSpawnImpl = spawn,