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

package/commonjs/src/webapi/devcontainer/templates/post-start.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# Runs on every container start (devcontainer postStartCommand).
+# Optional npm / gh login is y/N on a TTY. Install is post-create.sh.
+# MCP merge also runs here for later reconnects; the Compose service command
+# merges before Cursor attaches (postStart is too late for the first snapshot).
+set -euo pipefail
+
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+root="$(cd "$here/.." && pwd)"
+# shellcheck source=tty-prompt.sh
+source "$here/tty-prompt.sh"
+
+CODEBASE_RAG_WORKSPACE="$root" node --experimental-strip-types "$here/codebase-rag-mcp.ts" merge ||
+	echo "codebase-rag MCP: merge skipped" >&2
+
+AUTH_REGISTRY="https://registry.npmjs.org"
+
+ensure_npm_auth() {
+	if npm whoami --registry "$AUTH_REGISTRY" >/dev/null 2>&1; then
+		echo "npm: logged in as $(npm whoami --registry "$AUTH_REGISTRY")"
+		return 0
+	fi
+
+	if prompt_yn "Log in to npm?"; then
+		echo "npm: starting login..."
+		npm login --registry "$AUTH_REGISTRY" </dev/tty >/dev/tty
+		return 0
+	fi
+
+	echo "npm: skipped. Open a terminal and run: npm login" >&2
+	echo "    (creds persist in .devcontainer/npm-auth/)" >&2
+	return 1
+}
+
+ensure_gh_auth() {
+	if ! command -v gh >/dev/null 2>&1; then
+		echo "gh: not installed in this container" >&2
+		return 1
+	fi
+
+	if gh auth status >/dev/null 2>&1; then
+		echo "gh: $(gh auth status 2>&1 | head -n1)"
+		return 0
+	fi
+
+	local token="${GH_TOKEN:-${GITHUB_TOKEN:-}}"
+	if [[ -n "$token" ]]; then
+		echo "gh: authenticating from GH_TOKEN..."
+		printf '%s\n' "$token" | gh auth login --with-token
+		return 0
+	fi
+
+	if prompt_yn "Log in to GitHub CLI (gh)?"; then
+		echo "gh: starting login..."
+		gh auth login </dev/tty >/dev/tty
+		return 0
+	fi
+
+	echo "gh: skipped. Open a terminal and run: gh auth login" >&2
+	echo "    (creds persist in .devcontainer/gh-auth/; or set GH_TOKEN in .devcontainer/gh.env)" >&2
+	return 1
+}
+
+ensure_npm_auth || true
+ensure_gh_auth || true

package/commonjs/src/webapi/devcontainer/templates/tty-prompt.sh

@@ -0,0 +1,38 @@
+can_prompt() {
+	[[ -r /dev/tty && -w /dev/tty ]]
+}
+
+read_tty() {
+	local var="$1"
+	local hidden="${2:-}"
+	local value=""
+	if [[ -n "$hidden" ]]; then
+		read -r -s value </dev/tty || true
+		printf '\n' >/dev/tty
+	else
+		read -r value </dev/tty || true
+	fi
+	printf -v "$var" '%s' "$value"
+}
+
+# Returns 0 for yes. Default is n unless the second argument is y.
+prompt_yn() {
+	local question="$1"
+	local default="${2:-n}"
+	local reply=""
+	if ! can_prompt; then
+		return 1
+	fi
+	local hint="y/N"
+	if [[ "$default" == "y" ]]; then
+		hint="Y/n"
+	fi
+	printf '%s [%s] ' "$question" "$hint" >/dev/tty
+	read_tty reply
+	reply="$(printf '%s' "$reply" | tr '[:upper:]' '[:lower:]' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"
+	if [[ -z "$reply" ]]; then
+		[[ "$default" == "y" ]]
+		return
+	fi
+	[[ "$reply" == "y" || "$reply" == "yes" ]]
+}

package/commonjs/src/webapi/features/auth.feature.js

