@01.software/init 0.9.2 → 0.10.1

package/dist/create-app.js

@@ -0,0 +1,652 @@
+#!/usr/bin/env node
+import {
+  startBrowserAuth
+} from "./chunk-STM4DKVZ.js";
+import {
+  writeEnvFile
+} from "./chunk-4LHYICUL.js";
+
+// src/create-app.ts
+import { execSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import pc from "picocolors";
+import prompts from "prompts";
+
+// src/template-registry.ts
+import fs from "fs";
+import path from "path";
+var REGISTRY_FILE_NAME = "registry.json";
+function readTemplateRegistry(registryDir) {
+  const file = path.join(registryDir, REGISTRY_FILE_NAME);
+  const registry = JSON.parse(fs.readFileSync(file, "utf-8"));
+  if (!Array.isArray(registry.templates) || registry.templates.length === 0) {
+    throw new Error(`Template registry has no templates: ${file}`);
+  }
+  if (!registry.sdk?.package) {
+    throw new Error(`Template registry is missing sdk.package: ${file}`);
+  }
+  for (const template of registry.templates) {
+    if (!template.paymentProviders?.length) {
+      throw new Error(
+        `Template "${template.name}" has no payment providers in ${file}`
+      );
+    }
+    if (!findPaymentProvider(template, template.defaultPaymentProvider)) {
+      throw new Error(
+        `Template "${template.name}" defaultPaymentProvider "${template.defaultPaymentProvider}" is not a registered provider in ${file}`
+      );
+    }
+    for (const feature of template.features ?? []) {
+      if (!feature.id || !feature.marker || !Array.isArray(feature.paths)) {
+        throw new Error(
+          `Template "${template.name}" has a malformed feature (needs id, marker, paths) in ${file}`
+        );
+      }
+    }
+  }
+  return registry;
+}
+function findTemplate(registry, name) {
+  return registry.templates.find((template) => template.name === name);
+}
+function findPaymentProvider(template, id) {
+  return template.paymentProviders.find((provider) => provider.id === id);
+}
+function findFeature(template, id) {
+  return template.features?.find((feature) => feature.id === id);
+}
+
+// src/create-app.ts
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+var PACKAGE_MANAGER_VALUES = new Set(PACKAGE_MANAGERS);
+var AUTH_VALUES = /* @__PURE__ */ new Set(["browser", "manual", "skip"]);
+async function createApp(rawOptions = {}, deps = {}) {
+  const options = await resolveOptions(rawOptions);
+  const projectDir = path2.resolve(options.projectDir);
+  const sourceDir = path2.join(options.templateRoot, options.template.dir);
+  if (!fs2.existsSync(sourceDir)) {
+    throw new Error(`Template not found: ${options.template.name}`);
+  }
+  assertTargetAvailable(projectDir);
+  fs2.mkdirSync(projectDir, { recursive: true });
+  copyTemplate(sourceDir, projectDir);
+  rewritePackageName(projectDir);
+  applyPaymentProvider(projectDir, options);
+  applyCustomerAccounts(projectDir, options);
+  writeAppConfig(projectDir, options);
+  writeEnvExample(projectDir, options);
+  let tenantName;
+  if (options.auth === "browser") {
+    const creds = await (deps.startBrowserAuth ?? startBrowserAuth)();
+    writeSdkEnv(projectDir, creds.publishableKey, creds.secretKey);
+    tenantName = creds.tenantName;
+  } else if (options.auth === "manual") {
+    writeSdkEnv(projectDir, options.publishableKey, options.secretKey);
+  }
+  let installed = false;
+  if (options.install) {
+    const cmd = installCommand(options.packageManager);
+    const runInstall = deps.runInstall ?? ((installCmd, cwd) => execSync(installCmd, { cwd, stdio: "inherit" }));
+    runInstall(cmd, projectDir);
+    installed = true;
+  }
+  return {
+    projectDir,
+    template: options.template.name,
+    paymentProvider: options.provider.id,
+    packageManager: options.packageManager,
+    installed,
+    tenantName
+  };
+}
+async function resolveOptions(raw) {
+  const onCancel = () => {
+    throw new Error("cancelled");
+  };
+  const templateRoot = raw.templateRoot ?? defaultTemplateRoot();
+  const registry = readTemplateRegistry(templateRoot);
+  let projectDir = raw.projectDir;
+  if (!projectDir) {
+    const { name } = await prompts(
+      {
+        type: "text",
+        name: "name",
+        message: "Project directory",
+        initial: "my-01-store"
+      },
+      { onCancel }
+    );
+    projectDir = name;
+  }
+  const template = await resolveTemplate(registry, raw.template, onCancel);
+  const provider = await resolveProvider(
+    template,
+    raw.paymentProvider,
+    onCancel
+  );
+  const customerAccounts = await resolveCustomerAccounts(
+    template,
+    raw.customerAccounts,
+    onCancel
+  );
+  let packageManager = raw.packageManager;
+  if (!packageManager) {
+    const { pm } = await prompts(
+      {
+        type: "select",
+        name: "pm",
+        message: "Package manager",
+        choices: PACKAGE_MANAGERS.map((value) => ({ title: value, value })),
+        initial: 0
+      },
+      { onCancel }
+    );
+    packageManager = pm;
+  }
+  let auth = raw.auth;
+  if (!auth) {
+    const { mode } = await prompts(
+      {
+        type: "select",
+        name: "mode",
+        message: "Connect to a 01.software tenant now?",
+        choices: [
+          { title: "Browser login (recommended)", value: "browser" },
+          { title: "Enter keys manually", value: "manual" },
+          { title: "Skip and use demo data", value: "skip" }
+        ],
+        initial: 0
+      },
+      { onCancel }
+    );
+    auth = mode;
+  }
+  let publishableKey = raw.publishableKey ?? "";
+  let secretKey = raw.secretKey ?? "";
+  if (auth === "manual" && (!publishableKey || !secretKey)) {
+    const keys = await prompts(
+      [
+        {
+          type: "text",
+          name: "publishableKey",
+          message: "NEXT_PUBLIC_SOFTWARE_PUBLISHABLE_KEY",
+          initial: publishableKey
+        },
+        {
+          type: "password",
+          name: "secretKey",
+          message: "SOFTWARE_SECRET_KEY",
+          initial: secretKey
+        }
+      ],
+      { onCancel }
+    );
+    publishableKey = keys.publishableKey ?? "";
+    secretKey = keys.secretKey ?? "";
+  }
+  if (!projectDir?.trim()) {
+    throw new Error("Project directory is required.");
+  }
+  projectDir = projectDir.trim();
+  if (!packageManager) {
+    throw new Error("Package manager is required.");
+  }
+  if (!auth) {
+    throw new Error("Auth mode is required.");
+  }
+  if (auth === "manual" && (!publishableKey.trim() || !secretKey.trim())) {
+    throw new Error(
+      "Manual auth requires NEXT_PUBLIC_SOFTWARE_PUBLISHABLE_KEY and SOFTWARE_SECRET_KEY. Use --auth skip for demo data."
+    );
+  }
+  return {
+    projectDir,
+    templateRoot,
+    registry,
+    template,
+    provider,
+    customerAccounts,
+    packageManager,
+    auth,
+    publishableKey,
+    secretKey,
+    install: raw.install ?? true
+  };
+}
+async function resolveTemplate(registry, requested, onCancel) {
+  if (requested) {
+    const template2 = findTemplate(registry, requested);
+    if (!template2) {
+      throw new Error(`Invalid template: ${requested}`);
+    }
+    return template2;
+  }
+  if (registry.templates.length === 1) {
+    return registry.templates[0];
+  }
+  const { selected } = await prompts(
+    {
+      type: "select",
+      name: "selected",
+      message: "Choose a starter",
+      choices: registry.templates.map((template2) => ({
+        title: template2.title,
+        value: template2.name
+      })),
+      initial: 0
+    },
+    { onCancel }
+  );
+  const template = findTemplate(registry, selected);
+  if (!template) {
+    throw new Error("Template is required.");
+  }
+  return template;
+}
+async function resolveProvider(template, requested, onCancel) {
+  if (requested) {
+    const provider2 = findPaymentProvider(template, requested);
+    if (!provider2) {
+      throw new Error(`Invalid payment provider: ${requested}`);
+    }
+    return provider2;
+  }
+  if (template.paymentProviders.length === 1) {
+    return template.paymentProviders[0];
+  }
+  const { selected } = await prompts(
+    {
+      type: "select",
+      name: "selected",
+      message: "Choose a payment provider",
+      choices: template.paymentProviders.map((provider2) => ({
+        title: provider2.label,
+        value: provider2.id
+      })),
+      initial: defaultProviderIndex(template)
+    },
+    { onCancel }
+  );
+  const provider = findPaymentProvider(template, selected);
+  if (!provider) {
+    throw new Error("Payment provider is required.");
+  }
+  return provider;
+}
+async function resolveCustomerAccounts(template, requested, onCancel) {
+  const feature = findFeature(template, "customer-accounts");
+  if (!feature) return false;
+  if (requested !== void 0) return requested;
+  if (!process.stdin.isTTY) return feature.defaultEnabled ?? false;
+  const { include } = await prompts(
+    {
+      type: "confirm",
+      name: "include",
+      message: `Include ${feature.label}? Requires a starter+ plan; guest checkout works without it.`,
+      initial: feature.defaultEnabled ?? false
+    },
+    { onCancel }
+  );
+  return Boolean(include);
+}
+function defaultProviderIndex(template) {
+  const index = template.paymentProviders.findIndex(
+    (provider) => provider.id === template.defaultPaymentProvider
+  );
+  return index === -1 ? 0 : index;
+}
+function defaultTemplateRoot() {
+  return path2.join(path2.dirname(fileURLToPath(import.meta.url)), "create-app-templates");
+}
+function assertTargetAvailable(projectDir) {
+  if (!fs2.existsSync(projectDir)) return;
+  const entries = fs2.readdirSync(projectDir).filter((entry) => entry !== ".DS_Store");
+  if (entries.length > 0) {
+    throw new Error(`Target directory is not empty: ${projectDir}`);
+  }
+}
+function copyTemplate(sourceDir, targetDir) {
+  const ignored = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".next",
+    ".turbo",
+    "dist",
+    ".DS_Store",
+    ".mock-orders.json",
+    ".mock-payments.json"
+  ]);
+  for (const entry of fs2.readdirSync(sourceDir, { withFileTypes: true })) {
+    if (ignored.has(entry.name)) continue;
+    const source = path2.join(sourceDir, entry.name);
+    const target = path2.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      fs2.mkdirSync(target, { recursive: true });
+      copyTemplate(source, target);
+    } else if (entry.isFile()) {
+      fs2.mkdirSync(path2.dirname(target), { recursive: true });
+      fs2.copyFileSync(source, target);
+    }
+  }
+}
+function rewritePackageName(projectDir) {
+  const packagePath = path2.join(projectDir, "package.json");
+  const packageJson = JSON.parse(fs2.readFileSync(packagePath, "utf-8"));
+  packageJson.name = packageNameFromDir(projectDir);
+  packageJson.version = "0.1.0";
+  fs2.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+`);
+}
+function applyPaymentProvider(projectDir, options) {
+  const others = options.template.paymentProviders.filter(
+    (provider) => provider.id !== options.provider.id
+  );
+  for (const provider of others) {
+    fs2.rmSync(path2.join(projectDir, provider.adapterFile), { force: true });
+  }
+  stripProviderMarkers(
+    projectDir,
+    others.map((provider) => provider.id)
+  );
+  pruneDependencies(
+    projectDir,
+    others.flatMap((provider) => provider.dependencies),
+    options.registry.sdk.package
+  );
+}
+function stripProviderMarkers(projectDir, otherProviderIds) {
+  for (const file of walkSourceFiles(projectDir)) {
+    const content = fs2.readFileSync(file, "utf-8");
+    if (!content.includes("scaffold:provider:")) continue;
+    let next = content;
+    for (const id of otherProviderIds) {
+      next = stripMarkerBlocks(next, id);
+    }
+    next = removeMarkerLines(next);
+    if (next !== content) fs2.writeFileSync(file, next);
+  }
+}
+function applyCustomerAccounts(projectDir, options) {
+  const feature = findFeature(options.template, "customer-accounts");
+  if (!feature) return;
+  if (!options.customerAccounts) {
+    for (const rel of feature.paths) {
+      fs2.rmSync(path2.join(projectDir, rel), { recursive: true, force: true });
+    }
+  }
+  const tagPrefix = `scaffold:${feature.marker}:`;
+  const linePattern = new RegExp(`scaffold:${feature.marker}:(?:start|end)\\b`);
+  const transform = options.customerAccounts ? (content) => removeMarkerLinesFor(content, linePattern) : (content) => stripMarkerBlocksByTag(content, feature.marker);
+  const files = walkSourceFiles(projectDir);
+  const agentsMd = path2.join(projectDir, "AGENTS.md");
+  if (fs2.existsSync(agentsMd)) files.push(agentsMd);
+  for (const file of files) {
+    const content = fs2.readFileSync(file, "utf-8");
+    if (!content.includes(tagPrefix)) continue;
+    const next = transform(content);
+    if (next !== content) fs2.writeFileSync(file, next);
+  }
+}
+var MARKER_LINE = /scaffold:provider:[\w-]+:(?:start|end)\b/;
+function removeMarkerLinesFor(content, pattern) {
+  return content.split("\n").filter((line) => !pattern.test(line)).join("\n");
+}
+function removeMarkerLines(content) {
+  return removeMarkerLinesFor(content, MARKER_LINE);
+}
+function stripMarkerBlocks(content, providerId) {
+  return stripMarkerBlocksByTag(content, `provider:${providerId}`);
+}
+function stripMarkerBlocksByTag(content, tag) {
+  const startMarker = `scaffold:${tag}:start`;
+  const endMarker = `scaffold:${tag}:end`;
+  const lines = content.split("\n");
+  const result = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (!skipping && line.includes(startMarker)) {
+      skipping = true;
+      continue;
+    }
+    if (skipping) {
+      if (line.includes(endMarker)) skipping = false;
+      continue;
+    }
+    result.push(line);
+  }
+  if (skipping) {
+    throw new Error(
+      `Unterminated scaffold marker: missing "${endMarker}" to close "${startMarker}"`
+    );
+  }
+  return result.join("\n");
+}
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var WALK_IGNORED = /* @__PURE__ */ new Set(["node_modules", ".next", ".turbo", "dist", ".git"]);
+function walkSourceFiles(dir) {
+  const files = [];
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    if (WALK_IGNORED.has(entry.name)) continue;
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkSourceFiles(full));
+    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(path2.extname(entry.name))) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+function pruneDependencies(projectDir, depsToRemove, sdkPackage) {
+  const packagePath = path2.join(projectDir, "package.json");
+  const packageJson = JSON.parse(fs2.readFileSync(packagePath, "utf-8"));
+  const dependencies = packageJson.dependencies;
+  if (dependencies) {
+    for (const dep of depsToRemove) delete dependencies[dep];
+    const sdkRange = dependencies[sdkPackage];
+    if (sdkRange) dependencies[sdkPackage] = sdkRange.replace(/^[\^~]/, "");
+  }
+  fs2.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+`);
+}
+function writeAppConfig(projectDir, options) {
+  const brand = humanize(path2.basename(projectDir));
+  const slug = packageNameFromDir(projectDir);
+  const cartKey = `${slug}-cart`;
+  const customerKey = `${slug}-customer`;
+  const providerId = options.provider.id;
+  const label = options.provider.label;
+  const customerKeyField = options.customerAccounts ? `
+  /** Cookie name holding the HttpOnly customer session JWT. */
+  customerKey: string;` : "";
+  const customerKeyValue = options.customerAccounts ? `
+  customerKey: ${JSON.stringify(customerKey)},` : "";
+  const content = `/**
+ * App configuration generated by create-01-software-app.
+ *
+ * Generic source files read their per-app values from here so they stay
+ * consistent across the app. Edit freely \u2014 this is your project's config.
+ */
+export type PaymentProviderId = ${JSON.stringify(providerId)};
+
+export interface AppConfig {
+  /** Brand name shown in the storefront chrome. */
+  brand: string;
+  /** Document title for the app. */
+  title: string;
+  /** Cookie name holding the HttpOnly guest-cart ownership token. */
+  cartKey: string;${customerKeyField}
+  /** Payment provider this app was scaffolded for. */
+  paymentProvider: PaymentProviderId;
+}
+
+export const appConfig: AppConfig = {
+  brand: ${JSON.stringify(brand)},
+  title: ${JSON.stringify(brand)},
+  cartKey: ${JSON.stringify(cartKey)},${customerKeyValue}
+  paymentProvider: ${JSON.stringify(providerId)},
+};
+
+export const PAYMENT_PROVIDER_LABELS: Record<PaymentProviderId, string> = {
+  ${JSON.stringify(providerId)}: ${JSON.stringify(label)},
+};
+
+export function paymentProviderLabel(
+  provider: PaymentProviderId = appConfig.paymentProvider,
+): string {
+  return PAYMENT_PROVIDER_LABELS[provider];
+}
+`;
+  fs2.writeFileSync(path2.join(projectDir, "app-config.ts"), content);
+}
+function humanize(name) {
+  const words = name.replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1));
+  return words.join(" ") || "My 01 Store";
+}
+function packageNameFromDir(projectDir) {
+  const name = path2.basename(projectDir);
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "my-01-store";
+}
+function writeSdkEnv(projectDir, publishableKey, secretKey) {
+  writeEnvFile(
+    path2.join(projectDir, ".env.local"),
+    [
+      "# 01.software",
+      `NEXT_PUBLIC_SOFTWARE_PUBLISHABLE_KEY=${publishableKey}`,
+      `SOFTWARE_SECRET_KEY=${secretKey}`,
+      ""
+    ].join("\n")
+  );
+}
+function writeEnvExample(projectDir, options) {
+  const lines = ["# 01.software"];
+  for (const entry of options.registry.sdk.env) {
+    lines.push(`${entry.key}=${entry.value ?? ""}`);
+  }
+  lines.push("", `# ${options.provider.label}`);
+  for (const entry of options.provider.env) {
+    lines.push(`${entry.key}=${entry.value ?? ""}`);
+  }
+  lines.push("");
+  fs2.writeFileSync(path2.join(projectDir, ".env.local.example"), `${lines.join("\n")}
+`);
+}
+function installCommand(packageManager) {
+  if (packageManager === "yarn") return "yarn install";
+  if (packageManager === "bun") return "bun install";
+  return `${packageManager} install`;
+}
+function parseArgs(argv) {
+  const options = {};
+  const rest = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--template") {
+      options.template = argv[++index];
+    } else if (arg === "--adapter" || arg === "--provider") {
+      options.paymentProvider = argv[++index];
+    } else if (arg === "--customer-accounts") {
+      options.customerAccounts = true;
+    } else if (arg === "--no-customer-accounts") {
+      options.customerAccounts = false;
+    } else if (arg === "--package-manager") {
+      const value = argv[++index];
+      if (!isPackageManager(value)) {
+        throw new Error(`Invalid package manager: ${value}`);
+      }
+      options.packageManager = value;
+    } else if (arg === "--auth") {
+      const value = argv[++index];
+      if (!isAuthMode(value)) {
+        throw new Error(`Invalid auth mode: ${value}`);
+      }
+      options.auth = value;
+    } else if (arg === "--publishable-key") {
+      options.publishableKey = argv[++index];
+    } else if (arg === "--secret-key") {
+      options.secretKey = argv[++index];
+    } else if (arg === "--no-install") {
+      options.install = false;
+    } else if (arg.startsWith("--")) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else {
+      rest.push(arg);
+    }
+  }
+  if (rest[0]) options.projectDir = rest[0];
+  return options;
+}
+function isPackageManager(value) {
+  return PACKAGE_MANAGER_VALUES.has(value);
+}
+function isAuthMode(value) {
+  return AUTH_VALUES.has(value);
+}
+function printHelp() {
+  console.log(`
+create-01-software-app
+
+Usage:
+  create-01-software-app [project-dir] [options]
+
+Options:
+  --template <name>          template name from templates/registry.json
+  --adapter <id>             payment provider id (alias: --provider)
+  --customer-accounts        include customer accounts (login/register; starter+)
+  --no-customer-accounts     guest checkout only (default)
+  --package-manager pnpm|npm|yarn|bun
+  --auth browser|manual|skip
+  --publishable-key <key>
+  --secret-key <key>
+  --no-install
+`);
+}
+async function runCreateAppCli(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  console.log();
+  console.log(pc.bold("  create-01-software-app"));
+  console.log(pc.dim("  Create a greenfield 01.software commerce app"));
+  console.log();
+  const result = await createApp(options);
+  console.log();
+  console.log(pc.green("  Created"), path2.relative(process.cwd(), result.projectDir) || ".");
+  if (result.tenantName) console.log(pc.dim(`  Tenant: ${result.tenantName}`));
+  console.log();
+  console.log("  Next steps:");
+  console.log(pc.cyan(`    cd ${path2.relative(process.cwd(), result.projectDir) || "."}`));
+  if (!result.installed) console.log(pc.cyan(`    ${installCommand(result.packageManager)}`));
+  console.log(pc.cyan(`    ${result.packageManager === "npm" ? "npm run" : result.packageManager} dev`));
+  console.log();
+}
+var isDirectRun = process.argv[1] ? isEntrypoint(process.argv[1]) : false;
+function isEntrypoint(argvPath) {
+  try {
+    return fs2.realpathSync(argvPath) === fileURLToPath(import.meta.url);
+  } catch {
+    return path2.resolve(argvPath) === fileURLToPath(import.meta.url);
+  }
+}
+if (isDirectRun) {
+  runCreateAppCli().catch((error) => {
+    if (error instanceof Error && error.message === "cancelled") {
+      console.log(pc.yellow("  Cancelled."));
+      process.exit(0);
+    }
+    console.error(pc.red("  Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  createApp,
+  removeMarkerLines,
+  runCreateAppCli,
+  stripMarkerBlocks
+};
+//# sourceMappingURL=create-app.js.map