storyshelf 0.3.2

package/dist/commands/server/init.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { printError, printLine } from "../../output.js";
+import { generateComposeYaml, generateDockerfile, generateDockerignore } from "./docker.js";
+import { INFRA_PROMPTS, PROJECT_PROMPTS } from "./prompts.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import prompts from "prompts";
+//#region src/commands/server/init.ts
+const DB_PACKAGE = {
+	sqlite: "@storyshelf/db-sqlite",
+	turso: "@storyshelf/db-turso"
+};
+const STORAGE_PACKAGE = {
+	local: "@storyshelf/storage-local",
+	s3: "@storyshelf/storage-s3"
+};
+const AUTH_PACKAGE = {
+	none: null,
+	password: "@storyshelf/auth-password",
+	oauth: "@storyshelf/auth-oauth"
+};
+const GIT_PACKAGE = {
+	none: null,
+	github: "@storyshelf/git-github",
+	gitlab: "@storyshelf/git-gitlab"
+};
+const DB_IMPORT = {
+	sqlite: `import { createSqliteDatabase } from "@storyshelf/db-sqlite";`,
+	turso: `import { createTursoDatabase } from "@storyshelf/db-turso";`
+};
+const STORAGE_IMPORT = {
+	local: `import { createLocalStorage } from "@storyshelf/storage-local";`,
+	s3: `import { createS3Storage } from "@storyshelf/storage-s3";`
+};
+const DB_INIT = {
+	sqlite: `createSqliteDatabase(\`\${dataDir}/shelf.db\`)`,
+	turso: `createTursoDatabase({ url: process.env.TURSO_DATABASE_URL!, authToken: process.env.TURSO_AUTH_TOKEN })`
+};
+const STORAGE_INIT = {
+	local: `createLocalStorage(dataDir)`,
+	s3: `createS3Storage({ bucket: process.env.S3_BUCKET!, region: process.env.AWS_REGION })`
+};
+function buildImports(answers) {
+	const imports = [
+		`import { serve } from "@hono/node-server";`,
+		`import { createShelfRouter } from "@storyshelf/router";`,
+		`import { createShelfLogger } from "@storyshelf/core/logger";`,
+		DB_IMPORT[answers.database],
+		STORAGE_IMPORT[answers.storage]
+	];
+	if (answers.auth !== "none") imports.push(`import { createPasswordAuth } from "${AUTH_PACKAGE[answers.auth]}";`);
+	if (answers.git !== "none") {
+		const host = answers.git === "github" ? "gitHubHost" : "gitLabHost";
+		imports.push(`import { ${host} } from "${GIT_PACKAGE[answers.git]}";`);
+	}
+	imports.push(`import { createPlaywrightCaptureRunner } from "@storyshelf/runner-playwright";`);
+	return imports;
+}
+function buildAdapterLines(answers) {
+	return [
+		`// Adapters — swap these for your deployment`,
+		`const database = ${DB_INIT[answers.database]};`,
+		`const storage = ${STORAGE_INIT[answers.storage]};`,
+		`const captureRunner = createPlaywrightCaptureRunner();`,
+		`const logger = createShelfLogger({ level: process.env.LOG_LEVEL });`
+	];
+}
+function buildRouterLines(answers) {
+	const lines = [
+		`const app = createShelfRouter({`,
+		`  database,`,
+		`  storage,`,
+		`  captureRunner,`,
+		`  logger,`
+	];
+	if (answers.auth !== "none") lines.push(`  auth: createPasswordAuth({ password: process.env.AUTH_PASSWORD! }),`);
+	if (answers.git !== "none") {
+		const host = answers.git === "github" ? "gitHubHost" : "gitLabHost";
+		lines.push(`  gitHosts: [${host}],`);
+	}
+	lines.push(`  config: {`, `    secret: process.env.SECRET,`, `    scratchDir: dataDir,`, `  },`, `});`, ``, `await app.lifecycle.init();`);
+	return lines;
+}
+function generateServer(answers) {
+	return [
+		...buildImports(answers),
+		``,
+		`const dataDir = process.env.DATA_DIR || "./data";`,
+		`const port = Number(process.env.PORT) || 3000;`,
+		``,
+		...buildAdapterLines(answers),
+		``,
+		...buildRouterLines(answers),
+		``,
+		`const server = serve({ fetch: app.fetch, port }, () => {`,
+		`  logger.info({ port }, "StoryShelf server listening");`,
+		`});`,
+		``,
+		`const shutdown = async () => {`,
+		`  await app.lifecycle.close();`,
+		`  server.close();`,
+		`};`,
+		`process.on("SIGTERM", () => {`,
+		`  shutdown().catch(() => {});`,
+		`});`,
+		`process.on("SIGINT", () => {`,
+		`  shutdown().catch(() => {});`,
+		`});`,
+		``
+	].join("\n");
+}
+function buildDeps(answers) {
+	const deps = {
+		"@hono/node-server": "^1.17.0",
+		"@storyshelf/core": "0.3.2",
+		"@storyshelf/router": "0.3.2",
+		[DB_PACKAGE[answers.database]]: "0.3.2",
+		"@storyshelf/runner-playwright": "0.3.2"
+	};
+	if (answers.storage !== "local") deps[STORAGE_PACKAGE[answers.storage]] = "0.3.2";
+	if (answers.auth !== "none") deps[AUTH_PACKAGE[answers.auth] ?? ""] = "0.3.2";
+	if (answers.git !== "none") deps[GIT_PACKAGE[answers.git] ?? ""] = "0.3.2";
+	return deps;
+}
+function generatePackageJson(answers) {
+	const pkg = {
+		name: answers.name,
+		version: "0.1.0",
+		type: "module",
+		private: true,
+		description: "StoryShelf self-hosted visual testing server.",
+		scripts: {
+			start: "node --experimental-transform-types server.ts",
+			dev: "node --experimental-transform-types --watch server.ts"
+		},
+		dependencies: buildDeps(answers),
+		devDependencies: { typescript: "^7.0.2" }
+	};
+	return JSON.stringify(pkg, null, 2);
+}
+async function writeFiles(outDir, answers) {
+	const serverCode = generateServer(answers);
+	await writeFile(join(outDir, "server.ts"), serverCode);
+	printLine(`Created server.ts`);
+	const pkgCode = generatePackageJson(answers);
+	await writeFile(join(outDir, "package.json"), pkgCode);
+	printLine(`Created package.json`);
+	await writeDockerFiles(outDir, answers.docker);
+}
+async function writeDockerFiles(outDir, docker) {
+	if (!docker) return;
+	await writeFile(join(outDir, "Dockerfile"), generateDockerfile());
+	await writeFile(join(outDir, ".dockerignore"), generateDockerignore());
+	await writeFile(join(outDir, "compose.yaml"), generateComposeYaml());
+	printLine(`Created Dockerfile, .dockerignore, compose.yaml`);
+}
+function printNextSteps(answers) {
+	printLine(`\nScaffolded ${answers.name} in ${resolve(answers.dir)}`);
+	printLine(`\nNext steps:`);
+	printLine(`  cd ${answers.dir}`);
+	if (answers.docker) printLine(`  docker compose up`);
+	else {
+		printLine(`  npm install`);
+		printLine(`  npm start`);
+	}
+}
+/**
+* Scaffold a new StoryShelf server project.
+*
+* @param _options - Server init command options.
+*/
+async function runServerInit(_options) {
+	const responses = await prompts([...PROJECT_PROMPTS, ...INFRA_PROMPTS]);
+	if (!responses["name"] || !responses["dir"]) {
+		printError("Cancelled.");
+		return;
+	}
+	const answers = responses;
+	const outDir = resolve(answers.dir);
+	await mkdir(outDir, { recursive: true });
+	await writeFiles(outDir, answers);
+	printNextSteps(answers);
+}
+//#endregion
+export { runServerInit };

