@decohere/create 0.0.1-dev.17 → 0.0.1-dev.18

package/es6/src/webapi/features/database.feature.js

@@ -0,0 +1,141 @@
+import { randomBytes } from "node:crypto";
+import { pick } from "../../../v1/domain/prompt.js";
+import { CREATE_VERSION } from "../../../v1/version.js";
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+import { WEBAPI_PROJECT_DIR } from "../create-api.js";
+// Base config uses env-var references for production; the dev config section
+// written below overrides only the concrete values needed locally.
+const DATABASE_BASE_CONFIG_YAML = `database:
+  dataSources:
+    - name: default
+      provider: postgres
+      host: \${DB_HOST}
+      port: \${DB_PORT}
+      database: \${DB_NAME}
+      username: \${DB_USER}
+      password: \${DB_PASSWORD}
+      synchronize: false
+      seed: false
+      adminUser: \${DB_ADMIN_USER}
+      adminPassword: \${DB_ADMIN_PASSWORD}
+`;
+// Dev config only overrides what differs from base — credentials come from .env via env-var references.
+const DATABASE_DEV_CONFIG_YAML = `database:
+  dataSources:
+    - host: postgres
+      synchronize: true
+      seed: true
+`;
+const SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import type { Entity as IEntity } from "@decohere/codex";
+
+@Entity()
+export class SampleEntity implements IEntity {
+\t@PrimaryGeneratedColumn()
+\tpublic id!: number;
+
+\t@Column()
+\tpublic name!: string;
+}
+`;
+const SAMPLE_REPOSITORY_TS = `import { injectable } from "@decohere/crucible/decorators";
+import { injectUnitOfWork } from "@decohere/codex";
+import { TypeOrmRepository, TypeOrmUnitOfWork } from "@decohere/codex-typeorm";
+import { SampleEntity } from "../entities/sample.entity.js";
+
+@injectable()
+export class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {
+\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {
+\t\tsuper(unitOfWork, SampleEntity);
+\t}
+}
+`;
+async function getOptions(_workspace, cliOptions) {
+    if (cliOptions.databaseProvider != null) return {};
+    const choices = [
+        {
+            label: "none"
+        },
+        {
+            label: "postgres/typeorm"
+        }
+    ];
+    const selected = await pick("\n  Database: ", choices, (c)=>c.label);
+    return {
+        databaseProvider: selected?.label ?? "none"
+    };
+}
+function scaffold(workspace, options) {
+    if (options.databaseProvider !== "postgres/typeorm") return;
+    const name = workspace.name;
+    const password = randomBytes(16).toString("hex");
+    const db = `${name}_dev`;
+    const user = "postgres";
+    const devContainer = workspace.getModel(WELL_KNOWN_FILES.DEVCONTAINER_JSON);
+    const compose = workspace.getModel(WELL_KNOWN_FILES.DOCKER_COMPOSE);
+    // Add postgres service to compose
+    compose?.addService("postgres", {
+        image: "postgres:16",
+        restart: "unless-stopped",
+        environment: {
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
+            POSTGRES_DB: "${POSTGRES_DB}",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
+            POSTGRES_USER: "${POSTGRES_USER}",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
+            POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
+        },
+        ports: [
+            "5432:5432"
+        ],
+        volumes: [
+            "postgres-data:/var/lib/postgresql/data"
+        ]
+    }).addVolume("postgres-data");
+    compose?.addService("adminer", {
+        image: "adminer",
+        ports: [
+            "8080:8080"
+        ]
+    });
+    // Add SQLTools extension for DB browsing in VS Code
+    devContainer?.addExtension("mtxr.sqltools");
+    // Wire up main.ts
+    workspace.getModel(WELL_KNOWN_FILES.MAIN_TS)?.addSideEffectImport("@decohere/codex-typeorm").addEntity({
+        className: "SampleEntity",
+        importPath: "./entities/sample.entity.js"
+    }).addRepository({
+        className: "SampleEntityRepository",
+        importPath: "./repositories/sample.repository.js"
+    });
+    // Add codex + typeorm deps to root package.json
+    workspace.getModel(WELL_KNOWN_FILES.PACKAGE_JSON)?.addDependency("@decohere/codex", CREATE_VERSION).addDependency("typeorm", "^0.3.28").addDependency("@decohere/codex-typeorm", CREATE_VERSION);
+    // Add codex deps to api package.json
+    workspace.getModel(WELL_KNOWN_FILES.API_PACKAGE_JSON)?.addDependency("@decohere/codex", CREATE_VERSION).addDependency("@decohere/codex-typeorm", CREATE_VERSION);
+    // Append database config sections
+    workspace.getModel(WELL_KNOWN_FILES.CONFIG_YAML)?.addSection(DATABASE_BASE_CONFIG_YAML);
+    workspace.getModel(WELL_KNOWN_FILES.CONFIG_DEV_YAML)?.addSection(DATABASE_DEV_CONFIG_YAML);
+    // Register entity and repository source files in the api project
+    workspace.getProject(WEBAPI_PROJECT_DIR)?.addFile({
+        files: ()=>[
+                {
+                    filePath: "src/entities/sample.entity.ts",
+                    content: SAMPLE_ENTITY_TS
+                },
+                {
+                    filePath: "src/repositories/sample.repository.ts",
+                    content: SAMPLE_REPOSITORY_TS
+                }
+            ]
+    });
+    // .env at workspace root — mounted by compose via ../.env so both postgres
+    // and the devcontainer service can read credentials
+    compose?.addEnvFile("postgres", "../.env").addEnvFile("devcontainer", "../.env");
+    workspace.getModel(WELL_KNOWN_FILES.ENV_FILE)?.addEntry("POSTGRES_DB", db).addEntry("POSTGRES_USER", user).addEntry("POSTGRES_PASSWORD", password).addEntry("DB_HOST", "localhost").addEntry("DB_PORT", "5432").addEntry("DB_NAME", db).addEntry("DB_USER", user).addEntry("DB_PASSWORD", password).addEntry("DB_ADMIN_USER", user).addEntry("DB_ADMIN_PASSWORD", password);
+}
+export const DatabaseFeature = {
+    getOptions,
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/database.feature.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport { pick } from \"../../../v1/domain/prompt.js\";\nimport { CREATE_VERSION } from \"../../../v1/version.js\";\nimport type { DockerCompose } from \"../../models/compose.model.js\";\nimport type { ConfigYaml } from \"../../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { DevContainer } from \"../../models/dev-container.model.js\";\nimport type { EnvFile } from \"../../models/env-file.model.js\";\nimport type { PackageJson } from \"../../models/package-json.model.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport { WEBAPI_PROJECT_DIR } from \"../create-api.js\";\nimport type { ApiPackageJson } from \"../models/api-package-json.model.js\";\nimport type { MainSourceFile } from \"../models/main-source-file.model.js\";\n\nexport type DatabaseOptions = {\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n};\n\n// Base config uses env-var references for production; the dev config section\n// written below overrides only the concrete values needed locally.\nconst DATABASE_BASE_CONFIG_YAML = `database:\n  dataSources:\n    - name: default\n      provider: postgres\n      host: \\${DB_HOST}\n      port: \\${DB_PORT}\n      database: \\${DB_NAME}\n      username: \\${DB_USER}\n      password: \\${DB_PASSWORD}\n      synchronize: false\n      seed: false\n      adminUser: \\${DB_ADMIN_USER}\n      adminPassword: \\${DB_ADMIN_PASSWORD}\n`;\n\n// Dev config only overrides what differs from base — credentials come from .env via env-var references.\nconst DATABASE_DEV_CONFIG_YAML = `database:\n  dataSources:\n    - host: postgres\n      synchronize: true\n      seed: true\n`;\n\nconst SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from \"typeorm\";\nimport type { Entity as IEntity } from \"@decohere/codex\";\n\n@Entity()\nexport class SampleEntity implements IEntity {\n\\t@PrimaryGeneratedColumn()\n\\tpublic id!: number;\n\n\\t@Column()\n\\tpublic name!: string;\n}\n`;\n\nconst SAMPLE_REPOSITORY_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport { injectUnitOfWork } from \"@decohere/codex\";\nimport { TypeOrmRepository, TypeOrmUnitOfWork } from \"@decohere/codex-typeorm\";\nimport { SampleEntity } from \"../entities/sample.entity.js\";\n\n@injectable()\nexport class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {\n\\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {\n\\t\\tsuper(unitOfWork, SampleEntity);\n\\t}\n}\n`;\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<DatabaseOptions>,\n): Promise<Partial<DatabaseOptions>> {\n\tif (cliOptions.databaseProvider != null) return {};\n\n\tconst choices = [{ label: \"none\" as const }, { label: \"postgres/typeorm\" as const }];\n\tconst selected = await pick(\"\\n  Database: \", choices, (c) => c.label);\n\treturn { databaseProvider: selected?.label ?? \"none\" };\n}\n\nfunction scaffold(workspace: WorkspaceScaffold, options: DatabaseOptions): void {\n\tif (options.databaseProvider !== \"postgres/typeorm\") return;\n\n\tconst name = workspace.name;\n\tconst password = randomBytes(16).toString(\"hex\");\n\tconst db = `${name}_dev`;\n\tconst user = \"postgres\";\n\n\tconst devContainer = workspace.getModel<DevContainer>(WELL_KNOWN_FILES.DEVCONTAINER_JSON);\n\tconst compose = workspace.getModel<DockerCompose>(WELL_KNOWN_FILES.DOCKER_COMPOSE);\n\n\t// Add postgres service to compose\n\tcompose\n\t\t?.addService(\"postgres\", {\n\t\t\timage: \"postgres:16\",\n\t\t\trestart: \"unless-stopped\",\n\t\t\tenvironment: {\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env\n\t\t\t\tPOSTGRES_DB: \"${POSTGRES_DB}\",\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env\n\t\t\t\tPOSTGRES_USER: \"${POSTGRES_USER}\",\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env\n\t\t\t\tPOSTGRES_PASSWORD: \"${POSTGRES_PASSWORD}\",\n\t\t\t},\n\t\t\tports: [\"5432:5432\"],\n\t\t\tvolumes: [\"postgres-data:/var/lib/postgresql/data\"],\n\t\t})\n\t\t.addVolume(\"postgres-data\");\n\n\tcompose?.addService(\"adminer\", {\n\t\timage: \"adminer\",\n\t\tports: [\"8080:8080\"],\n\t});\n\n\t// Add SQLTools extension for DB browsing in VS Code\n\tdevContainer?.addExtension(\"mtxr.sqltools\");\n\n\t// Wire up main.ts\n\tworkspace\n\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t?.addSideEffectImport(\"@decohere/codex-typeorm\")\n\t\t.addEntity({ className: \"SampleEntity\", importPath: \"./entities/sample.entity.js\" })\n\t\t.addRepository({\n\t\t\tclassName: \"SampleEntityRepository\",\n\t\t\timportPath: \"./repositories/sample.repository.js\",\n\t\t});\n\n\t// Add codex + typeorm deps to root package.json\n\tworkspace\n\t\t.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON)\n\t\t?.addDependency(\"@decohere/codex\", CREATE_VERSION)\n\t\t.addDependency(\"typeorm\", \"^0.3.28\")\n\t\t.addDependency(\"@decohere/codex-typeorm\", CREATE_VERSION);\n\n\t// Add codex deps to api package.json\n\tworkspace\n\t\t.getModel<ApiPackageJson>(WELL_KNOWN_FILES.API_PACKAGE_JSON)\n\t\t?.addDependency(\"@decohere/codex\", CREATE_VERSION)\n\t\t.addDependency(\"@decohere/codex-typeorm\", CREATE_VERSION);\n\n\t// Append database config sections\n\tworkspace\n\t\t.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_YAML)\n\t\t?.addSection(DATABASE_BASE_CONFIG_YAML);\n\tworkspace\n\t\t.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_DEV_YAML)\n\t\t?.addSection(DATABASE_DEV_CONFIG_YAML);\n\n\t// Register entity and repository source files in the api project\n\tworkspace.getProject(WEBAPI_PROJECT_DIR)?.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"src/entities/sample.entity.ts\",\n\t\t\t\tcontent: SAMPLE_ENTITY_TS,\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: \"src/repositories/sample.repository.ts\",\n\t\t\t\tcontent: SAMPLE_REPOSITORY_TS,\n\t\t\t},\n\t\t],\n\t});\n\n\t// .env at workspace root — mounted by compose via ../.env so both postgres\n\t// and the devcontainer service can read credentials\n\tcompose?.addEnvFile(\"postgres\", \"../.env\").addEnvFile(\"devcontainer\", \"../.env\");\n\n\tworkspace\n\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t?.addEntry(\"POSTGRES_DB\", db)\n\t\t.addEntry(\"POSTGRES_USER\", user)\n\t\t.addEntry(\"POSTGRES_PASSWORD\", password)\n\t\t.addEntry(\"DB_HOST\", \"localhost\")\n\t\t.addEntry(\"DB_PORT\", \"5432\")\n\t\t.addEntry(\"DB_NAME\", db)\n\t\t.addEntry(\"DB_USER\", user)\n\t\t.addEntry(\"DB_PASSWORD\", password)\n\t\t.addEntry(\"DB_ADMIN_USER\", user)\n\t\t.addEntry(\"DB_ADMIN_PASSWORD\", password);\n}\n\nexport const DatabaseFeature: Feature<DatabaseOptions> = { getOptions, scaffold };\n"],"names":["randomBytes","pick","CREATE_VERSION","WELL_KNOWN_FILES","WEBAPI_PROJECT_DIR","DATABASE_BASE_CONFIG_YAML","DATABASE_DEV_CONFIG_YAML","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","getOptions","_workspace","cliOptions","databaseProvider","choices","label","selected","c","scaffold","workspace","options","name","password","toString","db","user","devContainer","getModel","DEVCONTAINER_JSON","compose","DOCKER_COMPOSE","addService","image","restart","environment","POSTGRES_DB","POSTGRES_USER","POSTGRES_PASSWORD","ports","volumes","addVolume","addExtension","MAIN_TS","addSideEffectImport","addEntity","className","importPath","addRepository","PACKAGE_JSON","addDependency","API_PACKAGE_JSON","CONFIG_YAML","addSection","CONFIG_DEV_YAML","getProject","addFile","files","filePath","content","addEnvFile","ENV_FILE","addEntry","DatabaseFeature"],"mappings":"AAAA,SAASA,WAAW,QAAQ,cAAc;AAC1C,SAASC,IAAI,QAAQ,+BAA+B;AACpD,SAASC,cAAc,QAAQ,yBAAyB;AAGxD,SAASC,gBAAgB,QAAQ,wBAAwB;AAMzD,SAASC,kBAAkB,QAAQ,mBAAmB;AAQtD,6EAA6E;AAC7E,mEAAmE;AACnE,MAAMC,4BAA4B,CAAC;;;;;;;;;;;;;AAanC,CAAC;AAED,wGAAwG;AACxG,MAAMC,2BAA2B,CAAC;;;;;AAKlC,CAAC;AAED,MAAMC,mBAAmB,CAAC;;;;;;;;;;;AAW1B,CAAC;AAED,MAAMC,uBAAuB,CAAC;;;;;;;;;;;AAW9B,CAAC;AAED,eAAeC,WACdC,UAA6B,EAC7BC,UAAoC;IAEpC,IAAIA,WAAWC,gBAAgB,IAAI,MAAM,OAAO,CAAC;IAEjD,MAAMC,UAAU;QAAC;YAAEC,OAAO;QAAgB;QAAG;YAAEA,OAAO;QAA4B;KAAE;IACpF,MAAMC,WAAW,MAAMd,KAAK,kBAAkBY,SAAS,CAACG,IAAMA,EAAEF,KAAK;IACrE,OAAO;QAAEF,kBAAkBG,UAAUD,SAAS;IAAO;AACtD;AAEA,SAASG,SAASC,SAA4B,EAAEC,OAAwB;IACvE,IAAIA,QAAQP,gBAAgB,KAAK,oBAAoB;IAErD,MAAMQ,OAAOF,UAAUE,IAAI;IAC3B,MAAMC,WAAWrB,YAAY,IAAIsB,QAAQ,CAAC;IAC1C,MAAMC,KAAK,GAAGH,KAAK,IAAI,CAAC;IACxB,MAAMI,OAAO;IAEb,MAAMC,eAAeP,UAAUQ,QAAQ,CAAevB,iBAAiBwB,iBAAiB;IACxF,MAAMC,UAAUV,UAAUQ,QAAQ,CAAgBvB,iBAAiB0B,cAAc;IAEjF,kCAAkC;IAClCD,SACGE,WAAW,YAAY;QACxBC,OAAO;QACPC,SAAS;QACTC,aAAa;YACZ,6FAA6F;YAC7FC,aAAa;YACb,6FAA6F;YAC7FC,eAAe;YACf,6FAA6F;YAC7FC,mBAAmB;QACpB;QACAC,OAAO;YAAC;SAAY;QACpBC,SAAS;YAAC;SAAyC;IACpD,GACCC,UAAU;IAEZX,SAASE,WAAW,WAAW;QAC9BC,OAAO;QACPM,OAAO;YAAC;SAAY;IACrB;IAEA,oDAAoD;IACpDZ,cAAce,aAAa;IAE3B,kBAAkB;IAClBtB,UACEQ,QAAQ,CAAiBvB,iBAAiBsC,OAAO,GAChDC,oBAAoB,2BACrBC,UAAU;QAAEC,WAAW;QAAgBC,YAAY;IAA8B,GACjFC,cAAc;QACdF,WAAW;QACXC,YAAY;IACb;IAED,gDAAgD;IAChD3B,UACEQ,QAAQ,CAAcvB,iBAAiB4C,YAAY,GAClDC,cAAc,mBAAmB9C,gBAClC8C,cAAc,WAAW,WACzBA,cAAc,2BAA2B9C;IAE3C,qCAAqC;IACrCgB,UACEQ,QAAQ,CAAiBvB,iBAAiB8C,gBAAgB,GACzDD,cAAc,mBAAmB9C,gBAClC8C,cAAc,2BAA2B9C;IAE3C,kCAAkC;IAClCgB,UACEQ,QAAQ,CAAavB,iBAAiB+C,WAAW,GAChDC,WAAW9C;IACda,UACEQ,QAAQ,CAAavB,iBAAiBiD,eAAe,GACpDD,WAAW7C;IAEd,iEAAiE;IACjEY,UAAUmC,UAAU,CAACjD,qBAAqBkD,QAAQ;QACjDC,OAAO,IAAM;gBACZ;oBACCC,UAAU;oBACVC,SAASlD;gBACV;gBACA;oBACCiD,UAAU;oBACVC,SAASjD;gBACV;aACA;IACF;IAEA,2EAA2E;IAC3E,oDAAoD;IACpDoB,SAAS8B,WAAW,YAAY,WAAWA,WAAW,gBAAgB;IAEtExC,UACEQ,QAAQ,CAAUvB,iBAAiBwD,QAAQ,GAC1CC,SAAS,eAAerC,IACzBqC,SAAS,iBAAiBpC,MAC1BoC,SAAS,qBAAqBvC,UAC9BuC,SAAS,WAAW,aACpBA,SAAS,WAAW,QACpBA,SAAS,WAAWrC,IACpBqC,SAAS,WAAWpC,MACpBoC,SAAS,eAAevC,UACxBuC,SAAS,iBAAiBpC,MAC1BoC,SAAS,qBAAqBvC;AACjC;AAEA,OAAO,MAAMwC,kBAA4C;IAAEpD;IAAYQ;AAAS,EAAE"}

