create-composure-app 1.0.0

package/dist/commands/create.d.ts

@@ -0,0 +1,8 @@
+export interface CreateOptions {
+    token?: string;
+    cleanMigrations?: boolean;
+    skipInstall?: boolean;
+    dev?: boolean;
+    tier?: string;
+}
+export declare function createCommand(name: string | undefined, options: CreateOptions): Promise<void>;

package/dist/commands/create.js

@@ -0,0 +1,89 @@
+import kleur from "kleur";
+import ora from "ora";
+import { validateTarget } from "../steps/validate-target.js";
+import { validateLicense } from "../steps/validate-license.js";
+import { downloadTemplate } from "../steps/download-template.js";
+import { rewritePackageNames } from "../steps/rewrite-package-names.js";
+import { resetMigrations } from "../steps/reset-migrations.js";
+import { scaffoldTier } from "../steps/scaffold-tier.js";
+import { initGit } from "../steps/init-git.js";
+import { installDeps } from "../steps/install-deps.js";
+import { printNextSteps } from "../steps/print-next-steps.js";
+import { promptProjectName, promptInstallTier } from "../lib/prompts.js";
+import { logger } from "../lib/logger.js";
+export async function createCommand(name, options) {
+    logger.info(kleur.bold().blue("\n  create-composure-app\n"));
+    try {
+        const projectName = name ?? (await promptProjectName());
+        await validateTarget(projectName);
+        // ── License validation ──────────────────────────────────
+        let tier;
+        if (options.dev) {
+            logger.warn("Dev mode — skipping license validation");
+            // In dev mode, allow tier flag or prompt
+            tier = options.tier ?? (await promptInstallTier("enterprise"));
+        }
+        else {
+            const spinner = ora("Validating license...").start();
+            const license = await validateLicense(options.token);
+            spinner.succeed(`License validated — ${kleur.green(license.plan)} plan (${license.email})`);
+            // ── Interactive tier selection ──────────────────────────
+            logger.info("");
+            tier = options.tier ?? (await promptInstallTier(license.plan));
+        }
+        const includeMobile = tier === "starter-mobile" || tier === "pro-mobile";
+        const includePro = tier === "pro" || tier === "pro-mobile";
+        logger.info(`\n  ${kleur.bold("Selected:")} ${tierLabel(tier)}\n`);
+        // ── Download ──────────────────────────────────────────────
+        const downloadSpinner = ora("Downloading template...").start();
+        await downloadTemplate(projectName, options.token, options.dev);
+        downloadSpinner.succeed("Template downloaded");
+        // ── Scaffold tier (remove unused files) ──────────────────
+        const scaffoldSpinner = ora("Scaffolding for selected tier...").start();
+        const { removed } = await scaffoldTier(projectName, tier);
+        if (removed.length > 0) {
+            scaffoldSpinner.succeed(`Scaffolded — removed ${removed.length} items not in ${tierLabel(tier)}`);
+        }
+        else {
+            scaffoldSpinner.succeed("Full template installed");
+        }
+        // ── Personalize ──────────────────────────────────────────
+        const rewriteSpinner = ora("Personalizing project...").start();
+        await rewritePackageNames(projectName);
+        rewriteSpinner.succeed("Project personalized");
+        // ── Migrations ───────────────────────────────────────────
+        if (options.cleanMigrations) {
+            const migSpinner = ora("Resetting migrations...").start();
+            await resetMigrations(projectName);
+            migSpinner.succeed("Migrations reset");
+        }
+        // ── Git ──────────────────────────────────────────────────
+        const gitSpinner = ora("Initializing git...").start();
+        await initGit(projectName);
+        gitSpinner.succeed("Git initialized");
+        // ── Dependencies ─────────────────────────────────────────
+        if (!options.skipInstall) {
+            const installSpinner = ora("Installing dependencies (this may take a minute)...").start();
+            await installDeps(projectName);
+            installSpinner.succeed("Dependencies installed");
+        }
+        // ── Summary ──────────────────────────────────────────────
+        printNextSteps(projectName, { includeMobile, includePro });
+    }
+    catch (error) {
+        logger.error(`\nFailed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+function tierLabel(tier) {
+    switch (tier) {
+        case "starter":
+            return "Starter (Web)";
+        case "starter-mobile":
+            return "Starter + Mobile";
+        case "pro":
+            return "Pro (Web)";
+        case "pro-mobile":
+            return "Pro + Mobile";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createCommand } from "./commands/create.js";
+const program = new Command();
+program
+    .name("create-composure-app")
+    .description("Scaffold a new Composure Template project — multi-tenant Next.js + Supabase + Expo")
+    .version("1.0.0");
+program
+    .argument("[name]", "Project name")
+    .option("-t, --token <token>", "OAuth license token (or use Composure login)")
+    .option("--tier <tier>", "Install tier: starter, starter-mobile, pro, pro-mobile")
+    .option("--clean-migrations", "Reset migrations to a single baseline", false)
+    .option("--skip-install", "Skip pnpm install step", false)
+    .option("--dev", "Development mode — skips license validation", false)
+    .action(createCommand);
+program.parse();

package/dist/lib/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};

package/dist/lib/logger.js

@@ -0,0 +1,7 @@
+import kleur from "kleur";
+export const logger = {
+    info: (msg) => console.log(kleur.blue(msg)),
+    success: (msg) => console.log(kleur.green(msg)),
+    warn: (msg) => console.log(kleur.yellow(msg)),
+    error: (msg) => console.error(kleur.red(msg)),
+};

package/dist/lib/prompts.d.ts

@@ -0,0 +1,9 @@
+import type { TemplatePlan } from "../steps/validate-license.js";
+export declare function promptProjectName(): Promise<string>;
+export declare function promptConfirm(message: string): Promise<boolean>;
+export type InstallTier = "starter" | "starter-mobile" | "pro" | "pro-mobile";
+/**
+ * Prompt the user to select their install tier.
+ * Enterprise users see all options. Free users see starter options only.
+ */
+export declare function promptInstallTier(plan: TemplatePlan): Promise<InstallTier>;

package/dist/lib/prompts.js

@@ -0,0 +1,85 @@
+import prompts from "prompts";
+export async function promptProjectName() {
+    const { name } = await prompts({
+        type: "text",
+        name: "name",
+        message: "Project name",
+        validate: (value) => /^[a-z0-9-_]+$/i.test(value) || "Use letters, numbers, dashes, and underscores only",
+    });
+    if (!name) {
+        throw new Error("Project name is required.");
+    }
+    return name;
+}
+export async function promptConfirm(message) {
+    const { confirmed } = await prompts({
+        type: "confirm",
+        name: "confirmed",
+        message,
+        initial: true,
+    });
+    return confirmed ?? false;
+}
+const ALL_TIERS = [
+    {
+        title: "Starter (Web only)",
+        value: "starter",
+        description: "Auth, accounts, users, contacts, settings, team",
+    },
+    {
+        title: "Starter + Mobile",
+        value: "starter-mobile",
+        description: "Starter + Expo app with 3 tenant tab layouts",
+    },
+    {
+        title: "Pro (Web only)",
+        value: "pro",
+        description: "All 30 tables, all screens, CRM, inbox, workflows, AI, commerce",
+    },
+    {
+        title: "Pro + Mobile",
+        value: "pro-mobile",
+        description: "Everything + Expo mobile app",
+    },
+];
+/**
+ * Get available tiers based on license plan.
+ *
+ * - enterprise: all tiers
+ * - pro: all tiers
+ * - free: starter tiers only
+ */
+function getAvailableTiers(plan) {
+    switch (plan) {
+        case "enterprise":
+        case "pro":
+            return ALL_TIERS;
+        case "free":
+        default:
+            return ALL_TIERS.filter((t) => t.value === "starter" || t.value === "starter-mobile");
+    }
+}
+/**
+ * Prompt the user to select their install tier.
+ * Enterprise users see all options. Free users see starter options only.
+ */
+export async function promptInstallTier(plan) {
+    const available = getAvailableTiers(plan);
+    // If enterprise with only one sensible choice, still show the prompt
+    // so internal users can choose web-only vs web+mobile
+    const { tier } = await prompts({
+        type: "select",
+        name: "tier",
+        message: "What would you like to install?",
+        choices: available.map((t) => ({
+            title: t.title,
+            value: t.value,
+            description: t.description,
+        })),
+        initial: available.length - 1, // Default to the highest tier available
+    });
+    if (!tier) {
+        throw new Error("Installation cancelled.");
+    }
+    return tier;
+}

package/dist/steps/download-template.d.ts

@@ -0,0 +1 @@
+export declare function downloadTemplate(projectName: string, token?: string, devMode?: boolean): Promise<void>;

package/dist/steps/download-template.js

@@ -0,0 +1,38 @@
+import { execFileSync } from "node:child_process";
+import { resolve, basename } from "node:path";
+const TEMPLATE_REPO = process.env.TEMPLATE_REPO_URL ?? "https://github.com/hrconsultnj/template-monorepo.git";
+export async function downloadTemplate(projectName, token, devMode) {
+    // Defense-in-depth: ensure projectName is just a directory name, no path traversal
+    if (basename(projectName) !== projectName) {
+        throw new Error(`Invalid project name: "${projectName}" contains path separators.`);
+    }
+    const targetPath = resolve(process.cwd(), projectName);
+    if (devMode) {
+        // execFileSync bypasses the shell — no injection possible
+        execFileSync("git", [
+            "clone", "--depth=1", "--single-branch", TEMPLATE_REPO, targetPath,
+        ], { stdio: "pipe" });
+        return;
+    }
+    // Production mode: download tarball from license server
+    const LICENSE_SERVER = process.env.TEMPLATE_LICENSE_SERVER ?? "https://composure-pro.com";
+    const response = await fetch(`${LICENSE_SERVER}/download`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Download failed: ${response.statusText}`);
+    }
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    mkdirSync(targetPath, { recursive: true });
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const tarballPath = resolve(targetPath, ".template.tar.gz");
+    writeFileSync(tarballPath, buffer);
+    // --no-absolute-names prevents path traversal in tarball entries
+    execFileSync("tar", [
+        "xzf", ".template.tar.gz", "--strip-components=1", "--no-absolute-names",
+    ], { cwd: targetPath, stdio: "pipe" });
+    const { unlinkSync } = await import("node:fs");
+    unlinkSync(tarballPath);
+}

