create-macostack 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# create-macostack
+
+Orquestador mínimo para crear ventures macostack desde templates privados.
+
+```bash
+export GITHUB_TOKEN="github_pat_..." # fine-grained, Contents: Read-only
+bun create macostack mi-tienda
+```
+
+Salida esperada:
+
+```txt
+mi-tienda/
+    server/    # repo git propio
+    client/    # repo git propio
+```
+
+La raíz no se inicializa como git. El CLI descarga tarballs privados, instala con
+`bun install`, delega `bun run setup` cuando existe, y asegura un repo git por
+mitad si el setup no lo creó.
+
+## Desarrollo local
+
+```bash
+bun install
+bun run dev mi-tienda
+```
+
+## Configuración
+
+Defaults:
+
+- owner: `macobits`
+- server repo: `macostack-server`
+- client repo: `macostack-client`
+- ref: `main`
+
+Flags útiles:
+
+```bash
+bun run dev mi-tienda --owner macobits --ref main
+bun run dev mi-api --server --skip-setup
+bun run dev mi-web --client --skip-install
+```
+
+También puedes usar env vars:
+
+```bash
+MACOSTACK_GITHUB_OWNER=macobits
+MACOSTACK_SERVER_REPO=macostack-server
+MACOSTACK_CLIENT_REPO=macostack-client
+GITHUB_TOKEN=github_pat_...
+```

package/bin/create-macostack.ts