@@ -0,0 +1,441 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AuthFeature", {
+    enumerable: true,
+    get: function() {
+        return AuthFeature;
+    }
+});
+const _prompt = require("../../domain/prompt.js");
+const _const = require("../../models/const.js");
+const _authconfigmodel = require("../models/auth-config.model.js");
+const _controllersourcefilemodel = require("../models/controller-source-file.model.js");
+const _auth0cli = /*#__PURE__*/ _interop_require_wildcard(require("./auth0-cli.js"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const ADMIN_ROLE = "admin";
+const USER_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import type { Entity as IEntity } from "@decohere/codex";
+
+@Entity()
+export class UserEntity implements IEntity {
+\t@PrimaryGeneratedColumn()
+\tpublic id!: number;
+
+\t@Column({ unique: true })
+\tpublic sub!: string;
+
+\t@Column({ type: "varchar", nullable: true })
+\tpublic email!: string | null;
+
+\t@Column()
+\tpublic displayName!: string;
+
+\t/** App-owned roles. The \`admin\` role grants CASL \`manage\`/\`all\` (wildcard). */
+\t@Column({ type: "simple-json", default: "[]" })
+\tpublic roles!: string[];
+}
+`;
+const USER_REPOSITORY_TS = `import { injectable } from "@decohere/crucible/decorators";
+import { injectUnitOfWork } from "@decohere/codex";
+import { TypeOrmRepository, TypeOrmUnitOfWork } from "@decohere/codex-typeorm";
+import { UserEntity } from "../entities/user.entity.js";
+
+@injectable()
+export class UserEntityRepository extends TypeOrmRepository<UserEntity> {
+\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {
+\t\tsuper(unitOfWork, UserEntity);
+\t}
+
+\tpublic findBySub(sub: string): Promise<UserEntity | null> {
+\t\treturn this.firstOrDefault({ where: { sub } });
+\t}
+}
+`;
+const USER_SERVICE_TS = `import { injectable } from "@decohere/crucible/decorators";
+import type { Principal } from "@decohere/cortex";
+import { UserEntity } from "../entities/user.entity.js";
+import { UserEntityRepository } from "../repositories/user.repository.js";
+
+function claimString(principal: Principal | undefined, key: string): string | undefined {
+\tconst value = principal?.[key];
+\treturn typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+@injectable()
+export class UserService {
+\tpublic constructor(private readonly users: UserEntityRepository) {}
+
+\t/**
+\t * Upsert a local profile keyed by JWT \`sub\`.
+\t * Profile fields from the token fill gaps; seeded rows keep displayName/email/roles.
+\t */
+\tpublic async ensureFromPrincipal(principal: Principal | undefined): Promise<UserEntity> {
+\t\tconst sub = principal?.sub;
+\t\tif (!sub) {
+\t\t\tthrow new Error("Authenticated request is missing principal.sub");
+\t\t}
+
+\t\tconst email =
+\t\t\tclaimString(principal, "email") ?? claimString(principal, "preferred_username");
+\t\tconst displayFromToken =
+\t\t\tclaimString(principal, "name") ??
+\t\t\tclaimString(principal, "nickname") ??
+\t\t\temail;
+
+\t\tconst existing = await this.users.findBySub(sub);
+\t\tif (existing) {
+\t\t\tlet dirty = false;
+\t\t\tif (!existing.email && email) {
+\t\t\t\texisting.email = email;
+\t\t\t\tdirty = true;
+\t\t\t}
+\t\t\tif (existing.displayName === existing.sub && displayFromToken) {
+\t\t\t\texisting.displayName = displayFromToken;
+\t\t\t\tdirty = true;
+\t\t\t}
+\t\t\treturn dirty ? this.users.save(existing) : existing;
+\t\t}
+
+\t\tconst created = new UserEntity();
+\t\tcreated.sub = sub;
+\t\tcreated.email = email ?? null;
+\t\tcreated.displayName = displayFromToken ?? sub;
+\t\tcreated.roles = Array.isArray(principal.roles)
+\t\t\t? principal.roles.filter((r): r is string => typeof r === "string")
+\t\t\t: [];
+\t\treturn this.users.save(created);
+\t}
+}
+`;
+const ABILITY_FACTORY_TS = `import type { Principal } from "@decohere/cortex";
+import {
+\tADMIN_ROLE,
+\tcreatePrincipalFromPayload,
+\tdefineAbilitiesFor as defaultDefineAbilitiesFor,
+} from "@decohere/cortex";
+
+/**
+ * Customize CASL authorization here (product-specific rules).
+ *
+ * Default delegates to cortex: \`admin\` role → \`manage\`/\`all\`; IdP scopes
+ * (\`action:Subject\`) → abilities. Replace the body when you need app rules
+ * beyond that — this file is the intentional extension point, not framework
+ * infrastructure to copy.
+ */
+export function defineAbilitiesFor(principal: Principal) {
+\treturn defaultDefineAbilitiesFor(principal);
+}
+
+/**
+ * Customize JWT → Principal mapping here (IdP-specific claims).
+ *
+ * Elevates \`AUTH0_ADMIN_USER_SUB\` to the admin role so the seeded admin works
+ * before/without roles on the access token.
+ */
+export function mapPrincipal(payload: Record<string, unknown>): Principal {
+\tconst principal = createPrincipalFromPayload(payload);
+\tconst sub = principal.sub;
+\tif (sub && sub === process.env.AUTH0_ADMIN_USER_SUB) {
+\t\treturn {
+\t\t\t...principal,
+\t\t\troles: [...new Set([ADMIN_ROLE, ...(principal.roles ?? [])])],
+\t\t};
+\t}
+\treturn principal;
+}
+`;
+async function getOptions(workspace, cliOptions) {
+    if (cliOptions.authProvider === "auth0" && !cliOptions.issuerBaseUrl) {
+        return getAuth0Options(workspace, cliOptions);
+    }
+    if (cliOptions.authProvider != null) return {};
+    const choices = [
+        {
+            label: "none"
+        },
+        {
+            label: "auth0"
+        }
+    ];
+    const selected = await (0, _prompt.pick)("\n  Auth provider: ", choices, (c)=>c.label);
+    const provider = selected?.label ?? "none";
+    if (provider !== "auth0") return {
+        authProvider: "none"
+    };
+    return getAuth0Options(workspace, cliOptions);
+}
+async function getAuth0Options(workspace, cliOptions) {
+    if (!_auth0cli.isInstalled()) {
+        console.error("\n  The Auth0 CLI is required for automated setup.\n" + "  Install: brew install auth0/auth0-cli/auth0\n" + "  Or visit: https://github.com/auth0/auth0-cli\n");
+        process.exit(1);
+    }
+    process.stdout.write("\n  Checking Auth0 credentials...");
+    let tenants = _auth0cli.listTenants();
+    if (tenants.length === 0) {
+        process.stdout.write(" not logged in.\n");
+        console.log("  Logging in to Auth0 (your browser will open)...");
+        if (!_auth0cli.login()) {
+            console.error("\n  Auth0 login failed.");
+            process.exit(1);
+        }
+        tenants = _auth0cli.listTenants();
+    }
+    try {
+        _auth0cli.listApis();
+        process.stdout.write(" ok.\n");
+    } catch (err) {
+        if (err instanceof _auth0cli.Auth0AuthError) {
+            process.stdout.write(" token expired.\n");
+            console.log("  Re-authenticating (your browser will open)...");
+            if (!_auth0cli.login()) {
+                console.error("\n  Auth0 login failed.");
+                process.exit(1);
+            }
+        }
+    }
+    const active = tenants.find((t)=>t.active) ?? tenants[0];
+    const issuerBaseUrl = `https://${active.name}`;
+    console.log(`\n  ✓ Auth0 tenant: ${issuerBaseUrl}`);
+    process.stdout.write("\n  Fetching Auth0 APIs...");
+    const userApis = _auth0cli.listApis().filter((a)=>!a.name.includes("Management API"));
+    process.stdout.write(` found ${userApis.length}.\n`);
+    const projectName = workspace.name;
+    const apiChoices = [
+        {
+            label: `<new> https://api.${projectName}`,
+            existing: null
+        },
+        ...userApis.map((a)=>({
+                label: `${a.name} — ${a.identifier}`,
+                existing: a.identifier
+            }))
+    ];
+    const apiSelected = await (0, _prompt.pick)("\n  Select Auth0 API: ", apiChoices, (c)=>c.label);
+    let audience;
+    if (!apiSelected || apiSelected.existing === null) {
+        const defaultId = `https://api.${projectName}`;
+        audience = await (0, _prompt.ask)(`  API Identifier [${defaultId}]: `, defaultId);
+        console.log("\n  Creating Auth0 API...");
+        audience = _auth0cli.createApi(`${projectName} API`, audience).identifier;
+        console.log(`  \u2713 API created: ${audience}`);
+    } else {
+        audience = apiSelected.existing;
+        console.log(`  \u2713 Selected: ${audience}`);
+        try {
+            _auth0cli.updateApiScopes(audience);
+            console.log(`  \u2713 API scopes ensured (${_auth0cli.HELLO_API_SCOPES.join(", ")})`);
+        } catch  {
+            console.error("  ✗ Failed to update API scopes — add Hello scopes in the Auth0 dashboard.");
+        }
+    }
+    const withLocalUsers = cliOptions.databaseProvider === "postgres/typeorm";
+    let adminUsername;
+    let adminPassword;
+    if (withLocalUsers) {
+        adminUsername = cliOptions.adminUsername ?? await (0, _prompt.ask)("\n  Admin username [admin]: ", "admin");
+        adminPassword = cliOptions.adminPassword;
+        if (adminPassword == null) {
+            adminPassword = await (0, _prompt.ask)("  Admin password (leave blank to generate): ");
+            if (!adminPassword) {
+                adminPassword = _auth0cli.generateAdminPassword();
+                console.log(`  ✓ Generated admin password (written to .env): ${adminPassword}`);
+            }
+        }
+    }
+    return {
+        authProvider: "auth0",
+        issuerBaseUrl,
+        audience,
+        ...withLocalUsers ? {
+            adminUsername,
+            adminPassword
+        } : {}
+    };
+}
+function adminEmail(workspaceName, username) {
+    if (username.includes("@")) return username;
+    const slug = workspaceName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    return `${username}@${slug}.example.com`;
+}
+function createAuth0AdminUser(workspace, options, authConfig) {
+    const username = options.adminUsername ?? "admin";
+    const password = options.adminPassword;
+    if (!password) return;
+    const email = adminEmail(workspace.name, username);
+    try {
+        const admin = _auth0cli.createAdminDatabaseUser({
+            email,
+            password,
+            username
+        });
+        authConfig.setAdminUser({
+            sub: admin.user_id,
+            email: admin.email,
+            password: admin.password,
+            username: admin.username
+        });
+        workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE)?.addEntry("AUTH0_ADMIN_USER_SUB", admin.user_id).addEntry("AUTH0_ADMIN_USER_EMAIL", admin.email).addEntry("AUTH0_ADMIN_USER_PASSWORD", admin.password).addEntry("AUTH0_ADMIN_USERNAME", admin.username);
+        console.log(`  ✓ Auth0 admin user ready: ${admin.email} (role: ${ADMIN_ROLE})`);
+        console.log(`    Login with EMAIL (not username): ${admin.email}`);
+        console.log(`    Password: see AUTH0_ADMIN_USER_PASSWORD in .env`);
+    } catch (err) {
+        console.error(`  ✗ Failed to ensure Auth0 admin user (${email}): ${err instanceof Error ? err.message : err}`);
+    }
+}
+function scaffoldLocalUserProfile(workspace) {
+    for (const project of workspace.getProjects()){
+        project.getModel(_const.WELL_KNOWN_FILES.MAIN_TS)?.addEntity({
+            className: "UserEntity",
+            importPath: "./entities/user.entity.js"
+        }).addRepository({
+            className: "UserEntityRepository",
+            importPath: "./repositories/user.repository.js"
+        }).addService({
+            className: "UserService",
+            importPath: "./services/user.service.js",
+            scope: "request"
+        }).addImport("defineAbilitiesFor", "./auth/ability.factory.js").addImport("mapPrincipal", "./auth/ability.factory.js").setTypeOrmSeed([
+            "const sub = process.env.AUTH0_ADMIN_USER_SUB;",
+            "if (!sub) return;",
+            "const repo = dataSource.getRepository(UserEntity);",
+            "const existing = await repo.findOne({ where: { sub } });",
+            "if (existing) return;",
+            "await repo.save(repo.create({",
+            "  sub,",
+            "  email: process.env.AUTH0_ADMIN_USER_EMAIL ?? null,",
+            '  displayName: process.env.AUTH0_ADMIN_USERNAME ?? "admin",',
+            '  roles: ["admin"],',
+            "}));"
+        ].join(" "));
+        project.addFile({
+            files: ()=>[
+                    {
+                        filePath: "src/entities/user.entity.ts",
+                        content: USER_ENTITY_TS
+                    },
+                    {
+                        filePath: "src/repositories/user.repository.ts",
+                        content: USER_REPOSITORY_TS
+                    },
+                    {
+                        filePath: "src/services/user.service.ts",
+                        content: USER_SERVICE_TS
+                    },
+                    {
+                        filePath: "src/auth/ability.factory.ts",
+                        content: ABILITY_FACTORY_TS
+                    }
+                ]
+        });
+    }
+    for (const controller of workspace.getModels(_controllersourcefilemodel.ControllerSourceFile)){
+        controller.addImport("UserService", "../services/user.service.js").addImport("inject", "@decohere/crucible/decorators").addConstructorParam('@inject("UserService") private readonly users: UserService');
+        controller.getMethod("getOne").setAsync(true).setBody([
+            "const user = await this.users.ensureFromPrincipal(this.principalProvider.currentPrincipal);",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code
+            "return { id, message: `Hello ${user.displayName}!`, username: user.displayName };"
+        ]);
+    }
+}
+function scaffold(workspace, options) {
+    if (options.authProvider !== "auth0") return;
+    const resource = "Hello";
+    const withLocalUsers = options.databaseProvider === "postgres/typeorm";
+    for (const controller of workspace.getModels(_controllersourcefilemodel.ControllerSourceFile)){
+        controller.addDecorator(`@Authorize("read", "${resource}")`).addCortexImport("AllowAnonymous").addCortexImport("Authorize").addCortexImport("IPrincipalProviderToken").addCortexImport("IPrincipalProvider", true).addImport("inject", "@decohere/crucible/decorators").addConstructorParam(`@inject(IPrincipalProviderToken) private readonly principalProvider: IPrincipalProvider`);
+        controller.getMethod("getAll").addDecorator("@AllowAnonymous()");
+        if (!withLocalUsers) {
+            controller.getMethod("getOne").setBody([
+                "const principal = this.principalProvider.currentPrincipal;",
+                "const username =",
+                '\t(typeof principal?.name === "string" && principal.name) ||',
+                '\t(typeof principal?.nickname === "string" && principal.nickname) ||',
+                '\t(typeof principal?.email === "string" && principal.email) ||',
+                '\t(typeof principal?.preferred_username === "string" && principal.preferred_username) ||',
+                "\tprincipal?.sub ||",
+                '\t"unknown";',
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code
+                "return { id, message: `Hello ${username}!`, username };"
+            ]);
+        }
+        controller.getMethod("create").addDecorator(`@Authorize("create", "${resource}")`);
+        controller.getMethod("update").addDecorator(`@Authorize("update", "${resource}")`);
+        controller.getMethod("remove").addDecorator(`@Authorize("delete", "${resource}")`);
+    }
+    for (const project of workspace.getProjects()){
+        project.getModel(_const.WELL_KNOWN_FILES.MAIN_TS)?.addSideEffectImport("@decohere/cortex/auth");
+    }
+    if (withLocalUsers) {
+        scaffoldLocalUserProfile(workspace);
+        for (const project of workspace.getProjects()){
+            project.getModel(_const.WELL_KNOWN_FILES.MAIN_TS)?.addBuilderCall(".withAuth(defineAbilitiesFor, { principalMapper: mapPrincipal })");
+        }
+    } else {
+        for (const project of workspace.getProjects()){
+            project.getModel(_const.WELL_KNOWN_FILES.MAIN_TS)?.addBuilderCall(".withAuth()");
+        }
+    }
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders
+    const issuerPlaceholder = "${AUTH0_ISSUER_BASE_URL}";
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders
+    const audPlaceholder = "${AUTH0_AUDIENCE}";
+    const configSection = `auth:\n  discoveryUrl: ${issuerPlaceholder}\n  audience: ${audPlaceholder}\n`;
+    workspace.getModel(_const.WELL_KNOWN_FILES.CONFIG_YAML)?.addSection(configSection);
+    workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE)?.addEntry("AUTH0_ISSUER_BASE_URL", options.issuerBaseUrl ?? "").addEntry("AUTH0_AUDIENCE", options.audience ?? "");
+    const authConfig = new _authconfigmodel.AuthConfigModel({
+        issuerBaseUrl: options.issuerBaseUrl ?? "",
+        audience: options.audience ?? ""
+    });
+    workspace.addModel(authConfig);
+    if (withLocalUsers && options.adminPassword) {
+        createAuth0AdminUser(workspace, options, authConfig);
+    }
+}
+const AuthFeature = {
+    getOptions,
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/features/auth.feature.ts"],"sourcesContent":["import { ask, pick } from \"../../domain/prompt.js\";\nimport type { ConfigYaml } from \"../../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { EnvFile } from \"../../models/env-file.model.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport { AuthConfigModel } from \"../models/auth-config.model.js\";\nimport { ControllerSourceFile } from \"../models/controller-source-file.model.js\";\nimport type { MainSourceFile } from \"../models/main-source-file.model.js\";\nimport * as auth0Cli from \"./auth0-cli.js\";\n\nexport type AuthOptions = {\n\tauthProvider?: \"auth0\" | \"none\";\n\tissuerBaseUrl?: string;\n\taudience?: string;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tadminUsername?: string;\n\tadminPassword?: string;\n};\n\nconst ADMIN_ROLE = \"admin\";\n\nconst USER_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from \"typeorm\";\nimport type { Entity as IEntity } from \"@decohere/codex\";\n\n@Entity()\nexport class UserEntity implements IEntity {\n\\t@PrimaryGeneratedColumn()\n\\tpublic id!: number;\n\n\\t@Column({ unique: true })\n\\tpublic sub!: string;\n\n\\t@Column({ type: \"varchar\", nullable: true })\n\\tpublic email!: string | null;\n\n\\t@Column()\n\\tpublic displayName!: string;\n\n\\t/** App-owned roles. The \\`admin\\` role grants CASL \\`manage\\`/\\`all\\` (wildcard). */\n\\t@Column({ type: \"simple-json\", default: \"[]\" })\n\\tpublic roles!: string[];\n}\n`;\n\nconst USER_REPOSITORY_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport { injectUnitOfWork } from \"@decohere/codex\";\nimport { TypeOrmRepository, TypeOrmUnitOfWork } from \"@decohere/codex-typeorm\";\nimport { UserEntity } from \"../entities/user.entity.js\";\n\n@injectable()\nexport class UserEntityRepository extends TypeOrmRepository<UserEntity> {\n\\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {\n\\t\\tsuper(unitOfWork, UserEntity);\n\\t}\n\n\\tpublic findBySub(sub: string): Promise<UserEntity | null> {\n\\t\\treturn this.firstOrDefault({ where: { sub } });\n\\t}\n}\n`;\n\nconst USER_SERVICE_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport type { Principal } from \"@decohere/cortex\";\nimport { UserEntity } from \"../entities/user.entity.js\";\nimport { UserEntityRepository } from \"../repositories/user.repository.js\";\n\nfunction claimString(principal: Principal | undefined, key: string): string | undefined {\n\\tconst value = principal?.[key];\n\\treturn typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\n@injectable()\nexport class UserService {\n\\tpublic constructor(private readonly users: UserEntityRepository) {}\n\n\\t/**\n\\t * Upsert a local profile keyed by JWT \\`sub\\`.\n\\t * Profile fields from the token fill gaps; seeded rows keep displayName/email/roles.\n\\t */\n\\tpublic async ensureFromPrincipal(principal: Principal | undefined): Promise<UserEntity> {\n\\t\\tconst sub = principal?.sub;\n\\t\\tif (!sub) {\n\\t\\t\\tthrow new Error(\"Authenticated request is missing principal.sub\");\n\\t\\t}\n\n\\t\\tconst email =\n\\t\\t\\tclaimString(principal, \"email\") ?? claimString(principal, \"preferred_username\");\n\\t\\tconst displayFromToken =\n\\t\\t\\tclaimString(principal, \"name\") ??\n\\t\\t\\tclaimString(principal, \"nickname\") ??\n\\t\\t\\temail;\n\n\\t\\tconst existing = await this.users.findBySub(sub);\n\\t\\tif (existing) {\n\\t\\t\\tlet dirty = false;\n\\t\\t\\tif (!existing.email && email) {\n\\t\\t\\t\\texisting.email = email;\n\\t\\t\\t\\tdirty = true;\n\\t\\t\\t}\n\\t\\t\\tif (existing.displayName === existing.sub && displayFromToken) {\n\\t\\t\\t\\texisting.displayName = displayFromToken;\n\\t\\t\\t\\tdirty = true;\n\\t\\t\\t}\n\\t\\t\\treturn dirty ? this.users.save(existing) : existing;\n\\t\\t}\n\n\\t\\tconst created = new UserEntity();\n\\t\\tcreated.sub = sub;\n\\t\\tcreated.email = email ?? null;\n\\t\\tcreated.displayName = displayFromToken ?? sub;\n\\t\\tcreated.roles = Array.isArray(principal.roles)\n\\t\\t\\t? principal.roles.filter((r): r is string => typeof r === \"string\")\n\\t\\t\\t: [];\n\\t\\treturn this.users.save(created);\n\\t}\n}\n`;\n\nconst ABILITY_FACTORY_TS = `import type { Principal } from \"@decohere/cortex\";\nimport {\n\\tADMIN_ROLE,\n\\tcreatePrincipalFromPayload,\n\\tdefineAbilitiesFor as defaultDefineAbilitiesFor,\n} from \"@decohere/cortex\";\n\n/**\n * Customize CASL authorization here (product-specific rules).\n *\n * Default delegates to cortex: \\`admin\\` role → \\`manage\\`/\\`all\\`; IdP scopes\n * (\\`action:Subject\\`) → abilities. Replace the body when you need app rules\n * beyond that — this file is the intentional extension point, not framework\n * infrastructure to copy.\n */\nexport function defineAbilitiesFor(principal: Principal) {\n\\treturn defaultDefineAbilitiesFor(principal);\n}\n\n/**\n * Customize JWT → Principal mapping here (IdP-specific claims).\n *\n * Elevates \\`AUTH0_ADMIN_USER_SUB\\` to the admin role so the seeded admin works\n * before/without roles on the access token.\n */\nexport function mapPrincipal(payload: Record<string, unknown>): Principal {\n\\tconst principal = createPrincipalFromPayload(payload);\n\\tconst sub = principal.sub;\n\\tif (sub && sub === process.env.AUTH0_ADMIN_USER_SUB) {\n\\t\\treturn {\n\\t\\t\\t...principal,\n\\t\\t\\troles: [...new Set([ADMIN_ROLE, ...(principal.roles ?? [])])],\n\\t\\t};\n\\t}\n\\treturn principal;\n}\n`;\n\nasync function getOptions(\n\tworkspace: WorkspaceScaffold,\n\tcliOptions: Partial<AuthOptions>,\n): Promise<Partial<AuthOptions>> {\n\tif (cliOptions.authProvider === \"auth0\" && !cliOptions.issuerBaseUrl) {\n\t\treturn getAuth0Options(workspace, cliOptions);\n\t}\n\tif (cliOptions.authProvider != null) return {};\n\n\tconst choices = [{ label: \"none\" as const }, { label: \"auth0\" as const }];\n\tconst selected = await pick(\"\\n  Auth provider: \", choices, (c) => c.label);\n\tconst provider = selected?.label ?? \"none\";\n\n\tif (provider !== \"auth0\") return { authProvider: \"none\" };\n\n\treturn getAuth0Options(workspace, cliOptions);\n}\n\nasync function getAuth0Options(\n\tworkspace: WorkspaceScaffold,\n\tcliOptions: Partial<AuthOptions>,\n): Promise<Partial<AuthOptions>> {\n\tif (!auth0Cli.isInstalled()) {\n\t\tconsole.error(\n\t\t\t\"\\n  The Auth0 CLI is required for automated setup.\\n\" +\n\t\t\t\t\"  Install: brew install auth0/auth0-cli/auth0\\n\" +\n\t\t\t\t\"  Or visit: https://github.com/auth0/auth0-cli\\n\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\tprocess.stdout.write(\"\\n  Checking Auth0 credentials...\");\n\tlet tenants = auth0Cli.listTenants();\n\tif (tenants.length === 0) {\n\t\tprocess.stdout.write(\" not logged in.\\n\");\n\t\tconsole.log(\"  Logging in to Auth0 (your browser will open)...\");\n\t\tif (!auth0Cli.login()) {\n\t\t\tconsole.error(\"\\n  Auth0 login failed.\");\n\t\t\tprocess.exit(1);\n\t\t}\n\t\ttenants = auth0Cli.listTenants();\n\t}\n\n\ttry {\n\t\tauth0Cli.listApis();\n\t\tprocess.stdout.write(\" ok.\\n\");\n\t} catch (err) {\n\t\tif (err instanceof auth0Cli.Auth0AuthError) {\n\t\t\tprocess.stdout.write(\" token expired.\\n\");\n\t\t\tconsole.log(\"  Re-authenticating (your browser will open)...\");\n\t\t\tif (!auth0Cli.login()) {\n\t\t\t\tconsole.error(\"\\n  Auth0 login failed.\");\n\t\t\t\tprocess.exit(1);\n\t\t\t}\n\t\t}\n\t}\n\n\tconst active = tenants.find((t) => t.active) ?? tenants[0];\n\tconst issuerBaseUrl = `https://${active.name}`;\n\tconsole.log(`\\n  ✓ Auth0 tenant: ${issuerBaseUrl}`);\n\n\tprocess.stdout.write(\"\\n  Fetching Auth0 APIs...\");\n\tconst userApis = auth0Cli.listApis().filter((a) => !a.name.includes(\"Management API\"));\n\tprocess.stdout.write(` found ${userApis.length}.\\n`);\n\n\ttype ApiChoice = { label: string; existing: string | null };\n\tconst projectName = workspace.name;\n\tconst apiChoices: ApiChoice[] = [\n\t\t{ label: `<new> https://api.${projectName}`, existing: null },\n\t\t...userApis.map((a) => ({ label: `${a.name} — ${a.identifier}`, existing: a.identifier })),\n\t];\n\n\tconst apiSelected = await pick(\"\\n  Select Auth0 API: \", apiChoices, (c) => c.label);\n\n\tlet audience: string;\n\tif (!apiSelected || apiSelected.existing === null) {\n\t\tconst defaultId = `https://api.${projectName}`;\n\t\taudience = await ask(`  API Identifier [${defaultId}]: `, defaultId);\n\t\tconsole.log(\"\\n  Creating Auth0 API...\");\n\t\taudience = auth0Cli.createApi(`${projectName} API`, audience).identifier;\n\t\tconsole.log(`  \\u2713 API created: ${audience}`);\n\t} else {\n\t\taudience = apiSelected.existing;\n\t\tconsole.log(`  \\u2713 Selected: ${audience}`);\n\t\ttry {\n\t\t\tauth0Cli.updateApiScopes(audience);\n\t\t\tconsole.log(`  \\u2713 API scopes ensured (${auth0Cli.HELLO_API_SCOPES.join(\", \")})`);\n\t\t} catch {\n\t\t\tconsole.error(\n\t\t\t\t\"  ✗ Failed to update API scopes — add Hello scopes in the Auth0 dashboard.\",\n\t\t\t);\n\t\t}\n\t}\n\n\tconst withLocalUsers = cliOptions.databaseProvider === \"postgres/typeorm\";\n\tlet adminUsername: string | undefined;\n\tlet adminPassword: string | undefined;\n\tif (withLocalUsers) {\n\t\tadminUsername =\n\t\t\tcliOptions.adminUsername ?? (await ask(\"\\n  Admin username [admin]: \", \"admin\"));\n\t\tadminPassword = cliOptions.adminPassword;\n\t\tif (adminPassword == null) {\n\t\t\tadminPassword = await ask(\"  Admin password (leave blank to generate): \");\n\t\t\tif (!adminPassword) {\n\t\t\t\tadminPassword = auth0Cli.generateAdminPassword();\n\t\t\t\tconsole.log(`  ✓ Generated admin password (written to .env): ${adminPassword}`);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn {\n\t\tauthProvider: \"auth0\",\n\t\tissuerBaseUrl,\n\t\taudience,\n\t\t...(withLocalUsers ? { adminUsername, adminPassword } : {}),\n\t};\n}\n\nfunction adminEmail(workspaceName: string, username: string): string {\n\tif (username.includes(\"@\")) return username;\n\tconst slug = workspaceName.toLowerCase().replace(/[^a-z0-9-]/g, \"-\");\n\treturn `${username}@${slug}.example.com`;\n}\n\nfunction createAuth0AdminUser(\n\tworkspace: WorkspaceScaffold,\n\toptions: AuthOptions,\n\tauthConfig: AuthConfigModel,\n): void {\n\tconst username = options.adminUsername ?? \"admin\";\n\tconst password = options.adminPassword;\n\tif (!password) return;\n\n\tconst email = adminEmail(workspace.name, username);\n\ttry {\n\t\tconst admin = auth0Cli.createAdminDatabaseUser({ email, password, username });\n\t\tauthConfig.setAdminUser({\n\t\t\tsub: admin.user_id,\n\t\t\temail: admin.email,\n\t\t\tpassword: admin.password,\n\t\t\tusername: admin.username,\n\t\t});\n\t\tworkspace\n\t\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t\t?.addEntry(\"AUTH0_ADMIN_USER_SUB\", admin.user_id)\n\t\t\t.addEntry(\"AUTH0_ADMIN_USER_EMAIL\", admin.email)\n\t\t\t.addEntry(\"AUTH0_ADMIN_USER_PASSWORD\", admin.password)\n\t\t\t.addEntry(\"AUTH0_ADMIN_USERNAME\", admin.username);\n\t\tconsole.log(`  ✓ Auth0 admin user ready: ${admin.email} (role: ${ADMIN_ROLE})`);\n\t\tconsole.log(`    Login with EMAIL (not username): ${admin.email}`);\n\t\tconsole.log(`    Password: see AUTH0_ADMIN_USER_PASSWORD in .env`);\n\t} catch (err) {\n\t\tconsole.error(\n\t\t\t`  ✗ Failed to ensure Auth0 admin user (${email}): ${err instanceof Error ? err.message : err}`,\n\t\t);\n\t}\n}\n\nfunction scaffoldLocalUserProfile(workspace: WorkspaceScaffold): void {\n\tfor (const project of workspace.getProjects()) {\n\t\tproject\n\t\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t\t?.addEntity({ className: \"UserEntity\", importPath: \"./entities/user.entity.js\" })\n\t\t\t.addRepository({\n\t\t\t\tclassName: \"UserEntityRepository\",\n\t\t\t\timportPath: \"./repositories/user.repository.js\",\n\t\t\t})\n\t\t\t.addService({\n\t\t\t\tclassName: \"UserService\",\n\t\t\t\timportPath: \"./services/user.service.js\",\n\t\t\t\tscope: \"request\",\n\t\t\t})\n\t\t\t.addImport(\"defineAbilitiesFor\", \"./auth/ability.factory.js\")\n\t\t\t.addImport(\"mapPrincipal\", \"./auth/ability.factory.js\")\n\t\t\t.setTypeOrmSeed(\n\t\t\t\t[\n\t\t\t\t\t\"const sub = process.env.AUTH0_ADMIN_USER_SUB;\",\n\t\t\t\t\t\"if (!sub) return;\",\n\t\t\t\t\t\"const repo = dataSource.getRepository(UserEntity);\",\n\t\t\t\t\t\"const existing = await repo.findOne({ where: { sub } });\",\n\t\t\t\t\t\"if (existing) return;\",\n\t\t\t\t\t\"await repo.save(repo.create({\",\n\t\t\t\t\t\"  sub,\",\n\t\t\t\t\t\"  email: process.env.AUTH0_ADMIN_USER_EMAIL ?? null,\",\n\t\t\t\t\t'  displayName: process.env.AUTH0_ADMIN_USERNAME ?? \"admin\",',\n\t\t\t\t\t'  roles: [\"admin\"],',\n\t\t\t\t\t\"}));\",\n\t\t\t\t].join(\" \"),\n\t\t\t);\n\n\t\tproject.addFile({\n\t\t\tfiles: () => [\n\t\t\t\t{ filePath: \"src/entities/user.entity.ts\", content: USER_ENTITY_TS },\n\t\t\t\t{ filePath: \"src/repositories/user.repository.ts\", content: USER_REPOSITORY_TS },\n\t\t\t\t{ filePath: \"src/services/user.service.ts\", content: USER_SERVICE_TS },\n\t\t\t\t{ filePath: \"src/auth/ability.factory.ts\", content: ABILITY_FACTORY_TS },\n\t\t\t],\n\t\t});\n\t}\n\n\tfor (const controller of workspace.getModels(ControllerSourceFile)) {\n\t\tcontroller\n\t\t\t.addImport(\"UserService\", \"../services/user.service.js\")\n\t\t\t.addImport(\"inject\", \"@decohere/crucible/decorators\")\n\t\t\t.addConstructorParam('@inject(\"UserService\") private readonly users: UserService');\n\t\tcontroller.getMethod(\"getOne\").setAsync(true).setBody([\n\t\t\t\"const user = await this.users.ensureFromPrincipal(this.principalProvider.currentPrincipal);\",\n\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code\n\t\t\t\"return { id, message: `Hello ${user.displayName}!`, username: user.displayName };\",\n\t\t]);\n\t}\n}\n\nfunction scaffold(workspace: WorkspaceScaffold, options: AuthOptions): void {\n\tif (options.authProvider !== \"auth0\") return;\n\n\tconst resource = \"Hello\";\n\tconst withLocalUsers = options.databaseProvider === \"postgres/typeorm\";\n\n\tfor (const controller of workspace.getModels(ControllerSourceFile)) {\n\t\tcontroller\n\t\t\t.addDecorator(`@Authorize(\"read\", \"${resource}\")`)\n\t\t\t.addCortexImport(\"AllowAnonymous\")\n\t\t\t.addCortexImport(\"Authorize\")\n\t\t\t.addCortexImport(\"IPrincipalProviderToken\")\n\t\t\t.addCortexImport(\"IPrincipalProvider\", true)\n\t\t\t.addImport(\"inject\", \"@decohere/crucible/decorators\")\n\t\t\t.addConstructorParam(\n\t\t\t\t`@inject(IPrincipalProviderToken) private readonly principalProvider: IPrincipalProvider`,\n\t\t\t);\n\t\tcontroller.getMethod(\"getAll\").addDecorator(\"@AllowAnonymous()\");\n\t\tif (!withLocalUsers) {\n\t\t\tcontroller.getMethod(\"getOne\").setBody([\n\t\t\t\t\"const principal = this.principalProvider.currentPrincipal;\",\n\t\t\t\t\"const username =\",\n\t\t\t\t'\\t(typeof principal?.name === \"string\" && principal.name) ||',\n\t\t\t\t'\\t(typeof principal?.nickname === \"string\" && principal.nickname) ||',\n\t\t\t\t'\\t(typeof principal?.email === \"string\" && principal.email) ||',\n\t\t\t\t'\\t(typeof principal?.preferred_username === \"string\" && principal.preferred_username) ||',\n\t\t\t\t\"\\tprincipal?.sub ||\",\n\t\t\t\t'\\t\"unknown\";',\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code\n\t\t\t\t\"return { id, message: `Hello ${username}!`, username };\",\n\t\t\t]);\n\t\t}\n\t\tcontroller.getMethod(\"create\").addDecorator(`@Authorize(\"create\", \"${resource}\")`);\n\t\tcontroller.getMethod(\"update\").addDecorator(`@Authorize(\"update\", \"${resource}\")`);\n\t\tcontroller.getMethod(\"remove\").addDecorator(`@Authorize(\"delete\", \"${resource}\")`);\n\t}\n\n\tfor (const project of workspace.getProjects()) {\n\t\tproject\n\t\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t\t?.addSideEffectImport(\"@decohere/cortex/auth\");\n\t}\n\n\tif (withLocalUsers) {\n\t\tscaffoldLocalUserProfile(workspace);\n\t\tfor (const project of workspace.getProjects()) {\n\t\t\tproject\n\t\t\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t\t\t?.addBuilderCall(\".withAuth(defineAbilitiesFor, { principalMapper: mapPrincipal })\");\n\t\t}\n\t} else {\n\t\tfor (const project of workspace.getProjects()) {\n\t\t\tproject\n\t\t\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t\t\t?.addBuilderCall(\".withAuth()\");\n\t\t}\n\t}\n\n\t// biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders\n\tconst issuerPlaceholder = \"${AUTH0_ISSUER_BASE_URL}\";\n\t// biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders\n\tconst audPlaceholder = \"${AUTH0_AUDIENCE}\";\n\n\tconst configSection = `auth:\\n  discoveryUrl: ${issuerPlaceholder}\\n  audience: ${audPlaceholder}\\n`;\n\n\tworkspace.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_YAML)?.addSection(configSection);\n\n\tworkspace\n\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t?.addEntry(\"AUTH0_ISSUER_BASE_URL\", options.issuerBaseUrl ?? \"\")\n\t\t.addEntry(\"AUTH0_AUDIENCE\", options.audience ?? \"\");\n\n\tconst authConfig = new AuthConfigModel({\n\t\tissuerBaseUrl: options.issuerBaseUrl ?? \"\",\n\t\taudience: options.audience ?? \"\",\n\t});\n\tworkspace.addModel(authConfig);\n\n\tif (withLocalUsers && options.adminPassword) {\n\t\tcreateAuth0AdminUser(workspace, options, authConfig);\n\t}\n}\n\nexport const AuthFeature: Feature<AuthOptions> = { getOptions, scaffold };\n"],"names":["AuthFeature","ADMIN_ROLE","USER_ENTITY_TS","USER_REPOSITORY_TS","USER_SERVICE_TS","ABILITY_FACTORY_TS","getOptions","workspace","cliOptions","authProvider","issuerBaseUrl","getAuth0Options","choices","label","selected","pick","c","provider","auth0Cli","isInstalled","console","error","process","exit","stdout","write","tenants","listTenants","length","log","login","listApis","err","Auth0AuthError","active","find","t","name","userApis","filter","a","includes","projectName","apiChoices","existing","map","identifier","apiSelected","audience","defaultId","ask","createApi","updateApiScopes","HELLO_API_SCOPES","join","withLocalUsers","databaseProvider","adminUsername","adminPassword","generateAdminPassword","adminEmail","workspaceName","username","slug","toLowerCase","replace","createAuth0AdminUser","options","authConfig","password","email","admin","createAdminDatabaseUser","setAdminUser","sub","user_id","getModel","WELL_KNOWN_FILES","ENV_FILE","addEntry","Error","message","scaffoldLocalUserProfile","project","getProjects","MAIN_TS","addEntity","className","importPath","addRepository","addService","scope","addImport","setTypeOrmSeed","addFile","files","filePath","content","controller","getModels","ControllerSourceFile","addConstructorParam","getMethod","setAsync","setBody","scaffold","resource","addDecorator","addCortexImport","addSideEffectImport","addBuilderCall","issuerPlaceholder","audPlaceholder","configSection","CONFIG_YAML","addSection","AuthConfigModel","addModel"],"mappings":"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"}