package/dist/commands/server/prompts.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/commands/server/prompts.ts
+const PROJECT_PROMPTS = [{
+	type: "text",
+	name: "name",
+	message: "Project name?",
+	initial: "my-storyshelf"
+}, {
+	type: "text",
+	name: "dir",
+	message: "Directory?",
+	initial: (prev) => `./${prev}`
+}];
+const INFRA_PROMPTS = [
+	{
+		type: "select",
+		name: "database",
+		message: "Which database?",
+		choices: [{
+			title: "SQLite (local)",
+			value: "sqlite"
+		}, {
+			title: "Turso (serverless)",
+			value: "turso"
+		}]
+	},
+	{
+		type: "select",
+		name: "storage",
+		message: "Which storage?",
+		choices: [{
+			title: "Local filesystem",
+			value: "local"
+		}, {
+			title: "S3-compatible",
+			value: "s3"
+		}]
+	},
+	{
+		type: "select",
+		name: "auth",
+		message: "Which auth?",
+		choices: [
+			{
+				title: "None",
+				value: "none"
+			},
+			{
+				title: "Shared password",
+				value: "password"
+			},
+			{
+				title: "OAuth/OIDC",
+				value: "oauth"
+			}
+		]
+	},
+	{
+		type: "select",
+		name: "git",
+		message: "Which git provider?",
+		choices: [
+			{
+				title: "None",
+				value: "none"
+			},
+			{
+				title: "GitHub",
+				value: "github"
+			},
+			{
+				title: "GitLab",
+				value: "gitlab"
+			}
+		]
+	},
+	{
+		type: "confirm",
+		name: "docker",
+		message: "Generate Docker files?",
+		initial: true
+	}
+];
+//#endregion
+export { INFRA_PROMPTS, PROJECT_PROMPTS };