@@ -0,0 +1,507 @@
+#!/usr/bin/env bun
+import {
+    cancel,
+    intro,
+    isCancel,
+    multiselect,
+    note,
+    outro,
+    spinner,
+    text,
+} from "@clack/prompts";
+import {
+    existsSync,
+    mkdirSync,
+    mkdtempSync,
+    readdirSync,
+    rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+const STACK_PART = {
+    SERVER: "server",
+    CLIENT: "client",
+} as const;
+
+type StackPart = (typeof STACK_PART)[keyof typeof STACK_PART];
+
+type TemplateConfig = {
+    part: StackPart;
+    directory: string;
+    repo: string;
+};
+
+type ScaffoldConfig = {
+    owner: string;
+    ref: string;
+    token: string;
+    targetRoot: string;
+    targetName: string;
+    skipInstall: boolean;
+    skipSetup: boolean;
+};
+
+type DownloadTemplateProps = {
+    config: ScaffoldConfig;
+    template: TemplateConfig;
+    destination: string;
+};
+
+type RunCommandProps = {
+    command: string[];
+    cwd: string;
+    label: string;
+    allowFailure?: boolean;
+};
+
+type PackageJson = {
+    scripts?: Record<string, string>;
+};
+
+const DEFAULT_OWNER = "macobits";
+const DEFAULT_REF = "main";
+const DEFAULT_SERVER_REPO = "macostack-server";
+const DEFAULT_CLIENT_REPO = "macostack-client";
+
+const parsedArgs = parseArgs({
+    args: Bun.argv.slice(2),
+    allowPositionals: true,
+    options: {
+        help: { type: "boolean", default: false },
+        yes: { type: "boolean", default: false },
+        server: { type: "boolean", default: false },
+        client: { type: "boolean", default: false },
+        owner: { type: "string" },
+        ref: { type: "string" },
+        "server-repo": { type: "string" },
+        "client-repo": { type: "string" },
+        "skip-install": { type: "boolean", default: false },
+        "skip-setup": { type: "boolean", default: false },
+    },
+});
+
+const flags = parsedArgs.values;
+
+const HELP_TEXT = `create-macostack
+
+Usage:
+  bun create macostack <venture-folder>
+  bun run dev <venture-folder> [flags]
+
+Flags:
+  --server              scaffold only server
+  --client              scaffold only client
+  --owner <owner>       GitHub owner/org (default: macobits)
+  --ref <ref>           Git ref/tag/branch (default: main)
+  --server-repo <repo>  server template repo (default: macostack-server)
+  --client-repo <repo>  client template repo (default: macostack-client)
+  --skip-install        do not run bun install in generated halves
+  --skip-setup          do not run bun run setup in generated halves
+  --yes                 skip create-macostack prompts; selects server + client
+  --help                show this help
+
+Auth:
+  Set GITHUB_TOKEN or run gh auth login for private template tarballs.
+`;
+
+if (flags.help === true) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+}
+
+const bail = (message: string): never => {
+    cancel(message);
+    process.exit(1);
+};
+
+const answered = <T>(value: T | symbol): T => {
+    if (isCancel(value)) {
+        cancel("Scaffold aborted — nothing else will be touched.");
+        process.exit(0);
+    }
+
+    return value as T;
+};
+
+const getStringFlag = (
+    value: string | boolean | undefined,
+    fallback: string,
+) => {
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+
+    return fallback;
+};
+
+const getBooleanFlag = (value: string | boolean | undefined) => value === true;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null;
+
+const isValidDirectoryName = (value: string) =>
+    /^[a-z0-9][a-z0-9-]*$/.test(value);
+
+const isStackPart = (value: string): value is StackPart =>
+    value === STACK_PART.SERVER || value === STACK_PART.CLIENT;
+
+const readPackageJson = async (directory: string): Promise<PackageJson | null> => {
+    const packagePath = resolve(directory, "package.json");
+    if (!existsSync(packagePath)) {
+        return null;
+    }
+
+    const value: unknown = await Bun.file(packagePath).json();
+    if (!isRecord(value)) {
+        return null;
+    }
+
+    const scriptsValue = value.scripts;
+    if (!isRecord(scriptsValue)) {
+        return {};
+    }
+
+    const scripts = Object.fromEntries(
+        Object.entries(scriptsValue).filter(
+            (entry): entry is [string, string] => typeof entry[1] === "string",
+        ),
+    );
+
+    return { scripts };
+};
+
+const getGhToken = (): string | null => {
+    const result = Bun.spawnSync(["gh", "auth", "token"], {
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+
+    if (result.exitCode !== 0) {
+        return null;
+    }
+
+    const token = result.stdout.toString().trim();
+    return token.length > 0 ? token : null;
+};
+
+const getGithubToken = (): string | null => {
+    const envToken = Bun.env.GITHUB_TOKEN ?? Bun.env.GH_TOKEN;
+    if (envToken && envToken.length > 0) {
+        return envToken;
+    }
+
+    return getGhToken();
+};
+
+const requireGithubToken = (): string => {
+    const token = getGithubToken();
+    if (typeof token === "string" && token.length > 0) {
+        return token;
+    }
+
+    return bail(
+        "Private templates require GitHub auth. Set GITHUB_TOKEN or run `gh auth login`. " +
+            "Use a fine-grained token with Contents: Read-only.",
+    );
+};
+
+const ensureEmptyDirectory = (directory: string, label: string) => {
+    if (!existsSync(directory)) {
+        mkdirSync(directory, { recursive: true });
+        return;
+    }
+
+    const entries = readdirSync(directory).filter((entry) => entry !== ".DS_Store");
+    if (entries.length > 0) {
+        bail(`${label} already exists and is not empty: ${directory}`);
+    }
+};
+
+const runCommand = ({
+    command,
+    cwd,
+    label,
+    allowFailure = false,
+}: RunCommandProps) => {
+    const result = Bun.spawnSync(command, {
+        cwd,
+        stdout: "inherit",
+        stderr: "inherit",
+    });
+
+    if (result.exitCode === 0 || allowFailure) {
+        return result.exitCode;
+    }
+
+    bail(`${label} failed with exit code ${result.exitCode}.`);
+};
+
+const downloadTemplate = async ({
+    config,
+    template,
+    destination,
+}: DownloadTemplateProps) => {
+    const temporaryDirectory = mkdtempSync(join(tmpdir(), "create-macostack-"));
+    const archivePath = join(temporaryDirectory, `${template.part}.tar.gz`);
+    const tarballUrl = `https://api.github.com/repos/${config.owner}/${template.repo}/tarball/${config.ref}`;
+
+    try {
+        const response = await fetch(tarballUrl, {
+            headers: {
+                Accept: "application/vnd.github+json",
+                Authorization: `Bearer ${config.token}`,
+                "User-Agent": "create-macostack",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        });
+
+        if (!response.ok) {
+            const details = await response.text();
+            bail(
+                `GitHub refused ${config.owner}/${template.repo}@${config.ref} (${response.status}). ` +
+                    `Check GITHUB_TOKEN permissions. ${details.slice(0, 240)}`,
+            );
+        }
+
+        await Bun.write(archivePath, await response.arrayBuffer());
+        ensureEmptyDirectory(destination, template.directory);
+        runCommand({
+            command: [
+                "tar",
+                "-xzf",
+                archivePath,
+                "-C",
+                destination,
+                "--strip-components=1",
+            ],
+            cwd: destination,
+            label: `Extract ${template.part}`,
+        });
+    } finally {
+        rmSync(temporaryDirectory, { recursive: true, force: true });
+    }
+};
+
+const runInstall = (directory: string, template: TemplateConfig) => {
+    runCommand({
+        command: ["bun", "install"],
+        cwd: directory,
+        label: `bun install in ${template.part}`,
+    });
+};
+
+const runSetup = async (directory: string, template: TemplateConfig) => {
+    const packageJson = await readPackageJson(directory);
+    if (!packageJson?.scripts?.setup) {
+        note(`No setup script found in ${template.directory}; skipping delegation.`, template.part);
+        return;
+    }
+
+    runCommand({
+        command: ["bun", "run", "setup"],
+        cwd: directory,
+        label: `setup in ${template.part}`,
+    });
+};
+
+const ensureGitRepository = (directory: string, template: TemplateConfig) => {
+    if (existsSync(resolve(directory, ".git"))) {
+        return;
+    }
+
+    runCommand({
+        command: ["git", "init", "-b", "main"],
+        cwd: directory,
+        label: `git init in ${template.part}`,
+    });
+    runCommand({
+        command: ["git", "add", "-A"],
+        cwd: directory,
+        label: `git add in ${template.part}`,
+    });
+
+    const commitExitCode = runCommand({
+        command: ["git", "commit", "-m", "init from template"],
+        cwd: directory,
+        label: `git commit in ${template.part}`,
+        allowFailure: true,
+    });
+
+    if (commitExitCode !== 0) {
+        note(
+            `Fresh ${template.part} repo created, but initial commit failed. ` +
+                `Run: cd ${template.directory} && git add -A && git commit -m "init"`,
+            "Git",
+        );
+    }
+};
+
+const getSelectedPartsFromFlags = () => {
+    const selected: StackPart[] = [];
+
+    if (getBooleanFlag(flags.server)) {
+        selected.push(STACK_PART.SERVER);
+    }
+
+    if (getBooleanFlag(flags.client)) {
+        selected.push(STACK_PART.CLIENT);
+    }
+
+    return selected;
+};
+
+const resolveTargetName = async () => {
+    const positionalTarget = parsedArgs.positionals[0];
+    if (positionalTarget) {
+        if (!isValidDirectoryName(positionalTarget)) {
+            bail("Project folder must use lowercase letters, digits and dashes only.");
+        }
+
+        return positionalTarget;
+    }
+
+    if (getBooleanFlag(flags.yes)) {
+        bail("Missing project folder. Usage: bun create macostack my-venture");
+    }
+
+    const value = answered(
+        await text({
+            message: "Venture folder",
+            placeholder: "mi-tienda",
+            validate: (input) =>
+                isValidDirectoryName(input ?? "")
+                    ? undefined
+                    : "lowercase letters, digits and dashes only",
+        }),
+    );
+
+    return value;
+};
+
+const resolveSelectedParts = async () => {
+    const selectedFromFlags = getSelectedPartsFromFlags();
+    if (selectedFromFlags.length > 0) {
+        return selectedFromFlags;
+    }
+
+    if (getBooleanFlag(flags.yes)) {
+        return [STACK_PART.SERVER, STACK_PART.CLIENT];
+    }
+
+    const selected = answered(
+        await multiselect({
+            message: "¿Qué incluye este venture?",
+            options: [
+                { value: STACK_PART.SERVER, label: "server" },
+                { value: STACK_PART.CLIENT, label: "client" },
+            ],
+            initialValues: [STACK_PART.SERVER, STACK_PART.CLIENT],
+            required: true,
+        }),
+    );
+
+    const validSelected = selected.filter(isStackPart);
+    if (validSelected.length === 0) {
+        bail("Select at least one half.");
+    }
+
+    return validSelected;
+};
+
+const buildTemplates = (selectedParts: StackPart[]) => {
+    const serverRepo = getStringFlag(
+        flags["server-repo"],
+        Bun.env.MACOSTACK_SERVER_REPO ?? DEFAULT_SERVER_REPO,
+    );
+    const clientRepo = getStringFlag(
+        flags["client-repo"],
+        Bun.env.MACOSTACK_CLIENT_REPO ?? DEFAULT_CLIENT_REPO,
+    );
+
+    const templates = {
+        [STACK_PART.SERVER]: {
+            part: STACK_PART.SERVER,
+            directory: "server",
+            repo: serverRepo,
+        },
+        [STACK_PART.CLIENT]: {
+            part: STACK_PART.CLIENT,
+            directory: "client",
+            repo: clientRepo,
+        },
+    } satisfies Record<StackPart, TemplateConfig>;
+
+    return selectedParts.map((part) => templates[part]);
+};
+
+const scaffoldTemplate = async (config: ScaffoldConfig, template: TemplateConfig) => {
+    const destination = resolve(config.targetRoot, template.directory);
+    const s = spinner();
+
+    s.start(`Downloading ${config.owner}/${template.repo}@${config.ref} → ${template.directory}`);
+    await downloadTemplate({ config, template, destination });
+    s.stop(`${template.directory} downloaded`);
+
+    if (!config.skipInstall) {
+        runInstall(destination, template);
+    }
+
+    if (!config.skipSetup) {
+        await runSetup(destination, template);
+    }
+
+    ensureGitRepository(destination, template);
+};
+
+const main = async () => {
+    intro("create-macostack");
+
+    const targetName = await resolveTargetName();
+    const selectedParts = await resolveSelectedParts();
+    const owner = getStringFlag(
+        flags.owner,
+        Bun.env.MACOSTACK_GITHUB_OWNER ?? DEFAULT_OWNER,
+    );
+    const ref = getStringFlag(flags.ref, Bun.env.MACOSTACK_REF ?? DEFAULT_REF);
+    const githubToken = requireGithubToken();
+
+    const config: ScaffoldConfig = {
+        owner,
+        ref,
+        token: githubToken,
+        targetRoot: resolve(process.cwd(), targetName),
+        targetName,
+        skipInstall: getBooleanFlag(flags["skip-install"]),
+        skipSetup: getBooleanFlag(flags["skip-setup"]),
+    };
+    const templates = buildTemplates(selectedParts);
+
+    ensureEmptyDirectory(config.targetRoot, "Target root");
+
+    for (const template of templates) {
+        await scaffoldTemplate(config, template);
+    }
+
+    const remoteSteps = templates
+        .map(
+            (template) =>
+                `  cd ${config.targetName}/${template.directory}\n` +
+                `  git remote add origin <${template.part}-repo-url>\n` +
+                "  git push -u origin main",
+        )
+        .join("\n\n");
+
+    const devSteps = templates
+        .map((template) => `  cd ${config.targetName}/${template.directory} && bun dev`)
+        .join("\n");
+
+    outro(
+        `Done. Root folder is intentionally not a git repo.\n\n` +
+            `Next remotes:\n${remoteSteps}\n\n` +
+            `Dev:\n${devSteps}`,
+    );
+};
+
+await main();

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "create-macostack",
+    "version": "0.1.0",
+    "description": "Private macostack scaffold orchestrator for detached server/client repos.",
+    "type": "module",
+    "bin": {
+        "create-macostack": "./bin/create-macostack.ts"
+    },
+    "files": [
+        "bin",
+        "README.md"
+    ],
+    "scripts": {
+        "dev": "bun run bin/create-macostack.ts",
+        "start": "bun run bin/create-macostack.ts",
+        "typecheck": "bunx tsc --noEmit"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@clack/prompts": "^1.7.0"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.14",
+        "typescript": "^6.0.3"
+    }
+}