primitive-admin 1.1.0-alpha.3 → 1.1.0-alpha.31

package/dist/src/commands/init.js

@@ -1,70 +1,390 @@
-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, validateInitConfig, } from "../lib/init-config.js";
+import { divider, error, info, keyValue, success, warn, } from "../lib/output.js";
+import { downloadAndExtractTemplate, gitInitialCommit, gitInitRepo, installPnpmGlobally, installPrimitiveCli, isDirectoryEmpty, isPnpmInstalled, isPortFree, isPrimitiveCliInstalled, isXcodeInstalled, IOS_TEMPLATE_URL, runPnpmInstall, runSwiftPackageResolve, updateEnvFile, updateEnvPort, updatePrimitiveJson, updateViteConfig, } from "../lib/template.js";
 const DEFAULT_SERVER_URL = process.env.PRIMITIVE_SERVER_URL || "https://primitiveapi.com";
+/**
+ * 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 = [
+        ".primitive/credentials.json",
+        ".primitive/sync/**/.primitive-sync.json",
+    ];
+    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}.`);
+    }
+    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,
+        });
+    }
+    const configHint = context.platform === "apple"
+        ? `You'll need to manually set appId in your primitive.json file to use this project.`
+        : `You'll need to manually set VITE_APP_ID in your .env file to use this project.`;
+    const configField = context.platform === "apple" ? "appId" : "VITE_APP_ID";
+    if (!shouldLogin) {
+        if (!context.allowSkip) {
+            error(`Cannot ${context.reason} without authentication. Use --use-existing-app-id to skip app creation.`);
+            warn(`Template files were extracted to "${context.targetDir}" but ${configField} is not configured.`);
+            warn(configHint);
+            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(`Template files were extracted to "${context.targetDir}" but ${configField} is not configured.`);
+        warn(configHint);
+        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("-p, --platform <platform>", "Target platform: web (default) or apple (iOS/macOS SwiftUI)", "web")
         .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 apple           # Create iOS/macOS 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)
+    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;
+    const platform = options.platform || "web";
+    const isApple = platform === "apple";
+    // `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);
+    // Validate platform
+    if (platform !== "web" && platform !== "apple") {
+        error(`Unknown platform "${platform}". Supported platforms: web, apple`);
+        process.exit(1);
+    }
+    // Apple platform requires macOS with Xcode
+    if (isApple && process.platform !== "darwin") {
+        error("The Apple platform requires 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.");
+        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 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;
+        }
+    }
+    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 3: Download template
-    info("Setting up your project...");
+    info(`Setting up your ${isApple ? "Apple" : "web"} project...`);
     try {
         await downloadAndExtractTemplate({
             targetDir,
+            templateUrl: isApple ? IOS_TEMPLATE_URL : undefined,
             onProgress: info,
         });
     }
@@ -73,6 +393,13 @@ async function handleInit(projectDirArg, options) {
         error("Check your internet connection and try again.");
         process.exit(1);
     }
+    // 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: Check authentication
     let credentials = loadCredentials();
     let appId;
@@ -81,27 +408,13 @@ async function handleInit(projectDirArg, options) {
         // 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,
-            });
-            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.");
-            }
-        }
+        credentials = await ensureAuthenticated(credentials, serverUrl, serverChanged, {
+            reason: "verify the app",
+            targetDir,
+            allowSkip: true,
+            platform,
+            nonInteractive: !!initConfig,
+        });
         if (credentials) {
             try {
                 const client = new ApiClient();
@@ -116,33 +429,24 @@ async function handleInit(projectDirArg, options) {
     }
     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",
+            targetDir,
+            allowSkip: false,
+            platform,
+            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,
-        });
         // Create app
         info("Creating app on Primitive server...");
         try {
@@ -162,52 +466,72 @@ 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.");
+            if (isApple) {
+                warn(`Template files were extracted to "${targetDir}" but appId is not configured.`);
+                warn("You'll need to manually set appId in your primitive.json file to use this project.");
+            }
+            else {
+                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);
         }
         // 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 +542,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 +611,282 @@ async function handleInit(projectDirArg, options) {
             }
         }
     }
-    // Step 5: Update .env file
-    info("Configuring environment...");
+    // Step 4.5: Update CLI to point at this app
     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).");
-        }
+        setCurrentApp(appId, appName);
+        info(`CLI now using app: ${appName} (${appId})`);
     }
     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...");
+        // 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 9: Show success message
+    // 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();
+            }
+        }
+    }
+    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", isApple ? "Apple (iOS/macOS 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.sh (macOS) / ./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