storyshelf 0.3.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Siddhant Gupta
+
+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,113 @@
+# storyshelf
+
+The StoryShelf command-line interface (binary `storyshelf`): scaffold servers, initialize client config, create projects and CI tokens, upload built Storybooks as builds, purge expired builds, and retry failed builds. It talks to a running StoryShelf server over `/api/v1` and has **no Playwright or server dependencies**, so it installs cleanly in CI.
+
+## Install
+
+```sh
+nub add storyshelf
+```
+
+or
+
+```sh
+npm install -g storyshelf
+```
+
+## Quick start
+
+Initialize client config (requires `.storybook/main.*`):
+
+```sh
+storyshelf init --url https://shelf.example.com --slug my-app
+# writes .storybook/storyshelf.json
+```
+
+Create a project on the server (requires site-admin token and `.storybook/main.*`):
+
+```sh
+storyshelf create --url https://shelf.example.com --name my-app --token $STORYSHELF_ADMIN_TOKEN
+# prints slug + CI token and writes .storybook/storyshelf.json
+```
+
+Scaffold a server:
+
+```sh
+storyshelf server init --dir ./my-shelf
+```
+
+## API
+
+### Commands
+
+`storyshelf init` — initialize `.storybook/storyshelf.json` (client config). Fails if `.storybook/main.*` not found. Prompts if flags missing.
+
+```sh
+storyshelf init --url <url> --slug <slug> [--build-dir <dir> --build-command <cmd> --skip <glob> -c <config>]
+```
+
+`storyshelf create` — create a project and CI token on a server (requires admin token). Fails if `.storybook/main.*` not found and writes `.storybook/storyshelf.json`.
+
+```sh
+storyshelf create --url <url> --name <name> --token <admin-token>
+# or env STORYSHELF_ADMIN_TOKEN / ADMIN_TOKEN
+```
+
+`storyshelf server init` — scaffold a new StoryShelf server project.
+
+```sh
+storyshelf server init --dir <dir>
+```
+
+`storyshelf upload` — upload a built Storybook as a build. `--url/--slug` optional when `.storybook/storyshelf.json` exists (flags > env > file). `--token/--sha/--branch` fallback to `STORYSHELF_TOKEN`/`GITHUB_SHA`/`GITHUB_REF_NAME`. Running `storyshelf` with no args defaults to `upload` if config exists, else shows help to run `init`.
+
+```sh
+storyshelf upload --url <url> --slug <slug> --token <token> \
+  --sha <sha> --branch <branch> \
+  [--build-dir <dir> --build-command <cmd> --force-build --skip <glob> -c <config>] [--message <msg>] \
+  [--author-email <email>] [--author-name <name>]
+```
+
+The default `--build-dir` is `storybook-static` or `buildDir` from `.storybook/storyshelf.json` (see [Configuration](../../apps/website/src/content/docs/guides/config.md)). If `buildDir` is missing/empty, `upload` runs `buildCommand` or `npm run <buildScriptName>`.
+
+`storyshelf purge` — purge expired builds (requires admin token when auth enabled).
+
+```sh
+storyshelf purge --url <url> [--token <admin-token>]
+```
+
+`storyshelf retry` — retry a failed build.
+
+```sh
+storyshelf retry --url <url> --slug <slug> --build-id <id> [--token <token>]
+```
+
+### Example CI snippet
+
+```yaml
+# .github/workflows/visual.yml
+on:
+  push:
+  pull_request:
+
+jobs:
+  visual:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 20 }
+      - run: nub install && nub run build
+      - run: nubx storybook build -o storybook-static
+      - run: nubx storyshelf upload \
+          --token "${{ secrets.STORYSHELF_TOKEN }}" \
+          --sha "${{ github.sha }}" \
+          --branch "${{ github.ref_name }}"
+          # --url/--slug from .storybook/storyshelf.json
+```
+
+## How it fits in
+
+The server is scaffolded via `storyshelf server init`, which assembles `@storyshelf/core`, `@storyshelf/db-sqlite`, and `@storyshelf/storage-local` and runs Playwright captures. The CLI never imports that stack — client-only by design.
+
+See `docs/architecture.md` for the capture workflow and `docs/testing.md` for the gated browser integration suite.