package/dist/steps/init-git.d.ts

@@ -0,0 +1 @@
+export declare function initGit(projectName: string): Promise<void>;

package/dist/steps/init-git.js

@@ -0,0 +1,12 @@
+import { execSync } from "node:child_process";
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+export async function initGit(projectName) {
+    const targetPath = resolve(process.cwd(), projectName);
+    // Remove the cloned .git directory
+    rmSync(resolve(targetPath, ".git"), { recursive: true, force: true });
+    // Initialize fresh git repo
+    execSync("git init", { cwd: targetPath, stdio: "pipe" });
+    execSync("git add -A", { cwd: targetPath, stdio: "pipe" });
+    execSync('git commit -m "chore: initial commit from create-composure-app"', { cwd: targetPath, stdio: "pipe" });
+}

package/dist/steps/install-deps.d.ts

@@ -0,0 +1 @@
+export declare function installDeps(projectName: string): Promise<void>;

package/dist/steps/install-deps.js

@@ -0,0 +1,6 @@
+import { execSync } from "node:child_process";
+import { resolve } from "node:path";
+export async function installDeps(projectName) {
+    const targetPath = resolve(process.cwd(), projectName);
+    execSync("pnpm install", { cwd: targetPath, stdio: "pipe" });
+}

package/dist/steps/print-next-steps.d.ts