package/es6/src/webapi/features/finalize.feature.js

@@ -0,0 +1,36 @@
+import { detectPackageManager, promptForPackageManager } from "@decohere/nexus/interop";
+import { ask } from "../../../v1/domain/prompt.js";
+// State resolved during scaffold(), consumed by finalize().
+let _pm = null;
+let _shouldInstall = true;
+async function getOptions(_workspace, _cliOptions) {
+    return {};
+}
+async function scaffold(workspace, _options) {
+    _pm = detectPackageManager(workspace.targetDir) ?? await promptForPackageManager();
+    const answer = await ask("\nInstall dependencies now? [yes/no] (yes): ", "yes");
+    _shouldInstall = answer.toLowerCase() !== "no";
+}
+async function finalize(workspace, _options) {
+    const pm = _pm;
+    if (_shouldInstall) {
+        console.log(`\nScaffolded ${workspace.name}. Installing dependencies...\n`);
+        await pm.install({
+            cwd: workspace.targetDir
+        });
+    }
+    console.log(`\nDone! ${_shouldInstall ? "Next" : "To get started:"} steps:\n`);
+    console.log(`  cd ${workspace.name}`);
+    if (!_shouldInstall) {
+        console.log(`  ${pm.name} install`);
+    }
+    console.log("  pnpm build     # forge build");
+    console.log("  pnpm dev       # flux serve\n");
+}
+export const FinalizeFeature = {
+    getOptions,
+    scaffold,
+    finalize
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/features/postman.feature.js

@@ -0,0 +1,258 @@
+import { pick } from "../../../v1/domain/prompt.js";
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+import * as auth0Cli from "./auth0-cli.js";
+async function getOptions(_workspace, cliOptions) {
+    if (cliOptions.postmanProvider != null) return {};
+    const choices = [
+        {
+            label: "none",
+            description: "skip"
+        },
+        {
+            label: "local",
+            description: "write collection + environment files"
+        },
+        {
+            label: "api",
+            description: "write files and upload to Postman.com"
+        }
+    ];
+    const selected = await pick("\n  Postman: ", choices, (c)=>`${c.label} — ${c.description}`);
+    const provider = selected?.label ?? "none";
+    if (provider === "none") return {
+        postmanProvider: "none"
+    };
+    if (provider === "local") return {
+        postmanProvider: "local"
+    };
+    // api: collect API key + workspace selection
+    const apiKey = process.env.POSTMAN_API_KEY ?? await import("../../../v1/domain/prompt.js").then((m)=>m.ask("\n  Postman API key (app.getpostman.com/settings/me/api-keys): "));
+    const headers = {
+        "X-Api-Key": apiKey,
+        "Content-Type": "application/json"
+    };
+    const wsRes = await fetch("https://api.getpostman.com/workspaces", {
+        headers
+    });
+    if (!wsRes.ok) {
+        console.error("\n  Postman API key invalid — falling back to local files.");
+        return {
+            postmanProvider: "local"
+        };
+    }
+    const { workspaces } = await wsRes.json();
+    const wsChoices = [
+        {
+            label: "<new workspace>",
+            id: null
+        },
+        ...workspaces.map((w)=>({
+                label: `${w.name} (${w.type})`,
+                id: w.id
+            }))
+    ];
+    const wsPicked = await pick("\n  Postman workspace: ", wsChoices, (c)=>c.label);
+    let workspaceId;
+    if (!wsPicked || wsPicked.id === null) {
+        const { ask } = await import("../../../v1/domain/prompt.js");
+        const wsName = await ask(`  Workspace name: `);
+        const createRes = await fetch("https://api.getpostman.com/workspaces", {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                workspace: {
+                    name: wsName,
+                    type: "personal"
+                }
+            })
+        });
+        const { workspace: ws } = await createRes.json();
+        workspaceId = ws.id;
+        console.log(`  ✓ Workspace created: ${wsName}`);
+    } else {
+        workspaceId = wsPicked.id;
+    }
+    return {
+        postmanProvider: "api",
+        apiKey,
+        workspaceId
+    };
+}
+function buildCollection(projectName, auth) {
+    const authObj = auth?.auth0Domain ? {
+        type: "oauth2",
+        oauth2: [
+            {
+                key: "grant_type",
+                value: "authorization_code_with_pkce",
+                type: "string"
+            },
+            {
+                key: "authUrl",
+                value: "https://{{auth0Domain}}/authorize?audience={{auth0Audience}}",
+                type: "string"
+            },
+            {
+                key: "accessTokenUrl",
+                value: "https://{{auth0Domain}}/oauth/token",
+                type: "string"
+            },
+            {
+                key: "clientId",
+                value: "{{auth0ClientId}}",
+                type: "string"
+            },
+            {
+                key: "scope",
+                value: "openid profile email",
+                type: "string"
+            },
+            {
+                key: "addTokenTo",
+                value: "header",
+                type: "string"
+            },
+            {
+                key: "challengeAlgorithm",
+                value: "S256",
+                type: "string"
+            }
+        ]
+    } : undefined;
+    return {
+        info: {
+            name: `${projectName} WebAPI`,
+            schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+        },
+        ...authObj ? {
+            auth: authObj
+        } : {},
+        item: [
+            {
+                name: "Hello",
+                request: {
+                    method: "GET",
+                    url: {
+                        raw: "{{baseUrl}}/hello",
+                        host: [
+                            "{{baseUrl}}"
+                        ],
+                        path: [
+                            "hello"
+                        ]
+                    }
+                }
+            }
+        ]
+    };
+}
+function buildEnvironmentYaml(name, auth) {
+    const auth0Section = auth?.auth0Domain ? [
+        "  - key: auth0Domain",
+        `    value: ${auth.auth0Domain}`,
+        "  - key: auth0Audience",
+        `    value: '${auth.auth0Audience ?? ""}'`,
+        "  - key: auth0ClientId",
+        `    value: '${auth.auth0ClientId ?? ""}'`,
+        "    description: Client ID of the Auth0 SPA application used by Postman for PKCE authentication"
+    ].join("\n") + "\n" : "";
+    return `name: ${name}\nvalues:\n  - key: baseUrl\n    value: 'http://localhost:3000'\n${auth0Section}`;
+}
+async function scaffold(workspace, options) {
+    if (options.postmanProvider === "none") return;
+    const authConfigModel = workspace.getModel(WELL_KNOWN_FILES.AUTH_CONFIG);
+    const authCfg = authConfigModel?.config;
+    let spaClientId;
+    if (options.postmanProvider === "api" && options.apiKey && authCfg?.issuerBaseUrl) {
+        try {
+            const app = auth0Cli.createSpaApp(`${workspace.name} Postman`, "https://oauth.pstmn.io/v1/callback");
+            spaClientId = app.client_id;
+            console.log("  ✓ Auth0 SPA app created for Postman PKCE");
+        } catch  {
+            console.error("  ✗ Failed to create Auth0 SPA app — continuing without it.");
+        }
+    }
+    const auth0Env = authCfg?.issuerBaseUrl ? {
+        auth0Domain: authCfg.issuerBaseUrl.replace(/^https?:\/\//, ""),
+        auth0Audience: authCfg.audience,
+        auth0ClientId: spaClientId
+    } : undefined;
+    const projectName = workspace.name;
+    const collection = buildCollection(projectName, auth0Env);
+    const envYaml = buildEnvironmentYaml(`${projectName} — Local`, auth0Env);
+    workspace.addFile({
+        files: ()=>[
+                {
+                    filePath: `postman/environments/${projectName} \u2014 Local.environment.yaml`,
+                    content: envYaml
+                },
+                {
+                    filePath: `postman/collections/${projectName}.postman_collection.json`,
+                    content: `${JSON.stringify(collection, null, 2)}\n`
+                }
+            ]
+    });
+    if (options.postmanProvider === "api" && options.apiKey) {
+        const headers = {
+            "X-Api-Key": options.apiKey,
+            "Content-Type": "application/json"
+        };
+        const colRes = await fetch(`https://api.getpostman.com/collections?workspace=${options.workspaceId}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                collection
+            })
+        });
+        if (colRes.ok) {
+            console.log("  ✓ Postman collection uploaded");
+        } else {
+            console.error("  ✗ Failed to upload Postman collection");
+        }
+        const envVars = [
+            {
+                key: "baseUrl",
+                value: "http://localhost:3000",
+                enabled: true
+            },
+            ...auth0Env?.auth0Domain ? [
+                {
+                    key: "auth0Domain",
+                    value: auth0Env.auth0Domain,
+                    enabled: true
+                },
+                {
+                    key: "auth0Audience",
+                    value: auth0Env.auth0Audience ?? "",
+                    enabled: true
+                },
+                {
+                    key: "auth0ClientId",
+                    value: auth0Env.auth0ClientId ?? "",
+                    enabled: true
+                }
+            ] : []
+        ];
+        const envRes = await fetch(`https://api.getpostman.com/environments?workspace=${options.workspaceId}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                environment: {
+                    name: `${projectName} — Local`,
+                    values: envVars
+                }
+            })
+        });
+        if (envRes.ok) {
+            console.log("  ✓ Postman environment uploaded");
+        } else {
+            console.error("  ✗ Failed to upload Postman environment");
+        }
+    }
+}
+export const PostmanFeature = {
+    getOptions,
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/postman.feature.ts"],"sourcesContent":["import { pick } from \"../../../v1/domain/prompt.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport type { AuthConfigModel } from \"../models/auth-config.model.js\";\nimport * as auth0Cli from \"./auth0-cli.js\";\n\nexport type PostmanOptions = {\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n\tapiKey?: string;\n\tworkspaceId?: string;\n};\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<PostmanOptions>,\n): Promise<Partial<PostmanOptions>> {\n\tif (cliOptions.postmanProvider != null) return {};\n\n\tconst choices = [\n\t\t{ label: \"none\" as const, description: \"skip\" },\n\t\t{ label: \"local\" as const, description: \"write collection + environment files\" },\n\t\t{ label: \"api\" as const, description: \"write files and upload to Postman.com\" },\n\t];\n\tconst selected = await pick(\n\t\t\"\\n  Postman: \",\n\t\tchoices,\n\t\t(c) => `${c.label} — ${c.description}`,\n\t);\n\tconst provider = selected?.label ?? \"none\";\n\n\tif (provider === \"none\") return { postmanProvider: \"none\" };\n\tif (provider === \"local\") return { postmanProvider: \"local\" };\n\n\t// api: collect API key + workspace selection\n\tconst apiKey =\n\t\tprocess.env.POSTMAN_API_KEY ??\n\t\t(await import(\"../../../v1/domain/prompt.js\").then((m) =>\n\t\t\tm.ask(\"\\n  Postman API key (app.getpostman.com/settings/me/api-keys): \"),\n\t\t));\n\n\tconst headers = { \"X-Api-Key\": apiKey, \"Content-Type\": \"application/json\" };\n\tconst wsRes = await fetch(\"https://api.getpostman.com/workspaces\", { headers });\n\n\tif (!wsRes.ok) {\n\t\tconsole.error(\"\\n  Postman API key invalid — falling back to local files.\");\n\t\treturn { postmanProvider: \"local\" };\n\t}\n\n\tconst { workspaces } = (await wsRes.json()) as {\n\t\tworkspaces: Array<{ id: string; name: string; type: string }>;\n\t};\n\n\ttype WsChoice = { label: string; id: string | null };\n\tconst wsChoices: WsChoice[] = [\n\t\t{ label: \"<new workspace>\", id: null },\n\t\t...workspaces.map((w) => ({ label: `${w.name} (${w.type})`, id: w.id })),\n\t];\n\n\tconst wsPicked = await pick(\"\\n  Postman workspace: \", wsChoices, (c) => c.label);\n\n\tlet workspaceId: string;\n\tif (!wsPicked || wsPicked.id === null) {\n\t\tconst { ask } = await import(\"../../../v1/domain/prompt.js\");\n\t\tconst wsName = await ask(`  Workspace name: `);\n\t\tconst createRes = await fetch(\"https://api.getpostman.com/workspaces\", {\n\t\t\tmethod: \"POST\",\n\t\t\theaders,\n\t\t\tbody: JSON.stringify({ workspace: { name: wsName, type: \"personal\" } }),\n\t\t});\n\t\tconst { workspace: ws } = (await createRes.json()) as { workspace: { id: string } };\n\t\tworkspaceId = ws.id;\n\t\tconsole.log(`  ✓ Workspace created: ${wsName}`);\n\t} else {\n\t\tworkspaceId = wsPicked.id;\n\t}\n\n\treturn { postmanProvider: \"api\", apiKey, workspaceId };\n}\n\ntype Auth0Env = {\n\tauth0Domain?: string;\n\tauth0Audience?: string;\n\tauth0ClientId?: string;\n};\n\nfunction buildCollection(projectName: string, auth?: Auth0Env): unknown {\n\tconst authObj = auth?.auth0Domain\n\t\t? {\n\t\t\t\ttype: \"oauth2\",\n\t\t\t\toauth2: [\n\t\t\t\t\t{ key: \"grant_type\", value: \"authorization_code_with_pkce\", type: \"string\" },\n\t\t\t\t\t{\n\t\t\t\t\t\tkey: \"authUrl\",\n\t\t\t\t\t\tvalue: \"https://{{auth0Domain}}/authorize?audience={{auth0Audience}}\",\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\t\t\tvalue: \"https://{{auth0Domain}}/oauth/token\",\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\t{ key: \"clientId\", value: \"{{auth0ClientId}}\", type: \"string\" },\n\t\t\t\t\t{ key: \"scope\", value: \"openid profile email\", type: \"string\" },\n\t\t\t\t\t{ key: \"addTokenTo\", value: \"header\", type: \"string\" },\n\t\t\t\t\t{ key: \"challengeAlgorithm\", value: \"S256\", type: \"string\" },\n\t\t\t\t],\n\t\t\t}\n\t\t: undefined;\n\n\treturn {\n\t\tinfo: {\n\t\t\tname: `${projectName} WebAPI`,\n\t\t\tschema: \"https://schema.getpostman.com/json/collection/v2.1.0/collection.json\",\n\t\t},\n\t\t...(authObj ? { auth: authObj } : {}),\n\t\titem: [\n\t\t\t{\n\t\t\t\tname: \"Hello\",\n\t\t\t\trequest: {\n\t\t\t\t\tmethod: \"GET\",\n\t\t\t\t\turl: { raw: \"{{baseUrl}}/hello\", host: [\"{{baseUrl}}\"], path: [\"hello\"] },\n\t\t\t\t},\n\t\t\t},\n\t\t],\n\t};\n}\n\nfunction buildEnvironmentYaml(name: string, auth?: Auth0Env): string {\n\tconst auth0Section = auth?.auth0Domain\n\t\t? [\n\t\t\t\t\"  - key: auth0Domain\",\n\t\t\t\t`    value: ${auth.auth0Domain}`,\n\t\t\t\t\"  - key: auth0Audience\",\n\t\t\t\t`    value: '${auth.auth0Audience ?? \"\"}'`,\n\t\t\t\t\"  - key: auth0ClientId\",\n\t\t\t\t`    value: '${auth.auth0ClientId ?? \"\"}'`,\n\t\t\t\t\"    description: Client ID of the Auth0 SPA application used by Postman for PKCE authentication\",\n\t\t\t].join(\"\\n\") + \"\\n\"\n\t\t: \"\";\n\n\treturn `name: ${name}\\nvalues:\\n  - key: baseUrl\\n    value: 'http://localhost:3000'\\n${auth0Section}`;\n}\n\nasync function scaffold(workspace: WorkspaceScaffold, options: PostmanOptions): Promise<void> {\n\tif (options.postmanProvider === \"none\") return;\n\n\tconst authConfigModel = workspace.getModel<AuthConfigModel>(WELL_KNOWN_FILES.AUTH_CONFIG);\n\tconst authCfg = authConfigModel?.config;\n\n\tlet spaClientId: string | undefined;\n\n\tif (options.postmanProvider === \"api\" && options.apiKey && authCfg?.issuerBaseUrl) {\n\t\ttry {\n\t\t\tconst app = auth0Cli.createSpaApp(\n\t\t\t\t`${workspace.name} Postman`,\n\t\t\t\t\"https://oauth.pstmn.io/v1/callback\",\n\t\t\t);\n\t\t\tspaClientId = app.client_id;\n\t\t\tconsole.log(\"  ✓ Auth0 SPA app created for Postman PKCE\");\n\t\t} catch {\n\t\t\tconsole.error(\"  ✗ Failed to create Auth0 SPA app — continuing without it.\");\n\t\t}\n\t}\n\n\tconst auth0Env: Auth0Env | undefined = authCfg?.issuerBaseUrl\n\t\t? {\n\t\t\t\tauth0Domain: authCfg.issuerBaseUrl.replace(/^https?:\\/\\//, \"\"),\n\t\t\t\tauth0Audience: authCfg.audience,\n\t\t\t\tauth0ClientId: spaClientId,\n\t\t\t}\n\t\t: undefined;\n\n\tconst projectName = workspace.name;\n\tconst collection = buildCollection(projectName, auth0Env);\n\tconst envYaml = buildEnvironmentYaml(`${projectName} — Local`, auth0Env);\n\n\tworkspace.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: `postman/environments/${projectName} \\u2014 Local.environment.yaml`,\n\t\t\t\tcontent: envYaml,\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: `postman/collections/${projectName}.postman_collection.json`,\n\t\t\t\tcontent: `${JSON.stringify(collection, null, 2)}\\n`,\n\t\t\t},\n\t\t],\n\t});\n\n\tif (options.postmanProvider === \"api\" && options.apiKey) {\n\t\tconst headers = { \"X-Api-Key\": options.apiKey, \"Content-Type\": \"application/json\" };\n\n\t\tconst colRes = await fetch(\n\t\t\t`https://api.getpostman.com/collections?workspace=${options.workspaceId}`,\n\t\t\t{\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders,\n\t\t\t\tbody: JSON.stringify({ collection }),\n\t\t\t},\n\t\t);\n\t\tif (colRes.ok) {\n\t\t\tconsole.log(\"  ✓ Postman collection uploaded\");\n\t\t} else {\n\t\t\tconsole.error(\"  ✗ Failed to upload Postman collection\");\n\t\t}\n\n\t\tconst envVars = [\n\t\t\t{ key: \"baseUrl\", value: \"http://localhost:3000\", enabled: true },\n\t\t\t...(auth0Env?.auth0Domain\n\t\t\t\t? [\n\t\t\t\t\t\t{ key: \"auth0Domain\", value: auth0Env.auth0Domain, enabled: true },\n\t\t\t\t\t\t{ key: \"auth0Audience\", value: auth0Env.auth0Audience ?? \"\", enabled: true },\n\t\t\t\t\t\t{ key: \"auth0ClientId\", value: auth0Env.auth0ClientId ?? \"\", enabled: true },\n\t\t\t\t\t]\n\t\t\t\t: []),\n\t\t];\n\t\tconst envRes = await fetch(\n\t\t\t`https://api.getpostman.com/environments?workspace=${options.workspaceId}`,\n\t\t\t{\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders,\n\t\t\t\tbody: JSON.stringify({\n\t\t\t\t\tenvironment: { name: `${projectName} — Local`, values: envVars },\n\t\t\t\t}),\n\t\t\t},\n\t\t);\n\t\tif (envRes.ok) {\n\t\t\tconsole.log(\"  ✓ Postman environment uploaded\");\n\t\t} else {\n\t\t\tconsole.error(\"  ✗ Failed to upload Postman environment\");\n\t\t}\n\t}\n}\n\nexport const PostmanFeature: Feature<PostmanOptions> = { getOptions, scaffold };\n"],"names":["pick","WELL_KNOWN_FILES","auth0Cli","getOptions","_workspace","cliOptions","postmanProvider","choices","label","description","selected","c","provider","apiKey","process","env","POSTMAN_API_KEY","then","m","ask","headers","wsRes","fetch","ok","console","error","workspaces","json","wsChoices","id","map","w","name","type","wsPicked","workspaceId","wsName","createRes","method","body","JSON","stringify","workspace","ws","log","buildCollection","projectName","auth","authObj","auth0Domain","oauth2","key","value","undefined","info","schema","item","request","url","raw","host","path","buildEnvironmentYaml","auth0Section","auth0Audience","auth0ClientId","join","scaffold","options","authConfigModel","getModel","AUTH_CONFIG","authCfg","config","spaClientId","issuerBaseUrl","app","createSpaApp","client_id","auth0Env","replace","audience","collection","envYaml","addFile","files","filePath","content","colRes","envVars","enabled","envRes","environment","values","PostmanFeature"],"mappings":"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"}

