primitive-admin 1.1.0-alpha.4 → 1.1.0-alpha.40

package/dist/src/commands/init.js

@@ -1,107 +1,480 @@
-import { existsSync } from "fs";
-import { resolve, basename } from "path";
-import { input, confirm, select } from "@inquirer/prompts";
-import { loadCredentials } from "../lib/config.js";
-import { browserLogin } from "../lib/auth-flow.js";
+import { confirm, input, select } from "@inquirer/prompts";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { basename, join, resolve } from "path";
+import { CURRENT_CONFIG_VERSION, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILENAME, PROJECT_CONFIG_DISPLAY_NAME, saveProjectConfig, loadProjectConfigFromPath, } from "../lib/project-config.js";
 import { ApiClient } from "../lib/api-client.js";
-import { downloadAndExtractTemplate, updateEnvFile, runPnpmInstall, isDirectoryEmpty, isPnpmInstalled, installPnpmGlobally, isPrimitiveCliInstalled, installPrimitiveCli, } from "../lib/template.js";
-import { success, error, info, warn, keyValue, divider, } from "../lib/output.js";
+import { browserLogin } from "../lib/auth-flow.js";
+import { loadCredentials, setCurrentApp } from "../lib/config.js";
+import { INIT_CONFIG_FILENAME, loadInitConfig, parseInitConfigToml, resolveUseExistingAppId, validateInitConfig, } from "../lib/init-config.js";
+import { resolvePlatform, } from "../lib/resolve-platform.js";
+import { divider, error, info, keyValue, success, warn, } from "../lib/output.js";
+import { gitInitialCommit, gitInitRepo, installPnpmGlobally, installPrimitiveCli, isDirectoryEmpty, isPnpmInstalled, isPortFree, isPrimitiveCliInstalled, isXcodeInstalled, IOS_TEMPLATE_URL, prepareTemplate, runPnpmInstall, runSwiftPackageResolve, updateEnvFile, updateEnvPort, updatePrimitiveJson, updateViteConfig, } from "../lib/template.js";
 const DEFAULT_SERVER_URL = process.env.PRIMITIVE_SERVER_URL || "https://primitiveapi.com";