package/dist/client.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/client.ts
+function buildAuthHeaders(token) {
+	return token ? { Authorization: `Bearer ${token}` } : {};
+}
+function buildRequestHeaders(authHeaders, contentType) {
+	const headers = { ...authHeaders };
+	if (contentType) headers["content-type"] = contentType;
+	return headers;
+}
+async function fetchJson(url, options) {
+	const res = await fetch(url, options);
+	if (!res.ok) throw new Error(`Request failed (${res.status}): ${await res.text()}`);
+	return res.json();
+}
+function createTokensApi(baseUrl, requestHeaders) {
+	return { create: async (slug, json) => await fetchJson(`${baseUrl}/api/v1/projects/${slug}/tokens`, {
+		method: "POST",
+		headers: requestHeaders("application/json"),
+		body: JSON.stringify(json)
+	}) };
+}
+function createBuildsApi(baseUrl, authHeaders, requestHeaders) {
+	return {
+		createJson: async (slug, json) => await fetchJson(`${baseUrl}/api/v1/projects/${slug}/builds`, {
+			method: "POST",
+			headers: requestHeaders("application/json"),
+			body: JSON.stringify(json)
+		}),
+		uploadZip: async (uploadUrl, body) => {
+			const init = {
+				method: "PUT",
+				headers: {
+					...authHeaders,
+					"content-type": "application/zip"
+				},
+				body,
+				duplex: "half"
+			};
+			const res = await fetch(`${baseUrl}${uploadUrl}`, init);
+			if (!res.ok) throw new Error(`Request failed (${res.status}): ${await res.text()}`);
+			return res.json();
+		},
+		retry: async (slug, buildId) => await fetchJson(`${baseUrl}/api/v1/projects/${slug}/builds/${buildId}/retry`, {
+			method: "POST",
+			headers: requestHeaders("application/json"),
+			body: JSON.stringify({})
+		})
+	};
+}
+function createAdminApi(baseUrl, requestHeaders) {
+	return { purge: async (json) => await fetchJson(`${baseUrl}/api/v1/admin/purge`, {
+		method: "POST",
+		headers: requestHeaders("application/json"),
+		body: JSON.stringify(json)
+	}) };
+}
+function createProjectsApi(baseUrl, authHeaders, requestHeaders) {
+	return {
+		create: async (json) => await fetchJson(`${baseUrl}/api/v1/projects`, {
+			method: "POST",
+			headers: requestHeaders("application/json"),
+			body: JSON.stringify(json)
+		}),
+		update: async (slug, json) => await fetchJson(`${baseUrl}/api/v1/projects/${slug}`, {
+			method: "PATCH",
+			headers: requestHeaders("application/json"),
+			body: JSON.stringify(json)
+		}),
+		get: async (slug) => await fetchJson(`${baseUrl}/api/v1/projects/${slug}`, { headers: requestHeaders() }),
+		list: async () => await fetchJson(`${baseUrl}/api/v1/projects`, { headers: requestHeaders() }),
+		tokens: createTokensApi(baseUrl, requestHeaders),
+		builds: createBuildsApi(baseUrl, authHeaders, requestHeaders),
+		admin: createAdminApi(baseUrl, requestHeaders)
+	};
+}
+function createClient(baseUrl, token) {
+	const authHeaders = buildAuthHeaders(token);
+	const requestHeaders = (contentType) => buildRequestHeaders(authHeaders, contentType);
+	return { projects: createProjectsApi(baseUrl, authHeaders, requestHeaders) };
+}
+//#endregion
+export { createClient };

