@anvil-works/anvil-cli 0.8.0-canary.21 → 0.8.0-canary.23

package/dist/index.js

@@ -6705,6 +6705,10 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("fs");
     },
+    ora (module) {
+        "use strict";
+        module.exports = require("ora");
+    },
     os (module) {
         "use strict";
         module.exports = require("os");
@@ -7373,6 +7377,7 @@ var __webpack_exports__ = {};
         AppIdWithContext: ()=>anvil_api_namespaceObject.AppIdWithContext,
         inspectCredentialHelperCommand: ()=>inspectCredentialHelperCommand,
         executeCheckout: ()=>executeCheckout,
+        executeCreate: ()=>executeCreate,
         validateCheckoutDestination: ()=>validateCheckoutDestination,
         DeviceAuthorizationResponse: ()=>oauth_login_namespaceObject.DeviceAuthorizationResponse,
         OAuthTokenResponse: ()=>oauth_login_namespaceObject.OAuthTokenResponse,
@@ -7446,7 +7451,9 @@ var __webpack_exports__ = {};
         setInMemoryTokens: ()=>setInMemoryTokens,
         validateAppId: ()=>anvil_api_validateAppId,
         pollDeviceAuthorization: ()=>pollDeviceAuthorization,
+        createAnvilApp: ()=>createAnvilApp,
         getValidAuthToken: ()=>auth_getValidAuthToken,
+        CreatedAnvilApp: ()=>anvil_api_namespaceObject.CreatedAnvilApp,
         watch: ()=>src_api_watch,
         deleteConfig: ()=>deleteConfig,
         installModelTokenHelperScript: ()=>installModelTokenHelperScript,
@@ -7462,11 +7469,12 @@ var __webpack_exports__ = {};
         CheckoutResult: ()=>checkout_namespaceObject.CheckoutResult,
         ParsedCheckoutInput: ()=>checkout_namespaceObject.ParsedCheckoutInput,
         parseCredentialHelperCommand: ()=>parseCredentialHelperCommand,
-        MODEL_TOKEN_LOCK_TIMEOUT_MS: ()=>MODEL_TOKEN_LOCK_TIMEOUT_MS,
+        CreateCheckoutError: ()=>CreateCheckoutError,
         GetValidAuthTokenOptions: ()=>auth_namespaceObject.GetValidAuthTokenOptions,
-        clearInMemoryTokens: ()=>clearInMemoryTokens,
+        MODEL_TOKEN_LOCK_TIMEOUT_MS: ()=>MODEL_TOKEN_LOCK_TIMEOUT_MS,
         getDefaultDestinationDirectory: ()=>getDefaultDestinationDirectory,
         AUTH_FILE_LOCK_DEFAULTS: ()=>AUTH_FILE_LOCK_DEFAULTS,
+        clearInMemoryTokens: ()=>clearInMemoryTokens,
         lookupByCommit: ()=>lookupByCommit,
         AppIdCandidate: ()=>anvil_api_namespaceObject.AppIdCandidate,
         verifyAuth: ()=>auth_verifyAuth
@@ -7483,6 +7491,7 @@ var __webpack_exports__ = {};
         P$: ()=>config_isCommandAvailable,
         n: ()=>config_isDevMode,
         Wj: ()=>config_isTestMode,
+        Wc: ()=>config_normalizeAnvilOrigin,
         Vl: ()=>config_normalizeAnvilUrl,
         PW: ()=>parseConfigSetValue,
         cx: ()=>preferredEditors,
@@ -7511,19 +7520,20 @@ var __webpack_exports__ = {};
     var anvil_api_namespaceObject = {};
     __webpack_require__.r(anvil_api_namespaceObject);
     __webpack_require__.d(anvil_api_namespaceObject, {
-        lx: ()=>anvil_api_detectAppIdsByCommitLookup,
-        NZ: ()=>anvil_api_detectAppIdsFromAllRemotes,
-        rZ: ()=>anvil_api_filterCandidates,
-        T_: ()=>anvil_api_formatCandidateLabel,
-        OI: ()=>anvil_api_getGitFetchUrl,
-        _r: ()=>anvil_api_getGitPushUrl,
-        CA: ()=>getLatestVersion,
-        $0: ()=>getWebSocketUrl,
-        A1: ()=>listAppsForCheckout,
-        l9: ()=>lookupByCommit,
-        Wj: ()=>anvil_api_lookupRemoteInfoForAppId,
-        Us: ()=>saveUpdates,
-        zW: ()=>anvil_api_validateAppId
+        createAnvilApp: ()=>createAnvilApp,
+        detectAppIdsByCommitLookup: ()=>anvil_api_detectAppIdsByCommitLookup,
+        detectAppIdsFromAllRemotes: ()=>anvil_api_detectAppIdsFromAllRemotes,
+        filterCandidates: ()=>anvil_api_filterCandidates,
+        formatCandidateLabel: ()=>anvil_api_formatCandidateLabel,
+        getGitFetchUrl: ()=>anvil_api_getGitFetchUrl,
+        getGitPushUrl: ()=>anvil_api_getGitPushUrl,
+        getLatestVersion: ()=>getLatestVersion,
+        getWebSocketUrl: ()=>getWebSocketUrl,
+        listAppsForCheckout: ()=>listAppsForCheckout,
+        lookupByCommit: ()=>lookupByCommit,
+        lookupRemoteInfoForAppId: ()=>anvil_api_lookupRemoteInfoForAppId,
+        saveUpdates: ()=>saveUpdates,
+        validateAppId: ()=>anvil_api_validateAppId
     });
     var validators_namespaceObject = {};
     __webpack_require__.r(validators_namespaceObject);
@@ -7553,6 +7563,7 @@ var __webpack_exports__ = {};
         A9: ()=>isDirectoryNonEmpty,
         oU: ()=>isPathInsideGitRepo,
         Qx: ()=>parseCheckoutInput,
+        B6: ()=>resolveCheckoutUrlForApi,
         KV: ()=>sanitizeDirectoryName,
         Bc: ()=>validateCheckoutDestination
     });