+/**
+ * The .gitignore lines `init` writes for Primitive CLI local state.
+ *
+ * Pre-pull sync snapshots (issue #578) are per-machine local recovery state and
+ * must never be committed. They can land in three places depending on how the
+ * sync dir resolves (see `resolveSnapshotsRoot` in `lib/sync-paths.ts`):
+ *   - project mode:        `<projectRoot>/.primitive/sync-backups/<env>/<appId>/`
+ *   - legacy `--dir <p>`:  `<p>/.snapshots/`        (sibling of the user dir)
+ *   - no-project fallback: `./config-snapshots/`
+ * The bare `.snapshots/` and `config-snapshots/` entries (no leading slash)
+ * match those directories wherever `--dir` points, so backup copies — including
+ * the restored `.primitive-sync.json` baseline — can never surface as untracked
+ * files in a tracked custom config dir.
+ */
+export const GITIGNORE_LOCAL_STATE_ENTRIES = [
+    ".primitive/credentials.json",
+    ".primitive/sync/**/.primitive-sync.json",
+    ".primitive/sync-backups/",
+    ".snapshots/",
+    "config-snapshots/",
+];
+/**
+ * Writes .primitive/config.json into the project directory and ensures the
+ * .gitignore entry for local state exists. Safe to call in a directory that
+ * already has a config — in that case we add/update the "dev" environment
+ * instead of overwriting the file.
+ */
+async function scaffoldProjectConfig(opts) {
+    const configPath = join(opts.targetDir, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILENAME);
+    let config;
+    if (existsSync(configPath)) {
+        // Respect an existing config: merge in the new dev env if missing.
+        try {
+            config = loadProjectConfigFromPath(configPath);
+        }
+        catch {
+            // Existing file is broken — don't clobber it; just warn and skip.
+            warn(`${PROJECT_CONFIG_DISPLAY_NAME} exists but is invalid. Skipping project config scaffold.`);
+            return;
+        }
+        if (!config.environments.dev) {
+            config.environments.dev = {
+                apiUrl: opts.serverUrl,
+                appId: opts.appId,
+                appName: opts.appName,
+            };
+            if (!config.defaultEnvironment)
+                config.defaultEnvironment = "dev";
+        }
+    }
+    else {
+        config = {
+            version: CURRENT_CONFIG_VERSION,
+            defaultEnvironment: "dev",
+            environments: {
+                dev: {
+                    apiUrl: opts.serverUrl,
+                    appId: opts.appId,
+                    appName: opts.appName,
+                },
+            },
+        };
+    }
+    saveProjectConfig(configPath, config);
+    // Ensure .primitive/ local state (credentials, per-machine sync state) is
+    // gitignored. The config.json itself lives in .primitive/ too, but we
+    // gitignore only the sensitive / per-machine artifacts — config.json and
+    // the exported TOML files under .primitive/sync/<env>/<appId>/ are meant
+    // to be committed. Only `.primitive-sync.json` (the auto-managed sync
+    // state baseline) is per-machine local state; everything else in the
+    // sync directory is the version-controllable export.
+    //
+    // Legacy note: an earlier version of init wrote `.primitive/sync/` here,
+    // which incorrectly hid the TOML export tree from `git status`. If we see
+    // that legacy entry, replace it with the targeted pattern in-place so
+    // users who re-run init pick up the fix.
+    const gitignorePath = join(opts.targetDir, ".gitignore");
+    const LEGACY_SYNC_IGNORE = ".primitive/sync/";
+    const gitignoreEntries = [...GITIGNORE_LOCAL_STATE_ENTRIES];
+    let linesToAdd = [];
+    if (existsSync(gitignorePath)) {
+        const existing = readFileSync(gitignorePath, "utf-8");
+        const trimmedLines = existing.split(/\r?\n/).map((l) => l.trim());
+        // Migrate the legacy `.primitive/sync/` entry to the targeted pattern,
+        // if present. Preserve original line endings/formatting elsewhere.
+        if (trimmedLines.includes(LEGACY_SYNC_IGNORE)) {
+            const rewritten = existing
+                .split(/\r?\n/)
+                .map((line) => line.trim() === LEGACY_SYNC_IGNORE
+                ? ".primitive/sync/**/.primitive-sync.json"
+                : line)
+                .join("\n");
+            try {
+                writeFileSync(gitignorePath, rewritten);
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        // Re-read after potential migration so we don't double-add entries.
+        const refreshed = readFileSync(gitignorePath, "utf-8")
+            .split(/\r?\n/)
+            .map((l) => l.trim());
+        for (const entry of gitignoreEntries) {
+            if (!refreshed.includes(entry)) {
+                linesToAdd.push(entry);
+            }
+        }
+    }
+    else {
+        linesToAdd = [...gitignoreEntries];
+    }
+    if (linesToAdd.length > 0) {
+        try {
+            const prefix = existsSync(gitignorePath) ? "\n# Primitive CLI local state\n" : "# Primitive CLI local state\n";
+            appendFileSync(gitignorePath, prefix + linesToAdd.join("\n") + "\n");
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    success(`Wrote ${PROJECT_CONFIG_DISPLAY_NAME} with dev environment`);
+}
+function validateServerUrl(url) {
+    if (!url.trim())
+        return "Server URL cannot be empty";
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return "Please enter a valid URL (e.g., https://example.com)";
+    }
+}
+/**
+ * Prompts for login when credentials are missing or the server has changed.
+ * Returns updated credentials on success, or exits/warns on failure.
+ * In non-interactive mode, auto-proceeds with login (no confirmation prompt).
+ */
+async function ensureAuthenticated(credentials, serverUrl, serverChanged, context) {
+    if (credentials && !serverChanged)
+        return credentials;
+    if (serverChanged) {
+        info(`Switching to ${serverUrl}. You need to log in.`);
+    }
+    else {
+        info(`You need to log in to ${context.reason}.`);
+    }
+    if (context.nonInteractive && context.allowSkip) {
+        warn(`Skipping ${context.reason}; no authentication is available.`);
+        warn(`Make sure the app ID is correct.`);
+        return null;
+    }
+    let shouldLogin;
+    if (context.nonInteractive) {
+        // In non-interactive mode, auto-proceed with login
+        shouldLogin = true;
+        info("Attempting automatic login...");
+    }
+    else {
+        shouldLogin = await confirm({
+            message: "Log in now?",
+            default: true,
+        });
+    }
+    if (!shouldLogin) {
+        if (!context.allowSkip) {
+            error(`Cannot ${context.reason} without authentication. Use --use-existing-app-id to skip app creation.`);
+            // Authentication happens before template prep, so a bail-out here leaves
+            // nothing on disk.
+            warn(`No project files were written. Re-run \`primitive init\` once you can authenticate.`);
+            process.exit(1);
+        }
+        warn(`Skipping. Make sure the app ID is correct.`);
+        return null;
+    }
+    const result = await browserLogin(serverUrl);
+    if (!result.success) {
+        error(`Login failed: ${result.error}`);
+        warn(`No project files were written. Re-run \`primitive init\` once you can authenticate.`);
+        process.exit(1);
+    }
+    success(`Logged in as ${result.credentials.email}`);
+    return result.credentials;
+}
+/**
+ * Loads the init config from --config flag or auto-discovers it in CWD.
+ * Returns null if no config file is found/specified.
+ * Exits with error if config file is specified but invalid.
+ */
+function loadInitConfigFromOptions(options) {
+    let config = null;
+    if (options.config) {
+        // Explicit config path
+        const configPath = resolve(process.cwd(), options.config);
+        if (!existsSync(configPath)) {
+            error(`Config file not found: ${configPath}`);
+            process.exit(1);
+        }
+        try {
+            const content = readFileSync(configPath, "utf-8");
+            config = parseInitConfigToml(content);
+        }
+        catch (err) {
+            error(`Failed to parse config file: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Auto-discover in CWD
+        config = loadInitConfig(process.cwd());
+    }
+    if (!config)
+        return null;
+    // Validate
+    info(`Using config file for non-interactive init`);
+    const validation = validateInitConfig(config);
+    if (!validation.valid) {
+        error("Invalid config file:");
+        for (const err of validation.errors) {
+            error(`  - ${err}`);
+        }
+        process.exit(1);
+    }
+    return config;
+}
 export function registerInitCommand(program) {
     program
         .command("init")
         .description("Create a new Primitive app from template")
         .argument("[directory]", "Directory to create the project in (default: current directory)")
         .option("--use-existing-app-id <id>", "Use an existing app ID instead of creating a new one")
-        .option("-s, --server <url>", "Server URL", DEFAULT_SERVER_URL)
-        .option("--skip-install", "Skip running pnpm install")
+        .option("-s, --server <url>", "Server URL (default: current CLI server or https://primitiveapi.com)")
+        .option("--skip-install", "Skip dependency installation")
+        .option("--config <path>", `Path to an init config file for non-interactive setup (default: auto-discover ${INIT_CONFIG_FILENAME} in the current directory)`)
+        .option("-p, --platform <platform>", "Target platform: web or ios (SwiftUI). Omit to be prompted interactively.")
         .addHelpText("after", `
 Examples:
-  $ primitive init my-app              # Create in ./my-app, prompt for app name
-  $ primitive init                     # Interactive: prompt for directory and app name
+  $ primitive init my-app                            # Create web app in ./my-app
+  $ primitive init                                   # Interactive: prompt for directory and app name
+  $ primitive init my-app --platform ios             # Create an iOS (SwiftUI) app
   $ primitive init . --use-existing-app-id 01HXY...  # Use existing app in current dir
   $ primitive init my-app --skip-install             # Skip dependency install
+  $ primitive init --config .primitive-init.toml     # Non-interactive from config file
+
+Non-interactive mode:
+  Create a ${INIT_CONFIG_FILENAME} file (or pass --config <path>) to skip all prompts.
+  The config file uses TOML format:
+
+    action = "create"          # "create" or "use-existing"
+    app_name = "My App"        # Required for action = "create"
+    app_id = "01HXY..."        # Required for action = "use-existing"
+    dir = "my-app"             # Project directory (optional)
+    platform = "web"           # "web" or "ios" (optional, defaults to web)
+    access_mode = "invite-only" # "public", "domain", or "invite-only" (optional)
+    dev_port = 5173            # Dev server port (optional)
+    skip_install = false       # Skip pnpm install (optional)
+    server = "https://..."     # Custom server URL (optional)
+    invite_emails = ["a@b.com"] # Emails to invite (optional, for invite-only)
+    allowed_domains = ["b.com"] # Allowed domains (optional, for domain mode)
+    overwrite = false           # Overwrite non-empty target directory (optional)
 
 This command will:
-  1. Download the Primitive app template
+  1. Download the Primitive app template (web or Apple SwiftUI)
   2. Prompt for an app name and create it on the Primitive server (or use existing)
   3. Configure the project with your app ID
-  4. Install dependencies with pnpm
+  4. Install dependencies (pnpm for web, swift package resolve for Apple)
 `)
         .action(handleInit);
 }
 async function handleInit(projectDirArg, options) {
-    const serverUrl = options.server || DEFAULT_SERVER_URL;
+    // Validate an explicitly-passed `--platform` flag up front. Only `web` and
+    // `ios` are supported (#1009 removed `macos`). An omitted flag is
+    // `undefined` (the commander default was dropped) and is resolved below.
+    if (options.platform !== undefined &&
+        options.platform !== "web" &&
+        options.platform !== "ios") {
+        error(`Unknown platform "${options.platform}". Supported platforms: web, ios`);
+        process.exit(1);
+    }
+    // `initConfig` is the parsed-and-validated `primitive-init.toml` for
+    // non-interactive runs (CI, scripted scaffolding). When non-null, the
+    // rest of this function uses it to skip prompts.
+    const initConfig = loadInitConfigFromOptions(options);
+    // Resolve the target platform per the 4-case interactivity contract:
+    //   (a) explicit --platform flag    -> use it (never prompt)
+    //   (b) init-config TOML present     -> use its platform or fall back to web
+    //   (c) interactive TTY, no flag/cfg -> prompt
+    //   (d) non-TTY, no flag/cfg         -> fall back to web (no hang/crash)
+    // The prompt is TTY-guarded inside `resolvePlatform` so a piped/CI stdin
+    // never triggers the `@inquirer/prompts` `ERR_USE_AFTER_CLOSE` crash.
+    const platform = await resolvePlatform({
+        flag: options.platform,
+        configPlatform: initConfig?.platform,
+        hasConfig: initConfig != null,
+        isTTY: Boolean(process.stdin.isTTY),
+        promptFn: () => select({
+            message: "What platform are you building for?",
+            choices: [
+                { value: "web", name: "web (Vue 3 + TypeScript + Tailwind)" },
+                { value: "ios", name: "ios (Swift + SwiftUI)" },
+            ],
+            default: "web",
+        }),
+    });
+    // iOS shares the SwiftUI template, Xcode toolchain, and primitive.json
+    // config path. (macOS was removed in #1009.)
+    const isApple = platform === "ios";
+    // Apple-family platforms require macOS with Xcode.
+    if (isApple && process.platform !== "darwin") {
+        error("iOS apps require macOS with Xcode installed.");
+        process.exit(1);
+    }
+    if (isApple) {
+        const xcodeAvailable = await isXcodeInstalled();
+        if (!xcodeAvailable) {
+            error("Xcode command-line tools are required for Apple development. Install them with: xcode-select --install");
+            process.exit(1);
+        }
+    }
     // Step 1: Determine project directory
     let projectDir = projectDirArg;
+    if (!projectDir && initConfig?.dir) {
+        projectDir = initConfig.dir;
+    }
     if (!projectDir) {
         projectDir = await input({
-            message: "Where would you like to create the project?",
-            default: ".",
+            message: "Project name (a new directory will be created):",
+            default: "my-primitive-app",
             validate: (value) => {
                 if (!value.trim())
-                    return "Directory cannot be empty";
+                    return "Project name cannot be empty";
                 return true;
             },
         });
     }
     const targetDir = resolve(process.cwd(), projectDir);
     // Used as the default app name suggestion when prompting
-    const defaultAppName = projectDir === "." ? basename(targetDir) : projectDir;
+    const defaultAppName = projectDir === "." ? basename(targetDir) : basename(projectDir);
     // Step 2: Check if directory exists and is non-empty
     if (existsSync(targetDir) && !isDirectoryEmpty(targetDir)) {
-        warn(`Directory "${projectDir}" already exists and is not empty.`);
-        const overwrite = await confirm({
-            message: "Do you want to overwrite the existing contents?",
-            default: false,
-        });
-        if (!overwrite) {
-            error("Aborted. Please choose a different project name.");
-            process.exit(1);
+        if (initConfig) {
+            // Non-interactive: require explicit overwrite opt-in
+            if (!initConfig.overwrite) {
+                error(`Directory "${projectDir}" already exists and is not empty.`);
+                error('Set overwrite = true in your config file to allow overwriting.');
+                process.exit(1);
+            }
+            warn(`Directory "${projectDir}" already exists and is not empty. Overwriting (overwrite = true in config).`);
+        }
+        else {
+            warn(`Directory "${projectDir}" already exists and is not empty.`);
+            const overwrite = await confirm({
+                message: "Do you want to overwrite the existing contents?",
+                default: false,
+            });
+            if (!overwrite) {
+                error("Aborted. Please choose a different project name.");
+                process.exit(1);
+            }
         }
     }
-    // Step 3: Download template
-    info("Setting up your project...");
-    try {
-        await downloadAndExtractTemplate({
-            targetDir,
-            onProgress: info,
-        });
+    // Step 2.5: Determine target server
+    let serverUrl;
+    let serverChanged = false;
+    if (options.server) {
+        const validation = validateServerUrl(options.server);
+        if (validation !== true) {
+            error(validation);
+            process.exit(1);
+        }
+        serverUrl = options.server;
+        // Check if explicit --server differs from current credentials
+        const existingCredentials = loadCredentials();
+        if (existingCredentials?.serverUrl &&
+            existingCredentials.serverUrl !== options.server) {
+            serverChanged = true;
+        }
     }
-    catch (err) {
-        error(`Failed to download template: ${err.message}`);
-        error("Check your internet connection and try again.");
-        process.exit(1);
+    else {
+        const existingCredentials = loadCredentials();
+        const currentServer = existingCredentials?.serverUrl;
+        if (currentServer && currentServer !== DEFAULT_SERVER_URL && !initConfig) {
+            console.log();
+            const serverChoice = await select({
+                message: `The Primitive CLI is currently using ${currentServer}.\nWhere do you want to create this app?`,
+                choices: [
+                    {
+                        value: currentServer,
+                        name: `Current server (${currentServer})`,
+                    },
+                    {
+                        value: DEFAULT_SERVER_URL,
+                        name: `Production (${DEFAULT_SERVER_URL})`,
+                    },
+                    {
+                        value: "__custom__",
+                        name: "Other server",
+                    },
+                ],
+                default: currentServer,
+            });
+            if (serverChoice === "__custom__") {
+                serverUrl = await input({
+                    message: "Enter the server URL:",
+                    validate: validateServerUrl,
+                });
+            }
+            else {
+                serverUrl = serverChoice;
+            }
+            serverChanged = currentServer !== serverUrl;
+        }
+        else {
+            serverUrl = currentServer || DEFAULT_SERVER_URL;
+        }
     }
     // Step 4: Check authentication
     let credentials = loadCredentials();
     let appId;
     let appName;
-    if (options.useExistingAppId) {
-        // Using existing app ID - verify it exists
-        appId = options.useExistingAppId;
-        appName = "(existing app)"; // Default if we can't verify
-        if (!credentials) {
-            info("You need to log in to verify the app.");
-            const shouldLogin = await confirm({
-                message: "Log in now?",
-                default: true,
+    let preparedTemplate = null;
+    const cleanupPreparedTemplate = () => {
+        try {
+            preparedTemplate?.cleanup();
+        }
+        catch {
+            // Non-fatal cleanup best effort
+        }
+        preparedTemplate = null;
+    };
+    const prepareTemplateOrExit = async () => {
+        if (preparedTemplate)
+            return;
+        // Download and validate the archive before app creation, but keep it staged
+        // in a temp directory. That avoids both failure modes: app-creation failure
+        // leaves no scaffold, and template-download failure leaves no orphaned app.
+        info(`Preparing your ${platform === "ios" ? "iOS" : "web"} project template...`);
+        try {
+            preparedTemplate = await prepareTemplate({
+                templateUrl: isApple ? IOS_TEMPLATE_URL : undefined,
+                onProgress: info,
             });
-            if (shouldLogin) {
-                const result = await browserLogin(serverUrl);
-                if (!result.success) {
-                    error(`Login failed: ${result.error}`);
-                    warn(`Template files were extracted to "${targetDir}" but VITE_APP_ID is not configured.`);
-                    warn("You'll need to manually set VITE_APP_ID in your .env file to use this project.");
-                    process.exit(1);
-                }
-                credentials = result.credentials;
-                success(`Logged in as ${credentials.email}`);
-            }
-            else {
-                warn("Skipping app verification. Make sure the app ID is correct.");
-            }
         }
+        catch (err) {
+            error(`Failed to download template: ${err.message}`);
+            error("Check your internet connection and try again.");
+            process.exit(1);
+        }
+    };
+    // An existing app can be selected two ways: the `--use-existing-app-id` flag,
+    // or `action = "use-existing"` + `app_id` in the init-config TOML. Reading
+    // only the flag (the old behavior) made a use-existing TOML fall through to
+    // the create branch and prompt for an app name — hanging non-interactive
+    // runs. (#1217)
+    const useExistingAppId = resolveUseExistingAppId(options.useExistingAppId, initConfig);
+    if (useExistingAppId) {
+        // Using existing app ID - verify it exists
+        appId = useExistingAppId;
+        appName = "(existing app)"; // Default if we can't verify
+        credentials = await ensureAuthenticated(credentials, serverUrl, serverChanged, {
+            reason: "verify the app",
+            allowSkip: true,
+            nonInteractive: !!initConfig,
+        });
         if (credentials) {
             try {
                 const client = new ApiClient();
@@ -113,36 +486,27 @@ async function handleInit(projectDirArg, options) {
                 warn(`Could not verify app: ${err.message}`);
             }
         }
+        await prepareTemplateOrExit();
     }
     else {
         // Creating new app - authentication required
-        if (!credentials) {
-            info("You need to log in to create an app.");
-            const shouldLogin = await confirm({
-                message: "Log in now?",
-                default: true,
+        credentials = await ensureAuthenticated(credentials, serverUrl, serverChanged, {
+            reason: "create an app",
+            allowSkip: false,
+            nonInteractive: !!initConfig,
+        });
+        // Determine app name
+        if (initConfig?.app_name) {
+            appName = initConfig.app_name;
+            info(`App name: ${appName} (from config)`);
+        }
+        else {
+            appName = await input({
+                message: "What would you like to name your app?",
+                default: defaultAppName,
             });
-            if (!shouldLogin) {
-                error("Cannot create app without authentication. Use --use-existing-app-id to skip app creation.");
-                warn(`Template files were extracted to "${targetDir}" but VITE_APP_ID is not configured.`);
-                warn("You'll need to manually set VITE_APP_ID in your .env file to use this project.");
-                process.exit(1);
-            }
-            const result = await browserLogin(serverUrl);
-            if (!result.success) {
-                error(`Login failed: ${result.error}`);
-                warn(`Template files were extracted to "${targetDir}" but VITE_APP_ID is not configured.`);
-                warn("You'll need to manually set VITE_APP_ID in your .env file to use this project.");
-                process.exit(1);
-            }
-            credentials = result.credentials;
-            success(`Logged in as ${credentials.email}`);
         }
-        // Prompt for app name
-        appName = await input({
-            message: "What would you like to name your app?",
-            default: defaultAppName,
-        });
+        await prepareTemplateOrExit();
         // Create app
         info("Creating app on Primitive server...");
         try {
@@ -162,52 +526,68 @@ async function handleInit(projectDirArg, options) {
         catch (err) {
             error(`Failed to create app: ${err.message}`);
             error("You can try again or use --use-existing-app-id with an existing app.");
-            warn(`Template files were extracted to "${targetDir}" but VITE_APP_ID is not configured.`);
-            warn("You'll need to manually set VITE_APP_ID in your .env file to use this project.");
+            // The template archive has been validated in a temp directory, but it has
+            // not been installed into targetDir yet (#1218).
+            warn("No project files were written. Re-run `primitive init` after resolving the app creation error.");
+            cleanupPreparedTemplate();
             process.exit(1);
         }
         // Configure app access mode
-        console.log();
-        info("Let's configure who can access your app.");
-        info("(You can change this later with 'primitive apps update')");
-        const accessMode = await select({
-            message: "Who should be able to sign up for your app?",
-            choices: [
-                {
-                    value: "public",
-                    name: "Anyone (public)",
-                    description: "Anyone can create an account",
-                },
-                {
-                    value: "domain",
-                    name: "Domain restricted",
-                    description: "Only users with email addresses from specific domains",
-                },
-                {
-                    value: "invite-only",
-                    name: "Invite only",
-                    description: "Only users you explicitly invite can sign up",
-                },
-            ],
-            default: "invite-only",
-        });
+        let accessMode;
+        if (initConfig?.access_mode) {
+            accessMode = initConfig.access_mode;
+            info(`Access mode: ${accessMode} (from config)`);
+        }
+        else {
+            console.log();
+            info("Let's configure who can access your app.");
+            info("(You can change this later with 'primitive apps update')");
+            accessMode = await select({
+                message: "Who should be able to sign up for your app?",
+                choices: [
+                    {
+                        value: "public",
+                        name: "Anyone (public)",
+                        description: "Anyone can create an account",
+                    },
+                    {
+                        value: "domain",
+                        name: "Domain restricted",
+                        description: "Only users with email addresses from specific domains",
+                    },
+                    {
+                        value: "invite-only",
+                        name: "Invite only",
+                        description: "Only users you explicitly invite can sign up",
+                    },
+                ],
+                default: "invite-only",
+            });
+        }
         const client = new ApiClient();
         const settingsPayload = {
             mode: accessMode,
         };
         if (accessMode === "domain") {
-            const domainsInput = await input({
-                message: "Enter allowed email domain(s) (comma-separated, e.g., 'acme.com, example.org'):",
-                validate: (value) => {
-                    if (!value.trim())
-                        return "Please enter at least one domain";
-                    return true;
-                },
-            });
-            const allowedDomains = domainsInput
-                .split(",")
-                .map((d) => d.trim().toLowerCase())
-                .filter((d) => d.length > 0);
+            let allowedDomains;
+            if (initConfig?.allowed_domains && initConfig.allowed_domains.length > 0) {
+                allowedDomains = initConfig.allowed_domains;
+                info(`Allowed domains: ${allowedDomains.join(", ")} (from config)`);
+            }
+            else {
+                const domainsInput = await input({
+                    message: "Enter allowed email domain(s) (comma-separated, e.g., 'acme.com, example.org'):",
+                    validate: (value) => {
+                        if (!value.trim())
+                            return "Please enter at least one domain";
+                        return true;
+                    },
+                });
+                allowedDomains = domainsInput
+                    .split(",")
+                    .map((d) => d.trim().toLowerCase())
+                    .filter((d) => d.length > 0);
+            }
             settingsPayload.allowedDomains = allowedDomains;
         }
         // Update app settings with the chosen mode
@@ -218,34 +598,57 @@ async function handleInit(projectDirArg, options) {
         catch (err) {
             warn(`Could not update app settings: ${err.message}`);
         }
-        // If invite-only, offer to add initial allowed users
+        // If invite-only, auto-add the authenticated user and offer to add others
         if (accessMode === "invite-only") {
-            const inviteNow = await confirm({
-                message: "Would you like to add initial users who can sign up? (no emails will be sent)",
-                default: false,
-            });
-            if (inviteNow) {
-                const emailsInput = await input({
-                    message: "Enter email address(es) to allow (comma-separated):",
-                    validate: (value) => {
-                        if (!value.trim())
-                            return "Please enter at least one email";
-                        const emails = value.split(",").map((e) => e.trim());
-                        for (const email of emails) {
-                            if (!email.includes("@")) {
-                                return `Invalid email: ${email}`;
-                            }
-                        }
-                        return true;
-                    },
+            try {
+                await client.createInvitation(appId, {
+                    email: credentials.email,
+                    role: "member",
+                    sendEmail: false,
                 });
-                const emails = emailsInput
-                    .split(",")
-                    .map((e) => e.trim())
-                    .filter((e) => e.length > 0);
+                success(`${credentials.email} added to the invite list.`);
+            }
+            catch (err) {
+                if (!err.message?.includes("already has a pending invitation")) {
+                    warn(`Could not add your email to the invite list: ${err.message}`);
+                }
+            }
+            // Determine emails to invite
+            let emailsToInvite = [];
+            if (initConfig?.invite_emails && initConfig.invite_emails.length > 0) {
+                emailsToInvite = initConfig.invite_emails;
+                info(`Inviting users from config: ${emailsToInvite.join(", ")}`);
+            }
+            else if (!initConfig) {
+                const inviteNow = await confirm({
+                    message: "Would you like to add initial users who can sign up? (no emails will be sent)",
+                    default: false,
+                });
+                if (inviteNow) {
+                    const emailsInput = await input({
+                        message: "Enter email address(es) to allow (comma-separated):",
+                        validate: (value) => {
+                            if (!value.trim())
+                                return "Please enter at least one email";
+                            const emails = value.split(",").map((e) => e.trim());
+                            for (const email of emails) {
+                                if (!email.includes("@")) {
+                                    return `Invalid email: ${email}`;
+                                }
+                            }
+                            return true;
+                        },
+                    });
+                    emailsToInvite = emailsInput
+                        .split(",")
+                        .map((e) => e.trim())
+                        .filter((e) => e.length > 0);
+                }
+            }
+            if (emailsToInvite.length > 0) {
                 info("Adding invited users...");
                 let inviteCount = 0;
-                for (const email of emails) {
+                for (const email of emailsToInvite) {
                     try {
                         await client.createInvitation(appId, {
                             email,
@@ -264,98 +667,305 @@ async function handleInit(projectDirArg, options) {
             }
         }
     }
-    // Step 5: Update .env file
-    info("Configuring environment...");
+    // Step 3 (deferred): install the already-prepared template + init git, now
+    // that the app exists. The network download and archive validation already
+    // happened before createApp, without touching targetDir.
+    info(`Setting up your ${platform === "ios" ? "iOS" : "web"} project...`);
     try {
-        const envResult = updateEnvFile(targetDir, appId);
-        if (!envResult.envUpdated) {
-            warn("No .env or .env.example file found in template.");
-            warn(`Please manually set VITE_APP_ID=${appId} in your .env file.`);
-        }
-        else if (!envResult.envProductionUpdated) {
-            info(".env configured. No .env.production file found (this is optional).");
-        }
-        else {
-            success("Environment configured (.env and .env.production).");
-        }
+        preparedTemplate.install(targetDir);
+        success("Template extracted successfully.");
     }
     catch (err) {
-        warn(`Could not update .env file: ${err.message}`);
-        warn(`Please manually set VITE_APP_ID=${appId} in your .env file.`);
-    }
-    // Step 6: Check if pnpm is installed globally, offer to install if not
-    const pnpmInstalled = await isPnpmInstalled();
-    if (!pnpmInstalled) {
-        console.log();
-        info("pnpm is not installed globally on your system.");
-        const installPnpm = await confirm({
-            message: "Install pnpm globally? (recommended for future use)",
-            default: true,
-        });
-        if (installPnpm) {
-            info("Installing pnpm...");
+        error(`Failed to write template files: ${err.message}`);
+        cleanupPreparedTemplate();
+        process.exit(1);
+    }
+    finally {
+        cleanupPreparedTemplate();
+    }
+    // Initialize git repository (commit happens later, after env + install)
+    try {
+        await gitInitRepo(targetDir);
+    }
+    catch {
+        // Non-fatal: git may not be installed, or already a git repo
+    }
+    // Step 4.5: Update CLI to point at this app
+    try {
+        setCurrentApp(appId, appName);
+        info(`CLI now using app: ${appName} (${appId})`);
+    }
+    catch (err) {
+        // Not critical - user may not be logged in (e.g. used --use-existing-app-id without login)
+        warn(`Could not set current app in CLI config: ${err.message}`);
+    }
+    // Steps 5-8: Platform-specific configuration and dependency installation
+    if (isApple) {
+        // ── Apple (SwiftUI) path ──────────────────────────────────────────
+        // Step 5: Update primitive.json
+        info("Configuring primitive.json...");
+        try {
+            const updated = updatePrimitiveJson(targetDir, appId, serverUrl, appName);
+            if (!updated) {
+                warn("No primitive.json file found in template.");
+                warn(`Please manually set appId to "${appId}" in your primitive.json.`);
+            }
+            else {
+                success("primitive.json configured.");
+            }
+        }
+        catch (err) {
+            warn(`Could not update primitive.json: ${err.message}`);
+            warn(`Please manually set appId to "${appId}" in your primitive.json.`);
+        }
+        // Step 6-7: Skip port selection and pnpm (not applicable to Apple)
+        // Step 8: Resolve Swift packages
+        if (!options.skipInstall) {
+            info("Resolving Swift packages (this may take a few minutes)...");
             try {
-                await installPnpmGlobally();
-                success("pnpm installed globally. You can now use 'pnpm' commands.");
+                await runSwiftPackageResolve(targetDir);
+                success("Swift packages resolved.");
             }
             catch (err) {
-                warn(`Could not install pnpm: ${err.message}`);
-                warn("Will use npx to run pnpm for dependency installation.");
+                warn(`Swift package resolution failed: ${err.message}`);
+                warn("You can try running 'swift package resolve' manually.");
             }
         }
+        else {
+            info("Skipping dependency installation (--skip-install).");
+        }
     }
-    // Step 7: Install dependencies with pnpm (via npx to handle version management)
-    if (!options.skipInstall) {
-        info("Installing dependencies...");
+    else {
+        // ── Web path ──────────────────────────────────────────────────────
+        // Step 5: Update .env file
+        info("Configuring environment...");
         try {
-            await runPnpmInstall(targetDir);
-            success("Dependencies installed.");
+            const envResult = updateEnvFile(targetDir, appId, serverUrl, appName);
+            if (!envResult.envUpdated) {
+                warn("No .env or .env.example file found in template.");
+                warn(`Please manually set VITE_APP_ID=${appId} in your .env file.`);
+            }
+            else if (!envResult.envProductionUpdated) {
+                info(".env configured. No .env.production file found (this is optional).");
+            }
+            else {
+                success("Environment configured (.env and .env.production).");
+            }
         }
         catch (err) {
-            warn(`Dependency installation failed: ${err.message}`);
-            warn("You can try running 'npx pnpm install' manually.");
+            warn(`Could not update .env file: ${err.message}`);
+            warn(`Please manually set VITE_APP_ID=${appId} in your .env file.`);
+        }
+        // Step 6: Confirm the dev port to use. Default to 5173; warn about taken ports.
+        try {
+            console.log();
+            const defaultPort = 5173;
+            const defaultOrigin = `http://localhost:${defaultPort}`;
+            // Scan up to 10 ports starting from 5173 to surface what's already in use
+            const takenPorts = [];
+            for (let p = defaultPort; p < defaultPort + 10; p++) {
+                if (!(await isPortFree(p)))
+                    takenPorts.push(p);
+                else
+                    break;
+            }
+            if (takenPorts.length > 0) {
+                warn(`Port${takenPorts.length > 1 ? "s" : ""} ${takenPorts.join(", ")} ${takenPorts.length > 1 ? "are" : "is"} already in use.`);
+            }
+            const portInput = await input({
+                message: "Dev server port for this project:",
+                default: String(defaultPort),
+                validate: (val) => {
+                    const n = parseInt(val, 10);
+                    if (isNaN(n) || n < 1 || n > 65535)
+                        return "Enter a valid port number.";
+                    return true;
+                },
+            });
+            const chosenPort = parseInt(portInput, 10);
+            if (chosenPort !== defaultPort) {
+                const devOrigin = `http://localhost:${chosenPort}`;
+                // Pin the port in vite.config.ts and update .env
+                updateViteConfig(targetDir, chosenPort);
+                updateEnvPort(targetDir, chosenPort);
+                // Update app settings: CORS, redirect URIs, baseUrl
+                if (!credentials) {
+                    info(`Local files updated. Skipping server CORS/redirect config — not authenticated.`);
+                }
+                else {
+                    try {
+                        const client = new ApiClient();
+                        let existingOrigins = [];
+                        let existingRedirectUris = [];
+                        try {
+                            const currentSettings = await client.getAppSettings(appId);
+                            if (currentSettings.corsMode === "custom" &&
+                                Array.isArray(currentSettings.corsAllowedOrigins)) {
+                                existingOrigins = currentSettings.corsAllowedOrigins;
+                            }
+                            if (Array.isArray(currentSettings.redirectUris)) {
+                                existingRedirectUris = currentSettings.redirectUris;
+                            }
+                        }
+                        catch {
+                            // Ignore — will set a fresh config
+                        }
+                        // Always include 5173 since it's the universal localhost default
+                        const corsOrigins = Array.from(new Set([...existingOrigins, defaultOrigin, devOrigin]));
+                        const redirectUris = Array.from(new Set([
+                            ...existingRedirectUris,
+                            `${defaultOrigin}/oauth/callback`,
+                            `${devOrigin}/oauth/callback`,
+                        ]));
+                        await client.updateAppSettings(appId, {
+                            corsMode: "custom",
+                            corsAllowedOrigins: corsOrigins,
+                            corsAllowCredentials: true,
+                            redirectUris,
+                            baseUrl: devOrigin,
+                        });
+                        success(`Dev port set to ${chosenPort}: vite.config.ts, .env, CORS, redirect URIs, and base URL updated.`);
+                    }
+                    catch (err) {
+                        warn(`Could not update app settings: ${err.message}`);
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-fatal: port detection or settings update failed silently
+        }
+        // Step 7: Check if pnpm is installed globally, offer to install if not
+        const pnpmInstalled = await isPnpmInstalled();
+        if (!pnpmInstalled) {
+            console.log();
+            info("pnpm is not installed globally on your system.");
+            const installPnpm = await confirm({
+                message: "Install pnpm globally? (recommended for future use)",
+                default: true,
+            });
+            if (installPnpm) {
+                info("Installing pnpm...");
+                try {
+                    await installPnpmGlobally();
+                    success("pnpm installed globally. You can now use 'pnpm' commands.");
+                }
+                catch (err) {
+                    warn(`Could not install pnpm: ${err.message}`);
+                    warn("Will use npx to run pnpm for dependency installation.");
+                }
+            }
+        }
+        // Step 8: Install dependencies with pnpm (via npx to handle version management)
+        if (!options.skipInstall) {
+            info("Installing dependencies...");
+            try {
+                await runPnpmInstall(targetDir);
+                success("Dependencies installed.");
+            }
+            catch (err) {
+                warn(`Dependency installation failed: ${err.message}`);
+                warn("You can try running 'npx pnpm install' manually.");
+            }
+        }
+        else {
+            info("Skipping dependency installation (--skip-install).");
         }
     }
-    else {
-        info("Skipping dependency installation (--skip-install).");
-    }
-    // Step 8: Install primitive CLI globally if not already installed
+    // Step 9: Install primitive CLI globally if not already installed
     const cliInstalled = await isPrimitiveCliInstalled();
     if (!cliInstalled) {
-        console.log();
-        info("The Primitive CLI helps you manage your app from the command line.");
-        const installCli = await confirm({
-            message: "Install the Primitive CLI globally?",
-            default: true,
-        });
-        if (installCli) {
+        if (initConfig) {
+            // Non-interactive: auto-install CLI
             info("Installing Primitive CLI...");
             try {
                 await installPrimitiveCli();
-                success("Primitive CLI installed. You can now use 'primitive' commands.");
+                success("Primitive CLI installed.");
             }
             catch (err) {
                 warn(`Could not install CLI: ${err.message}`);
                 warn("You can install it manually with: npm install -g primitive-admin");
             }
         }
+        else {
+            console.log();
+            info("The Primitive CLI helps you manage your app from the command line.");
+            const installCli = await confirm({
+                message: "Install the Primitive CLI globally?",
+                default: true,
+            });
+            if (installCli) {
+                info("Installing Primitive CLI...");
+                try {
+                    await installPrimitiveCli();
+                    success("Primitive CLI installed. You can now use 'primitive' commands.");
+                }
+                catch (err) {
+                    warn(`Could not install CLI: ${err.message}`);
+                    warn("You can install it manually with: npm install -g primitive-admin");
+                }
+            }
+        }
+    }
+    // Step 10: Offer to install Claude Code skill if not already installed
+    try {
+        const { isSkillInstalled, installSkillExplicit, checkSkillStatus } = await import("../lib/skill-installer.js");
+        if (isSkillInstalled()) {
+            // Already installed — silently auto-update if a newer version is bundled
+            await checkSkillStatus();
+        }
+        else if (initConfig) {
+            // Non-interactive: auto-install skill
+            installSkillExplicit();
+        }
+        else {
+            console.log();
+            info("The Primitive platform skill gives Claude Code expertise with Primitive APIs and patterns.");
+            const installSkill = await confirm({
+                message: "Install the Primitive platform skill for Claude Code?",
+                default: true,
+            });
+            if (installSkill) {
+                installSkillExplicit();
+            }
+        }
     }
-    // Step 9: Show success message
+    catch {
+        // Non-fatal: skill installation should never block init
+    }
+    // Step 11: Create initial git commit (captures env config + installed dependencies)
+    try {
+        await gitInitialCommit(targetDir);
+    }
+    catch {
+        // Non-fatal: git may not be installed, or already committed
+    }
+    // Step 12: Show success message
     divider();
     success("Project initialized successfully!");
     divider();
     keyValue("Directory", targetDir);
     keyValue("App Name", appName);
     keyValue("App ID", appId);
+    keyValue("Platform", platform === "ios" ? "iOS (SwiftUI)" : "Web");
     divider();
     info("Next steps:");
     if (projectDir !== ".") {
         console.log(`  cd ${projectDir}`);
     }
-    if (options.skipInstall) {
-        console.log("  pnpm install");
+    if (isApple) {
+        if (options.skipInstall) {
+            console.log("  swift package resolve");
+        }
+        console.log("  open *.xcodeproj");
+        console.log("  # or: ./run-ios.sh (iOS Simulator)");
+    }
+    else {
+        if (options.skipInstall) {
+            console.log("  pnpm install");
+        }
+        console.log("  pnpm dev");
     }
-    console.log("  pnpm run dev");
     console.log();
 }
 //# sourceMappingURL=init.js.map