package/dist/commands/create.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createClient } from "../client.js";
+import { assertStorybookMain, detectGitDefaultBranch, detectGitRepository, detectPackageName, detectStorybookMeta, writeStorybookConfig } from "../config.js";
+import { printError, printLine } from "../output.js";
+//#region src/commands/create.ts
+async function readCreateInputs(options, cwd) {
+	const name = (options.name === "" ? void 0 : options.name) ?? await detectPackageName(cwd);
+	return {
+		url: options.url ?? process.env["STORYSHELF_URL"] ?? process.env["STORYSHELF_HOST"],
+		name: name ?? void 0,
+		token: options.token ?? process.env["STORYSHELF_ADMIN_TOKEN"] ?? process.env["ADMIN_TOKEN"],
+		gitRepository: detectGitRepository(cwd) ?? void 0,
+		gitDefaultBranch: detectGitDefaultBranch(cwd) ?? void 0,
+		storybookMeta: await detectStorybookMeta(cwd)
+	};
+}
+function createInputError(inputs) {
+	if (!inputs.url) return "--url is required (or STORYSHELF_URL env)";
+	if (!inputs.name) return "--name is required (or ensure package.json has a name)";
+	if (!inputs.token) return "--token is required for site-admin (or STORYSHELF_ADMIN_TOKEN env)";
+	return null;
+}
+function buildCreatePayload(name, inputs) {
+	const payload = { name };
+	if (inputs.gitRepository) payload.gitRepository = inputs.gitRepository;
+	if (inputs.gitDefaultBranch) payload.gitDefaultBranch = inputs.gitDefaultBranch;
+	if (Object.keys(inputs.storybookMeta).length > 0) payload.storybookMeta = inputs.storybookMeta;
+	return payload;
+}
+async function executeCreate(url, token, payload, cwd) {
+	const client = createClient(url, token);
+	const project = await client.projects.create(payload);
+	const tokenRes = await client.projects.tokens.create(project.slug, { name: "ci" });
+	const written = await writeStorybookConfig({
+		slug: project.slug,
+		url
+	}, cwd);
+	printLine(`Project slug: ${project.slug}`);
+	printLine(`CI token: ${tokenRes.token}`);
+	printLine(`Wrote ${written}`);
+	printLine("Store CI token in secrets (STORYSHELF_TOKEN) — not in git");
+}
+/**
+* Create a project and CI token on a StoryShelf server.
+* Requires .storybook/main.* to exist and writes .storybook/storyshelf.json.
+*
+* @param options - Create command options.
+*/
+async function runCreate(options) {
+	const cwd = options.cwd ?? process.cwd();
+	await assertStorybookMain(cwd);
+	const inputs = await readCreateInputs(options, cwd);
+	const error = createInputError(inputs);
+	if (error || !inputs.url || !inputs.name || !inputs.token) {
+		printError(error ?? "Missing required options");
+		process.exitCode = 1;
+		return;
+	}
+	await executeCreate(inputs.url, inputs.token, buildCreatePayload(inputs.name, inputs), cwd);
+}
+//#endregion
+export { runCreate };

