create-feedbax 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,28 +1,1263 @@
 #!/usr/bin/env node
-import { createInterface } from 'node:readline/promises';
-import { createProject, resolveCreateOptions, resolveInteractiveCreateOptions, } from './index.js';
+
+// src/cli.ts
+import * as prompt from "@clack/prompts";
+import { spawn } from "node:child_process";
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename as basename2, resolve as resolve2 } from "node:path";
+
+// src/index.ts
+import { createHash, randomBytes } from "node:crypto";
+import { readFile as readFile2, readdir as readdir2, writeFile as writeFile2 } from "node:fs/promises";
+
+// ../config/src/index.ts
+var rootKeys = [
+  "product",
+  "theme",
+  "notion",
+  "changelog",
+  "features",
+  "submissions",
+  "turnstile"
+];
+var featureKeys = ["voting", "comments", "changelog"];
+var feedbackPropertyKeys = [
+  "title",
+  "slug",
+  "description",
+  "type",
+  "status",
+  "published",
+  "voteCount",
+  "teamResponse",
+  "releaseNotesUrl",
+  "submitterName",
+  "submitterEmail",
+  "source",
+  "externalId",
+  "editTokenHash",
+  "createdAt",
+  "updatedAt"
+];
+var changelogPropertyKeys = [
+  "title",
+  "slug",
+  "date",
+  "summary",
+  "body",
+  "labels",
+  "image",
+  "published",
+  "createdAt",
+  "updatedAt"
+];
+function defineFeedbax(config) {
+  const value = object(config, "Feedbax configuration");
+  rejectUnknown(value, rootKeys, "Feedbax configuration");
+  const product = object(value.product, "product");
+  rejectUnknown(
+    product,
+    ["name", "description", "logo", "siteUrl", "supportUrl", "privacyUrl"],
+    "product"
+  );
+  const validatedProduct = {
+    name: text(product.name, "product.name"),
+    description: text(product.description, "product.description"),
+    logo: publicUrl(product.logo, "product.logo", true),
+    ...optionalPublicUrl(product, "siteUrl"),
+    ...optionalPublicUrl(product, "supportUrl"),
+    ...optionalPublicUrl(product, "privacyUrl")
+  };
+  const theme = object(value.theme, "theme");
+  rejectUnknown(theme, ["preset"], "theme");
+  const notion = storage(
+    value.notion,
+    feedbackPropertyKeys,
+    "notion"
+  );
+  const features = object(value.features, "features");
+  rejectUnknown(features, featureKeys, "features");
+  const validatedFeatures = Object.fromEntries(
+    featureKeys.map((key) => {
+      if (typeof features[key] !== "boolean")
+        throw new Error(`features.${key} must be true or false.`);
+      return [key, features[key]];
+    })
+  );
+  const changelog = value.changelog === void 0 ? void 0 : storage(
+    value.changelog,
+    changelogPropertyKeys,
+    "changelog"
+  );
+  if (validatedFeatures.changelog && !changelog)
+    throw new Error(
+      "Changelog is enabled but changelog storage is not configured. Add changelog identifiers and property mappings, or set features.changelog to false."
+    );
+  const submissions = object(value.submissions, "submissions");
+  rejectUnknown(
+    submissions,
+    ["moderation", "maxTitleLength", "maxDescriptionLength"],
+    "submissions"
+  );
+  if (submissions.moderation !== "required")
+    throw new Error('submissions.moderation must be "required".');
+  const turnstile = object(value.turnstile, "turnstile");
+  rejectUnknown(turnstile, ["enabled", "siteKey"], "turnstile");
+  if (typeof turnstile.enabled !== "boolean")
+    throw new Error("turnstile.enabled must be true or false.");
+  const siteKey = turnstile.siteKey === void 0 ? void 0 : text(turnstile.siteKey, "turnstile.siteKey");
+  if (turnstile.enabled && !siteKey)
+    throw new Error("Turnstile is enabled but turnstile.siteKey is missing.");
+  return {
+    product: validatedProduct,
+    theme: { preset: text(theme.preset, "theme.preset") },
+    notion,
+    ...changelog ? { changelog } : {},
+    features: validatedFeatures,
+    submissions: {
+      moderation: "required",
+      maxTitleLength: positiveInteger(
+        submissions.maxTitleLength,
+        "submissions.maxTitleLength"
+      ),
+      maxDescriptionLength: positiveInteger(
+        submissions.maxDescriptionLength,
+        "submissions.maxDescriptionLength"
+      )
+    },
+    turnstile: { enabled: turnstile.enabled, ...siteKey ? { siteKey } : {} }
+  };
+}
+function storage(value, keys, label) {
+  const input = object(value, label);
+  rejectUnknown(input, ["databaseId", "dataSourceId", "properties"], label);
+  const properties = object(input.properties, `${label}.properties`);
+  rejectUnknown(properties, keys, `${label}.properties`);
+  for (const key of keys) text(properties[key], `${label}.properties.${key}`);
+  return {
+    databaseId: text(input.databaseId, `${label}.databaseId`),
+    dataSourceId: text(input.dataSourceId, `${label}.dataSourceId`),
+    properties: { ...properties }
+  };
+}
+function object(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object.`);
+  return value;
+}
+function text(value, label) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${label} must be a non-empty string.`);
+  return value.trim();
+}
+function positiveInteger(value, label) {
+  if (!Number.isInteger(value) || Number(value) <= 0)
+    throw new Error(`${label} must be a positive integer.`);
+  return Number(value);
+}
+function rejectUnknown(value, allowed, label) {
+  const key = Object.keys(value).find(
+    (candidate) => !allowed.includes(candidate)
+  );
+  if (key) throw new Error(`Unknown ${label} key "${key}".`);
+}
+function optionalPublicUrl(value, key) {
+  return value[key] === void 0 ? {} : { [key]: publicUrl(value[key], `product.${key}`, false) };
+}
+function publicUrl(value, label, allowRelative) {
+  const url = text(value, label);
+  if (allowRelative && url.startsWith("/") && !url.startsWith("//") && !url.includes("\\") && !Array.from(url).some((character) => character.charCodeAt(0) <= 32))
+    return url;
+  try {
+    if (new URL(url).protocol === "https:") return url;
+  } catch {
+  }
+  throw new Error(
+    `${label} must be ${allowRelative ? "root-relative or " : ""}an HTTPS URL.`
+  );
+}
+
+// src/index.ts
+import { basename, join as join2 } from "node:path";
+
+// src/template.ts
+import { parse } from "jsonc-parser";
+import {
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var packagedTemplateDirectory = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "../template"
+);
+async function copyPackagedTemplate(destination, packaged = packagedTemplateDirectory) {
+  const target = resolve(destination);
+  await mkdir(target, { recursive: true });
+  if ((await readdir(target)).length)
+    throw new Error(
+      `Refusing to generate into non-empty destination: ${target}`
+    );
+  await cp(packaged, target, { recursive: true });
+  await renameIgnoreTemplates(target);
+}
+async function renameIgnoreTemplates(target) {
+  const { rename } = await import("node:fs/promises");
+  for (const name of [".gitignore", ".npmignore", ".prettierignore"])
+    await rename(join(target, `${name}.template`), join(target, name));
+}
+
+// ../feedback/src/notion-request.ts
+var MAX_ATTEMPTS = 3;
+var BASE_BACKOFF_MILLISECONDS = 250;
+var MAX_BACKOFF_MILLISECONDS = 2e3;
+async function requestNotion(input, init = {}, {
+  request,
+  retry = {},
+  operation
+}) {
+  const sleep = retry.sleep ?? defaultSleep;
+  const random = retry.random ?? Math.random;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    const response = await request(input, init);
+    if (!isRetryableNotionFailure(response.status, operation)) return response;
+    if (attempt === MAX_ATTEMPTS) {
+      throw new Error(
+        `Notion request failed after ${MAX_ATTEMPTS} attempts (${response.status}).`
+      );
+    }
+    await sleep(retryDelayMilliseconds(response, attempt, random));
+  }
+  throw new Error("Notion request retry loop ended unexpectedly.");
+}
+function isRetryableNotionFailure(status, operation) {
+  return status === 429 || status === 529 && operation === "idempotent";
+}
+function retryDelayMilliseconds(response, attempt, random) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  }
+  return exponentialDelayMilliseconds(attempt, random);
+}
+function exponentialDelayMilliseconds(attempt, random) {
+  const ceiling = Math.min(
+    BASE_BACKOFF_MILLISECONDS * 2 ** (attempt - 1),
+    MAX_BACKOFF_MILLISECONDS
+  );
+  return Math.round(ceiling / 2 + random() * (ceiling / 2));
+}
+async function defaultSleep(milliseconds) {
+  await new Promise((resolve3) => setTimeout(resolve3, milliseconds));
+}
+
+// ../feedback/src/notion-data-source.ts
+var NOTION_API_URL = "https://api.notion.com/v1";
+var NOTION_API_VERSION = "2026-03-11";
+var canonicalProperties = {
+  title: { name: "Title", type: "title", schema: { title: {} } },
+  slug: { name: "Slug", type: "rich_text", schema: { rich_text: {} } },
+  description: {
+    name: "Description",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  type: {
+    name: "Type",
+    type: "select",
+    schema: {
+      select: {
+        options: [
+          { name: "Feature Request" },
+          { name: "Bug Report" },
+          { name: "General Feedback" }
+        ]
+      }
+    }
+  },
+  status: {
+    name: "Status",
+    type: "select",
+    schema: {
+      select: {
+        options: [
+          { name: "New" },
+          { name: "Reviewing" },
+          { name: "Planned" },
+          { name: "In Progress" },
+          { name: "Shipped" },
+          { name: "Closed" }
+        ]
+      }
+    }
+  },
+  published: {
+    name: "Published",
+    type: "checkbox",
+    schema: { checkbox: {} }
+  },
+  voteCount: {
+    name: "Vote Count",
+    type: "number",
+    schema: { number: { format: "number" } }
+  },
+  teamResponse: {
+    name: "Team Response",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  releaseNotesUrl: {
+    name: "Release Notes URL",
+    type: "url",
+    schema: { url: {} }
+  },
+  submitterName: {
+    name: "Submitter Name",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  submitterEmail: {
+    name: "Submitter Email",
+    type: "email",
+    schema: { email: {} }
+  },
+  source: {
+    name: "Source",
+    type: "select",
+    schema: {
+      select: {
+        options: [{ name: "Portal" }, { name: "API" }, { name: "Team" }]
+      }
+    }
+  },
+  externalId: {
+    name: "External ID",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  editTokenHash: {
+    name: "Edit Token Hash",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  createdAt: {
+    name: "Created At",
+    type: "created_time",
+    schema: { created_time: {} }
+  },
+  updatedAt: {
+    name: "Updated At",
+    type: "last_edited_time",
+    schema: { last_edited_time: {} }
+  }
+};
+var feedbackWorkflowProperties = {
+  Owner: { people: {} },
+  Priority: {
+    select: {
+      options: [
+        { name: "Urgent" },
+        { name: "High" },
+        { name: "Medium" },
+        { name: "Low" }
+      ]
+    }
+  },
+  "Strategic Theme": { multi_select: { options: [] } },
+  "Participant Segment": { multi_select: { options: [] } },
+  Impact: {
+    select: {
+      options: [{ name: "High" }, { name: "Medium" }, { name: "Low" }]
+    }
+  },
+  Effort: {
+    select: {
+      options: [{ name: "Small" }, { name: "Medium" }, { name: "Large" }]
+    }
+  },
+  "Decision Note": { rich_text: {} },
+  "Needs Follow-up": { checkbox: {} }
+};
+async function createNotionFeedbackDataSource({
+  token,
+  parentPageId,
+  request = fetch,
+  retry
+}) {
+  const response = await requestNotion(
+    `${NOTION_API_URL}/databases`,
+    {
+      method: "POST",
+      headers: notionHeaders(token),
+      body: JSON.stringify({
+        parent: { type: "page_id", page_id: parentPageId },
+        title: [{ type: "text", text: { content: "Feedback" } }],
+        initial_data_source: {
+          properties: {
+            ...Object.fromEntries(
+              Object.values(canonicalProperties).map(({ name, schema }) => [
+                name,
+                schema
+              ])
+            ),
+            ...feedbackWorkflowProperties
+          }
+        }
+      })
+    },
+    { request, retry, operation: "create" }
+  );
+  const database = await readNotionResponse(response);
+  if (typeof database.id !== "string") {
+    throw new Error("Notion did not return the created Feedback database.");
+  }
+  const dataSourceId = firstDataSourceId(database);
+  const dataSourceResponse = await requestNotion(
+    `${NOTION_API_URL}/data_sources/${dataSourceId}`,
+    { method: "GET", headers: notionHeaders(token) },
+    { request, retry, operation: "idempotent" }
+  );
+  const dataSource = await readNotionResponse(dataSourceResponse);
+  return configurationFromCanonicalNames(dataSource, database.id);
+}
+async function createFeedbackWorkflowViews({
+  token,
+  databaseId,
+  dataSourceId,
+  propertyIds: propertyIds2,
+  request = fetch
+}) {
+  const views = [
+    {
+      name: "Inbox",
+      type: "table",
+      filter: selectFilter(propertyIds2.status, "New"),
+      sorts: [{ property: propertyIds2.createdAt, direction: "descending" }]
+    },
+    {
+      name: "Reviewing",
+      type: "table",
+      filter: selectFilter(propertyIds2.status, "Reviewing"),
+      sorts: [{ property: propertyIds2.updatedAt, direction: "descending" }]
+    },
+    {
+      name: "Prioritization",
+      type: "table",
+      filter: {
+        or: [
+          selectFilter(propertyIds2.status, "Reviewing"),
+          selectFilter(propertyIds2.status, "Planned")
+        ]
+      },
+      sorts: [
+        { property: "Priority", direction: "ascending" },
+        { property: propertyIds2.voteCount, direction: "descending" }
+      ]
+    },
+    {
+      name: "Follow-up",
+      type: "table",
+      filter: { property: "Needs Follow-up", checkbox: { equals: true } }
+    },
+    {
+      name: "Roadmap",
+      type: "board",
+      filter: {
+        or: ["Planned", "In Progress", "Shipped"].map(
+          (status) => selectFilter(propertyIds2.status, status)
+        )
+      },
+      configuration: {
+        type: "board",
+        group_by: {
+          type: "select",
+          property_id: propertyIds2.status,
+          group_by: "option",
+          sort: { type: "manual" }
+        }
+      }
+    },
+    {
+      name: "Shipped",
+      type: "table",
+      filter: selectFilter(propertyIds2.status, "Shipped"),
+      sorts: [{ property: propertyIds2.updatedAt, direction: "descending" }]
+    }
+  ];
+  for (const view of views) {
+    const response = await requestNotion(
+      `${NOTION_API_URL}/views`,
+      {
+        method: "POST",
+        headers: notionHeaders(token),
+        body: JSON.stringify({
+          database_id: databaseId,
+          data_source_id: dataSourceId,
+          ...view
+        })
+      },
+      { request, operation: "create" }
+    );
+    await readNotionResponse(response);
+  }
+}
+function selectFilter(property, value) {
+  return { property, select: { equals: value } };
+}
+async function validateNotionFeedbackDataSource({
+  token,
+  dataSourceId,
+  propertyIds: propertyIds2,
+  request = fetch,
+  retry
+}) {
+  const response = await requestNotion(
+    `${NOTION_API_URL}/data_sources/${dataSourceId}`,
+    {
+      method: "GET",
+      headers: notionHeaders(token)
+    },
+    { request, retry, operation: "idempotent" }
+  );
+  const dataSource = await readNotionResponse(response);
+  const properties = dataSource.properties;
+  if (typeof dataSource.id !== "string" || !isPropertyMap(properties)) {
+    throw new Error(
+      "Notion returned an invalid Feedback Data Source response."
+    );
+  }
+  const propertiesById = new Map(
+    Object.values(properties).filter(
+      (property) => Boolean(property) && typeof property.id === "string"
+    ).map((property) => [property.id, property])
+  );
+  const repairs = [];
+  for (const [key, { name, type }] of Object.entries(canonicalProperties)) {
+    const configuredId = propertyIds2[key];
+    const property = propertiesById.get(configuredId);
+    if (!property) {
+      repairs.push(
+        `Restore the "${name}" property with ID "${configuredId}" and type "${type}", then update the configured property ID if Notion assigns a new one.`
+      );
+    } else if (property.type !== type) {
+      repairs.push(
+        `Change the property configured as "${name}" (ID "${configuredId}") from "${String(property.type)}" to "${type}", or restore a ${type} property and configure its ID.`
+      );
+    }
+  }
+  if (repairs.length > 0) {
+    throw new Error(repairs.join("\n"));
+  }
+  return {
+    databaseId: databaseIdFromDataSource(dataSource),
+    dataSourceId,
+    propertyIds: { ...propertyIds2 }
+  };
+}
+function notionHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": NOTION_API_VERSION
+  };
+}
+async function readNotionResponse(response) {
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      `Notion rejected the Feedback Data Source request (${response.status}).`
+    );
+  }
+  if (!body || typeof body !== "object") {
+    throw new Error(
+      "Notion returned an invalid Feedback Data Source response."
+    );
+  }
+  return body;
+}
+function firstDataSourceId(database) {
+  const dataSources = Reflect.get(database, "data_sources");
+  const firstDataSource = Array.isArray(dataSources) ? dataSources[0] : void 0;
+  const id = firstDataSource && typeof firstDataSource === "object" ? Reflect.get(firstDataSource, "id") : void 0;
+  if (typeof id !== "string") {
+    throw new Error("Notion did not return the created Feedback Data Source.");
+  }
+  return id;
+}
+function configurationFromCanonicalNames(dataSource, databaseId) {
+  const properties = dataSource.properties;
+  if (typeof dataSource.id !== "string" || !isPropertyMap(properties)) {
+    throw new Error(
+      "Notion returned an invalid Feedback Data Source response."
+    );
+  }
+  return {
+    databaseId,
+    dataSourceId: dataSource.id,
+    propertyIds: Object.fromEntries(
+      Object.entries(canonicalProperties).map(([key, { name }]) => {
+        const property = properties[name];
+        if (!property || typeof property.id !== "string") {
+          throw new Error(
+            `Notion did not return the required ${name} property.`
+          );
+        }
+        return [key, property.id];
+      })
+    )
+  };
+}
+function databaseIdFromDataSource(dataSource) {
+  const parent = dataSource.parent;
+  const databaseId = parent && typeof parent === "object" ? Reflect.get(parent, "database_id") : void 0;
+  if (typeof databaseId !== "string") {
+    throw new Error(
+      "Notion did not return the Feedback Data Source parent database."
+    );
+  }
+  return databaseId;
+}
+function isPropertyMap(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// ../feedback/src/index.ts
+var postCreationQueue = Promise.resolve();
+
+// ../changelog/src/notion-changelog.ts
+var NOTION_API_URL2 = "https://api.notion.com/v1";
+var NOTION_API_VERSION2 = "2026-03-11";
+var canonicalProperties2 = {
+  title: { name: "Title", type: "title", schema: { title: {} } },
+  slug: { name: "Slug", type: "rich_text", schema: { rich_text: {} } },
+  date: { name: "Date", type: "date", schema: { date: {} } },
+  summary: {
+    name: "Summary",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  body: { name: "Body", type: "rich_text", schema: { rich_text: {} } },
+  labels: {
+    name: "Labels",
+    type: "multi_select",
+    schema: { multi_select: { options: [] } }
+  },
+  image: { name: "Image", type: "files", schema: { files: {} } },
+  published: {
+    name: "Published",
+    type: "checkbox",
+    schema: { checkbox: {} }
+  },
+  createdAt: {
+    name: "Created At",
+    type: "created_time",
+    schema: { created_time: {} }
+  },
+  updatedAt: {
+    name: "Updated At",
+    type: "last_edited_time",
+    schema: { last_edited_time: {} }
+  }
+};
+async function createNotionChangelogDataSource({
+  token,
+  databaseId,
+  request = fetch
+}) {
+  const response = await request(`${NOTION_API_URL2}/data_sources`, {
+    method: "POST",
+    headers: notionHeaders2(token),
+    body: JSON.stringify({
+      parent: { database_id: databaseId },
+      title: [{ type: "text", text: { content: "Changelog" } }],
+      properties: Object.fromEntries(
+        Object.values(canonicalProperties2).map(({ name, schema }) => [
+          name,
+          schema
+        ])
+      )
+    })
+  });
+  return configurationFromResponse(
+    await readObject(response, "Changelog Data Source"),
+    databaseId
+  );
+}
+async function validateNotionChangelogDataSource({
+  token,
+  dataSourceId,
+  propertyIds: propertyIds2,
+  request = fetch
+}) {
+  const response = await request(
+    `${NOTION_API_URL2}/data_sources/${dataSourceId}`,
+    { headers: notionHeaders2(token) }
+  );
+  const dataSource = await readObject(response, "Changelog Data Source");
+  const properties = recordAt(dataSource, "properties");
+  const propertiesById = new Map(
+    Object.values(properties).flatMap((property) => {
+      if (!isRecord(property) || typeof property.id !== "string") return [];
+      return [[property.id, property]];
+    })
+  );
+  const repairs = [];
+  for (const [key, { name, type }] of Object.entries(canonicalProperties2)) {
+    const configuredId = propertyIds2[key];
+    const property = propertiesById.get(configuredId);
+    if (!property) {
+      repairs.push(
+        `Restore the "${name}" property with ID "${configuredId}" and type "${type}", then update the configured property ID if Notion assigns a new one.`
+      );
+    } else if (property.type !== type) {
+      repairs.push(
+        `Change the property configured as "${name}" (ID "${configuredId}") from "${String(property.type)}" to "${type}", or restore a ${type} property and configure its ID.`
+      );
+    }
+  }
+  if (repairs.length) throw new Error(repairs.join("\n"));
+  return {
+    databaseId: databaseIdFromResponse(dataSource),
+    dataSourceId,
+    propertyIds: { ...propertyIds2 }
+  };
+}
+function configurationFromResponse(dataSource, databaseId) {
+  const properties = recordAt(dataSource, "properties");
+  return {
+    databaseId,
+    dataSourceId: requiredString(dataSource.id),
+    propertyIds: Object.fromEntries(
+      Object.entries(canonicalProperties2).map(([key, { name }]) => [
+        key,
+        requiredString(recordAt(properties, name).id)
+      ])
+    )
+  };
+}
+function databaseIdFromResponse(dataSource) {
+  return requiredString(recordAt(dataSource, "parent").database_id);
+}
+function notionHeaders2(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": NOTION_API_VERSION2
+  };
+}
+async function readObject(response, subject) {
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      `Notion rejected the ${subject} request (${response.status}).`
+    );
+  }
+  if (!isRecord(body))
+    throw new Error(`Notion returned an invalid ${subject} response.`);
+  return body;
+}
+function recordAt(value, key) {
+  return record(value[key]);
+}
+function record(value) {
+  if (!isRecord(value))
+    throw new Error("Notion returned an invalid Changelog response.");
+  return value;
+}
+function requiredString(value) {
+  if (typeof value !== "string")
+    throw new Error("Notion returned an invalid Changelog response.");
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/index.ts
+async function provisionGuidedInstallation({
+  destination,
+  product,
+  themePreset,
+  workerName,
+  commentProbePageId,
+  features,
+  feedbackSelection,
+  changelogSelection,
+  notionToken,
+  turnstile,
+  preview,
+  request = fetch
+}) {
+  try {
+    if ((await readdir2(destination)).length)
+      throw new Error(
+        `Refusing to generate into non-empty destination: ${destination}`
+      );
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (product.siteUrl && new URL(product.siteUrl).protocol !== "https:")
+    throw new Error("product.siteUrl must be an HTTPS URL.");
+  const targetName = workerName ?? basename(destination).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(targetName))
+    throw new Error(
+      "Worker name must contain 1\u201363 lowercase letters, numbers, or hyphens."
+    );
+  const approved = await preview(
+    feedbackSelection.kind === "create" ? `Create the canonical Feedback Data Source inside Notion page ${feedbackSelection.parentPageId}.` : `Validate existing Feedback Data Source ${feedbackSelection.configuration.dataSourceId} without changing it.`
+  );
+  if (!approved)
+    throw new Error(
+      "Feedback setup was not approved. No local files were created."
+    );
+  const feedback = feedbackSelection.kind === "create" ? await createNotionFeedbackDataSource({
+    token: notionToken,
+    parentPageId: feedbackSelection.parentPageId,
+    request
+  }) : await validateNotionFeedbackDataSource({
+    token: notionToken,
+    ...feedbackSelection.configuration,
+    request
+  });
+  if (feedbackSelection.kind === "create") {
+    if (!await preview(
+      "Create six Notion team views: Inbox, Reviewing, Prioritization, Follow-up, Roadmap, and Shipped."
+    ))
+      throw new Error("Workflow view creation was not approved.");
+    await createFeedbackWorkflowViews({
+      token: notionToken,
+      ...feedback,
+      request
+    });
+  }
+  await verifySelectedCommentCapabilities(features, {
+    token: notionToken,
+    pageId: commentProbePageId ?? (feedbackSelection.kind === "create" ? feedbackSelection.parentPageId : feedback.databaseId),
+    request,
+    command: "setup"
+  });
+  const changelog = await configureChangelogStorage({
+    features,
+    selection: changelogSelection ?? (features.changelog ? { kind: "create", databaseId: feedback.databaseId } : void 0),
+    token: notionToken,
+    request,
+    preview
+  });
+  await copyPackagedTemplate(destination);
+  const wranglerPath = join2(destination, "wrangler.jsonc");
+  const wrangler = JSON.parse(await readFile2(wranglerPath, "utf8"));
+  await writeFile2(
+    wranglerPath,
+    JSON.stringify({ ...wrangler, name: targetName }, null, 2) + "\n"
+  );
+  const apiKey = randomBytes(32).toString("base64url");
+  const signingSecret = randomBytes(32).toString("base64url");
+  const values = {
+    NOTION_TOKEN: notionToken,
+    NOTION_FEEDBACK_DATABASE_ID: feedback.databaseId,
+    NOTION_FEEDBACK_DATA_SOURCE_ID: feedback.dataSourceId,
+    ...prefixProperties("NOTION_FEEDBACK", feedback.propertyIds),
+    FEEDBAX_API_KEY_HASH: createHash("sha256").update(apiKey).digest("base64url"),
+    PARTICIPATION_SIGNING_SECRET: signingSecret,
+    FEEDBAX_VOTING_ENABLED: String(features.voting),
+    FEEDBAX_COMMENTS_ENABLED: String(features.comments),
+    FEEDBAX_CHANGELOG_ENABLED: String(features.changelog),
+    ...turnstile.siteKey ? { VITE_TURNSTILE_SITE_KEY: turnstile.siteKey } : {},
+    ...turnstile.secretKey ? { TURNSTILE_SECRET_KEY: turnstile.secretKey } : {},
+    ...changelog ? {
+      NOTION_CHANGELOG_DATABASE_ID: changelog.databaseId,
+      NOTION_CHANGELOG_DATA_SOURCE_ID: changelog.dataSourceId,
+      ...prefixProperties("NOTION_CHANGELOG", changelog.propertyIds)
+    } : {}
+  };
+  await writeFile2(
+    join2(destination, ".dev.vars"),
+    Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n") + "\n",
+    { mode: 384 }
+  );
+  const configuration = defineFeedbax({
+    product: { ...product, logo: "/feedbax-mark.svg" },
+    theme: { preset: themePreset },
+    notion: {
+      databaseId: feedback.databaseId,
+      dataSourceId: feedback.dataSourceId,
+      properties: feedback.propertyIds
+    },
+    ...changelog ? {
+      changelog: {
+        databaseId: changelog.databaseId,
+        dataSourceId: changelog.dataSourceId,
+        properties: changelog.propertyIds
+      }
+    } : {},
+    features,
+    submissions: {
+      moderation: "required",
+      maxTitleLength: 160,
+      maxDescriptionLength: 5e3
+    },
+    turnstile: {
+      enabled: Boolean(turnstile.siteKey),
+      ...turnstile.siteKey ? { siteKey: turnstile.siteKey } : {}
+    }
+  });
+  await writeFile2(
+    join2(destination, "src/feedbax.ts"),
+    `import { defineFeedbax } from "@feedbax/config";
+
+export default defineFeedbax(${JSON.stringify(configuration, null, 2)});
+`
+  );
+  const probePage = commentProbePageId ?? (feedbackSelection.kind === "create" ? feedbackSelection.parentPageId : feedback.databaseId);
+  await writeFile2(
+    join2(destination, ".dev.vars"),
+    `NOTION_COMMENT_CAPABILITY_PROBE_PAGE_ID=${JSON.stringify(probePage)}
+`,
+    { flag: "a", mode: 384 }
+  );
+  return { apiKey, feedback, changelog };
+}
+function prefixProperties(prefix, properties) {
+  return Object.fromEntries(
+    Object.entries(properties).map(([key, value]) => [
+      `${prefix}_${key.replace(/[A-Z]/g, (letter) => `_${letter}`).toUpperCase()}_PROPERTY_ID`,
+      value
+    ])
+  );
+}
+var featureChoices = [
+  { key: "voting", label: "Voting", initialValue: true },
+  { key: "comments", label: "Comments", initialValue: true },
+  { key: "changelog", label: "Changelog", initialValue: true }
+];
+async function collectFeatureSelection(prompter) {
+  const selections = [];
+  for (const { key, label, initialValue } of featureChoices) {
+    selections.push([
+      key,
+      await prompter.confirm({
+        message: `Enable ${label}?`,
+        initialValue
+      })
+    ]);
+  }
+  return Object.fromEntries(selections);
+}
+async function verifySelectedCommentCapabilities(features, {
+  token,
+  pageId,
+  request = fetch,
+  command = "setup"
+}) {
+  if (!features.comments) return;
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Notion-Version": "2026-03-11"
+  };
+  const readResponse = await request(
+    `https://api.notion.com/v1/comments?block_id=${encodeURIComponent(pageId)}&page_size=1`,
+    { headers }
+  );
+  if (!readResponse.ok) {
+    if (readResponse.status === 403)
+      assertEnabledCommentCapabilities({
+        commentsEnabled: true,
+        capabilities: { readComments: false, insertComments: true },
+        command
+      });
+    throw new Error(
+      `Notion Comment read check failed (HTTP ${readResponse.status}). Verify a shared page ID and connection access.`
+    );
+  }
+  if (command === "doctor") {
+    assertEnabledCommentCapabilities({
+      commentsEnabled: true,
+      capabilities: {
+        readComments: readResponse.status !== 403,
+        // Setup proves Insert comments before enabling the capability. Doctor
+        // deliberately avoids a write-method probe and verifies the live read path.
+        insertComments: true
+      },
+      command
+    });
+    return;
+  }
+  const insertResponse = await request("https://api.notion.com/v1/comments", {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: "{}"
+  });
+  if (insertResponse.status !== 400 && insertResponse.status !== 403)
+    throw new Error(
+      `Notion Comment insert capability check failed (HTTP ${insertResponse.status}).`
+    );
+  const capabilities = {
+    readComments: readResponse.status !== 403,
+    insertComments: insertResponse.status !== 403
+  };
+  assertEnabledCommentCapabilities({
+    commentsEnabled: true,
+    capabilities,
+    command
+  });
+}
+function assertEnabledCommentCapabilities({
+  commentsEnabled,
+  capabilities,
+  command = "setup"
+}) {
+  if (!commentsEnabled) return;
+  const missing = [
+    ...capabilities.readComments ? [] : ["Read comments"],
+    ...capabilities.insertComments ? [] : ["Insert comments"]
+  ];
+  if (missing.length === 0) return;
+  const retry = command === "doctor" ? "rerun doctor. No changes were made." : "retry setup.";
+  throw new Error(
+    `Enable ${missing.join(" and ")} in the Notion connection settings, then ${retry}`
+  );
+}
+async function configureChangelogStorage({
+  features,
+  selection,
+  token,
+  request = fetch,
+  preview
+}) {
+  if (!features.changelog) return;
+  if (!selection) {
+    throw new Error(
+      "Choose an existing compatible Changelog Data Source or create one beside Feedback."
+    );
+  }
+  if (selection.kind === "existing") {
+    return validateNotionChangelogDataSource({
+      token,
+      dataSourceId: selection.dataSourceId,
+      propertyIds: selection.propertyIds,
+      request
+    });
+  }
+  const approved = await preview(
+    `Create an empty Changelog Data Source beside Feedback in Feedbax Database ${selection.databaseId}. No sample entries will be published.`
+  );
+  if (!approved) throw new Error("Changelog creation was not approved.");
+  return createNotionChangelogDataSource({
+    token,
+    databaseId: selection.databaseId,
+    request
+  });
+}
+
+// src/cli.ts
 try {
-    const argv = process.argv.slice(2);
-    const interactive = process.stdin.isTTY && process.stdout.isTTY;
-    const options = interactive
-        ? await (async () => {
-            const terminal = createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            try {
-                return await resolveInteractiveCreateOptions(argv, async (question, defaultValue) => terminal.question(`${question} [${defaultValue}]: `));
-            }
-            finally {
-                terminal.close();
-            }
-        })()
-        : resolveCreateOptions(argv);
-    const result = await createProject(options);
-    process.stdout.write(`Created Feedbax in ${result.destination}\n\n${result.nextSteps.join('\n')}\n`);
-}
-catch (error) {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-}
-//# sourceMappingURL=cli.js.map
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(
+      "Usage: create-feedbax [directory] [--template-only]\nGuided setup prompts for a destination, product, Notion connection, features, and deployment.\n--template-only copies source without external requests or installing dependencies."
+    );
+  } else if (args.includes("--version")) {
+    console.log(
+      JSON.parse(
+        await readFile3(new URL("../package.json", import.meta.url), "utf8")
+      ).version
+    );
+  } else {
+    if (args.some((arg) => arg.startsWith("-") && arg !== "--template-only"))
+      throw new Error("Unknown option. Run create-feedbax --help.");
+    const destination = resolve2(
+      args.find((arg) => !arg.startsWith("-")) ?? await text3("Project directory", "my-feedback")
+    );
+    if (args.includes("--template-only")) {
+      await copyPackagedTemplate(destination);
+      console.log(`Created a flat Feedbax application in ${destination}.`);
+    } else {
+      prompt.intro("Create a Feedbax portal");
+      const product = {
+        name: await text3("Product name", "My product"),
+        description: await text3(
+          "Public description",
+          "Share feedback and follow product progress."
+        ),
+        siteUrl: await text3(
+          "Public portal URL (your workers.dev URL or custom domain)",
+          "https://my-feedback.example.workers.dev"
+        )
+      };
+      const workerName = await text3(
+        "Cloudflare Worker name (choose a distinct name for this product)",
+        basename2(destination).toLowerCase().replace(/[^a-z0-9-]/g, "-")
+      );
+      const themePreset = await text3(
+        "shadcn preset code, or lyra-neutral for the included preset",
+        "lyra-neutral"
+      );
+      const notionToken = process.env.NOTION_TOKEN?.trim() || await secret("Notion internal integration token");
+      const existing = await confirm2(
+        "Use an existing compatible Feedback Data Source?",
+        false
+      );
+      const feedbackSelection = existing ? { kind: "existing", configuration: await existingFeedback() } : {
+        kind: "create",
+        parentPageId: await text3(
+          "Notion parent page ID (share it with the integration)"
+        )
+      };
+      const features = await collectFeatureSelection({
+        confirm: ({ message, initialValue }) => confirm2(message, initialValue)
+      });
+      const commentProbePageId = existing && features.comments ? await text3("Shared Notion page ID for checking Comment permissions") : void 0;
+      const changelogSelection = features.changelog && await confirm2(
+        "Use an existing compatible Changelog Data Source?",
+        false
+      ) ? {
+        kind: "existing",
+        dataSourceId: await text3("Changelog Data Source ID"),
+        propertyIds: await propertyIds([
+          "title",
+          "slug",
+          "date",
+          "summary",
+          "body",
+          "labels",
+          "image",
+          "published",
+          "createdAt",
+          "updatedAt"
+        ])
+      } : void 0;
+      const turnstile = await confirm2(
+        "Enable Cloudflare Turnstile? Recommended for production.",
+        true
+      ) ? {
+        siteKey: await text3("Turnstile site key"),
+        secretKey: process.env.TURNSTILE_SECRET_KEY || await secret("Turnstile secret key")
+      } : {};
+      const result = await provisionGuidedInstallation({
+        destination,
+        product,
+        themePreset,
+        workerName,
+        commentProbePageId,
+        features,
+        feedbackSelection,
+        changelogSelection,
+        notionToken,
+        turnstile,
+        preview: (message) => confirm2(message, false)
+      });
+      console.log(
+        `Created ${destination}.
+Trusted API key \u2014 copy it now; plaintext is not stored:
+${result.apiKey}`
+      );
+      await runIn(destination, "pnpm", ["install"]);
+      if (themePreset !== "lyra-neutral")
+        await runIn(destination, "pnpm", [
+          "dlx",
+          "shadcn@latest",
+          "init",
+          "--preset",
+          themePreset,
+          "--yes",
+          "--force"
+        ]);
+      await runIn(destination, "pnpm", [
+        "exec",
+        "prettier",
+        "--write",
+        "src/feedbax.ts"
+      ]);
+      await runIn(destination, "pnpm", ["exec", "feedbax", "doctor"]);
+      if (await confirm2(
+        "Authenticate with Cloudflare and deploy this portal?",
+        false
+      )) {
+        await runIn(destination, "pnpm", ["exec", "wrangler", "login"]);
+        await runIn(destination, "pnpm", ["exec", "feedbax", "deploy"]);
+      }
+      prompt.outro(`Your portal source is ready in ${destination}.`);
+    }
+  }
+} catch (error) {
+  console.error(
+    error instanceof Error ? error.message : "Feedbax setup failed."
+  );
+  process.exitCode = 10;
+}
+function checked(value) {
+  if (prompt.isCancel(value)) throw new Error("Setup cancelled.");
+  return value;
+}
+async function text3(message, defaultValue) {
+  return checked(
+    await prompt.text({
+      message,
+      defaultValue,
+      placeholder: defaultValue,
+      validate: (value) => value?.trim() || defaultValue ? void 0 : "A value is required."
+    })
+  ).trim();
+}
+async function secret(message) {
+  return checked(
+    await prompt.password({
+      message,
+      validate: (value) => value?.trim() ? void 0 : "A value is required."
+    })
+  ).trim();
+}
+async function confirm2(message, initialValue) {
+  return checked(await prompt.confirm({ message, initialValue }));
+}
+async function propertyIds(keys) {
+  const entries = [];
+  for (const key of keys)
+    entries.push([key, await text3(`Stable property ID: ${key}`)]);
+  return Object.fromEntries(entries);
+}
+async function existingFeedback() {
+  return {
+    databaseId: await text3("Feedback Database ID"),
+    dataSourceId: await text3("Feedback Data Source ID"),
+    propertyIds: await propertyIds([
+      "title",
+      "slug",
+      "description",
+      "type",
+      "status",
+      "published",
+      "voteCount",
+      "teamResponse",
+      "releaseNotesUrl",
+      "submitterName",
+      "submitterEmail",
+      "source",
+      "externalId",
+      "editTokenHash",
+      "createdAt",
+      "updatedAt"
+    ])
+  };
+}
+function runIn(cwd, command, args) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit" });
+    child.on("error", reject);
+    child.on(
+      "exit",
+      (code) => code === 0 ? resolve3() : reject(
+        new Error(
+          `${command} failed with exit code ${code}. The generated source has been preserved.`
+        )
+      )
+    );
+  });
+}