create-daniworks-app 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HJ-company
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# create-daniworks-app
+
+Scaffold a new [Daniworks Builder](https://github.com/HJ-company/daniworks-builder-v2)
+project — a Strapi v5 CMS + a Next.js front end that renders CMS block content.
+
+```bash
+npx create-daniworks-app my-site
+cd my-site
+pnpm dev
+```
+
+The scaffold wires the front end (`apps/web`) — `@dani-builder/blocks` provider,
+Tailwind `@theme` + `@source`, and a `home` page renderer — and generates all
+secrets. It also creates the Strapi CMS (`apps/cms`), installs the Builder plugin
+and its custom-field peer plugins, enables Builder, and configures sqlite's
+default database filename.
+
+## License
+
+MIT © HJ-company

package/bin/cms.js

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+export const CMS_PACKAGES = [
+  ["@dani-builder/strapi-plugin-builder", "latest"],
+  ["@strapi/plugin-color-picker", "^5.0.0"],
+  ["@d3levvv/strapi-react-icons-plugin", "^1.0.0"],
+];
+
+export function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, { stdio: "inherit", ...options });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `Command failed (${result.status}): ${command} ${args.join(" ")}`,
+    );
+  }
+
+  return result;
+}
+
+export function enableBuilder(cmsDir) {
+  const pluginsFile = join(cmsDir, "config", "plugins.ts");
+  const config = readFileSync(pluginsFile, "utf-8");
+  const objectStart = /=> \(\{\r?\n/;
+
+  if (!objectStart.test(config)) {
+    throw new Error(`Cannot enable Builder in ${pluginsFile}`);
+  }
+
+  writeFileSync(
+    pluginsFile,
+    config.replace(
+      objectStart,
+      (match) => `${match}  builder: { enabled: true },\n`,
+    ),
+  );
+}
+
+export function addCmsDependencies(cmsDir) {
+  const packageFile = join(cmsDir, "package.json");
+  const packageJson = JSON.parse(readFileSync(packageFile, "utf-8"));
+
+  packageJson.dependencies ??= {};
+  for (const [name, version] of CMS_PACKAGES) {
+    packageJson.dependencies[name] = version;
+  }
+
+  writeFileSync(packageFile, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+
+export function fixSqliteDatabaseFilename(cmsDir) {
+  const envFile = join(cmsDir, ".env");
+
+  if (!existsSync(envFile)) return;
+
+  const env = readFileSync(envFile, "utf-8");
+  const fixed = /^DATABASE_FILENAME=[ \t]*$/m.test(env)
+    ? env.replace(
+        /^DATABASE_FILENAME=[ \t]*$/m,
+        "DATABASE_FILENAME=.tmp/data.db",
+      )
+    : env;
+
+  if (fixed !== env) writeFileSync(envFile, fixed);
+}
+
+export function createCms(projectDir, execute = runCommand) {
+  const cmsDir = join(projectDir, "apps", "cms");
+
+  execute(
+    "pnpm",
+    [
+      "dlx",
+      "create-strapi-app@^5",
+      "apps/cms",
+      "--ts",
+      "--use-pnpm",
+      "--skip-cloud",
+      "--no-example",
+      "--no-git-init",
+      "--no-run",
+      "--no-install",
+      "--non-interactive",
+      "--dbclient",
+      "sqlite",
+      "--dbfile",
+      ".tmp/data.db",
+    ],
+    { cwd: projectDir },
+  );
+
+  addCmsDependencies(cmsDir);
+  enableBuilder(cmsDir);
+  fixSqliteDatabaseFilename(cmsDir);
+  execute("pnpm", ["install"], { cwd: projectDir });
+}

package/bin/index.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+"use strict";
+
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  rmSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomBytes } from "node:crypto";
+
+import { createCms, runCommand } from "./cms.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = join(__dirname, "..", "template");
+
+const c = {
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+};
+
+function secret(bytes = 16) {
+  return randomBytes(bytes).toString("base64");
+}
+
+function die(msg) {
+  console.error(c.red(`\n✗ ${msg}\n`));
+  process.exit(1);
+}
+
+// ── Args ──
+const args = process.argv.slice(2);
+const input = args.find((a) => !a.startsWith("-"));
+if (!input) {
+  die("Usage: create-daniworks-app <project-name>");
+}
+const target = join(process.cwd(), input);
+// The workspace package name must be a valid npm name — derive it from the
+// target directory, not the raw arg (which may be a path like "./my-site").
+const pkgName = basename(target)
+  .toLowerCase()
+  .replace(/[^a-z0-9._-]+/g, "-")
+  .replace(/^[._-]+|[._-]+$/g, "");
+if (!pkgName) {
+  die(`Cannot derive a valid package name from "${input}".`);
+}
+if (existsSync(target) && readdirSync(target).length > 0) {
+  die(`Directory "${input}" already exists and is not empty.`);
+}
+
+try {
+  const result = runCommand("pnpm", ["--version"], {
+    stdio: "pipe",
+    encoding: "utf-8",
+  });
+  const [major, minor] = result.stdout.trim().split(".").map(Number);
+  if (
+    !Number.isInteger(major) ||
+    !Number.isInteger(minor) ||
+    major < 9 ||
+    (major === 9 && minor < 4)
+  ) {
+    throw new Error("create-daniworks-app requires pnpm >=9.4 on PATH.");
+  }
+} catch (error) {
+  die(error instanceof Error ? error.message : String(error));
+}
+
+console.log(
+  `\n${c.bold("create-daniworks-app")} ${c.dim("· scaffolding a Strapi + Next.js block site")}\n`,
+);
+console.log(`  ${c.cyan("→")} ${target}`);
+console.log(`  ${c.dim("package name:")} ${pkgName}`);
+
+const targetExisted = existsSync(target);
+
+try {
+  // ── Copy template ──
+  mkdirSync(target, { recursive: true });
+  cpSync(TEMPLATE_DIR, target, { recursive: true });
+
+  // Rename dotfile stand-ins that npm would otherwise strip on publish.
+  for (const [from, to] of [
+    ["_gitignore", ".gitignore"],
+    ["_env.example", ".env.example"],
+  ]) {
+    walk(target, (file) => {
+      if (basename(file) === from) renameSync(file, join(dirname(file), to));
+    });
+  }
+
+  // ── Interpolate {{PROJECT_NAME}} ──
+  walk(target, (file) => {
+    if (/\.(json|ts|tsx|js|md|css|yaml)$/.test(file)) {
+      const content = readFileSync(file, "utf-8");
+      if (content.includes("{{PROJECT_NAME}}")) {
+        writeFileSync(file, content.split("{{PROJECT_NAME}}").join(pkgName));
+      }
+    }
+  });
+
+  // ── Generate real secrets into a gitignored .env.local ──
+  // .env.example stays committed with blank values; the runtime secrets live in
+  // .env.local (already covered by the template's .gitignore).
+  const webEnvExample = join(target, "apps", "web", ".env.example");
+  if (existsSync(webEnvExample)) {
+    const local = readFileSync(webEnvExample, "utf-8")
+      .replace(/^REVALIDATE_SECRET=.*$/m, `REVALIDATE_SECRET=${secret()}`)
+      .replace(/^PREVIEW_SECRET=.*$/m, `PREVIEW_SECRET=${secret()}`);
+    writeFileSync(join(target, "apps", "web", ".env.local"), local);
+  }
+
+  // ── Create and configure the Strapi CMS ──
+  console.log(`  ${c.cyan("→")} Creating Strapi CMS`);
+  createCms(target);
+} catch (error) {
+  rmSync(target, { recursive: true, force: true });
+  if (targetExisted) mkdirSync(target, { recursive: true });
+  die(error instanceof Error ? error.message : String(error));
+}
+
+// ── Done ──
+console.log(c.green("\n✓ Project created.\n"));
+console.log(c.bold("Next steps:"));
+console.log(`  ${c.cyan("cd")} ${input}`);
+console.log(
+  `  ${c.cyan("pnpm --filter cms strapi admin:create-user")} ${c.dim("# create an admin + Full-access API token")}`,
+);
+console.log(`  ${c.dim("# set STRAPI_TOKEN in apps/web/.env.local, then:")}`);
+console.log(`  ${c.cyan("pnpm dev")}\n`);
+
+function walk(dir, fn) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, fn);
+    else fn(full);
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "create-daniworks-app",
+  "version": "0.2.0",
+  "description": "Scaffold a new Daniworks Builder project (Strapi v5 CMS + Next.js block-rendering front end)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-daniworks-app": "bin/index.js"
+  },
+  "engines": {
+    "node": ">=22.13",
+    "pnpm": ">=9.4"
+  },
+  "files": [
+    "bin",
+    "template",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HJ-company/daniworks-builder-v2.git",
+    "directory": "packages/create-daniworks-app"
+  },
+  "keywords": [
+    "strapi",
+    "strapi-v5",
+    "nextjs",
+    "daniworks-builder",
+    "scaffold",
+    "create-app",
+    "cli"
+  ],
+  "homepage": "https://github.com/HJ-company/daniworks-builder-v2/tree/main/packages/create-daniworks-app#readme",
+  "author": "HJ-company",
+  "scripts": {
+    "test": "node --test",
+    "sync:skills": "rm -rf template/.claude/skills/builder-extender && mkdir -p template/.claude/skills && cp -R ../../.claude/skills/builder-extender template/.claude/skills/"
+  }
+}