package/dist/commands/default.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { loadStorybookConfig } from "../config.js";
+import { printError } from "../output.js";
+import { runUpload } from "./upload.js";
+//#region src/commands/default.ts
+/** Print an error and mark the process as failed. */
+function handleError(error) {
+	printError(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+}
+function defaultUploadOptions(cfg) {
+	const url = cfg?.url ?? process.env["STORYSHELF_URL"];
+	const slug = cfg?.slug;
+	const token = process.env["STORYSHELF_TOKEN"] ?? process.env["SHELF_TOKEN"];
+	const sha = process.env["GITHUB_SHA"] ?? process.env["VERCEL_GIT_COMMIT_SHA"] ?? process.env["CI_COMMIT_SHA"];
+	const branch = process.env["GITHUB_REF_NAME"] ?? process.env["VERCEL_GIT_COMMIT_REF"] ?? process.env["CI_COMMIT_REF_NAME"];
+	if (!url || !slug || !token || !sha || !branch) return null;
+	return {
+		url,
+		slug,
+		token,
+		sha,
+		branch,
+		buildDir: cfg?.buildDir ?? "storybook-static",
+		buildCommand: cfg?.buildCommand,
+		buildScriptName: cfg?.buildScriptName,
+		skip: cfg?.skip
+	};
+}
+/**
+* Default behavior for bare `storyshelf` (no subcommand): upload when a
+* client config exists, otherwise point at init.
+*/
+async function runDefaultCommand(program) {
+	const cfg = await loadStorybookConfig();
+	const options = defaultUploadOptions(cfg);
+	if (!options) {
+		program.outputHelp();
+		if (cfg) printError("Missing required upload options — ensure STORYSHELF_URL/SLUG/TOKEN and GITHUB_SHA/BRANCH are set or run `storyshelf upload --help`");
+		else printError("No .storybook/storyshelf.json found — run `storyshelf init --url <url> --slug <slug>` first");
+		process.exitCode = 1;
+		return;
+	}
+	await runUpload(options).catch(handleError);
+}
+//#endregion
+export { handleError, runDefaultCommand };

package/dist/commands/init.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createClient } from "../client.js";
+import { assertStorybookMain, detectStorybookMeta, loadStorybookConfig, writeStorybookConfig } from "../config.js";
+import { printError, printLine } from "../output.js";
+import prompts from "prompts";
+//#region src/commands/init.ts
+/** Human description of the detected Storybook (framework, addons, path). */
+function describeMeta(meta) {
+	const hintParts = [];
+	if (meta.framework?.name) hintParts.push(meta.framework.name);
+	if (meta.addons?.length) hintParts.push(`${meta.addons.length} addons`);
+	if (meta.packagePath && meta.packagePath !== ".") hintParts.push(meta.packagePath);
+	return hintParts.join(" • ");
+}
+function buildQuestions(url, slug, hint) {
+	const questions = [];
+	if (!url) questions.push({
+		type: "text",
+		name: "url",
+		message: `Server URL?${hint}`
+	});
+	if (!slug) questions.push({
+		type: "text",
+		name: "slug",
+		message: `Project slug?${hint}`
+	});
+	return questions;
+}
+/** Prompt for whichever of url/slug is still missing; null when cancelled. */
+async function promptMissing(url, slug, hintSuffix) {
+	const questions = buildQuestions(url, slug, hintSuffix);
+	if (questions.length === 0) return {};
+	const answers = await prompts(questions);
+	if (questions.some((question) => !answers[question.name])) {
+		printError("Cancelled.");
+		return null;
+	}
+	return answers;
+}
+function narrowAnswer(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Layer explicit options over an existing config file. */
+function mergeWithExisting(options, existing) {
+	const url = options.url ?? process.env["STORYSHELF_URL"];
+	const slug = options.slug ?? process.env["STORYSHELF_SLUG"];
+	if (!existing) return {
+		url,
+		slug,
+		buildDir: options.buildDir,
+		buildCommand: options.buildCommand,
+		buildScriptName: options.buildScriptName,
+		skip: options.skip
+	};
+	return {
+		url: url ?? existing.url,
+		slug: slug ?? existing.slug,
+		buildDir: options.buildDir ?? existing.buildDir,
+		buildCommand: options.buildCommand ?? existing.buildCommand,
+		buildScriptName: options.buildScriptName ?? existing.buildScriptName,
+		skip: options.skip ?? existing.skip
+	};
+}
+/** Resolve init answers from options, existing config, and prompts. */
+async function resolveInitAnswers(options, cwd) {
+	const merged = mergeWithExisting(options, await loadStorybookConfig(cwd, options.config));
+	const detected = describeMeta(await detectStorybookMeta(cwd));
+	const hintSuffix = detected ? ` (detected ${detected})` : "";
+	const answers = await promptMissing(merged.url, merged.slug, hintSuffix);
+	if (!answers) return null;
+	return {
+		...merged,
+		url: narrowAnswer(answers.url) ?? merged.url,
+		slug: narrowAnswer(answers.slug) ?? merged.slug,
+		detected
+	};
+}
+const OPTIONAL_INIT_KEYS = [
+	"url",
+	"buildDir",
+	"buildCommand",
+	"buildScriptName",
+	"skip"
+];
+function buildInitConfig(answers, slug) {
+	const config = { slug };
+	for (const key of OPTIONAL_INIT_KEYS) {
+		const value = answers[key];
+		if (value) config[key] = value;
+	}
+	return config;
+}
+/** Persist the resolved answers to .storybook/storyshelf.json. */
+async function persistInitConfig(answers, slug, cwd, configPath) {
+	try {
+		const written = await writeStorybookConfig(buildInitConfig(answers, slug), cwd, configPath);
+		printLine(`Wrote ${written}`);
+		if (answers.detected) printLine(`Detected ${answers.detected}`);
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+}
+function isProviderError(error, status) {
+	return error instanceof Error && error.message.includes(status);
+}
+/** Fetch the project; classify get-phase failures. */
+async function fetchProjectForSync(url, token, slug) {
+	try {
+		await createClient(url, token).projects.get(slug);
+		return "synced";
+	} catch (error) {
+		if (isProviderError(error, "404")) return "not-found";
+		return "next";
+	}
+}
+/** Patch storybook_meta; 403 means the token lacks admin (try next). */
+async function patchProjectMeta(url, token, slug, metaToSync) {
+	try {
+		await createClient(url, token).projects.update(slug, { storybookMeta: metaToSync });
+		return "synced";
+	} catch (error) {
+		if (isProviderError(error, "403")) return "next";
+		throw error;
+	}
+}
+/** Try syncing storybook_meta with one token. */
+async function trySyncToken(url, token, slug, metaToSync) {
+	const fetched = await fetchProjectForSync(url, token, slug);
+	if (fetched !== "synced") return fetched;
+	return await patchProjectMeta(url, token, slug, metaToSync);
+}
+/** Candidate tokens for the meta sync, in try order. */
+function collectSyncTokens(token) {
+	return [token ?? process.env["STORYSHELF_TOKEN"] ?? process.env["SHELF_TOKEN"], process.env["STORYSHELF_ADMIN_TOKEN"] ?? process.env["ADMIN_TOKEN"]].filter((candidate) => Boolean(candidate));
+}
+/** Try each token in order until sync, not-found, or exhaustion. */
+async function runTokenLoop(url, slug, metaToSync, tokens) {
+	for (const candidate of tokens) {
+		const outcome = await trySyncToken(url, candidate, slug, metaToSync);
+		if (outcome === "synced") {
+			printLine(`Synced storybook_meta for ${slug}`);
+			return {
+				synced: true,
+				notFound: false
+			};
+		}
+		if (outcome === "not-found") return {
+			synced: false,
+			notFound: true
+		};
+	}
+	return {
+		synced: false,
+		notFound: false
+	};
+}
+/** Sync storybook_meta to the server when the project already exists. */
+async function syncStorybookMeta(url, slug, cwd, token) {
+	const metaToSync = await detectStorybookMeta(cwd);
+	if (Object.keys(metaToSync).length === 0) return;
+	const tokens = collectSyncTokens(token);
+	if (tokens.length === 0) return;
+	const { synced, notFound } = await runTokenLoop(url, slug, metaToSync, tokens);
+	if (!synced && notFound) {
+		printError(`Project "${slug}" does not exist on ${url} — run \`storyshelf create --url ${url} --name <name> --token $STORYSHELF_ADMIN_TOKEN\` first`);
+		process.exitCode = 1;
+	}
+}
+/** Write the config and sync meta once the slug is known. */
+async function finalizeInit(answers, cwd, options) {
+	if (!answers.slug) {
+		printError("--slug is required (or run `storyshelf create --url <url> --name <name>`)");
+		process.exitCode = 1;
+		return;
+	}
+	await persistInitConfig(answers, answers.slug, cwd, options.config);
+	if (answers.url) await syncStorybookMeta(answers.url, answers.slug, cwd, options.token);
+}
+/**
+* Initialize .storybook/storyshelf.json for the current Storybook.
+* Fails if .storybook/main.* is not found.
+*
+* @param options - Init command options.
+*/
+async function runInit(options) {
+	const cwd = options.cwd ?? process.cwd();
+	await assertStorybookMain(cwd);
+	const answers = await resolveInitAnswers(options, cwd);
+	if (!answers) return;
+	await finalizeInit(answers, cwd, options);
+}
+//#endregion
+export { runInit };

package/dist/commands/purge.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createClient } from "../client.js";
+import { printLine } from "../output.js";
+//#region src/commands/purge.ts
+/**
+* Purge expired builds on a StoryShelf server.
+*
+* @param options - Purge command options.
+*/
+async function runPurge(options) {
+	const token = options.token ?? process.env["STORYSHELF_ADMIN_TOKEN"] ?? process.env["ADMIN_TOKEN"];
+	const resultData = await createClient(options.url, token).projects.admin.purge({});
+	printLine(`Removed ${resultData.removedBuilds} build(s) and ${resultData.removedFiles ?? 0} file(s)`);
+}
+//#endregion
+export { runPurge };

package/dist/commands/retry.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createClient } from "../client.js";
+import { printLine } from "../output.js";
+//#region src/commands/retry.ts
+/**
+* Retry a failed StoryShelf build.
+*
+* @param options - Retry command options.
+*/
+async function runRetry(options) {
+	const token = options.token ?? process.env["STORYSHELF_TOKEN"] ?? process.env["SHELF_TOKEN"];
+	const buildData = await createClient(options.url, token).projects.builds.retry(options.slug, options.buildId);
+	printLine(`Build ${buildData.id} queued for retry`);
+}
+//#endregion
+export { runRetry };