@@ -0,0 +1,6 @@
+interface NextStepsOptions {
+    includeMobile?: boolean;
+    includePro?: boolean;
+}
+export declare function printNextSteps(projectName: string, options?: NextStepsOptions): void;
+export {};

package/dist/steps/print-next-steps.js

@@ -0,0 +1,39 @@
+import kleur from "kleur";
+export function printNextSteps(projectName, options = {}) {
+    const { includeMobile = false, includePro = false } = options;
+    const name = kleur.cyan(projectName);
+    const features = [
+        `- ${kleur.blue("Web app")} — Next.js 16 + Tailwind + shadcn`,
+        `- ${kleur.blue("Database")} — Supabase + typed queries + RLS`,
+        `- ${kleur.blue("3 tenant types")} — Admin / Workspace / Portal`,
+        `- ${kleur.blue("Auth")} — Contact-first signup + multi-account`,
+    ];
+    if (includeMobile) {
+        features.push(`- ${kleur.blue("Mobile app")} — Expo SDK 55 + React Native`);
+    }
+    if (includePro) {
+        features.push(`- ${kleur.blue("CRM")} — Tasks, deals, pipelines`, `- ${kleur.blue("Inbox")} — Threads, compose, reply`, `- ${kleur.blue("AI")} — Agents, memory graph, thinking`, `- ${kleur.blue("Commerce")} — Invoices, quotes, payments`, `- ${kleur.blue("Workflows")} — Visual automation engine`);
+    }
+    console.log(`
+${kleur.green().bold("Your project is ready!")}
+
+${kleur.bold("Next steps:")}
+  ${kleur.gray("$")} cd ${name}
+  ${kleur.gray("$")} pnpm supabase start
+  ${kleur.gray("$")} pnpm dev
+
+${kleur.bold("First-time setup:")}
+  1. Copy ${kleur.yellow(".env.example")} to ${kleur.yellow(".env")}
+  2. Fill in your Supabase keys
+  3. Run ${kleur.yellow(`pnpm --filter @${projectName}/database db:types`)} after migrations apply
+  4. Visit ${kleur.underline("http://localhost:3000")} to sign up
+
+${kleur.bold("What's included:")}
+${features.map((f) => `  ${f}`).join("\n")}
+${!includePro ? `\n${kleur.yellow("Upgrade to Pro for CRM, inbox, workflows, AI, and commerce.")}` : ""}
+${!includeMobile ? `\n${kleur.yellow("Add mobile with the + Mobile tier for Expo SDK 55 support.")}` : ""}
+
+${kleur.gray("Docs: https://composure-pro.com/template/docs")}
+${kleur.gray("Support: support@composure-pro.com")}
+`);
+}