package/template/.claude/skills/builder-extender/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: builder-extender
+description: "Extend @dani-builder/strapi-plugin-builder from a consumer Strapi
+  project without touching the plugin. Actions: add a custom block to
+  Page.blocks, add fields to a plugin component (hero, features, cta, ...),
+  register populate for a custom block, install the plugin with its peer
+  plugins, verify an extension boots. Triggers: 'add a block', 'custom
+  component', 'new hero variant', 'add field to hero', 'extend the builder',
+  'dynamic zone', 'plugin::builder', 'strapi-server.ts', 'registerBlock'."
+---
+
+# Builder Extender
+
+Adds project-specific blocks and fields to a Strapi project that consumes
+`@dani-builder/strapi-plugin-builder` from npm. Every change lands in the
+consumer's `src/`; the plugin package is never edited.
+
+Long-form rationale and reproduced failure cases:
+`docs/guides/extending-builder.md` (in the builder monorepo). This skill is the
+executable version.
+
+## 1. When to apply
+
+- The user wants a block that the plugin does not ship (a project-specific
+  hero, a product grid, an embed) selectable in `Page.blocks`.
+- The user wants extra fields on a plugin block or shared component
+  (`blocks.hero`, `shared.link`, …).
+- The user is installing the plugin into a fresh Strapi app.
+- `cms-content-populator` was asked for a block that does not exist.
+
+Do **not** apply when the working directory is the builder monorepo itself and
+the request is to change the plugin for everyone — edit
+`packages/strapi-plugin-builder/server/src/components/**` there instead and
+run `pnpm docs:gen`.
+
+## 2. Locate the consumer project
+
+The consumer is the directory whose `package.json` lists
+`@dani-builder/strapi-plugin-builder` in `dependencies` and has
+`config/plugins.ts`. In a scaffolded customer repo that is the CMS app; in the
+builder monorepo it is `apps/demo-cms`. All paths below are relative to it.
+
+## 3. Procedure
+
+### 3.1 Install (only if the plugin is not yet a dependency)
+
+```bash
+pnpm add @dani-builder/strapi-plugin-builder @strapi/plugin-color-picker @d3levvv/strapi-react-icons-plugin
+```
+
+All three are required: the plugin's components use the two peers' custom
+fields, and Strapi only loads plugins listed in the consumer's own
+`package.json`. Then ensure `config/plugins.ts` contains
+`builder: { enabled: true }`.
+
+### 3.2 Add a custom block
+
+1. Create `src/components/<category>/<name>.json`. Use a project category
+   (`custom`, or the project name) — never `blocks`, `elements`, or `shared`.
+   Reuse plugin sub-components (`elements.section`, `shared.link`,
+   `shared.image`, `shared.slider-item`, …) for anything the front end already
+   knows how to render. Follow Strapi component JSON: `collectionName`,
+   `info.displayName`, `attributes`.
+2. Create or update `src/extensions/builder/strapi-server.ts` from
+   `references/strapi-server.template.ts`:
+   - push the uid (`<category>.<name>`) onto
+     `plugin.contentTypes.page.schema.attributes.blocks.components`;
+   - inside the wrapped `register`, call
+     `strapi.plugin('builder').service('populate').registerBlock(uid, populate)`
+     with a populate object that covers every nested component, media, and
+     relation of the new block. Scalars need nothing.
+3. Verify (§3.4).
+4. Remind the user that `BlockRenderer` from `@dani-builder/blocks` will not
+   render the new block: the front end needs a project renderer keyed on the
+   uid (see guide §4).
+
+### 3.3 Add fields to a plugin component
+
+1. In `src/extensions/builder/strapi-server.ts`, inside the wrapped
+   `register` **after** `await baseRegister(ctx)`:
+   ```ts
+   const target = ctx.strapi.get('components').get('blocks.hero');
+   Object.assign(target.attributes, EXTRA);
+   Object.assign(target.__schema__.attributes, EXTRA);
+   ```
+   Update both objects. Additive changes only — never delete or rename a
+   plugin attribute (the DB sync drops the column and its data).
+2. Verify (§3.4). The new columns appear on the component table; the Content
+   Manager layout updates itself; the smart API returns scalars without a
+   populate change. A nested component or media added this way also needs
+   the block's populate extended via `registerBlock` with the full populate
+   for that block (it replaces the plugin's entry for that uid).
+3. Remind the user the front-end block component must be wrapped or replaced
+   to show the new fields.
+
+### 3.4 Verify
+
+```bash
+rm -rf dist            # TypeScript consumers: stale compiled JSON is loaded as current
+node <path-to>/references/verify-boot.cjs
+```
+
+Copy `references/verify-boot.cjs` into the consumer (e.g. `scripts/`) so it
+resolves the consumer's `@strapi/strapi` and `.env`. It boots Strapi headlessly
+and prints the Page dynamic-zone list, the attributes and DB columns of any
+component named in `VERIFY_COMPONENTS`, and the registered populate keys.
+Confirm all three show the change, then start the server normally.
+
+If the boot fails with `unable to open database file` on sqlite, set
+`DATABASE_FILENAME=.tmp/data.db` in `.env` and create `.tmp/`.
+
+## 4. Hard rules
+
+| Never | Because |
+|---|---|
+| Write a partial `src/extensions/builder/content-types/<ct>/schema.json` | Strapi shallow-merges it: `attributes` is replaced wholesale, the other fields vanish, and the DB sync drops their columns without an error. |
+| Create `src/components/blocks/*.json`, `elements/*.json`, or `shared/*.json` with a plugin uid | Boot fails: `Component <uid> has already been registered.` |
+| Edit a plugin component in the Content-Type Builder UI | Save returns 400 (`Error writing schema files … "path" argument must be of type string`) and the edit is lost. Plugin content types are read-only there by design. |
+| Copy plugin content-type schemas into `src/api/` | Duplicate `collectionName`s prevent boot (see plugin README). |
+| Register populate at the top level of `strapi-server.ts` | Plugin services do not exist until the plugin loads; do it inside the wrapped `register`. |
+
+## 5. Reference
+
+- `references/strapi-server.template.ts` — complete extension file to copy.
+- `references/verify-boot.cjs` — headless boot verifier.
+- Guide with reproduced failure cases: `docs/guides/extending-builder.md`
+  (builder monorepo).
+- Plugin populate hook: `packages/strapi-plugin-builder/server/src/services/populate.ts`
+  (`registerBlock`, `getPageBlocksPopulate`, `getGlobalPopulate`).

package/template/.claude/skills/builder-extender/references/strapi-server.template.ts

@@ -0,0 +1,71 @@
+/**
+ * src/extensions/builder/strapi-server.ts
+ *
+ * Project-level extension of @dani-builder/strapi-plugin-builder. Strapi loads
+ * this file after the plugin package and before the plugin registers, passes
+ * the plugin object in, and uses whatever is returned.
+ *
+ * Copy into the consumer project and edit the three marked sections. Delete
+ * any section you do not need. Everything is additive: never remove or rename
+ * a plugin attribute here (the DB sync would drop the column and its data).
+ */
+import type { Core } from '@strapi/strapi';
+
+type AnyRecord = Record<string, any>;
+
+interface BuilderPlugin extends AnyRecord {
+  register?: (ctx: { strapi: Core.Strapi }) => void | Promise<void>;
+  contentTypes: Record<string, { schema: AnyRecord }>;
+}
+
+// ── 1. Project blocks to make selectable in Page.blocks ──────────────────────
+// Each entry is a component defined in src/components/<category>/<name>.json
+// with its smart-API populate. Cover every nested component / media / relation;
+// scalars need nothing. `true` populates a flat component or media field.
+const PROJECT_BLOCKS: Record<string, AnyRecord> = {
+  'custom.dynamic-hero': {
+    populate: {
+      section: { populate: { backgroundImage: true } },
+      slides: { populate: { link: true, image: { populate: { media: true } } } },
+      ctaLink: true,
+    },
+  },
+};
+
+// ── 2. Extra attributes on plugin components ─────────────────────────────────
+// Keyed by component uid. Plain Strapi attribute definitions.
+const COMPONENT_EXTENSIONS: Record<string, AnyRecord> = {
+  'blocks.hero': {
+    badgeText: { type: 'string' },
+    videoUrl: { type: 'string' },
+  },
+};
+
+export default (plugin: BuilderPlugin): BuilderPlugin => {
+  const pageBlocks: string[] = plugin.contentTypes.page.schema.attributes.blocks.components;
+  for (const uid of Object.keys(PROJECT_BLOCKS)) {
+    if (!pageBlocks.includes(uid)) pageBlocks.push(uid);
+  }
+
+  const baseRegister = plugin.register;
+  plugin.register = async (ctx) => {
+    // Plugin components are registered here; extend them only afterwards.
+    await baseRegister?.(ctx);
+
+    const components: AnyRecord = ctx.strapi.get('components');
+    for (const [uid, attributes] of Object.entries(COMPONENT_EXTENSIONS)) {
+      const component = components.get(uid);
+      if (!component) throw new Error(`[builder extension] unknown plugin component ${uid}`);
+      Object.assign(component.attributes, attributes);
+      Object.assign(component.__schema__.attributes, attributes);
+    }
+
+    // ── 3. Populate registration (must run after the plugin loaded) ──────────
+    const populate = ctx.strapi.plugin('builder').service('populate');
+    for (const [uid, config] of Object.entries(PROJECT_BLOCKS)) {
+      populate.registerBlock(uid, config);
+    }
+  };
+
+  return plugin;
+};

package/template/.claude/skills/builder-extender/references/verify-boot.cjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Headless boot verifier for builder extensions.
+ *
+ * Copy into the consumer Strapi project (e.g. scripts/verify-boot.cjs) and run
+ * from the project root so it resolves the project's @strapi/strapi and .env:
+ *
+ *   rm -rf dist && node scripts/verify-boot.cjs
+ *
+ * Boots Strapi (register + bootstrap + DB sync, no HTTP listener) and prints:
+ *   - the Page.blocks dynamic-zone component list
+ *   - attributes and DB columns for each component in VERIFY_COMPONENTS
+ *   - the populate keys the smart API will use for Page.blocks
+ *
+ * Environment:
+ *   VERIFY_COMPONENTS  comma-separated uids to inspect (default: blocks.hero)
+ */
+const { createStrapi, compileStrapi } = require('@strapi/strapi');
+
+const componentsToInspect = (process.env.VERIFY_COMPONENTS || 'blocks.hero')
+  .split(',')
+  .map((s) => s.trim())
+  .filter(Boolean);
+
+async function columnsOf(app, table) {
+  const client = app.db.connection.client.config.client;
+  if (client === 'sqlite' || client === 'better-sqlite3') {
+    const rows = await app.db.connection.raw(`pragma table_info('${table}')`);
+    return rows.map((r) => r.name);
+  }
+  const rows = await app.db.connection('information_schema.columns')
+    .select('column_name')
+    .where({ table_name: table });
+  return rows.map((r) => r.column_name);
+}
+
+(async () => {
+  const app = await createStrapi(await compileStrapi()).load();
+  try {
+    const page = app.contentTypes['plugin::builder.page'];
+    if (!page) throw new Error('plugin::builder.page is not registered — is the builder plugin enabled?');
+
+    const report = {
+      pageBlocks: page.attributes.blocks.components,
+      components: {},
+      populateKeys: Object.keys(app.plugin('builder').service('populate').getPageBlocksPopulate().on),
+    };
+
+    for (const uid of componentsToInspect) {
+      const component = app.components[uid];
+      if (!component) {
+        report.components[uid] = 'NOT REGISTERED';
+        continue;
+      }
+      report.components[uid] = {
+        attributes: Object.keys(component.attributes),
+        ctbAttributes: Object.keys(component.__schema__?.attributes || {}),
+        columns: await columnsOf(app, component.collectionName),
+      };
+    }
+
+    console.log(JSON.stringify(report, null, 2));
+  } finally {
+    await app.destroy();
+  }
+  process.exit(0);
+})().catch((error) => {
+  console.error('BOOT FAILED:', error.message);
+  process.exit(1);
+});

package/template/README.md

@@ -0,0 +1,46 @@
+# {{PROJECT_NAME}}
+
+A [Daniworks Builder](https://github.com/HJ-company/daniworks-builder-v2) site:
+a Strapi v5 CMS + a Next.js front end that renders the CMS's block content.
+
+This scaffold ships the front end (`apps/web`) and Strapi CMS (`apps/cms`) fully
+wired.
+
+The generator installed the workspace and created `apps/cms` with Builder and
+its two custom-field peer plugins as direct dependencies. It also enabled
+Builder in `apps/cms/config/plugins.ts` and configured sqlite's database
+filename.
+
+The plugin registers page/article/etc. and the write-only inquiry router when
+Strapi starts. Do not copy these schemas into `apps/cms/src/api/`.
+
+To add your own blocks or extra fields on the builder's components, use
+`apps/cms/src/extensions/builder/strapi-server.ts` — the `builder-extender`
+skill in `.claude/skills/` walks an agent through it, and the full guide is
+[docs/guides/extending-builder.md](https://github.com/HJ-company/daniworks-builder-v2/blob/main/docs/guides/extending-builder.md).
+
+Create an admin and a **Full-access API token** (Strapi Admin → Settings →
+API Tokens), then set it as `STRAPI_TOKEN` in `apps/web/.env.local` (this file
+was generated for you from `.env.example`, with `REVALIDATE_SECRET` /
+`PREVIEW_SECRET` already filled in).
+
+## Run
+
+```bash
+pnpm dev
+```
+
+- CMS admin: http://localhost:1337/admin — create a `page` with slug `home`.
+- Front end: http://localhost:3000
+
+## What's wired for you
+
+- `apps/web/components/blocks-provider.tsx` — injects `next/image` / `next/link`
+  and a token-free `resolveAssetUrl` into `@dani-builder/blocks`.
+- `apps/web/app/globals.css` — Tailwind v4 `@theme` tokens + `@source` for the
+  block package + `@dani-builder/blocks/styles.css` import in the layout.
+- `apps/web/app/page.tsx` — fetches the `home` page and renders it with
+  `<BlockRenderer>`.
+
+Runtime secrets were generated into `apps/web/.env.local` (gitignored). The
+committed `.env.example` keeps blank placeholders.

package/template/_gitignore

@@ -0,0 +1,10 @@
+node_modules
+.next
+dist
+.turbo
+.tmp
+.env
+.env.local
+!.env.example
+*.log
+.DS_Store

package/template/apps/web/_env.example

@@ -0,0 +1,6 @@
+STRAPI_URL=http://localhost:1337
+STRAPI_MEDIA_HOST=http://localhost:1337
+STRAPI_TOKEN=
+SITE_URL=http://localhost:3000
+REVALIDATE_SECRET=
+PREVIEW_SECRET=

package/template/apps/web/app/globals.css

@@ -0,0 +1,14 @@
+@import "tailwindcss";
+@source "../node_modules/@dani-builder/blocks/dist";
+
+@theme {
+  --color-primary: #6366F1;
+  --color-primary-light: #818CF8;
+  --color-cta: #047857;
+  --color-cta-hover: #065F46;
+  --color-bg: #F5F3FF;
+  --color-text: #1E1B4B;
+  --color-text-muted: #4B5563;
+}
+
+body { background-color: #fff; color: var(--color-text); }

package/template/apps/web/app/layout.tsx

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+import { BlocksProvider } from "@/components/blocks-provider";
+import { mediaHost } from "@/lib/strapi";
+import "./globals.css";
+import "@dani-builder/blocks/styles.css";
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <script dangerouslySetInnerHTML={{ __html: "document.documentElement.classList.add('js')" }} />
+      </head>
+      <body>
+        <BlocksProvider mediaHost={mediaHost}>{children}</BlocksProvider>
+      </body>
+    </html>
+  );
+}

package/template/apps/web/app/page.tsx

@@ -0,0 +1,11 @@
+import { notFound } from "next/navigation";
+import { BlockRenderer } from "@dani-builder/blocks";
+import { fetchPageBySlug } from "@/lib/strapi";
+
+export const revalidate = 60;
+
+export default async function HomePage() {
+  const page = await fetchPageBySlug("home");
+  if (!page) notFound();
+  return <BlockRenderer blocks={page.blocks} />;
+}

package/template/apps/web/components/blocks-provider.tsx

@@ -0,0 +1,19 @@
+"use client";
+
+import NextImage from "next/image";
+import NextLink from "next/link";
+import type { ReactNode } from "react";
+import { getAssetUrl } from "@dani-builder/strapi-client/utils";
+import type { StrapiMedia } from "@dani-builder/strapi-client/types";
+import { BlocksProvider as Provider, type BlocksImageProps, type BlocksLinkProps } from "@dani-builder/blocks";
+
+const Image = (p: BlocksImageProps) => <NextImage {...p} />;
+const Link = ({ href, children, ...r }: BlocksLinkProps) => (
+  <NextLink href={href} {...r}>{children}</NextLink>
+);
+
+export function BlocksProvider({ mediaHost, children }: { mediaHost: string; children: ReactNode }) {
+  const resolveAssetUrl = (a: StrapiMedia | null | undefined, f?: "thumbnail" | "small" | "medium" | "large") =>
+    getAssetUrl(a, f, mediaHost);
+  return <Provider value={{ Image, Link, resolveAssetUrl }}>{children}</Provider>;
+}

package/template/apps/web/lib/strapi.ts

@@ -0,0 +1,17 @@
+import { cache } from "react";
+import { createStrapiClient } from "@dani-builder/strapi-client/client";
+import { getPageBySlug } from "@dani-builder/strapi-client/api";
+
+const strapiUrl = process.env.STRAPI_URL ?? "http://localhost:1337";
+export const mediaHost = process.env.STRAPI_MEDIA_HOST ?? strapiUrl;
+
+const strapi = createStrapiClient({
+  baseUrl: strapiUrl,
+  apiToken: process.env.STRAPI_TOKEN,
+  mediaHost,
+});
+
+// getPageBySlug returns null for a genuinely missing slug (200 + empty result),
+// which the page turns into a 404. Real failures (network/auth/5xx) are left to
+// throw so they surface in the error boundary instead of silently 404-ing.
+export const fetchPageBySlug = cache((slug: string) => getPageBySlug(strapi, slug));

package/template/apps/web/next.config.ts

@@ -0,0 +1,19 @@
+import type { NextConfig } from "next";
+
+const withScheme = (v: string) => (/^https?:\/\//.test(v) ? v : `https://${v}`);
+const mediaHost = withScheme(process.env.STRAPI_MEDIA_HOST ?? process.env.STRAPI_URL ?? "http://localhost:1337");
+
+// Next 16 refuses to optimize images from local/loopback IPs (SSRF guard) even
+// when remotePatterns matches — /_next/image 400s. Local dev serves Strapi media
+// from localhost, so opt in ONLY when the media host is loopback.
+const mediaHostname = new URL(mediaHost).hostname;
+const allowLocalIP = /^(localhost|127\.|0\.0\.0\.0|::1|\[::1\])/.test(mediaHostname);
+
+const nextConfig: NextConfig = {
+  images: {
+    remotePatterns: [new URL(`${mediaHost}/**`)],
+    ...(allowLocalIP ? { dangerouslyAllowLocalIP: true } : {}),
+  },
+  transpilePackages: ["@dani-builder/strapi-client", "@dani-builder/blocks"],
+};
+export default nextConfig;

package/template/apps/web/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "web",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "@dani-builder/blocks": "latest",
+    "@dani-builder/strapi-client": "latest",
+    "next": "^16",
+    "react": "^19",
+    "react-dom": "^19"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^26",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "tailwindcss": "^4",
+    "typescript": "^6.0.3"
+  }
+}

package/template/apps/web/postcss.config.mjs

@@ -0,0 +1 @@
+export default { plugins: { "@tailwindcss/postcss": {} } };

package/template/apps/web/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022", "lib": ["dom", "dom.iterable", "esnext"],
+    "module": "esnext", "moduleResolution": "bundler", "jsx": "preserve",
+    "strict": true, "noEmit": true, "esModuleInterop": true, "skipLibCheck": true,
+    "incremental": true, "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/template/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "private": true,
+  "packageManager": "pnpm@11.21.0",
+  "engines": {
+    "node": ">=22.13"
+  },
+  "scripts": {
+    "dev": "turbo run dev",
+    "build": "turbo run build"
+  },
+  "devDependencies": {
+    "turbo": "^2"
+  }
+}

package/template/pnpm-workspace.yaml

@@ -0,0 +1,8 @@
+packages:
+  - "apps/*"
+
+allowBuilds:
+  "@swc/core": true
+  better-sqlite3: true
+  core-js-pure: true
+  esbuild: true

package/template/turbo.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://turborepo.dev/schema.json",
+  "tasks": {
+    "build": { "dependsOn": ["^build"], "outputs": [".next/**", "!.next/cache/**"] },
+    "dev": { "cache": false, "persistent": true }
+  }
+}