package/dist/commands/server/docker.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/commands/server/docker.ts
+const DOCKERFILE_LINES = [
+	"FROM node:lts-alpine AS builder",
+	"WORKDIR /app",
+	"COPY package.json ./",
+	"RUN npm install",
+	"COPY server.ts ./",
+	"RUN npx esbuild server.ts --bundle --platform=node --format=esm \\",
+	"  --external:playwright \\",
+	"  --outfile=dist/server.mjs",
+	"",
+	"FROM mcr.microsoft.com/playwright:latest",
+	"WORKDIR /app",
+	"COPY --from=builder /app/dist/server.mjs ./",
+	"COPY --from=builder /app/node_modules/playwright \\",
+	"  ./node_modules/playwright/",
+	"EXPOSE 3000",
+	"ENV PORT=3000",
+	"ENV DATA_DIR=/data",
+	"CMD [\"node\", \"dist/server.mjs\"]"
+];
+const DOCKERIGNORE_LINES = [
+	"node_modules/",
+	".git/",
+	"*.md",
+	".env*",
+	"data/"
+];
+const COMPOSE_LINES = [
+	"services:",
+	"  storyshelf:",
+	"    build: .",
+	"    ports:",
+	"      - \"3000:3000\"",
+	"    volumes:",
+	"      - storyshelf-data:/data",
+	"    environment:",
+	"      - SECRET=change-me",
+	"      - PORT=3000",
+	"      - DATA_DIR=/data",
+	"      # Add your env vars here:",
+	"      # - AUTH_PASSWORD=your-password",
+	"      # - TURSO_DATABASE_URL=libsql://...",
+	"      # - TURSO_AUTH_TOKEN=...",
+	"volumes:",
+	"  storyshelf-data:"
+];
+function generateDockerfile() {
+	return DOCKERFILE_LINES.join("\n");
+}
+function generateDockerignore() {
+	return DOCKERIGNORE_LINES.join("\n");
+}
+function generateComposeYaml() {
+	return COMPOSE_LINES.join("\n");
+}
+//#endregion
+export { generateComposeYaml, generateDockerfile, generateDockerignore };