@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.81

package/commonjs/src/webapi/features/auth0-cli.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Auth0AuthError () {
+        return Auth0AuthError;
+    },
+    get DB_CONNECTION_NAME () {
+        return DB_CONNECTION_NAME;
+    },
+    get HELLO_API_SCOPES () {
+        return HELLO_API_SCOPES;
+    },
+    get REQUIRED_SCOPES () {
+        return REQUIRED_SCOPES;
+    },
+    get createAdminDatabaseUser () {
+        return createAdminDatabaseUser;
+    },
+    get createApi () {
+        return createApi;
+    },
+    get createSpaApp () {
+        return createSpaApp;
+    },
+    get enableConnectionForClient () {
+        return enableConnectionForClient;
+    },
+    get ensureSpaApp () {
+        return ensureSpaApp;
+    },
+    get findUserByEmail () {
+        return findUserByEmail;
+    },
+    get formatSpaEntityLimitError () {
+        return formatSpaEntityLimitError;
+    },
+    get generateAdminPassword () {
+        return generateAdminPassword;
+    },
+    get isAuth0EntityLimitError () {
+        return isAuth0EntityLimitError;
+    },
+    get isInstalled () {
+        return isInstalled;
+    },
+    get listApis () {
+        return listApis;
+    },
+    get listApps () {
+        return listApps;
+    },
+    get listTenants () {
+        return listTenants;
+    },
+    get login () {
+        return login;
+    },
+    get updateApiScopes () {
+        return updateApiScopes;
+    },
+    get updateSpaCallbacks () {
+        return updateSpaCallbacks;
+    },
+    get updateUserPassword () {
+        return updateUserPassword;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _nodecrypto = require("node:crypto");
+/** Management API scopes needed for API, SPA, connections, and admin users. */ const REQUIRED_SCOPES = [
+    "create:clients",
+    "read:clients",
+    "update:clients",
+    "create:resource_servers",
+    "read:resource_servers",
+    "update:resource_servers",
+    "read:connections",
+    "update:connections",
+    "create:users",
+    "read:users",
+    "update:users"
+].join(",");
+/** Hard timeout for any Management API call. Prevents indefinite hangs on token re-auth. */ const API_TIMEOUT_MS = 8_000;
+const HELLO_API_SCOPES = [
+    "read:Hello",
+    "create:Hello",
+    "update:Hello",
+    "delete:Hello"
+];
+const DB_CONNECTION_NAME = "Username-Password-Authentication";
+class Auth0AuthError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "Auth0AuthError";
+    }
+}
+/** Returns true if an error or stderr output looks like an expired/missing token. */ function isAuthError(text) {
+    return text.includes("renew access token") || text.includes("log in") || text.includes("Unauthorized");
+}
+/** Strip Auth0 CLI banner lines before JSON. */ function parseJsonOutput(stdout) {
+    const start = stdout.indexOf("{");
+    const arrayStart = stdout.indexOf("[");
+    let idx = -1;
+    if (start === -1) idx = arrayStart;
+    else if (arrayStart === -1) idx = start;
+    else idx = Math.min(start, arrayStart);
+    if (idx < 0) throw new Error(`Expected JSON from auth0 CLI, got: ${stdout.slice(0, 200)}`);
+    return JSON.parse(stdout.slice(idx));
+}
+/** Run an auth0 CLI command with a hard timeout. Returns stdout on success, throws on failure. */ function runAuth0(args) {
+    const result = (0, _nodechild_process.spawnSync)("auth0", args, {
+        encoding: "utf8",
+        timeout: API_TIMEOUT_MS,
+        input: "",
+        stdio: "pipe"
+    });
+    if (result.error) {
+        const msg = result.error.message;
+        if (isAuthError(msg) || result.error.code === "ETIMEDOUT") {
+            throw new Auth0AuthError(msg);
+        }
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr ?? "";
+        if (isAuthError(stderr)) throw new Auth0AuthError(stderr);
+        throw new Error(stderr || `auth0 exited with code ${result.status}`);
+    }
+    return result.stdout;
+}
+function isInstalled() {
+    try {
+        (0, _nodechild_process.execFileSync)("auth0", [
+            "--version"
+        ], {
+            stdio: "pipe"
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function listTenants() {
+    try {
+        const out = (0, _nodechild_process.execFileSync)("auth0", [
+            "tenants",
+            "list",
+            "--json"
+        ], {
+            encoding: "utf8",
+            stdio: "pipe"
+        });
+        return JSON.parse(out);
+    } catch  {
+        return [];
+    }
+}
+function login() {
+    const result = (0, _nodechild_process.spawnSync)("auth0", [
+        "login",
+        "--scopes",
+        REQUIRED_SCOPES
+    ], {
+        stdio: "inherit"
+    });
+    return result.status === 0;
+}
+function listApis() {
+    try {
+        const out = runAuth0([
+            "apis",
+            "list",
+            "--json",
+            "--no-input"
+        ]);
+        return parseJsonOutput(out);
+    } catch (err) {
+        if (err instanceof Auth0AuthError) throw err;
+        return [];
+    }
+}
+function createApi(name, identifier, scopes = HELLO_API_SCOPES) {
+    const out = runAuth0([
+        "apis",
+        "create",
+        "--name",
+        name,
+        "--identifier",
+        identifier,
+        "--scopes",
+        scopes.join(","),
+        // RBAC: only permissions assigned to the user/role appear on the token.
+        "--enforce-policies",
+        // Include Auth0 `permissions[]` claim (consumed by sample principalMapper).
+        "--token-dialect",
+        "access_token_authz",
+        "--json",
+        "--no-input"
+    ]);
+    return parseJsonOutput(out);
+}
+function updateApiScopes(identifier, scopes = HELLO_API_SCOPES) {
+    runAuth0([
+        "apis",
+        "update",
+        identifier,
+        "--scopes",
+        scopes.join(","),
+        "--enforce-policies",
+        "--token-dialect",
+        "access_token_authz",
+        "--no-input"
+    ]);
+}
+function isAuth0EntityLimitError(err) {
+    const text = err instanceof Error ? err.message : String(err);
+    return /limit of entities|reached the limit|tenant application limit reached/i.test(text);
+}
+function formatSpaEntityLimitError(appName, apps) {
+    const listed = apps.length === 0 ? "Could not list existing applications." : `This tenant already has ${apps.length} application(s):\n${apps.map((a)=>`  - ${a.name} (${a.client_id})`).join("\n")}`;
+    return [
+        `Auth0 refused to create SPA "${appName}": tenant application limit reached.`,
+        listed,
+        "",
+        "Fix: Auth0 Dashboard → Applications → Applications → delete unused apps,",
+        `then re-run the scaffold (or choose Postman "none" to skip SPA creation).`,
+        "Re-scaffold of the same project name reuses an exact-name match when it still exists."
+    ].join("\n");
+}
+function createSpaApp(name, callbackUrls) {
+    const callbacks = typeof callbackUrls === "string" ? callbackUrls : callbackUrls.join(",");
+    const out = runAuth0([
+        "apps",
+        "create",
+        "--name",
+        name,
+        "--type",
+        "spa",
+        "--callbacks",
+        callbacks,
+        "--json",
+        "--no-input"
+    ]);
+    const app = parseJsonOutput(out);
+    const clientId = app.client_id ?? app.clientId;
+    if (!clientId) {
+        throw new Error(`Auth0 create SPA response missing client_id. stdout: ${out.slice(0, 300)}`);
+    }
+    return {
+        client_id: clientId
+    };
+}
+function listApps() {
+    try {
+        const out = runAuth0([
+            "apps",
+            "list",
+            "--json",
+            "--no-input"
+        ]);
+        const apps = parseJsonOutput(out);
+        return apps.map((a)=>({
+                client_id: a.client_id ?? a.clientId ?? "",
+                name: a.name ?? ""
+            })).filter((a)=>a.client_id && a.name);
+    } catch (err) {
+        if (err instanceof Auth0AuthError) throw err;
+        return [];
+    }
+}
+function updateSpaCallbacks(clientId, callbackUrls) {
+    const callbacks = typeof callbackUrls === "string" ? callbackUrls : callbackUrls.join(",");
+    runAuth0([
+        "apps",
+        "update",
+        clientId,
+        "--callbacks",
+        callbacks,
+        "--no-input"
+    ]);
+}
+function ensureSpaApp(name, callbackUrls) {
+    const apps = listApps();
+    const existing = apps.find((a)=>a.name === name);
+    if (existing) {
+        try {
+            updateSpaCallbacks(existing.client_id, callbackUrls);
+        } catch  {
+        // Callbacks may already match; still usable for Postman.
+        }
+        return {
+            client_id: existing.client_id,
+            reused: true
+        };
+    }
+    try {
+        return {
+            ...createSpaApp(name, callbackUrls),
+            reused: false
+        };
+    } catch (err) {
+        if (isAuth0EntityLimitError(err)) {
+            throw new Error(formatSpaEntityLimitError(name, apps));
+        }
+        throw err;
+    }
+}
+function enableConnectionForClient(connectionName, clientId) {
+    const listOut = runAuth0([
+        "api",
+        "get",
+        "connections",
+        "--no-input"
+    ]);
+    const connections = parseJsonOutput(listOut);
+    const connection = connections.find((c)=>c.name === connectionName);
+    if (!connection) {
+        throw new Error(`Auth0 connection not found: ${connectionName}`);
+    }
+    const clientsOut = runAuth0([
+        "api",
+        "get",
+        `connections/${connection.id}/clients`,
+        "--no-input"
+    ]);
+    const { clients } = parseJsonOutput(clientsOut);
+    if (clients.some((c)=>c.client_id === clientId)) return;
+    // Dedicated enabled-clients endpoint (enabled_clients on connection PATCH is deprecated).
+    runAuth0([
+        "api",
+        "patch",
+        `connections/${connection.id}/clients`,
+        "--data",
+        JSON.stringify([
+            {
+                client_id: clientId,
+                status: true
+            }
+        ]),
+        "--no-input"
+    ]);
+}
+function generateAdminPassword() {
+    return `${(0, _nodecrypto.randomBytes)(12).toString("base64url")}aA1!`;
+}
+function isUserAlreadyExistsError(err) {
+    const text = err instanceof Error ? err.message : String(err);
+    return /already exists|user exists|Conflict|409/i.test(text);
+}
+function findUserByEmail(email) {
+    const out = runAuth0([
+        "api",
+        "get",
+        `users-by-email?email=${encodeURIComponent(email)}`,
+        "--no-input"
+    ]);
+    const users = parseJsonOutput(out);
+    const user = users.find((u)=>u.user_id && u.email);
+    if (!user?.user_id || !user.email) return null;
+    return {
+        user_id: user.user_id,
+        email: user.email
+    };
+}
+function updateUserPassword(userId, password) {
+    runAuth0([
+        "api",
+        "patch",
+        `users/${encodeURIComponent(userId)}`,
+        "--data",
+        JSON.stringify({
+            password,
+            connection: DB_CONNECTION_NAME
+        }),
+        "--no-input"
+    ]);
+}
+function createAdminDatabaseUser(input) {
+    const body = {
+        email: input.email,
+        connection: DB_CONNECTION_NAME,
+        password: input.password,
+        name: input.username,
+        email_verified: true,
+        verify_email: false,
+        app_metadata: {
+            roles: [
+                "admin"
+            ]
+        }
+    };
+    try {
+        const out = runAuth0([
+            "api",
+            "post",
+            "users",
+            "--data",
+            JSON.stringify(body),
+            "--no-input"
+        ]);
+        const user = parseJsonOutput(out);
+        if (!user.user_id || !user.email) {
+            throw new Error(`Auth0 create user response missing user_id/email. stdout: ${out.slice(0, 300)}`);
+        }
+        return {
+            user_id: user.user_id,
+            email: user.email,
+            password: input.password,
+            username: input.username
+        };
+    } catch (err) {
+        if (!isUserAlreadyExistsError(err)) throw err;
+        const existing = findUserByEmail(input.email);
+        if (!existing) {
+            throw new Error(`Auth0 user already exists for ${input.email}, but lookup by email returned no user.`);
+        }
+        updateUserPassword(existing.user_id, input.password);
+        return {
+            user_id: existing.user_id,
+            email: existing.email,
+            password: input.password,
+            username: input.username
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/features/auth0-cli.ts"],"sourcesContent":["import { execFileSync, spawnSync } from \"node:child_process\";\nimport { randomBytes } from \"node:crypto\";\n\n/** Management API scopes needed for API, SPA, connections, and admin users. */\nconst REQUIRED_SCOPES = [\n\t\"create:clients\",\n\t\"read:clients\",\n\t\"update:clients\",\n\t\"create:resource_servers\",\n\t\"read:resource_servers\",\n\t\"update:resource_servers\",\n\t\"read:connections\",\n\t\"update:connections\",\n\t\"create:users\",\n\t\"read:users\",\n\t\"update:users\",\n].join(\",\");\n\n/** Hard timeout for any Management API call. Prevents indefinite hangs on token re-auth. */\nconst API_TIMEOUT_MS = 8_000;\n\n/** Default API scopes matching Hello CASL Authorize decorators. */\nexport const HELLO_API_SCOPES = [\n\t\"read:Hello\",\n\t\"create:Hello\",\n\t\"update:Hello\",\n\t\"delete:Hello\",\n] as const;\n\nexport const DB_CONNECTION_NAME = \"Username-Password-Authentication\";\n\nexport class Auth0AuthError extends Error {\n\tpublic constructor(message: string) {\n\t\tsuper(message);\n\t\tthis.name = \"Auth0AuthError\";\n\t}\n}\n\n/** Returns true if an error or stderr output looks like an expired/missing token. */\nfunction isAuthError(text: string): boolean {\n\treturn (\n\t\ttext.includes(\"renew access token\") ||\n\t\ttext.includes(\"log in\") ||\n\t\ttext.includes(\"Unauthorized\")\n\t);\n}\n\n/** Strip Auth0 CLI banner lines before JSON. */\nfunction parseJsonOutput<T>(stdout: string): T {\n\tconst start = stdout.indexOf(\"{\");\n\tconst arrayStart = stdout.indexOf(\"[\");\n\tlet idx = -1;\n\tif (start === -1) idx = arrayStart;\n\telse if (arrayStart === -1) idx = start;\n\telse idx = Math.min(start, arrayStart);\n\tif (idx < 0) throw new Error(`Expected JSON from auth0 CLI, got: ${stdout.slice(0, 200)}`);\n\treturn JSON.parse(stdout.slice(idx)) as T;\n}\n\n/** Run an auth0 CLI command with a hard timeout. Returns stdout on success, throws on failure. */\nfunction runAuth0(args: string[]): string {\n\tconst result = spawnSync(\"auth0\", args, {\n\t\tencoding: \"utf8\",\n\t\ttimeout: API_TIMEOUT_MS,\n\t\tinput: \"\",\n\t\tstdio: \"pipe\",\n\t});\n\n\tif (result.error) {\n\t\tconst msg = result.error.message;\n\t\tif (isAuthError(msg) || (result.error as NodeJS.ErrnoException).code === \"ETIMEDOUT\") {\n\t\t\tthrow new Auth0AuthError(msg);\n\t\t}\n\t\tthrow result.error;\n\t}\n\n\tif (result.status !== 0) {\n\t\tconst stderr = result.stderr ?? \"\";\n\t\tif (isAuthError(stderr)) throw new Auth0AuthError(stderr);\n\t\tthrow new Error(stderr || `auth0 exited with code ${result.status}`);\n\t}\n\n\treturn result.stdout;\n}\n\nexport interface Auth0Tenant {\n\tname: string;\n\tactive?: boolean;\n}\n\nexport function isInstalled(): boolean {\n\ttry {\n\t\texecFileSync(\"auth0\", [\"--version\"], { stdio: \"pipe\" });\n\t\treturn true;\n\t} catch {\n\t\treturn false;\n\t}\n}\n\nexport function listTenants(): Auth0Tenant[] {\n\ttry {\n\t\tconst out = execFileSync(\"auth0\", [\"tenants\", \"list\", \"--json\"], {\n\t\t\tencoding: \"utf8\",\n\t\t\tstdio: \"pipe\",\n\t\t});\n\t\treturn JSON.parse(out) as Auth0Tenant[];\n\t} catch {\n\t\treturn [];\n\t}\n}\n\nexport function login(): boolean {\n\tconst result = spawnSync(\"auth0\", [\"login\", \"--scopes\", REQUIRED_SCOPES], {\n\t\tstdio: \"inherit\",\n\t});\n\treturn result.status === 0;\n}\n\nexport function listApis(): Array<{ identifier: string; name: string }> {\n\ttry {\n\t\tconst out = runAuth0([\"apis\", \"list\", \"--json\", \"--no-input\"]);\n\t\treturn parseJsonOutput(out);\n\t} catch (err) {\n\t\tif (err instanceof Auth0AuthError) throw err;\n\t\treturn [];\n\t}\n}\n\nexport function createApi(\n\tname: string,\n\tidentifier: string,\n\tscopes: readonly string[] = HELLO_API_SCOPES,\n): { identifier: string } {\n\tconst out = runAuth0([\n\t\t\"apis\",\n\t\t\"create\",\n\t\t\"--name\",\n\t\tname,\n\t\t\"--identifier\",\n\t\tidentifier,\n\t\t\"--scopes\",\n\t\tscopes.join(\",\"),\n\t\t// RBAC: only permissions assigned to the user/role appear on the token.\n\t\t\"--enforce-policies\",\n\t\t// Include Auth0 `permissions[]` claim (consumed by sample principalMapper).\n\t\t\"--token-dialect\",\n\t\t\"access_token_authz\",\n\t\t\"--json\",\n\t\t\"--no-input\",\n\t]);\n\treturn parseJsonOutput(out);\n}\n\n/**\n * Replace an API's scopes and enable RBAC policy enforcement.\n * Auth0 CLI `--scopes` replaces the full set.\n */\nexport function updateApiScopes(\n\tidentifier: string,\n\tscopes: readonly string[] = HELLO_API_SCOPES,\n): void {\n\trunAuth0([\n\t\t\"apis\",\n\t\t\"update\",\n\t\tidentifier,\n\t\t\"--scopes\",\n\t\tscopes.join(\",\"),\n\t\t\"--enforce-policies\",\n\t\t\"--token-dialect\",\n\t\t\"access_token_authz\",\n\t\t\"--no-input\",\n\t]);\n}\n\n/** True when Auth0 refuses create because the tenant hit its Applications quota. */\nexport function isAuth0EntityLimitError(err: unknown): boolean {\n\tconst text = err instanceof Error ? err.message : String(err);\n\treturn /limit of entities|reached the limit|tenant application limit reached/i.test(text);\n}\n\n/**\n * Actionable message when Auth0 will not create another application.\n * Does not suggest reusing unrelated apps — free tenants must delete unused ones.\n */\nexport function formatSpaEntityLimitError(appName: string, apps: Auth0App[]): string {\n\tconst listed =\n\t\tapps.length === 0\n\t\t\t? \"Could not list existing applications.\"\n\t\t\t: `This tenant already has ${apps.length} application(s):\\n${apps\n\t\t\t\t\t.map((a) => `  - ${a.name} (${a.client_id})`)\n\t\t\t\t\t.join(\"\\n\")}`;\n\n\treturn [\n\t\t`Auth0 refused to create SPA \"${appName}\": tenant application limit reached.`,\n\t\tlisted,\n\t\t\"\",\n\t\t\"Fix: Auth0 Dashboard → Applications → Applications → delete unused apps,\",\n\t\t`then re-run the scaffold (or choose Postman \"none\" to skip SPA creation).`,\n\t\t\"Re-scaffold of the same project name reuses an exact-name match when it still exists.\",\n\t].join(\"\\n\");\n}\n\nexport function createSpaApp(\n\tname: string,\n\tcallbackUrls: string | readonly string[],\n): { client_id: string } {\n\tconst callbacks = typeof callbackUrls === \"string\" ? callbackUrls : callbackUrls.join(\",\");\n\tconst out = runAuth0([\n\t\t\"apps\",\n\t\t\"create\",\n\t\t\"--name\",\n\t\tname,\n\t\t\"--type\",\n\t\t\"spa\",\n\t\t\"--callbacks\",\n\t\tcallbacks,\n\t\t\"--json\",\n\t\t\"--no-input\",\n\t]);\n\tconst app = parseJsonOutput<{ client_id?: string; clientId?: string }>(out);\n\tconst clientId = app.client_id ?? app.clientId;\n\tif (!clientId) {\n\t\tthrow new Error(\n\t\t\t`Auth0 create SPA response missing client_id. stdout: ${out.slice(0, 300)}`,\n\t\t);\n\t}\n\treturn { client_id: clientId };\n}\n\nexport type Auth0App = { client_id: string; name: string };\n\nexport function listApps(): Auth0App[] {\n\ttry {\n\t\tconst out = runAuth0([\"apps\", \"list\", \"--json\", \"--no-input\"]);\n\t\tconst apps =\n\t\t\tparseJsonOutput<Array<{ client_id?: string; clientId?: string; name?: string }>>(out);\n\t\treturn apps\n\t\t\t.map((a) => ({\n\t\t\t\tclient_id: a.client_id ?? a.clientId ?? \"\",\n\t\t\t\tname: a.name ?? \"\",\n\t\t\t}))\n\t\t\t.filter((a) => a.client_id && a.name);\n\t} catch (err) {\n\t\tif (err instanceof Auth0AuthError) throw err;\n\t\treturn [];\n\t}\n}\n\nexport function updateSpaCallbacks(\n\tclientId: string,\n\tcallbackUrls: string | readonly string[],\n): void {\n\tconst callbacks = typeof callbackUrls === \"string\" ? callbackUrls : callbackUrls.join(\",\");\n\trunAuth0([\"apps\", \"update\", clientId, \"--callbacks\", callbacks, \"--no-input\"]);\n}\n\n/**\n * Create a Postman SPA, or reuse an existing app with the same name (re-scaffold).\n * Always returns a client_id suitable for Postman auth0ClientId.\n * On Auth0 application-quota errors, throws a clear delete-apps message (no cross-app reuse).\n */\nexport function ensureSpaApp(\n\tname: string,\n\tcallbackUrls: string | readonly string[],\n): { client_id: string; reused: boolean } {\n\tconst apps = listApps();\n\tconst existing = apps.find((a) => a.name === name);\n\tif (existing) {\n\t\ttry {\n\t\t\tupdateSpaCallbacks(existing.client_id, callbackUrls);\n\t\t} catch {\n\t\t\t// Callbacks may already match; still usable for Postman.\n\t\t}\n\t\treturn { client_id: existing.client_id, reused: true };\n\t}\n\ttry {\n\t\treturn { ...createSpaApp(name, callbackUrls), reused: false };\n\t} catch (err) {\n\t\tif (isAuth0EntityLimitError(err)) {\n\t\t\tthrow new Error(formatSpaEntityLimitError(name, apps));\n\t\t}\n\t\tthrow err;\n\t}\n}\n\ntype Auth0Connection = { id: string; name: string; strategy: string };\n\n/** Enable a database connection for an application (required for username/password login). */\nexport function enableConnectionForClient(connectionName: string, clientId: string): void {\n\tconst listOut = runAuth0([\"api\", \"get\", \"connections\", \"--no-input\"]);\n\tconst connections = parseJsonOutput<Auth0Connection[]>(listOut);\n\tconst connection = connections.find((c) => c.name === connectionName);\n\tif (!connection) {\n\t\tthrow new Error(`Auth0 connection not found: ${connectionName}`);\n\t}\n\n\tconst clientsOut = runAuth0([\n\t\t\"api\",\n\t\t\"get\",\n\t\t`connections/${connection.id}/clients`,\n\t\t\"--no-input\",\n\t]);\n\tconst { clients } = parseJsonOutput<{ clients: Array<{ client_id: string }> }>(clientsOut);\n\tif (clients.some((c) => c.client_id === clientId)) return;\n\n\t// Dedicated enabled-clients endpoint (enabled_clients on connection PATCH is deprecated).\n\trunAuth0([\n\t\t\"api\",\n\t\t\"patch\",\n\t\t`connections/${connection.id}/clients`,\n\t\t\"--data\",\n\t\tJSON.stringify([{ client_id: clientId, status: true }]),\n\t\t\"--no-input\",\n\t]);\n}\n\nexport type AdminDatabaseUser = {\n\tuser_id: string;\n\temail: string;\n\tpassword: string;\n\tusername: string;\n};\n\n/** Strong default password when the scaffolder caller leaves password blank. */\nexport function generateAdminPassword(): string {\n\treturn `${randomBytes(12).toString(\"base64url\")}aA1!`;\n}\n\nfunction isUserAlreadyExistsError(err: unknown): boolean {\n\tconst text = err instanceof Error ? err.message : String(err);\n\treturn /already exists|user exists|Conflict|409/i.test(text);\n}\n\n/** Look up a user by email (Management API users-by-email). */\nexport function findUserByEmail(email: string): { user_id: string; email: string } | null {\n\tconst out = runAuth0([\n\t\t\"api\",\n\t\t\"get\",\n\t\t`users-by-email?email=${encodeURIComponent(email)}`,\n\t\t\"--no-input\",\n\t]);\n\tconst users = parseJsonOutput<Array<{ user_id?: string; email?: string }>>(out);\n\tconst user = users.find((u) => u.user_id && u.email);\n\tif (!user?.user_id || !user.email) return null;\n\treturn { user_id: user.user_id, email: user.email };\n}\n\n/** Reset password so a re-scaffold can write a known password to .env. */\nexport function updateUserPassword(userId: string, password: string): void {\n\trunAuth0([\n\t\t\"api\",\n\t\t\"patch\",\n\t\t`users/${encodeURIComponent(userId)}`,\n\t\t\"--data\",\n\t\tJSON.stringify({ password, connection: DB_CONNECTION_NAME }),\n\t\t\"--no-input\",\n\t]);\n}\n\n/**\n * Create a DB connection root-admin user for local / Postman login.\n * If the user already exists, look them up, reset password to `input.password`,\n * and return that identity so callers can still write .env credentials.\n */\nexport function createAdminDatabaseUser(input: {\n\temail: string;\n\tpassword: string;\n\tusername: string;\n}): AdminDatabaseUser {\n\tconst body = {\n\t\temail: input.email,\n\t\tconnection: DB_CONNECTION_NAME,\n\t\tpassword: input.password,\n\t\tname: input.username,\n\t\temail_verified: true,\n\t\tverify_email: false,\n\t\tapp_metadata: { roles: [\"admin\"] },\n\t};\n\n\ttry {\n\t\tconst out = runAuth0([\n\t\t\t\"api\",\n\t\t\t\"post\",\n\t\t\t\"users\",\n\t\t\t\"--data\",\n\t\t\tJSON.stringify(body),\n\t\t\t\"--no-input\",\n\t\t]);\n\t\tconst user = parseJsonOutput<{ user_id?: string; email?: string }>(out);\n\t\tif (!user.user_id || !user.email) {\n\t\t\tthrow new Error(\n\t\t\t\t`Auth0 create user response missing user_id/email. stdout: ${out.slice(0, 300)}`,\n\t\t\t);\n\t\t}\n\t\treturn {\n\t\t\tuser_id: user.user_id,\n\t\t\temail: user.email,\n\t\t\tpassword: input.password,\n\t\t\tusername: input.username,\n\t\t};\n\t} catch (err) {\n\t\tif (!isUserAlreadyExistsError(err)) throw err;\n\n\t\tconst existing = findUserByEmail(input.email);\n\t\tif (!existing) {\n\t\t\tthrow new Error(\n\t\t\t\t`Auth0 user already exists for ${input.email}, but lookup by email returned no user.`,\n\t\t\t);\n\t\t}\n\n\t\tupdateUserPassword(existing.user_id, input.password);\n\t\treturn {\n\t\t\tuser_id: existing.user_id,\n\t\t\temail: existing.email,\n\t\t\tpassword: input.password,\n\t\t\tusername: input.username,\n\t\t};\n\t}\n}\n\nexport { REQUIRED_SCOPES };\n"],"names":["Auth0AuthError","DB_CONNECTION_NAME","HELLO_API_SCOPES","REQUIRED_SCOPES","createAdminDatabaseUser","createApi","createSpaApp","enableConnectionForClient","ensureSpaApp","findUserByEmail","formatSpaEntityLimitError","generateAdminPassword","isAuth0EntityLimitError","isInstalled","listApis","listApps","listTenants","login","updateApiScopes","updateSpaCallbacks","updateUserPassword","join","API_TIMEOUT_MS","Error","message","name","isAuthError","text","includes","parseJsonOutput","stdout","start","indexOf","arrayStart","idx","Math","min","slice","JSON","parse","runAuth0","args","result","spawnSync","encoding","timeout","input","stdio","error","msg","code","status","stderr","execFileSync","out","err","identifier","scopes","String","test","appName","apps","listed","length","map","a","client_id","callbackUrls","callbacks","app","clientId","filter","existing","find","reused","connectionName","listOut","connections","connection","c","clientsOut","id","clients","some","stringify","randomBytes","toString","isUserAlreadyExistsError","email","encodeURIComponent","users","user","u","user_id","userId","password","body","username","email_verified","verify_email","app_metadata","roles"],"mappings":"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"}

package/commonjs/src/webapi/features/biome-format.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatScaffoldedFiles", {
+    enumerable: true,
+    get: function() {
+        return formatScaffoldedFiles;
+    }
+});
+const _nodechild_process = require("node:child_process");
+function formatScaffoldedFiles(targetDir, paths = [
+    "."
+]) {
+    process.stdout.write("\n  Formatting scaffolded files with Biome...");
+    let result = (0, _nodechild_process.spawnSync)("biome", [
+        "check",
+        "--write",
+        ...paths
+    ], {
+        cwd: targetDir,
+        encoding: "utf8",
+        stdio: "pipe"
+    });
+    if (result.error && result.error.code === "ENOENT") {
+        result = (0, _nodechild_process.spawnSync)("npx", [
+            "--yes",
+            "@biomejs/biome",
+            "check",
+            "--write",
+            ...paths
+        ], {
+            cwd: targetDir,
+            encoding: "utf8",
+            stdio: "pipe"
+        });
+    }
+    if (result.status === 0) {
+        process.stdout.write(" done.\n");
+        return;
+    }
+    const detail = (result.stderr || result.stdout || result.error?.message || "").trim();
+    process.stdout.write(" failed.\n");
+    if (detail) {
+        console.error(`  ✗ Biome: ${detail.slice(0, 400)}`);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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