package/es6/src/webapi/models/api-package-json.model.js

@@ -0,0 +1,52 @@
+import { CREATE_VERSION } from "../../../v1/version.js";
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+/**
+ * Builder for `projects/api/package.json`.
+ *
+ * Starts with the core cortex + crucible deps. Features can call
+ * `addDependency` / `addDevDependency` to extend.
+ */ export class ApiPackageJson {
+    projectName;
+    key = WELL_KNOWN_FILES.API_PACKAGE_JSON;
+    _dependencies;
+    _devDependencies = {};
+    constructor(projectName){
+        this.projectName = projectName;
+        this._dependencies = {
+            "@decohere/cortex": CREATE_VERSION,
+            "@decohere/crucible": CREATE_VERSION
+        };
+    }
+    addDependency(name, version) {
+        this._dependencies[name] = version;
+        return this;
+    }
+    addDevDependency(name, version) {
+        this._devDependencies[name] = version;
+        return this;
+    }
+    files() {
+        const pkg = {
+            name: `@${this.projectName}/api`,
+            version: "0.0.1",
+            type: "module",
+            main: "src/main.ts",
+            dependencies: {
+                ...this._dependencies
+            }
+        };
+        if (Object.keys(this._devDependencies).length > 0) {
+            pkg.devDependencies = {
+                ...this._devDependencies
+            };
+        }
+        return [
+            {
+                filePath: "package.json",
+                content: JSON.stringify(pkg, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/models/auth-config.model.js

@@ -0,0 +1,19 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+/**
+ * Data-carrier model for auth configuration.
+ *
+ * Registered by AuthFeature when auth0 is configured. Other features (e.g.
+ * PostmanFeature) retrieve it via workspace.getModel(WELL_KNOWN_FILES.AUTH_CONFIG).
+ * Produces no files — exists solely so features can communicate auth details.
+ */ export class AuthConfigModel {
+    config;
+    key = WELL_KNOWN_FILES.AUTH_CONFIG;
+    constructor(config){
+        this.config = config;
+    }
+    files() {
+        return [];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvd2ViYXBpL21vZGVscy9hdXRoLWNvbmZpZy5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4uLy4uL21vZGVscy9jb25zdC5qc1wiO1xuaW1wb3J0IHR5cGUgeyBLZXllZE1vZGVsLCBTb3VyY2VGaWxlIH0gZnJvbSBcIi4uLy4uL21vZGVscy9zb3VyY2UtZmlsZS5qc1wiO1xuXG5leHBvcnQgdHlwZSBBdXRoQ29uZmlnID0ge1xuXHRpc3N1ZXJCYXNlVXJsOiBzdHJpbmc7XG5cdGF1ZGllbmNlOiBzdHJpbmc7XG59O1xuXG4vKipcbiAqIERhdGEtY2FycmllciBtb2RlbCBmb3IgYXV0aCBjb25maWd1cmF0aW9uLlxuICpcbiAqIFJlZ2lzdGVyZWQgYnkgQXV0aEZlYXR1cmUgd2hlbiBhdXRoMCBpcyBjb25maWd1cmVkLiBPdGhlciBmZWF0dXJlcyAoZS5nLlxuICogUG9zdG1hbkZlYXR1cmUpIHJldHJpZXZlIGl0IHZpYSB3b3Jrc3BhY2UuZ2V0TW9kZWwoV0VMTF9LTk9XTl9GSUxFUy5BVVRIX0NPTkZJRykuXG4gKiBQcm9kdWNlcyBubyBmaWxlcyDigJQgZXhpc3RzIHNvbGVseSBzbyBmZWF0dXJlcyBjYW4gY29tbXVuaWNhdGUgYXV0aCBkZXRhaWxzLlxuICovXG5leHBvcnQgY2xhc3MgQXV0aENvbmZpZ01vZGVsIGltcGxlbWVudHMgS2V5ZWRNb2RlbCB7XG5cdHB1YmxpYyByZWFkb25seSBrZXkgPSBXRUxMX0tOT1dOX0ZJTEVTLkFVVEhfQ09ORklHO1xuXG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihwdWJsaWMgcmVhZG9ubHkgY29uZmlnOiBBdXRoQ29uZmlnKSB7fVxuXG5cdHB1YmxpYyBmaWxlcygpOiBTb3VyY2VGaWxlW10ge1xuXHRcdHJldHVybiBbXTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIldFTExfS05PV05fRklMRVMiLCJBdXRoQ29uZmlnTW9kZWwiLCJrZXkiLCJBVVRIX0NPTkZJRyIsImNvbmZpZyIsImZpbGVzIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxnQkFBZ0IsUUFBUSx3QkFBd0I7QUFRekQ7Ozs7OztDQU1DLEdBQ0QsT0FBTyxNQUFNQzs7SUFDSUMsTUFBTUYsaUJBQWlCRyxXQUFXLENBQUM7SUFFbkQsWUFBbUIsQUFBZ0JDLE1BQWtCLENBQUU7YUFBcEJBLFNBQUFBO0lBQXFCO0lBRWpEQyxRQUFzQjtRQUM1QixPQUFPLEVBQUU7SUFDVjtBQUNEIn0=