create-100x-mobile 0.4.1 → 0.4.3

package/dist/cli.js

@@ -8,9 +8,18 @@ function printUsage() {
 
 Usage:
   bunx create-100x-mobile [name]
+  bunx create-100x-mobile [name] [options]
   bun create 100x-mobile [name]
   npx create-100x-mobile [name]
 
+Options:
+  --yes                   Run without prompts (defaults name to "my-app")
+  --no-install            Skip dependency installation
+  --skip-git              Skip git init/commit
+  --sdk <value>           Use "latest", "previous", or a specific version (e.g. 54.0.33)
+  --clerk-pk <key>        Pre-fill Clerk publishable key
+  --clerk-domain <domain> Pre-fill Clerk issuer domain
+
 Scaffolds a full-stack mobile app with Expo + Convex + Clerk.
 `);
 }
@@ -26,15 +35,7 @@ async function main() {
         console.log(pkg.version ?? "0.0.0");
         return;
     }
-    // Default action: scaffold a new app
-    // If first arg looks like a flag, show help; otherwise treat as app name
-    if (command && command.startsWith("-")) {
-        prompts_1.log.error(`Unknown flag: ${command}`);
-        printUsage();
-        process.exitCode = 1;
-        return;
-    }
-    await (0, new_1.cmdNew)(args);
+    await (0, new_1.runNewCommand)(args);
 }
 main().catch((err) => {
     const message = err instanceof Error ? err.message : String(err);

package/dist/commands/new/args.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNewCommandArgs = parseNewCommandArgs;
+function getInlineOrNextValue(arg, args, i) {
+    const eqIndex = arg.indexOf("=");
+    if (eqIndex !== -1) {
+        const value = arg.slice(eqIndex + 1).trim();
+        if (!value) {
+            throw new Error(`Flag "${arg.slice(0, eqIndex)}" requires a value.`);
+        }
+        return { value, nextIndex: i };
+    }
+    const nextValue = args[i + 1];
+    if (!nextValue || nextValue.startsWith("-")) {
+        throw new Error(`Flag "${arg}" requires a value.`);
+    }
+    return { value: nextValue.trim(), nextIndex: i + 1 };
+}
+function parseNewCommandArgs(args) {
+    const options = {
+        interactive: true,
+        installDependencies: true,
+        initializeGit: true,
+        sdk: null,
+        clerkPublishableKey: null,
+        clerkDomain: null,
+    };
+    let projectName = null;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        if (!arg.startsWith("-")) {
+            if (projectName) {
+                throw new Error(`Unexpected argument "${arg}". Only one project name is allowed.`);
+            }
+            projectName = arg;
+            continue;
+        }
+        if (arg === "--yes") {
+            options.interactive = false;
+            continue;
+        }
+        if (arg === "--no-install") {
+            options.installDependencies = false;
+            continue;
+        }
+        if (arg === "--skip-git") {
+            options.initializeGit = false;
+            continue;
+        }
+        if (arg === "--sdk" || arg.startsWith("--sdk=")) {
+            const { value, nextIndex } = getInlineOrNextValue(arg, args, i);
+            options.sdk = value;
+            i = nextIndex;
+            continue;
+        }
+        if (arg === "--clerk-pk" || arg.startsWith("--clerk-pk=")) {
+            const { value, nextIndex } = getInlineOrNextValue(arg, args, i);
+            options.clerkPublishableKey = value;
+            i = nextIndex;
+            continue;
+        }
+        if (arg === "--clerk-domain" || arg.startsWith("--clerk-domain=")) {
+            const { value, nextIndex } = getInlineOrNextValue(arg, args, i);
+            options.clerkDomain = value;
+            i = nextIndex;
+            continue;
+        }
+        throw new Error(`Unknown flag: ${arg}`);
+    }
+    if (!projectName && !options.interactive) {
+        projectName = "my-app";
+    }
+    return { projectName, options };
+}

package/dist/commands/new/scaffold.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectDirectories = createProjectDirectories;
+exports.writeScaffoldFiles = writeScaffoldFiles;
+exports.writeDefaultAssetFiles = writeDefaultAssetFiles;
+const node_path_1 = require("node:path");
+const fs_1 = require("../../lib/fs");
+// 1x1 transparent PNG placeholder.
+const TRANSPARENT_PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO7+P5kAAAAASUVORK5CYII=";
+async function createProjectDirectories(projectDir) {
+    const dirs = [
+        "app/(auth)",
+        "app/(tabs)",
+        "app/providers",
+        "components",
+        "convex",
+        "hooks",
+        "assets/images",
+    ];
+    for (const dir of dirs) {
+        await (0, fs_1.ensureDir)((0, node_path_1.join)(projectDir, dir));
+    }
+}
+async function writeScaffoldFiles(projectDir, files) {
+    for (const file of files) {
+        await (0, fs_1.writeTextFile)((0, node_path_1.join)(projectDir, file.path), file.content);
+    }
+}
+async function writeDefaultAssetFiles(projectDir) {
+    const png = Buffer.from(TRANSPARENT_PNG_BASE64, "base64");
+    await (0, fs_1.writeBinaryFile)((0, node_path_1.join)(projectDir, "assets/images/icon.png"), png);
+    await (0, fs_1.writeBinaryFile)((0, node_path_1.join)(projectDir, "assets/images/favicon.png"), png);
+}

package/dist/commands/new/steps.js

@@ -0,0 +1,379 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeClerkDomain = normalizeClerkDomain;
+exports.toErrorMessage = toErrorMessage;
+exports.resolveExpoVersion = resolveExpoVersion;
+exports.installDependencies = installDependencies;
+exports.resolveExpoDependencies = resolveExpoDependencies;
+exports.promptClerkSetup = promptClerkSetup;
+exports.writeAuthEnvironment = writeAuthEnvironment;
+exports.initializeConvex = initializeConvex;
+exports.ensureExpoPublicConvexUrl = ensureExpoPublicConvexUrl;
+exports.setConvexClerkEnv = setConvexClerkEnv;
+exports.initializeGit = initializeGit;
+exports.runHealthChecks = runHealthChecks;
+const node_path_1 = require("node:path");
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = __importDefault(require("picocolors"));
+const clerk_1 = require("../../lib/clerk");
+const dotenv_1 = require("../../lib/dotenv");
+const fs_1 = require("../../lib/fs");
+const run_1 = require("../../lib/run");
+function normalizeClerkDomain(rawDomain) {
+    const trimmed = rawDomain.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+        return trimmed;
+    }
+    return `https://${trimmed}`;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function isErrnoException(error) {
+    return error instanceof Error && "code" in error;
+}
+function normalizeSdkArg(sdk) {
+    const value = sdk.trim();
+    if (!value) {
+        throw new Error("`--sdk` cannot be empty.");
+    }
+    if (value === "latest") {
+        return "latest";
+    }
+    if (value === "previous") {
+        return "previous";
+    }
+    if (/^\d+\.\d+\.\d+$/.test(value)) {
+        return `~${value}`;
+    }
+    if (/^~\d+\.\d+\.\d+$/.test(value)) {
+        return value;
+    }
+    throw new Error(`Invalid --sdk value "${value}". Use "latest", "previous", or a version like "54.0.33".`);
+}
+async function resolveExpoVersion(options) {
+    if (options.sdk) {
+        const normalized = normalizeSdkArg(options.sdk);
+        if (normalized !== "previous") {
+            return normalized;
+        }
+    }
+    const sdkSpinner = (0, prompts_1.spinner)();
+    const shouldPrompt = options.interactive && !options.sdk;
+    sdkSpinner.start("Fetching available Expo SDK versions");
+    try {
+        const latestVersion = (await (0, run_1.runCapture)("npm", ["view", "expo", "version"])).trim();
+        const latestMajor = parseInt(latestVersion.split(".")[0], 10);
+        if (Number.isNaN(latestMajor)) {
+            sdkSpinner.stop("Could not parse Expo version, using latest.");
+            return "latest";
+        }
+        const prevMajor = latestMajor - 1;
+        const prevJson = await (0, run_1.runCapture)("npm", [
+            "view",
+            `expo@^${prevMajor}.0.0`,
+            "version",
+            "--json",
+        ]);
+        const prevParsed = JSON.parse(prevJson);
+        const prevVersion = Array.isArray(prevParsed)
+            ? prevParsed[prevParsed.length - 1]
+            : prevParsed;
+        if (!prevVersion) {
+            sdkSpinner.stop("Could not resolve previous Expo SDK version.");
+            return `~${latestVersion}`;
+        }
+        if (options.sdk && normalizeSdkArg(options.sdk) === "previous") {
+            sdkSpinner.stop("Using previous Expo SDK.");
+            return `~${prevVersion}`;
+        }
+        if (!shouldPrompt) {
+            sdkSpinner.stop("Using latest Expo SDK.");
+            return `~${latestVersion}`;
+        }
+        sdkSpinner.stop("Expo SDK versions fetched.");
+        const sdkChoice = await (0, prompts_1.select)({
+            message: "Which Expo SDK version?",
+            options: [
+                {
+                    value: latestVersion,
+                    label: `SDK ${latestMajor} (latest)`,
+                    hint: `expo ~${latestVersion}`,
+                },
+                {
+                    value: prevVersion,
+                    label: `SDK ${prevMajor}`,
+                    hint: `expo ~${prevVersion}`,
+                },
+            ],
+        });
+        if ((0, prompts_1.isCancel)(sdkChoice)) {
+            return `~${latestVersion}`;
+        }
+        return `~${sdkChoice}`;
+    }
+    catch (error) {
+        sdkSpinner.stop("Could not fetch Expo versions, using latest.");
+        prompts_1.log.warn(picocolors_1.default.dim(`  Details: ${toErrorMessage(error)}`));
+        return "latest";
+    }
+}
+async function installDependencies(projectDir) {
+    try {
+        await (0, run_1.run)("bun", ["install"], { cwd: projectDir });
+        return true;
+    }
+    catch (bunError) {
+        prompts_1.log.warn(`bun install failed: ${toErrorMessage(bunError)}`);
+        prompts_1.log.warn("Trying npm install...");
+        try {
+            await (0, run_1.run)("npm", ["install"], { cwd: projectDir });
+            return true;
+        }
+        catch (npmError) {
+            prompts_1.log.error(`Failed to install dependencies. ${toErrorMessage(npmError)}`);
+            prompts_1.log.info(picocolors_1.default.dim("Run `bun install` or `npm install` manually."));
+            return false;
+        }
+    }
+}
+async function resolveExpoDependencies(projectDir) {
+    const expoPackages = [
+        "react",
+        "react-dom",
+        "react-native",
+        "expo-router",
+        "@expo/vector-icons",
+        "expo-auth-session",
+        "expo-blur",
+        "expo-constants",
+        "expo-font",
+        "expo-haptics",
+        "expo-linking",
+        "expo-secure-store",
+        "expo-splash-screen",
+        "expo-status-bar",
+        "expo-system-ui",
+        "expo-web-browser",
+        "react-native-gesture-handler",
+        "react-native-reanimated",
+        "react-native-safe-area-context",
+        "react-native-screens",
+        "react-native-svg",
+        "react-native-web",
+    ];
+    try {
+        await (0, run_1.run)("npx", ["expo", "install", ...expoPackages], { cwd: projectDir });
+        return true;
+    }
+    catch (error) {
+        prompts_1.log.warn(`Could not resolve Expo deps automatically: ${toErrorMessage(error)}`);
+        prompts_1.log.info(picocolors_1.default.dim("Run manually: npx expo install --fix"));
+        return false;
+    }
+}
+async function promptClerkSetup(options) {
+    let publishableKey = options.clerkPublishableKey?.trim() ?? "";
+    let domain = options.clerkDomain ? normalizeClerkDomain(options.clerkDomain) : "";
+    let jwtCreated = false;
+    if (!publishableKey && options.interactive) {
+        prompts_1.log.info("");
+        prompts_1.log.info(picocolors_1.default.bold("Clerk Authentication Setup"));
+        prompts_1.log.info(picocolors_1.default.dim("Get your keys from https://dashboard.clerk.com → Your App → API Keys"));
+        prompts_1.log.info(picocolors_1.default.dim("Press Enter to skip and configure later."));
+        const clerkKey = await (0, prompts_1.text)({
+            message: "Clerk Publishable Key",
+            placeholder: "pk_test_...",
+            defaultValue: "",
+        });
+        if (!(0, prompts_1.isCancel)(clerkKey) && clerkKey) {
+            publishableKey = clerkKey.trim();
+        }
+    }
+    if (publishableKey && !domain) {
+        const derivedDomain = (0, clerk_1.extractDomainFromPublishableKey)(publishableKey);
+        if (derivedDomain) {
+            domain = derivedDomain;
+            prompts_1.log.info(`  Detected issuer domain: ${picocolors_1.default.cyan(domain)}`);
+        }
+        else if (options.interactive) {
+            const domainInput = await (0, prompts_1.text)({
+                message: "Clerk JWT Issuer Domain",
+                placeholder: "https://your-app.clerk.accounts.dev",
+                defaultValue: "",
+            });
+            if (!(0, prompts_1.isCancel)(domainInput) && domainInput) {
+                domain = normalizeClerkDomain(domainInput);
+            }
+        }
+    }
+    if (publishableKey && options.interactive) {
+        prompts_1.log.info("");
+        prompts_1.log.info(picocolors_1.default.dim('Provide your Clerk Secret Key to auto-create the "convex" JWT template.'));
+        prompts_1.log.info(picocolors_1.default.dim("Press Enter to skip if you already have one."));
+        const secretInput = await (0, prompts_1.text)({
+            message: "Clerk Secret Key",
+            placeholder: "sk_test_...",
+            defaultValue: "",
+        });
+        const secretKey = (0, prompts_1.isCancel)(secretInput) || !secretInput ? "" : secretInput.trim();
+        if (secretKey) {
+            const jwtSpinner = (0, prompts_1.spinner)();
+            jwtSpinner.start('Creating "convex" JWT template in Clerk');
+            const result = await (0, clerk_1.createConvexJwtTemplate)(secretKey);
+            if (result.success) {
+                jwtSpinner.stop('JWT template "convex" created in Clerk.');
+                jwtCreated = true;
+            }
+            else {
+                jwtSpinner.stop("Could not create JWT template.");
+                prompts_1.log.warn(`Clerk API: ${result.error}`);
+            }
+        }
+    }
+    return { publishableKey, domain, jwtCreated };
+}
+async function writeAuthEnvironment(projectDir, clerk) {
+    const envLocalPath = (0, node_path_1.join)(projectDir, ".env.local");
+    let envContents = "";
+    try {
+        envContents = await (0, fs_1.readTextFile)(envLocalPath);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code !== "ENOENT") {
+            prompts_1.log.warn(`Could not read .env.local: ${toErrorMessage(error)}`);
+        }
+    }
+    if (clerk.publishableKey) {
+        envContents = (0, dotenv_1.upsertDotenvVar)(envContents, "EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY", clerk.publishableKey);
+    }
+    if (clerk.domain) {
+        envContents = (0, dotenv_1.upsertDotenvVar)(envContents, "CLERK_JWT_ISSUER_DOMAIN", clerk.domain);
+    }
+    if (envContents) {
+        await (0, fs_1.writeTextFile)(envLocalPath, envContents);
+    }
+    if (clerk.domain) {
+        const serializedDomain = JSON.stringify(clerk.domain);
+        await (0, fs_1.writeTextFile)((0, node_path_1.join)(projectDir, "convex/auth.config.ts"), `export default {\n  providers: [\n    {\n      domain: ${serializedDomain},\n      applicationID: "convex",\n    },\n  ],\n};\n`);
+    }
+}
+async function initializeConvex(projectDir) {
+    try {
+        await (0, run_1.run)("bunx", ["convex", "dev", "--once"], { cwd: projectDir });
+        return true;
+    }
+    catch (error) {
+        prompts_1.log.warn(`Convex setup needs attention: ${toErrorMessage(error)}`);
+        return false;
+    }
+}
+async function ensureExpoPublicConvexUrl(projectDir) {
+    const envLocalPath = (0, node_path_1.join)(projectDir, ".env.local");
+    try {
+        let updatedEnv = "";
+        try {
+            updatedEnv = await (0, fs_1.readTextFile)(envLocalPath);
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code !== "ENOENT") {
+                prompts_1.log.warn(`Could not read .env.local: ${toErrorMessage(error)}`);
+            }
+        }
+        if (!updatedEnv) {
+            return false;
+        }
+        if (updatedEnv.includes("EXPO_PUBLIC_CONVEX_URL")) {
+            return true;
+        }
+        const parsed = (0, dotenv_1.parseDotenv)(updatedEnv);
+        let convexUrl = parsed["CONVEX_URL"] || "";
+        if (!convexUrl) {
+            try {
+                convexUrl = await (0, run_1.runCapture)("bunx", ["convex", "url"], {
+                    cwd: projectDir,
+                });
+            }
+            catch (error) {
+                prompts_1.log.warn(picocolors_1.default.dim(`Could not auto-detect Convex URL: ${toErrorMessage(error)}`));
+            }
+        }
+        if (!convexUrl) {
+            return false;
+        }
+        updatedEnv = (0, dotenv_1.upsertDotenvVar)(updatedEnv, "EXPO_PUBLIC_CONVEX_URL", convexUrl);
+        await (0, fs_1.writeTextFile)(envLocalPath, updatedEnv);
+        return true;
+    }
+    catch (error) {
+        prompts_1.log.warn(`Could not finalize EXPO_PUBLIC_CONVEX_URL: ${toErrorMessage(error)}`);
+        return false;
+    }
+}
+async function setConvexClerkEnv(projectDir, clerkDomain) {
+    if (!clerkDomain)
+        return true;
+    try {
+        await (0, run_1.run)("bunx", ["convex", "env", "set", "CLERK_JWT_ISSUER_DOMAIN", clerkDomain], { cwd: projectDir });
+        return true;
+    }
+    catch (error) {
+        prompts_1.log.warn(`Could not set Convex environment variable automatically: ${toErrorMessage(error)}`);
+        return false;
+    }
+}
+async function initializeGit(projectDir) {
+    try {
+        await (0, run_1.run)("git", ["init"], { cwd: projectDir });
+        await (0, run_1.run)("git", ["add", "-A"], { cwd: projectDir });
+        await (0, run_1.run)("git", ["commit", "-m", "Initial commit from create-100x-mobile"], {
+            cwd: projectDir,
+        });
+        return true;
+    }
+    catch (error) {
+        prompts_1.log.warn(`Git initialization skipped: ${toErrorMessage(error)}`);
+        return false;
+    }
+}
+async function runHealthChecks(projectDir, clerkPublishableKey) {
+    const envLocalPath = (0, node_path_1.join)(projectDir, ".env.local");
+    const checks = [];
+    const envExists = await (0, fs_1.pathExists)(envLocalPath);
+    checks.push({ label: ".env.local exists", ok: envExists });
+    if (!envExists) {
+        checks.push({ label: "EXPO_PUBLIC_CONVEX_URL is set", ok: false });
+        if (clerkPublishableKey) {
+            checks.push({
+                label: "EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY is set",
+                ok: false,
+            });
+        }
+        return checks;
+    }
+    let envContent = "";
+    try {
+        envContent = await (0, fs_1.readTextFile)(envLocalPath);
+    }
+    catch (error) {
+        prompts_1.log.warn(`Could not read .env.local during health checks: ${toErrorMessage(error)}`);
+    }
+    checks.push({
+        label: "EXPO_PUBLIC_CONVEX_URL is set",
+        ok: envContent.includes("EXPO_PUBLIC_CONVEX_URL"),
+    });
+    if (clerkPublishableKey) {
+        checks.push({
+            label: "EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY is set",
+            ok: envContent.includes("EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY"),
+        });
+    }
+    return checks;
+}