package/dist/steps/reset-migrations.d.ts

@@ -0,0 +1 @@
+export declare function resetMigrations(projectName: string): Promise<void>;

package/dist/steps/reset-migrations.js

@@ -0,0 +1,23 @@
+import { readdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { resolve, join } from "node:path";
+export async function resetMigrations(projectName) {
+    const migrationsDir = resolve(process.cwd(), projectName, "supabase/migrations");
+    const files = readdirSync(migrationsDir)
+        .filter((f) => f.endsWith(".sql"))
+        .sort();
+    if (files.length <= 1)
+        return; // Already a single migration
+    // Concatenate all migrations into one baseline
+    let combined = "-- Baseline migration generated by create-composure-app --clean-migrations\n\n";
+    for (const file of files) {
+        combined += `-- Source: ${file}\n`;
+        combined += readFileSync(join(migrationsDir, file), "utf-8");
+        combined += "\n\n";
+    }
+    // Delete all existing migrations
+    for (const file of files) {
+        unlinkSync(join(migrationsDir, file));
+    }
+    // Write the combined baseline
+    writeFileSync(join(migrationsDir, "20260101000001_init.sql"), combined, "utf-8");
+}

package/dist/steps/rewrite-package-names.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pure function: rewrite @template/* references in a package.json string.
+ * Exported separately for unit testing.
+ */
+export declare function rewritePackageJsonContent(content: string, projectName: string): string;
+/**
+ * Rewrite all @template/* references to @<projectName>/* across the project.
+ */
+export declare function rewritePackageNames(projectName: string): Promise<void>;

package/dist/steps/rewrite-package-names.js

@@ -0,0 +1,51 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { readdirSync, statSync } from "node:fs";
+/**
+ * Pure function: rewrite @template/* references in a package.json string.
+ * Exported separately for unit testing.
+ */
+export function rewritePackageJsonContent(content, projectName) {
+    return content.replace(/@template\//g, `@${projectName}/`);
+}
+/**
+ * Walk a directory tree and find all package.json files.
+ */
+function findPackageJsonFiles(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir)) {
+        if (entry === "node_modules" || entry === ".git")
+            continue;
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            results.push(...findPackageJsonFiles(fullPath));
+        }
+        else if (entry === "package.json") {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+/**
+ * Rewrite all @template/* references to @<projectName>/* across the project.
+ */
+export async function rewritePackageNames(projectName) {
+    const targetPath = resolve(process.cwd(), projectName);
+    const packageFiles = findPackageJsonFiles(targetPath);
+    for (const file of packageFiles) {
+        const content = readFileSync(file, "utf-8");
+        if (content.includes("@template/")) {
+            const rewritten = rewritePackageJsonContent(content, projectName);
+            writeFileSync(file, rewritten, "utf-8");
+        }
+    }
+    // Also rewrite the root package.json name
+    const rootPkg = resolve(targetPath, "package.json");
+    const rootContent = readFileSync(rootPkg, "utf-8");
+    const parsed = JSON.parse(rootContent);
+    if (parsed.name === "template-monorepo") {
+        parsed.name = projectName;
+        writeFileSync(rootPkg, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+    }
+}

package/dist/steps/rewrite-package-names.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/steps/rewrite-package-names.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { rewritePackageJsonContent } from "./rewrite-package-names.js";
+describe("rewritePackageJsonContent", () => {
+    it("replaces @template/* references with project name", () => {
+        const input = JSON.stringify({
+            name: "@template/web",
+            dependencies: {
+                "@template/database": "workspace:*",
+                "@template/shared": "workspace:*",
+            },
+        });
+        const output = rewritePackageJsonContent(input, "my-app");
+        const parsed = JSON.parse(output);
+        expect(parsed.name).toBe("@my-app/web");
+        expect(parsed.dependencies["@my-app/database"]).toBe("workspace:*");
+        expect(parsed.dependencies["@my-app/shared"]).toBe("workspace:*");
+    });
+    it("preserves non-template dependencies", () => {
+        const input = JSON.stringify({
+            dependencies: { react: "^19.0.0", "@template/database": "workspace:*" },
+        });
+        const output = rewritePackageJsonContent(input, "acme");
+        const parsed = JSON.parse(output);
+        expect(parsed.dependencies.react).toBe("^19.0.0");
+        expect(parsed.dependencies["@acme/database"]).toBe("workspace:*");
+    });
+    it("handles content with no @template/ references", () => {
+        const input = JSON.stringify({ name: "plain-package", version: "1.0.0" });
+        const output = rewritePackageJsonContent(input, "my-app");
+        expect(output).toBe(input);
+    });
+});

package/dist/steps/scaffold-tier.d.ts

@@ -0,0 +1,13 @@
+import type { InstallTier } from "../lib/prompts.js";
+/**
+ * Remove files and folders that don't belong in the selected tier.
+ *
+ * Tier hierarchy:
+ *   starter       → core web only
+ *   starter-mobile → core web + mobile
+ *   pro           → all web features
+ *   pro-mobile    → all web features + mobile
+ */
+export declare function scaffoldTier(projectName: string, tier: InstallTier): Promise<{
+    removed: string[];
+}>;

package/dist/steps/scaffold-tier.js

@@ -0,0 +1,141 @@
+import { resolve } from "node:path";
+import { rmSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+/**
+ * Remove files and folders that don't belong in the selected tier.
+ *
+ * Tier hierarchy:
+ *   starter       → core web only
+ *   starter-mobile → core web + mobile
+ *   pro           → all web features
+ *   pro-mobile    → all web features + mobile
+ */
+export async function scaffoldTier(projectName, tier) {
+    const root = resolve(process.cwd(), projectName);
+    const removed = [];
+    const includeMobile = tier === "starter-mobile" || tier === "pro-mobile";
+    const includePro = tier === "pro" || tier === "pro-mobile";
+    // ── Remove mobile app if not included ───────────────────────
+    if (!includeMobile) {
+        const mobilePath = resolve(root, "apps/mobile");
+        if (existsSync(mobilePath)) {
+            rmSync(mobilePath, { recursive: true, force: true });
+            removed.push("apps/mobile");
+        }
+        // Remove mobile from pnpm-workspace.yaml
+        updateWorkspaceYaml(root, false);
+    }
+    // ── Remove pro features if starter tier ─────────────────────
+    if (!includePro) {
+        // Pro-only route pages (workspace)
+        const proWorkspaceRoutes = [
+            "inbox",
+            "events",
+            "timecards",
+            "forms",
+            "templates",
+            "commercial",
+            "connected-services",
+            "documents",
+            "tags",
+        ];
+        for (const route of proWorkspaceRoutes) {
+            const routePath = resolve(root, `apps/web/app/(protected)/(tenant)/workspace/[id_prefix]/${route}`);
+            if (existsSync(routePath)) {
+                rmSync(routePath, { recursive: true, force: true });
+                removed.push(`workspace/${route}`);
+            }
+        }
+        // Pro-only route pages (admin)
+        const proAdminRoutes = [
+            "broadcasts",
+            "ai-agents",
+            "integrations",
+        ];
+        for (const route of proAdminRoutes) {
+            const routePath = resolve(root, `apps/web/app/(protected)/(internal)/admin/[id_prefix]/${route}`);
+            if (existsSync(routePath)) {
+                rmSync(routePath, { recursive: true, force: true });
+                removed.push(`admin/${route}`);
+            }
+        }
+        // Pro-only route pages (portal)
+        const proPortalRoutes = [
+            "documents",
+            "messages",
+            "invoices",
+        ];
+        for (const route of proPortalRoutes) {
+            const routePath = resolve(root, `apps/web/app/(protected)/(external)/portal/[id_prefix]/${route}`);
+            if (existsSync(routePath)) {
+                rmSync(routePath, { recursive: true, force: true });
+                removed.push(`portal/${route}`);
+            }
+        }
+        // Pro-only components
+        const proComponents = [
+            "inbox",
+            "events",
+            "timecards",
+            "forms",
+            "templates",
+            "commercial",
+            "connected-services",
+            "documents",
+            "tags",
+        ];
+        for (const component of proComponents) {
+            const componentPath = resolve(root, `apps/web/components/${component}`);
+            if (existsSync(componentPath)) {
+                rmSync(componentPath, { recursive: true, force: true });
+                removed.push(`components/${component}`);
+            }
+        }
+        // Pro-only migrations
+        const proMigrations = [
+            "20260101000012_docs.sql",
+            "20260101000013_inboxes.sql",
+            "20260101000014_inbox_threads.sql",
+            "20260101000015_inbox_messages.sql",
+            "20260101000016_events.sql",
+            "20260101000017_timecards.sql",
+            "20260101000020_docs_versions.sql",
+            "20260127000001_broadcasts.sql",
+            "20260127000002_ai_system.sql",
+            "20260127000003_inbox_seed.sql",
+            "20260128000001_document_payment_enums.sql",
+            "20260128000002_tags.sql",
+            "20260128000003_entity_documents.sql",
+            "20260128000004_entity_document_storage.sql",
+            "20260128000005_commercial_documents_enums.sql",
+            "20260128000006_commercial_documents.sql",
+            "20260128000007_payments.sql",
+            "20260403000001_ai_thinking_system.sql",
+            "20260409000001_connected_services.sql",
+        ];
+        for (const migration of proMigrations) {
+            const migrationPath = resolve(root, `supabase/migrations/${migration}`);
+            if (existsSync(migrationPath)) {
+                rmSync(migrationPath, { force: true });
+                removed.push(`migrations/${migration}`);
+            }
+        }
+    }
+    return { removed };
+}
+/**
+ * Update pnpm-workspace.yaml to include/exclude mobile
+ */
+function updateWorkspaceYaml(root, includeMobile) {
+    const workspacePath = resolve(root, "pnpm-workspace.yaml");
+    if (!existsSync(workspacePath))
+        return;
+    let content = readFileSync(workspacePath, "utf8");
+    if (!includeMobile) {
+        // Remove apps/mobile line
+        content = content
+            .split("\n")
+            .filter((line) => !line.includes("apps/mobile"))
+            .join("\n");
+        writeFileSync(workspacePath, content, "utf8");
+    }
+}

package/dist/steps/validate-license.d.ts

@@ -0,0 +1,17 @@
+export type TemplatePlan = "free" | "pro" | "enterprise";
+export interface LicenseInfo {
+    valid: boolean;
+    plan: TemplatePlan;
+    email: string;
+    features: string[];
+}
+/**
+ * Validate license via Composure's auth system.
+ *
+ * Priority:
+ *   1. --token flag (legacy, still supported)
+ *   2. ~/.composure/credentials.json (Composure login)
+ *
+ * Returns plan info used to determine available tiers.
+ */
+export declare function validateLicense(token: string | undefined): Promise<LicenseInfo>;