package/dist/commands/upload.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createClient } from "../client.js";
+import { loadStorybookConfig } from "../config.js";
+import { createSpinner, printLine, spinnerFrames } from "../output.js";
+import { execSync } from "node:child_process";
+import { access, readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { ZipArchive } from "archiver";
+import * as picomatch from "picomatch";
+//#region src/commands/upload.ts
+/** First set value among the given env var names. */
+function envOf(...names) {
+	for (const name of names) {
+		const value = process.env[name];
+		if (value) return value;
+	}
+}
+/** Layer explicit options over env and the client config file. */
+function collectUploadOptions(options, cfg) {
+	return {
+		url: options.url ?? cfg?.url ?? envOf("STORYSHELF_URL"),
+		slug: options.slug ?? cfg?.slug ?? envOf("STORYSHELF_SLUG"),
+		token: options.token ?? envOf("STORYSHELF_TOKEN", "SHELF_TOKEN"),
+		sha: options.sha ?? envOf("GITHUB_SHA", "VERCEL_GIT_COMMIT_SHA", "CI_COMMIT_SHA"),
+		branch: options.branch ?? envOf("GITHUB_REF_NAME", "VERCEL_GIT_COMMIT_REF", "CI_COMMIT_REF_NAME"),
+		buildDir: options.buildDir ?? cfg?.buildDir ?? "storybook-static",
+		buildCommand: options.buildCommand ?? cfg?.buildCommand,
+		buildScriptName: options.buildScriptName ?? cfg?.buildScriptName,
+		skip: options.skip ?? cfg?.skip,
+		message: options.message,
+		authorEmail: options.authorEmail,
+		authorName: options.authorName,
+		label: options.label
+	};
+}
+/** Throw on the first missing required upload option. */
+function assertUploadOptions(collected) {
+	if (!collected.url) throw new Error("--url is required (or .storybook/storyshelf.json / STORYSHELF_URL)");
+	if (!collected.slug) throw new Error("--slug is required (or .storybook/storyshelf.json / STORYSHELF_SLUG)");
+	if (!collected.token) throw new Error("--token is required (or STORYSHELF_TOKEN env)");
+	if (!collected.sha) throw new Error("--sha is required (or GITHUB_SHA env)");
+	if (!collected.branch) throw new Error("--branch is required (or GITHUB_REF_NAME env)");
+}
+function shouldSkipUpload(skip, branch) {
+	return Boolean(skip && branch && picomatch.isMatch(branch, skip));
+}
+/** Parse `--label key=value` flags into label pairs. */
+function parseLabels(flags) {
+	return (flags ?? []).map((flag) => {
+		const eq = flag.indexOf("=");
+		if (eq <= 0) throw new Error(`--label must be key=value, got "${flag}"`);
+		return {
+			key: flag.slice(0, eq),
+			value: flag.slice(eq + 1)
+		};
+	});
+}
+/** Zip the built Storybook directory as a stream (bounded memory). */
+function zipBuildDirStream(cwd, buildDir) {
+	const archive = new ZipArchive({ zlib: { level: 9 } });
+	archive.on("warning", (warning) => {
+		printLine(`Zip warning: ${warning.message}`);
+	});
+	archive.on("error", (error) => {
+		archive.destroy(error);
+	});
+	archive.directory(resolve(cwd, buildDir), false);
+	archive.finalize().catch(() => {});
+	return archive;
+}
+/**
+* Upload a built Storybook and create a build record.
+*
+* @param options - Upload command options.
+*/
+async function runUpload(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const collected = collectUploadOptions(options, await loadStorybookConfig(cwd, options.config));
+	if (shouldSkipUpload(collected.skip, collected.branch)) {
+		printLine(`Skipped per config skip="${collected.skip}" for branch "${collected.branch}"`);
+		return;
+	}
+	assertUploadOptions(collected);
+	await buildAndPost(cwd, collected, options.forceBuild);
+}
+/** Ensure, create, and stream the build directory. */
+async function buildAndPost(cwd, collected, force) {
+	await ensureBuildDir({
+		cwd,
+		buildDir: collected.buildDir,
+		buildCommand: collected.buildCommand,
+		buildScriptName: collected.buildScriptName,
+		force
+	});
+	const client = createClient(collected.url, collected.token);
+	const created = await client.projects.builds.createJson(collected.slug, {
+		gitSha: collected.sha,
+		gitBranch: collected.branch,
+		message: collected.message,
+		authorEmail: collected.authorEmail,
+		authorName: collected.authorName,
+		labels: parseLabels(collected.label)
+	});
+	await putZipStream(client, created, cwd, collected.buildDir);
+	printLine(`Build created: ${created.build.id}`);
+}
+/** PUT the streamed zip, then report the created build id. */
+async function putZipStream(client, created, cwd, buildDir) {
+	const spinner = createSpinner("Uploading...", spinnerFrames);
+	try {
+		await client.projects.builds.uploadZip(created.uploadUrl, zipBuildDirStream(cwd, buildDir));
+		spinner.stop("Upload complete");
+	} catch (error) {
+		spinner.stop("Upload failed");
+		throw error;
+	}
+}
+async function ensureBuildDir(opts) {
+	if (opts.buildCommand && opts.buildScriptName) throw new Error("buildCommand and buildScriptName are mutually exclusive");
+	const full = resolve(opts.cwd, opts.buildDir);
+	if (!(opts.force ?? await needsBuild(full))) return;
+	const command = opts.buildCommand ?? `npm run ${opts.buildScriptName ?? "build-storybook"} -- --output-dir ${opts.buildDir}`;
+	printLine(`Building Storybook: ${command}`);
+	execSync(command, {
+		stdio: "inherit",
+		env: {
+			...process.env,
+			STORYBOOK_BUILD_STORIES_JSON: "true"
+		}
+	});
+}
+/** True when the build directory is missing or empty. */
+async function needsBuild(full) {
+	try {
+		await access(full);
+		return (await readdir(full)).length === 0;
+	} catch {
+		return true;
+	}
+}
+//#endregion
+export { runUpload };

package/dist/config.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { execSync } from "node:child_process";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { z } from "zod";
+//#region src/config.ts
+const storybookConfigSchema = z.object({
+	slug: z.string().min(1, "slug is required"),
+	url: z.string().url().optional(),
+	buildDir: z.string().min(1).optional(),
+	buildCommand: z.string().min(1).optional(),
+	buildScriptName: z.string().min(1).optional(),
+	skip: z.string().min(1).optional()
+}).refine((data) => !(data.buildCommand && data.buildScriptName), {
+	message: "buildCommand and buildScriptName are mutually exclusive",
+	path: ["buildCommand"]
+});
+const CONFIG_RELATIVE = join(".storybook", "storyshelf.json");
+const MAIN_CANDIDATES = [
+	".storybook/main.js",
+	".storybook/main.ts",
+	".storybook/main.mjs",
+	".storybook/main.cjs",
+	".storybook/main.mts",
+	".storybook/main.cts",
+	".storybook/main.jsx",
+	".storybook/main.tsx"
+];
+async function findStorybookMain(cwd = process.cwd()) {
+	for (const candidate of MAIN_CANDIDATES) {
+		const full = resolve(cwd, candidate);
+		try {
+			await access(full);
+			return full;
+		} catch {}
+	}
+	return null;
+}
+async function assertStorybookMain(cwd = process.cwd()) {
+	if (!await findStorybookMain(cwd)) throw new Error(".storybook/main.* not found — ensure Storybook is set up in this project");
+}
+async function loadStorybookConfig(cwd = process.cwd(), customPath) {
+	const full = customPath ? resolve(cwd, customPath) : resolve(cwd, CONFIG_RELATIVE);
+	try {
+		const raw = await readFile(full, "utf8");
+		const parsed = JSON.parse(raw);
+		const result = storybookConfigSchema.safeParse(parsed);
+		if (!result.success) return null;
+		return result.data;
+	} catch {
+		return null;
+	}
+}
+/** Merge an existing config with new values. */
+function mergeConfigs(existing, config) {
+	return existing ? {
+		...existing,
+		...config
+	} : { ...config };
+}
+async function writeStorybookConfig(config, cwd = process.cwd(), customPath) {
+	const full = customPath ? resolve(cwd, customPath) : resolve(cwd, CONFIG_RELATIVE);
+	const dir = dirname(full);
+	await mkdir(dir, { recursive: true });
+	const merged = mergeConfigs(await loadStorybookConfig(cwd, customPath), config);
+	const result = storybookConfigSchema.safeParse(merged);
+	if (!result.success) throw new Error(`Invalid storybook config: ${result.error.message}`);
+	await writeFile(full, `${JSON.stringify(result.data, null, 2)}\n`, "utf8");
+	return full;
+}
+async function detectStorybookMeta(cwd = process.cwd()) {
+	const mainPath = await findStorybookMain(cwd);
+	if (!mainPath) return { packagePath: "." };
+	const meta = await parseMetaSource(mainPath);
+	const rel = relative(cwd, dirname(mainPath));
+	meta.packagePath = rel === "" ? "." : rel;
+	return meta;
+}
+function parseFrameworkName(raw) {
+	return /framework\s*:\s*\{\s*name\s*:\s*["'](?<name>[^"']+)["']/u.exec(raw)?.groups?.["name"];
+}
+function parseQuotedList(raw, key) {
+	const content = new RegExp(`${key}\\s*:\\s*\\[(?<content>[\\s\\S]*?)\\]`, "u").exec(raw)?.groups?.["content"];
+	if (!content) return [];
+	return [...content.matchAll(/["'](?<item>[^"']+)["']/gu)].map((match) => match.groups?.["item"]).filter((item) => item !== void 0 && item.length > 0);
+}
+async function parseMetaSource(mainPath) {
+	const meta = {};
+	try {
+		const raw = await readFile(mainPath, "utf8");
+		Object.assign(meta, parseMetaLists(raw));
+		const framework = parseFrameworkName(raw);
+		if (framework) meta.framework = { name: framework };
+	} catch {}
+	return meta;
+}
+function parseMetaLists(raw) {
+	const lists = {};
+	for (const [key, prop] of [
+		["addons", "addons"],
+		["stories", "storiesGlobs"],
+		["staticDirs", "staticDirs"]
+	]) {
+		const values = parseQuotedList(raw, key);
+		if (values.length > 0) lists[prop] = values;
+	}
+	return lists;
+}
+async function detectPackageName(cwd = process.cwd()) {
+	try {
+		const raw = await readFile(resolve(cwd, "package.json"), "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.name === "string" && parsed.name.length > 0) return parsed.name;
+		return null;
+	} catch {
+		return null;
+	}
+}
+function detectGitRepository(cwd = process.cwd()) {
+	try {
+		const url = execSync("git config --get remote.origin.url", {
+			cwd,
+			encoding: "utf8"
+		}).trim();
+		if (!url) return null;
+		return url.replace(/\.git$/u, "").replace(/^git@[^:]+:/u, "").replace(/^https?:\/\/[^/]+\//u, "").replace(/^ssh:\/\/[^/]+\//u, "") || null;
+	} catch {
+		return null;
+	}
+}
+function detectGitDefaultBranch(cwd = process.cwd()) {
+	try {
+		const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
+			cwd,
+			encoding: "utf8"
+		}).trim();
+		const match = /refs\/remotes\/origin\/(?<branch>.+)/u.exec(ref);
+		if (match?.[1]) return match[1];
+	} catch {}
+	try {
+		const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+			cwd,
+			encoding: "utf8"
+		}).trim();
+		if (branch && branch !== "HEAD") return branch;
+	} catch {}
+	return null;
+}
+//#endregion
+export { assertStorybookMain, detectGitDefaultBranch, detectGitRepository, detectPackageName, detectStorybookMeta, findStorybookMain, loadStorybookConfig, storybookConfigSchema, writeStorybookConfig };

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+import { runCreate } from "./commands/create.js";
+import { runUpload } from "./commands/upload.js";
+import { handleError, runDefaultCommand } from "./commands/default.js";
+import { runInit } from "./commands/init.js";
+import { runPurge } from "./commands/purge.js";
+import { runRetry } from "./commands/retry.js";
+import { runServerInit } from "./commands/server/init.js";
+import { Command } from "commander";
+import { pathToFileURL } from "node:url";
+//#region src/index.ts
+function run(fn) {
+	return async (args) => {
+		await fn(args).catch(handleError);
+	};
+}
+function buildInitCommand() {
+	return new Command("init").description("Initialize Storybook project with .storybook/storyshelf.json (client config)").option("--url <url>", "server base URL").option("--slug <slug>", "project slug").option("--build-dir <dir>", "built Storybook directory (default storybook-static)").option("--build-command <cmd>", "build command (e.g. \"npm run build-storybook\")").option("--build-script-name <name>", "npm script to build Storybook (default build-storybook)").option("--skip <glob>", "skip upload for matching branch (glob)").option("-c, --config <path>", "config file path (default .storybook/storyshelf.json)").option("--token <token>", "auth token for sync (or STORYSHELF_TOKEN/STORYSHELF_ADMIN_TOKEN env)").action(run(runInit));
+}
+function buildCreateCommand() {
+	return new Command("create").description("Create a project on StoryShelf server (requires admin token)").option("--url <url>", "server base URL").option("--name <name>", "project name").option("--token <token>", "admin token (or STORYSHELF_ADMIN_TOKEN env)").action(run(runCreate));
+}
+function buildServerCommand() {
+	const server = new Command("server").description("Server operations");
+	server.command("init").description("Scaffold a new StoryShelf server project").option("--dir <dir>", "output directory").action(run(runServerInit));
+	return server;
+}
+function buildPurgeCommand() {
+	return new Command("purge").description("Purge expired builds on a StoryShelf server").requiredOption("--url <url>", "server base URL").option("--token <token>", "admin token (or STORYSHELF_ADMIN_TOKEN env)").action(run(runPurge));
+}
+function buildUploadCommand() {
+	return new Command("upload").description("Create a build record for a StoryShelf project").option("--url <url>", "server base URL (or .storybook/storyshelf.json)").option("--slug <slug>", "project slug (or .storybook/storyshelf.json)").option("--token <token>", "CI token (or STORYSHELF_TOKEN env)").option("--sha <sha>", "git sha (or GITHUB_SHA env)").option("--branch <branch>", "git branch (or GITHUB_REF_NAME env)").option("--build-dir <dir>", "built Storybook directory (default storybook-static)").option("-c, --config <path>", "config file path (default .storybook/storyshelf.json)").option("--build-command <cmd>", "build command to run if buildDir missing/empty").option("--build-script-name <name>", "npm script to build Storybook (default build-storybook)").option("--force-build", "force rebuild even if buildDir exists").option("--skip <glob>", "skip upload for matching branch (glob)").option("--message <message>", "commit message").option("--author-email <email>", "author email").option("--author-name <name>", "author name").option("--label <key=value>", "build label (repeatable: --label pr=123)", (value, previous) => [...previous, value], []).action(run(runUpload));
+}
+function buildRetryCommand() {
+	return new Command("retry").description("Retry a failed StoryShelf build").requiredOption("--url <url>", "server base URL").requiredOption("--slug <slug>", "project slug").requiredOption("--build-id <id>", "build id").option("--token <token>", "CI token (or STORYSHELF_TOKEN env)").action(run(runRetry));
+}
+/**
+* Build the StoryShelf CLI program with all subcommands registered.
+*
+* @returns The configured commander Command instance.
+*/
+function createProgram() {
+	const program = new Command();
+	program.name("storyshelf").description("Self-hosted visual testing for Storybook.").version("0.2.0");
+	program.addCommand(buildInitCommand());
+	program.addCommand(buildCreateCommand());
+	program.addCommand(buildServerCommand());
+	program.addCommand(buildPurgeCommand());
+	program.addCommand(buildUploadCommand());
+	program.addCommand(buildRetryCommand());
+	return program;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	const program = createProgram();
+	if (process.argv.length <= 2) await runDefaultCommand(program);
+	else program.parse(process.argv);
+}
+//#endregion
+export { createProgram };

package/dist/output.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/output.ts
+function printLine(message) {
+	process.stdout.write(`${message}\n`);
+}
+function printError(message) {
+	process.stderr.write(`${message}\n`);
+}
+const spinnerFrames = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+function createSpinner(message, frames = spinnerFrames) {
+	let frame = 0;
+	const interval = setInterval(() => {
+		process.stdout.write(`\r${frames[frame % frames.length]} ${message}`);
+		frame += 1;
+	}, 80);
+	return { stop: (finalMessage) => {
+		clearInterval(interval);
+		if (finalMessage) process.stdout.write(`\r${finalMessage}\n`);
+		else process.stdout.write("\r");
+	} };
+}
+//#endregion
+export { createSpinner, printError, printLine, spinnerFrames };