create-composure-app 1.0.0

package/src/steps/rewrite-package-names.ts

@@ -0,0 +1,59 @@
+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: string,
+  projectName: string,
+): string {
+  return content.replace(/@template\//g, `@${projectName}/`);
+}
+
+/**
+ * Walk a directory tree and find all package.json files.
+ */
+function findPackageJsonFiles(dir: string): string[] {
+  const results: string[] = [];
+
+  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: string): Promise<void> {
+  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/src/steps/scaffold-tier.ts

@@ -0,0 +1,172 @@
+import { resolve } from "node:path";
+import { rmSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+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 async function scaffoldTier(
+  projectName: string,
+  tier: InstallTier,
+): Promise<{ removed: string[] }> {
+  const root = resolve(process.cwd(), projectName);
+  const removed: string[] = [];
+
+  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: string, includeMobile: boolean): void {
+  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/src/steps/validate-license.ts

@@ -0,0 +1,181 @@
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
+
+export type TemplatePlan = "free" | "pro" | "enterprise";
+
+export interface LicenseInfo {
+  valid: boolean;
+  plan: TemplatePlan;
+  email: string;
+  features: string[];
+}
+
+const COMPOSURE_DIR = join(homedir(), ".composure");
+const CREDENTIALS_PATH = join(COMPOSURE_DIR, "credentials.json");
+const TOKEN_SCRIPT = join(COMPOSURE_DIR, "bin", "composure-token.mjs");
+
+/**
+ * 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 async function validateLicense(
+  token: string | undefined,
+): Promise<LicenseInfo> {
+  // Method 1: Composure credentials (preferred)
+  if (existsSync(CREDENTIALS_PATH)) {
+    return validateViaComposure();
+  }
+
+  // Method 2: Legacy token flag
+  if (token) {
+    return validateViaToken(token);
+  }
+
+  throw new Error(
+    "Not authenticated. Log in with Composure first:\n" +
+      "  Run: /composure:auth login\n\n" +
+      "Or use a license token:\n" +
+      "  npx create-composure-app --token=<your-token>\n\n" +
+      "Get a license at https://composure-pro.com/template",
+  );
+}
+
+/**
+ * Validate using Composure's composure-token.mjs CLI
+ */
+async function validateViaComposure(): Promise<LicenseInfo> {
+  // Check if composure-token.mjs exists
+  if (!existsSync(TOKEN_SCRIPT)) {
+    throw new Error(
+      "Composure CLI not found. Install Composure first:\n" +
+        "  claude plugin install composure@composure-suite\n" +
+        "  Then: /composure:auth login",
+    );
+  }
+
+  try {
+    // Step 1: Validate token is current (handles refresh automatically)
+    const validateOutput = execFileSync("node", [TOKEN_SCRIPT, "validate"], {
+      encoding: "utf8",
+      timeout: 15000,
+    }).trim();
+
+    // Output format: "valid:{plan}:{email}" or "expired" or "not-authenticated"
+    if (validateOutput === "not-authenticated") {
+      throw new Error("Not authenticated. Run: /composure:auth login");
+    }
+    if (validateOutput === "expired") {
+      throw new Error(
+        "Session expired. Run: /composure:auth login to refresh.",
+      );
+    }
+
+    const parts = validateOutput.split(":");
+    if (parts[0] !== "valid" || parts.length < 3) {
+      throw new Error(`Unexpected validation response: ${validateOutput}`);
+    }
+
+    const plan = normalizePlan(parts[1]);
+    const email = parts.slice(2).join(":"); // email may contain colons (unlikely but safe)
+
+    // Step 2: Get full license info (features, etc.)
+    let features: string[] = [];
+    try {
+      const licenseOutput = execFileSync(
+        "node",
+        [TOKEN_SCRIPT, "license"],
+        { encoding: "utf8", timeout: 15000 },
+      ).trim();
+      const licenseData = JSON.parse(licenseOutput);
+      features = licenseData.features ?? [];
+    } catch {
+      // License endpoint unavailable — proceed with plan-based features
+      features = getDefaultFeatures(plan);
+    }
+
+    return { valid: true, plan, email, features };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Not authenticated")) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("Session expired")) {
+      throw error;
+    }
+    throw new Error(
+      `License validation failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+/**
+ * Validate using legacy token (standalone license server)
+ */
+async function validateViaToken(token: string): Promise<LicenseInfo> {
+  const LICENSE_SERVER =
+    process.env.TEMPLATE_LICENSE_SERVER ?? "https://composure-pro.com";
+
+  const response = await fetch(`${LICENSE_SERVER}/api/v1/license/validate`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    const body = await response
+      .json()
+      .catch(() => ({ message: "Unknown error" }));
+    throw new Error(
+      `License validation failed: ${(body as { message?: string }).message ?? response.statusText}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    plan?: string;
+    email?: string;
+    features?: string[];
+  };
+
+  return {
+    valid: true,
+    plan: normalizePlan(data.plan),
+    email: data.email ?? "unknown",
+    features: data.features ?? getDefaultFeatures(normalizePlan(data.plan)),
+  };
+}
+
+/**
+ * Normalize plan string to TemplatePlan
+ */
+function normalizePlan(plan: string | undefined): TemplatePlan {
+  switch (plan?.toLowerCase()) {
+    case "enterprise":
+      return "enterprise";
+    case "pro":
+      return "pro";
+    default:
+      return "free";
+  }
+}
+
+/**
+ * Default features by plan when license endpoint doesn't return them
+ */
+function getDefaultFeatures(plan: TemplatePlan): string[] {
+  switch (plan) {
+    case "enterprise":
+      return ["starter", "pro", "mobile", "support"];
+    case "pro":
+      return ["starter", "pro", "mobile"];
+    case "free":
+    default:
+      return ["starter", "mobile"];
+  }
+}

package/src/steps/validate-target.ts

@@ -0,0 +1,21 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+export async function validateTarget(projectName: string): Promise<void> {
+  if (!/^[a-z0-9-_]+$/i.test(projectName)) {
+    throw new Error(
+      `Invalid project name "${projectName}". Use letters, numbers, dashes, and underscores only.`,
+    );
+  }
+
+  const targetPath = resolve(process.cwd(), projectName);
+
+  if (existsSync(targetPath)) {
+    const contents = readdirSync(targetPath);
+    if (contents.length > 0) {
+      throw new Error(
+        `Target directory "${projectName}" exists and is not empty. Refusing to overwrite.`,
+      );
+    }
+  }
+}

package/tests/e2e.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { execSync } from "node:child_process";
+import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const CLI_PATH = resolve(__dirname, "../dist/index.js");
+
+describe("create-composure-app E2E", () => {
+  let tempDir: string;
+
+  afterEach(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("creates a project in dev mode with --skip-install", async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "cta-e2e-"));
+    const projectName = "test-project";
+
+    execSync(
+      `node "${CLI_PATH}" ${projectName} --dev --skip-install`,
+      { cwd: tempDir, timeout: 120_000 },
+    );
+
+    const projectPath = join(tempDir, projectName);
+    expect(existsSync(projectPath)).toBe(true);
+
+    // Verify package.json was rewritten
+    const pkg = JSON.parse(
+      readFileSync(join(projectPath, "package.json"), "utf-8"),
+    );
+    expect(pkg.name).toBe(projectName);
+
+    // Verify @template/* was replaced
+    const content = readFileSync(join(projectPath, "package.json"), "utf-8");
+    expect(content).not.toContain("@template/");
+
+    // Verify git was initialized
+    expect(existsSync(join(projectPath, ".git"))).toBe(true);
+  }, 120_000);
+
+  it("refuses to overwrite a non-empty directory", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "cta-e2e-"));
+    const projectName = "existing";
+    const projectPath = join(tempDir, projectName);
+
+    // Create non-empty directory
+    execSync(`mkdir -p "${projectPath}" && touch "${projectPath}/README.md"`);
+
+    expect(() =>
+      execSync(
+        `node "${CLI_PATH}" ${projectName} --dev --skip-install`,
+        { cwd: tempDir, stdio: "pipe" },
+      ),
+    ).toThrow();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}