@@ -13109,12 +13120,25 @@ var __webpack_exports__ = {};
         if (!urlInput || "string" != typeof urlInput) return urlInput;
         let url = urlInput.trim();
         url = url.replace(/\/+$/, "");
-        if ("localhost" === url || url.startsWith("localhost:")) return "http://localhost:3000";
-        if ("http://localhost" === url || url.startsWith("http://localhost:")) return "http://localhost:3000";
-        if ("https://localhost" === url || url.startsWith("https://localhost:")) return "http://localhost:3000";
-        if (/^https?:\/\//.test(url)) return url;
+        if ("localhost" === url) return "http://localhost:3000";
+        if (url.startsWith("localhost:")) return `http://${url}`;
+        if (/^https?:\/\//i.test(url)) return url;
         return `https://${url}`;
     }
+    function config_normalizeAnvilOrigin(input) {
+        try {
+            const raw = input.trim();
+            const normalized = config_normalizeAnvilUrl(raw);
+            const url = new URL(raw.includes("://") ? raw : normalized);
+            if (![
+                "http:",
+                "https:"
+            ].includes(url.protocol) || url.username || url.password || "/" !== url.pathname || url.search || url.hash) throw new Error("Invalid origin");
+            return normalized;
+        } catch  {
+            throw new Error("Server URL must be an HTTP(S) origin without credentials, a path, query, or fragment.");
+        }
+    }
     function resolveAnvilUrl() {
         const fromConfig = config_getConfig("anvilUrl");
         if ("string" == typeof fromConfig && fromConfig.trim()) return fromConfig.trim();
@@ -14774,6 +14798,39 @@ Promise.resolve()
     function anvil_api_getDefaultAnvilUrl() {
         return resolveAnvilUrl();
     }
+    async function createAnvilApp(options) {
+        let response;
+        try {
+            response = await fetch(`${options.anvilUrl}/ide/api/_/apps`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${options.authToken}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    name: options.name,
+                    tags: options.tags
+                })
+            });
+        } catch (error) {
+            throw createNetworkError.network(error.message);
+        }
+        const data = await response.json().catch(()=>({}));
+        if (!response.ok) {
+            if (401 === response.status || 403 === response.status) throw createAuthError.invalid(data.error || "Not authorized to create an app");
+            throw new Error(data.error || `Failed to create app: ${response.status} ${response.statusText}`);
+        }
+        if ("string" != typeof data.id || !data.id) throw new Error("App creation response did not contain an app ID.");
+        return {
+            id: data.id,
+            ..."string" == typeof data.name ? {
+                name: data.name
+            } : {},
+            ...data.tags ? {
+                tags: data.tags
+            } : {}
+        };
+    }
     async function anvil_api_validateAppId(appId, anvilUrl = anvil_api_getDefaultAnvilUrl(), username) {
         const authToken = await auth_getValidAuthToken(anvilUrl, username);
         try {
@@ -14945,14 +15002,15 @@ Promise.resolve()
         try {
             const remotes = await git.getRemotes(true);
             for (const remote of remotes){
-                const httpMatch = remote.refs.fetch?.match(/(?:http|https):\/\/(?:[^@]+@)?([^:\/]+)(?::\d+)?\/git\/([A-Z0-9]+)\.git/);
+                const httpMatch = remote.refs.fetch?.match(/(https?):\/\/(?:[^@\/]+@)?([^\/]+)\/git\/([A-Z0-9]+)\.git/);
                 if (httpMatch) {
-                    const [, host, detectedAppId] = httpMatch;
+                    const [, scheme, host, detectedAppId] = httpMatch;
+                    const origin = new URL(`${scheme}://${host}`).origin;
                     out.push({
                         appId: detectedAppId,
                         source: "remote",
                         description: `Git remote '${remote.name}'`,
-                        detectedUrl: config_normalizeAnvilUrl(host)
+                        detectedUrl: config_normalizeAnvilUrl(origin)
                     });
                     continue;
                 }
@@ -15016,6 +15074,29 @@ Promise.resolve()
     }
     const external_fs_promises_namespaceObject = require("fs/promises");
     var external_fs_promises_default = /*#__PURE__*/ __webpack_require__.n(external_fs_promises_namespaceObject);
+    function formatHttpError(prefix, status, body) {
+        if (!body) return `${prefix}: ${status}`;
+        try {
+            const parsed = JSON.parse(body);
+            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
+        } catch  {}
+        return `${prefix}: ${status} ${body}`;
+    }
+    const ANVIL_GITIGNORE_ENTRY = "/.anvil/";
+    async function ensureProjectGitignoreIgnoresAnvilDir(projectRoot) {
+        const rootGitignorePath = external_path_default().join(projectRoot, ".gitignore");
+        try {
+            const existing = await external_fs_.promises.readFile(rootGitignorePath, "utf8");
+            if (existing.includes(ANVIL_GITIGNORE_ENTRY)) return false;
+            const prefix = existing.endsWith("\n") || 0 === existing.length ? "" : "\n";
+            await external_fs_.promises.writeFile(rootGitignorePath, `${existing}${prefix}${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
+            return true;
+        } catch (error) {
+            if ("ENOENT" !== error.code) throw error;
+            await external_fs_.promises.writeFile(rootGitignorePath, `${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
+            return true;
+        }
+    }
     function normalizeLineEndings(content) {
         return content.replace(/\r\n/g, "\n");
     }
@@ -15060,32 +15141,67 @@ Promise.resolve()
             html: htmlContent
         };
     }
-    function formatHttpError(prefix, status, body) {
-        if (!body) return `${prefix}: ${status}`;
+    const ANVIL_DEPS_DIR = ".anvil/deps";
+    const ANVIL_DEPS_MANIFEST = "manifest.json";
+    const DEPS_MANIFEST_VERSION = 3;
+    function depsCache_depsDir(projectRoot) {
+        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
+    }
+    function depsManifestPath(projectRoot) {
+        return external_path_default().join(depsCache_depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
+    }
+    function isResolvedDependencyManifestEntry(value) {
+        if (!value || "object" != typeof value) return false;
+        const entry = value;
+        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
+    }
+    function isCachedDependencyManifestEntry(value) {
+        if (!isResolvedDependencyManifestEntry(value)) return false;
+        const entry = value;
+        return "string" == typeof entry.package_name && entry.package_name.length > 0;
+    }
+    function isDepsCacheManifest(value) {
+        if (!value || "object" != typeof value) return false;
+        const manifest = value;
+        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && (null === manifest.source_dependencies || Array.isArray(manifest.source_dependencies)) && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
+    }
+    async function readDepsCacheManifest(projectRoot) {
         try {
-            const parsed = JSON.parse(body);
-            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
-        } catch  {}
-        return `${prefix}: ${status} ${body}`;
+            const raw = await external_fs_promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
+            const parsed = JSON.parse(raw);
+            return isDepsCacheManifest(parsed) ? parsed : void 0;
+        } catch  {
+            return;
+        }
     }
-    const ANVIL_GITIGNORE_ENTRY = "/.anvil/";
-    async function ensureProjectGitignoreIgnoresAnvilDir(projectRoot) {
-        const rootGitignorePath = external_path_default().join(projectRoot, ".gitignore");
+    function normalizeAnvilYamlDependenciesFromContent(content) {
+        const parsed = external_js_yaml_default().load(content);
+        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
+        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
+    }
+    function normalizeAnvilYamlDependenciesValue(value) {
+        if (!Array.isArray(value)) return [];
+        return value.map(normalizeForComparison);
+    }
+    async function readAnvilYamlDependencies(projectRoot) {
         try {
-            const existing = await external_fs_.promises.readFile(rootGitignorePath, "utf8");
-            if (existing.includes(ANVIL_GITIGNORE_ENTRY)) return false;
-            const prefix = existing.endsWith("\n") || 0 === existing.length ? "" : "\n";
-            await external_fs_.promises.writeFile(rootGitignorePath, `${existing}${prefix}${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
-            return true;
-        } catch (error) {
-            if ("ENOENT" !== error.code) throw error;
-            await external_fs_.promises.writeFile(rootGitignorePath, `${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
-            return true;
+            const content = await external_fs_promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
+            return normalizeAnvilYamlDependenciesFromContent(content);
+        } catch  {
+            return [];
         }
     }
-    const ANVIL_DEPS_DIR = ".anvil/deps";
-    const ANVIL_DEPS_MANIFEST = "manifest.json";
-    const DEPS_MANIFEST_VERSION = 3;
+    function anvilYamlDependenciesEqual(left, right) {
+        return deepEqual(left, right);
+    }
+    function normalizeForComparison(value) {
+        if (Array.isArray(value)) return value.map(normalizeForComparison);
+        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
+                key,
+                normalizeForComparison(entryValue)
+            ]));
+        return value;
+    }
     async function fetchAllDependencies(appId, anvilUrl, options = {}) {
         const { commit, includeDocs = true, knownDependencies = [] } = options;
         anvilUrl ??= await auth_resolveAuthAnvilUrl();
@@ -15144,36 +15260,6 @@ Promise.resolve()
             addedGitignoreEntry
         };
     }
-    function depsDir(projectRoot) {
-        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
-    }
-    function depsManifestPath(projectRoot) {
-        return external_path_default().join(depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
-    }
-    function isResolvedDependencyManifestEntry(value) {
-        if (!value || "object" != typeof value) return false;
-        const entry = value;
-        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
-    }
-    function isCachedDependencyManifestEntry(value) {
-        if (!isResolvedDependencyManifestEntry(value)) return false;
-        const entry = value;
-        return "string" == typeof entry.package_name && entry.package_name.length > 0;
-    }
-    function isDepsCacheManifest(value) {
-        if (!value || "object" != typeof value) return false;
-        const manifest = value;
-        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && (null === manifest.source_dependencies || Array.isArray(manifest.source_dependencies)) && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
-    }
-    async function readDepsCacheManifest(projectRoot) {
-        try {
-            const raw = await external_fs_promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
-            const parsed = JSON.parse(raw);
-            return isDepsCacheManifest(parsed) ? parsed : void 0;
-        } catch  {
-            return;
-        }
-    }
     async function getKnownDependenciesForCache(projectRoot, includeDocs) {
         const manifest = await readDepsCacheManifest(projectRoot);
         if (!manifest || manifest.includeDocs !== includeDocs) return [];
@@ -15199,34 +15285,6 @@ Promise.resolve()
             ];
         });
     }
-    function normalizeAnvilYamlDependenciesFromContent(content) {
-        const parsed = external_js_yaml_default().load(content);
-        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
-        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
-    }
-    function normalizeAnvilYamlDependenciesValue(value) {
-        if (!Array.isArray(value)) return [];
-        return value.map(normalizeForComparison);
-    }
-    async function readAnvilYamlDependencies(projectRoot) {
-        try {
-            const content = await external_fs_promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
-            return normalizeAnvilYamlDependenciesFromContent(content);
-        } catch  {
-            return [];
-        }
-    }
-    function anvilYamlDependenciesEqual(left, right) {
-        return deepEqual(left, right);
-    }
-    function normalizeForComparison(value) {
-        if (Array.isArray(value)) return value.map(normalizeForComparison);
-        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
-                key,
-                normalizeForComparison(entryValue)
-            ]));
-        return value;
-    }
     function cachedManifestEntry(dep, packageName) {
         return {
             app_id: dep.app_id,
@@ -15248,7 +15306,7 @@ Promise.resolve()
         return external_path_default().join(...parts);
     }
     async function writeDepToCache(projectRoot, dep) {
-        const depDir = external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name);
+        const depDir = external_path_default().join(depsCache_depsDir(projectRoot), dep.package_name);
         await external_fs_promises_default().rm(depDir, {
             recursive: true,
             force: true
@@ -15332,7 +15390,7 @@ Promise.resolve()
         if (!canReuseExistingCache) await clearDepsCache(projectRoot);
         const previousCached = canReuseExistingCache ? manifest.cached_dependencies : [];
         const resolvedAppIds = new Set(response.resolved_dependencies.map((dep)=>dep.app_id));
-        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await external_fs_promises_default().rm(external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name), {
+        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await external_fs_promises_default().rm(external_path_default().join(depsCache_depsDir(projectRoot), dep.package_name), {
             recursive: true,
             force: true
         });
@@ -15359,13 +15417,13 @@ Promise.resolve()
             resolved_dependencies: response.resolved_dependencies,
             cached_dependencies: cachedDependencies
         };
-        await external_fs_promises_default().mkdir(depsDir(projectRoot), {
+        await external_fs_promises_default().mkdir(depsCache_depsDir(projectRoot), {
             recursive: true
         });
         await external_fs_promises_default().writeFile(depsManifestPath(projectRoot), `${JSON.stringify(newManifest, null, 2)}\n`);
     }
     async function clearDepsCache(projectRoot) {
-        await external_fs_promises_default().rm(depsDir(projectRoot), {
+        await external_fs_promises_default().rm(depsCache_depsDir(projectRoot), {
             recursive: true,
             force: true
         });
@@ -16434,7 +16492,8 @@ Promise.resolve()
         if (void 0 !== value.layout_metadata && !isPlainObject(value.layout_metadata)) formTemplateValidation_pushIssue(issues, path("layout_metadata"), "must be an object");
         if (void 0 !== value.help_text && "string" != typeof value.help_text) formTemplateValidation_pushIssue(issues, path("help_text"), "must be a string");
         if (void 0 !== value.item_type) if (isPlainObject(value.item_type)) {
-            if ("number" != typeof value.item_type.table_id) formTemplateValidation_pushIssue(issues, path("item_type.table_id"), "must be a number");
+            if (void 0 !== value.item_type.table_name) validateNonEmptyString(value.item_type.table_name, path("item_type.table_name"), issues);
+            else if ("number" != typeof value.item_type.table_id) formTemplateValidation_pushIssue(issues, path("item_type.table_id"), "must be a number");
         } else formTemplateValidation_pushIssue(issues, path("item_type"), "must be an object");
         return issues;
     }
@@ -20166,6 +20225,18 @@ print(json.dumps({"issues": issues}))
         }
         throw new Error("Device login expired before it was approved.");
     }
+    function quoteForPosixShell(value) {
+        if ("" === value) return "''";
+        return `'${value.replace(/'/g, "'\"'\"'")}'`;
+    }
+    function quoteForCmdShell(value) {
+        const escaped = value.replace(/[%^&|<>()"!]/g, "^$&");
+        return `"${escaped}"`;
+    }
+    function buildShellCommandLine(tokens) {
+        if ("win32" === process.platform) return tokens.map(quoteForCmdShell).join(" ");
+        return tokens.map(quoteForPosixShell).join(" ");
+    }
     const CHECKOUT_ERROR_VALUE = "__ERROR__";
     function isAbortLikeError(error) {
         if (error instanceof Error && "AbortError" === error.name) return true;
@@ -20342,8 +20413,122 @@ print(json.dumps({"issues": issues}))
             }
         };
     }
-    require("inquirer");
-    require("ora");
+    class CreateCheckoutError extends Error {
+        created;
+        constructor(message, created, options){
+            super(message, options), this.created = created;
+            this.name = "CreateCheckoutError";
+        }
+    }
+    const create_defaultDeps = {
+        getAccountsForUrl: auth_getAccountsForUrl,
+        getValidAuthToken: auth_getValidAuthToken,
+        createApp: createAnvilApp,
+        checkout: executeCheckout
+    };
+    function validateCheckoutOptions(options) {
+        if (false === options.checkout && (void 0 !== options.directory || void 0 !== options.gitUrl || options.open)) throw new Error("--no-checkout cannot be combined with a destination argument, --directory, --git-url, or --open.");
+    }
+    async function validateCreateInput(options) {
+        validateCheckoutOptions(options);
+        const name = options.name.trim();
+        if (!name) throw new Error("App name is required.");
+        const tags = void 0 === options.tags ? void 0 : [
+            ...new Set(options.tags.map((tag)=>tag.trim().toLowerCase()))
+        ];
+        if (tags && (tags.length > 20 || tags.some((tag)=>tag.length > 50 || !/^[a-z0-9_-]+$/.test(tag)))) throw new Error("Use at most 20 unique tags, each 1–50 characters: letters, numbers, hyphens, or underscores.");
+        if (false === options.checkout) return {
+            name,
+            tags,
+            destinationPath: void 0
+        };
+        const directory = options.directory ?? sanitizeDirectoryName(name);
+        if (!directory) throw new Error("App name cannot be used as a directory. Pass --directory <PATH>.");
+        const destinationPath = external_path_default().resolve(directory);
+        await validateCheckoutDestination(destinationPath);
+        return {
+            name,
+            tags,
+            destinationPath
+        };
+    }
+    async function executeCreate(options, deps = create_defaultDeps) {
+        const { name, tags, destinationPath } = await validateCreateInput(options);
+        const anvilUrl = config_normalizeAnvilOrigin(options.anvilUrl ?? await resolveCheckoutUrlForApi() ?? "");
+        const gitUrl = void 0 === options.gitUrl ? void 0 : config_normalizeAnvilOrigin(options.gitUrl);
+        const accounts = options.user ? [] : await deps.getAccountsForUrl(anvilUrl);
+        const username = options.user ?? accounts[0];
+        if (!username) throw new Error(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
+        if (!options.user && accounts.length > 1) throw new Error(`Multiple accounts found for ${anvilUrl}: ${accounts.join(", ")}. Use --user <USERNAME>.`);
+        const authToken = await deps.getValidAuthToken(anvilUrl, username);
+        const created = await deps.createApp({
+            name,
+            anvilUrl,
+            authToken,
+            ...tags ? {
+                tags
+            } : {}
+        });
+        if (void 0 === destinationPath) return {
+            appId: created.id,
+            appName: created.name,
+            anvilUrl,
+            username,
+            tags: created.tags ?? tags ?? [],
+            editorUrl: `${anvilUrl}/build/apps/${encodeURIComponent(created.id)}`
+        };
+        try {
+            const checkout = await deps.checkout({
+                input: created.id,
+                directory: destinationPath,
+                anvilUrl,
+                ...gitUrl ? {
+                    gitUrl
+                } : {},
+                user: username
+            });
+            return {
+                ...checkout,
+                tags: created.tags ?? tags ?? []
+            };
+        } catch (error) {
+            const details = {
+                appId: created.id,
+                appName: created.name,
+                anvilUrl,
+                gitUrl,
+                destinationPath,
+                username,
+                tags: created.tags ?? tags ?? []
+            };
+            const retry = buildShellCommandLine([
+                "anvil",
+                "checkout",
+                created.id,
+                destinationPath,
+                "--url",
+                anvilUrl,
+                "--user",
+                username,
+                ...gitUrl ? [
+                    "--git-url",
+                    gitUrl
+                ] : []
+            ]);
+            const remainingFiles = await isDirectoryNonEmpty(destinationPath).catch(()=>true);
+            const recovery = remainingFiles ? `Inspect the existing checkout at ${destinationPath} before retrying. For Git authentication problems, run ${buildShellCommandLine([
+                "anvil",
+                "git-auth",
+                "doctor",
+                "--repo",
+                destinationPath
+            ])}.` : `Retry checkout with: ${retry}`;
+            const message = errors_getErrorMessage(error).replaceAll(authToken, "[REDACTED]").replaceAll(encodeURIComponent(authToken), "[REDACTED]");
+            throw new CreateCheckoutError(`Created app ${created.id} at ${anvilUrl}, but checkout failed: ${message}. Do not rerun create. ${recovery}`, details, {
+                cause: error
+            });
+        }
+    }
     const defaultGitAuthDoctorDeps = {
         getAppAuthBinding: git_auth_getAppAuthBinding,
         getAccountsForUrl: auth_getAccountsForUrl,
@@ -20799,7 +20984,7 @@ print(json.dumps({"issues": issues}))
         const token = await getModelToken(options);
         process.stdout.write(`${token}\n`);
     }
-    async function watch_decideFallbackUrl(explicitUrl, availableUrls) {
+    async function appDetection_decideFallbackUrl(explicitUrl, availableUrls) {
         if (explicitUrl) return {
             source: "explicit",
             url: config_normalizeAnvilUrl(explicitUrl)
@@ -20885,7 +21070,7 @@ print(json.dumps({"issues": issues}))
     async function resolveCheckoutUrlForApi(explicitUrl, parsedUrl) {
         if (explicitUrl) return config_normalizeAnvilUrl(explicitUrl);
         if (parsedUrl) return config_normalizeAnvilUrl(parsedUrl);
-        const decision = await watch_decideFallbackUrl(void 0);
+        const decision = await appDetection_decideFallbackUrl(void 0);
         if ("available-multiple" === decision.source) throw new Error(`Multiple logged-in Anvil URLs found: ${decision.urls.join(", ")}. Use --url <ANVIL_URL> to choose one.`);
         return decision.url;
     }
@@ -20945,7 +21130,7 @@ print(json.dumps({"issues": issues}))
         logger_logger.verbose(external_chalk_default().cyan("Resolved app ID: ") + external_chalk_default().bold(parsed.appId));
         const anvilUrl = await resolveCheckoutUrlForApi(options.anvilUrl, parsed.detectedUrl);
         if (!anvilUrl) throw new Error("Anvil URL is required. Use --url <ANVIL_URL> or pass an input URL containing the host.");
-        const gitUrl = options.gitUrl ?? anvilUrl;
+        const gitUrl = void 0 === options.gitUrl ? anvilUrl : config_normalizeAnvilOrigin(options.gitUrl);
         const resolvedUsername = await resolveCheckoutUsernameForApi(anvilUrl, options.user);
         if (resolvedUsername) logger_logger.verbose(external_chalk_default().cyan("Using account: ") + external_chalk_default().bold(resolvedUsername));
         else logger_logger.verbose(external_chalk_default().cyan("No account preselected; resolving after auth token lookup."));
@@ -21185,6 +21370,8 @@ exports.CheckoutCloneOptions = __webpack_exports__.CheckoutCloneOptions;
 exports.CheckoutExecutionDeps = __webpack_exports__.CheckoutExecutionDeps;
 exports.CheckoutOptions = __webpack_exports__.CheckoutOptions;
 exports.CheckoutResult = __webpack_exports__.CheckoutResult;
+exports.CreateCheckoutError = __webpack_exports__.CreateCheckoutError;
+exports.CreatedAnvilApp = __webpack_exports__.CreatedAnvilApp;
 exports.DeviceAuthorizationResponse = __webpack_exports__.DeviceAuthorizationResponse;
 exports.FormTemplateValidationResult = __webpack_exports__.FormTemplateValidationResult;
 exports.GetValidAuthTokenOptions = __webpack_exports__.GetValidAuthTokenOptions;
@@ -21208,6 +21395,7 @@ exports.branchFromEnvironmentVersion = __webpack_exports__.branchFromEnvironment
 exports.buildGitAuthDoctorReport = __webpack_exports__.buildGitAuthDoctorReport;
 exports.checkUncommittedChanges = __webpack_exports__.checkUncommittedChanges;
 exports.clearInMemoryTokens = __webpack_exports__.clearInMemoryTokens;
+exports.createAnvilApp = __webpack_exports__.createAnvilApp;
 exports.createCheckoutPickerSource = __webpack_exports__.createCheckoutPickerSource;
 exports.createWatchDiagnostic = __webpack_exports__.createWatchDiagnostic;
 exports.createWatchDiagnosticFromMessage = __webpack_exports__.createWatchDiagnosticFromMessage;
@@ -21215,6 +21403,7 @@ exports.deleteConfig = __webpack_exports__.deleteConfig;
 exports.detectAppIdsByCommitLookup = __webpack_exports__.detectAppIdsByCommitLookup;
 exports.detectAppIdsFromAllRemotes = __webpack_exports__.detectAppIdsFromAllRemotes;
 exports.executeCheckout = __webpack_exports__.executeCheckout;
+exports.executeCreate = __webpack_exports__.executeCreate;
 exports.executeGitCredentialOperation = __webpack_exports__.executeGitCredentialOperation;
 exports.executeModelTokenOperation = __webpack_exports__.executeModelTokenOperation;
 exports.filterCandidates = __webpack_exports__.filterCandidates;
@@ -21288,6 +21477,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CheckoutExecutionDeps",
     "CheckoutOptions",
     "CheckoutResult",
+    "CreateCheckoutError",
+    "CreatedAnvilApp",
     "DeviceAuthorizationResponse",
     "FormTemplateValidationResult",
     "GetValidAuthTokenOptions",
@@ -21311,6 +21502,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildGitAuthDoctorReport",
     "checkUncommittedChanges",
     "clearInMemoryTokens",
+    "createAnvilApp",
     "createCheckoutPickerSource",
     "createWatchDiagnostic",
     "createWatchDiagnosticFromMessage",
@@ -21318,6 +21510,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "detectAppIdsByCommitLookup",
     "detectAppIdsFromAllRemotes",
     "executeCheckout",
+    "executeCreate",
     "executeGitCredentialOperation",
     "executeModelTokenOperation",
     "filterCandidates",

package/dist/program.d.ts

@@ -1,13 +1,6 @@
-import { Command } from "commander";
-import { type ValidationIssue } from "./validators";
-type ValidateCommandWarning = ValidationIssue & {
-    file?: string;
-    rule?: string;
-    severity?: string;
-};
-export declare function formatValidationWarning(file: string, warning: ValidateCommandWarning): string;
+import type { Command } from "commander";
+export { formatValidationWarning } from "./commands/validate";
 export declare function getUpdateInstructions(platform: NodeJS.Platform): string[];
 export declare function handleUpdateCommand(): Promise<void>;
 export declare function buildProgram(): Command;
-export {};
 //# sourceMappingURL=program.d.ts.map

package/dist/program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiCpC,OAAO,EAAyD,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAiC3G,KAAK,sBAAsB,GAAG,eAAe,GAAG;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAoKF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAO7F;AAmLD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,GAAG,MAAM,EAAE,CAezE;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAwFzD;AAiBD,wBAAgB,YAAY,IAAI,OAAO,CAqGtC"}
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBzC,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,GAAG,MAAM,EAAE,CAezE;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAwFzD;AAED,wBAAgB,YAAY,IAAI,OAAO,CAwDtC"}

package/dist/programBase.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+export declare const VERSION: any;
+export declare function addGlobalOptionsHelp(command: Command): void;
+export declare function buildBaseProgram(): Command;
+//# sourceMappingURL=programBase.d.ts.map