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

package/es6/src/webapi/models/production-dockerfile.model.js

@@ -1,66 +1,148 @@
 import { WELL_KNOWN_FILES } from "../../models/const.js";
-import { DEFAULT_WEBAPI_NAME, webapiPackagedEntry, webapiProjectDir } from "../const.js";
+import { DEFAULT_WEBAPI_NAME, webapiProjectDir, webapiReleaseEntry } from "../const.js";
 /**
- * Production Dockerfile for each API, in the API's own folder: `projects/<name>/Dockerfile`.
- * That is where `forge docker` and `forge package` look for a deployable, and the folder is
- * the Docker build context.
+ * Production Dockerfiles for PaaS (Railway/Fly) and local `docker build`.
  *
- * The image copies `.package/`, which `forge package` writes before Docker runs: the API's
- * compiled code, the workspace libraries it imports, and a real (symlink-free) `node_modules`
- * of the third-party packages it reaches. So the image build installs nothing, runs no
- * workspace tooling, and needs no npm token.
+ * Context is always the **repo root** (`docker build -f Dockerfile.billing .`).
+ * Root `Dockerfile` is the first API (`pnpm start`). Extra or custom-named APIs
+ * also get `Dockerfile.<name>` so each service can be deployed on its own.
+ *
+ * Runtime `node_modules` come from a **prod-deps** stage (`pnpm install --prod`),
+ * not the full build install (Forge, TypeScript, Biome, Vitest).
  */ export class WebapiProductionDockerfile {
     apiNames;
+    options;
     key = WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;
     constructor(apiNames = [
         DEFAULT_WEBAPI_NAME
-    ]){
+    ], options = {}){
         this.apiNames = apiNames;
+        this.options = options;
     }
     files() {
         const names = this.apiNames.length > 0 ? this.apiNames : [
             DEFAULT_WEBAPI_NAME
         ];
-        return names.flatMap((name)=>[
-                {
-                    filePath: `${webapiProjectDir(name)}/Dockerfile`,
-                    content: renderProductionDockerfile(name)
-                },
-                {
-                    filePath: `${webapiProjectDir(name)}/.dockerignore`,
-                    content: dockerignoreContent()
-                }
-            ]);
+        const first = names[0] ?? DEFAULT_WEBAPI_NAME;
+        const files = [];
+        if (!this.options.namedOnly) {
+            files.push({
+                filePath: ".dockerignore",
+                content: dockerignoreContent()
+            });
+            files.push({
+                filePath: "Dockerfile",
+                content: renderProductionDockerfile(first, "start")
+            });
+        }
+        const emitNamed = this.options.namedOnly || names.length > 1 || first !== DEFAULT_WEBAPI_NAME;
+        if (emitNamed) {
+            for (const name of names){
+                files.push({
+                    filePath: `Dockerfile.${name}`,
+                    content: renderProductionDockerfile(name, `start:${name}`)
+                });
+            }
+        }
+        return files;
     }
 }
-export function renderProductionDockerfile(apiName) {
+export function renderProductionDockerfile(apiName, startScript) {
     const projectDir = webapiProjectDir(apiName);
-    const entry = webapiPackagedEntry();
+    const startCmd = startScript === "start" ? 'CMD ["pnpm", "start"]' : `CMD ["pnpm", "run", "${startScript}"]`;
+    const startEntry = webapiReleaseEntry(apiName);
+    const dockerfileFlag = startScript === "start" ? "" : `.${apiName}`;
     return `# syntax=docker/dockerfile:1
-# Production image for ${apiName}. Docker only copies the packaged app; it installs nothing.
+# Self-contained production image: install + forge build happen inside docker build.
+# Hosts (Railway/Fly/etc.) clone git and run \`docker build\` — they do not receive CI dist/.
+# Build from the repo root: docker build -f Dockerfile${dockerfileFlag} .
 #
-# Build the package first (release build, then .package/ in each API), then the image:
-#   pnpm run package:${apiName}
-#   docker build -t ${apiName} ${projectDir}
-# or, with the image name and tags from the workspace:
-#   pnpm run package:${apiName} && pnpm exec forge docker --configuration release
+# Runtime node_modules are a production-only install (prod-deps). The build stage's
+# full install (Forge, TypeScript, Biome, Vitest) is not copied into the run image.
 #
-# Hosts that build from a git clone (Railway, Fly) do not have .package/. Build and push the
-# image from CI instead, or run the package step before \`docker build\`.
-FROM node:24-bookworm-slim
+# Private @decohere/* packages: pass a BuildKit secret named npm_token (npm auth token), e.g.
+#   docker build --secret id=npm_token,env=NODE_AUTH_TOKEN .
+# Or set NODE_AUTH_TOKEN as a build-arg on hosts that only support build-args.
+
+FROM node:24-bookworm AS build
+WORKDIR /app
+RUN corepack enable && corepack prepare pnpm@10 --activate
+
+COPY package.json ./
+COPY pnpm-lock.yaml* ./
+COPY tsconfig.json biome.json ./
+COPY config ./config
+COPY ${projectDir} ./${projectDir}
+
+${renderPnpmInstall("all")}
+
+RUN pnpm run build
+
+FROM node:24-bookworm AS prod-deps
 WORKDIR /app
 ENV NODE_ENV=production
+RUN corepack enable && corepack prepare pnpm@10 --activate
 
-COPY .package/ ./
+COPY package.json ./
+COPY pnpm-lock.yaml* ./
+COPY ${projectDir}/package.json ./${projectDir}/package.json
+
+${renderPnpmInstall("prod")}
+
+FROM node:24-bookworm-slim AS run
+WORKDIR /app
+ENV NODE_ENV=production
+RUN corepack enable && corepack prepare pnpm@10 --activate
+
+COPY --from=prod-deps /app/package.json ./
+COPY --from=prod-deps /app/pnpm-lock.yaml* ./
+COPY --from=build /app/config ./config
+COPY --from=build /app/dist ./dist
+COPY --from=prod-deps /app/node_modules ./node_modules
+COPY --from=prod-deps /app/${projectDir}/package.json ./${projectDir}/package.json
 
 EXPOSE 3000
-CMD ["node", "${entry}"]
+${startCmd}
+# Entry resolved by package.json "${startScript}" → node ${startEntry}
 `;
 }
-/** The build context is the project folder; only the package belongs in the image. */ function dockerignoreContent() {
+/** npm auth + pnpm install. Token is required again in prod-deps (separate stage, no store). */ function renderPnpmInstall(mode) {
+    const flags = mode === "prod" ? " --prod" : "";
+    return `ARG NODE_AUTH_TOKEN=
+RUN --mount=type=secret,id=npm_token,required=false \\
+	if [ -f /run/secrets/npm_token ]; then \\
+		TOKEN="$(cat /run/secrets/npm_token)"; \\
+	else \\
+		TOKEN="\${NODE_AUTH_TOKEN}"; \\
+	fi; \\
+	if [ -n "$TOKEN" ]; then \\
+		echo "//registry.npmjs.org/:_authToken=\${TOKEN}" > .npmrc; \\
+	fi; \\
+	if [ -f pnpm-lock.yaml ]; then \\
+		pnpm install --frozen-lockfile${flags}; \\
+	else \\
+		pnpm install${flags}; \\
+	fi; \\
+	rm -f .npmrc`;
+}
+function dockerignoreContent() {
     return [
-        "*",
-        "!.package",
+        "node_modules",
+        "dist",
+        ".git",
+        ".devcontainer",
+        ".vscode",
+        ".github",
+        "postman",
+        ".postman",
+        ".env",
+        ".env.*",
+        "!.env.example",
+        "coverage",
+        "**/*.spec.ts",
+        "**/*.test.ts",
         ""
     ].join("\n");
 }
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/models/production-dockerfile.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { KeyedModel, SourceFile } from \"../../models/source-file.js\";\nimport { DEFAULT_WEBAPI_NAME, webapiProjectDir, webapiReleaseEntry } from \"../const.js\";\n\nexport type ProductionDockerfileOptions = {\n\t/** When true, only write `Dockerfile.<name>` (existing workspace — do not replace root Dockerfile). */\n\tnamedOnly?: boolean;\n};\n\n/**\n * Production Dockerfiles for PaaS (Railway/Fly) and local `docker build`.\n *\n * Context is always the **repo root** (`docker build -f Dockerfile.billing .`).\n * Root `Dockerfile` is the first API (`pnpm start`). Extra or custom-named APIs\n * also get `Dockerfile.<name>` so each service can be deployed on its own.\n *\n * Runtime `node_modules` come from a **prod-deps** stage (`pnpm install --prod`),\n * not the full build install (Forge, TypeScript, Biome, Vitest).\n */\nexport class WebapiProductionDockerfile implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;\n\n\tpublic constructor(\n\t\tprivate readonly apiNames: readonly string[] = [DEFAULT_WEBAPI_NAME],\n\t\tprivate readonly options: ProductionDockerfileOptions = {},\n\t) {}\n\n\tpublic files(): SourceFile[] {\n\t\tconst names = this.apiNames.length > 0 ? this.apiNames : [DEFAULT_WEBAPI_NAME];\n\t\tconst first = names[0] ?? DEFAULT_WEBAPI_NAME;\n\t\tconst files: SourceFile[] = [];\n\n\t\tif (!this.options.namedOnly) {\n\t\t\tfiles.push({\n\t\t\t\tfilePath: \".dockerignore\",\n\t\t\t\tcontent: dockerignoreContent(),\n\t\t\t});\n\t\t\tfiles.push({\n\t\t\t\tfilePath: \"Dockerfile\",\n\t\t\t\tcontent: renderProductionDockerfile(first, \"start\"),\n\t\t\t});\n\t\t}\n\n\t\tconst emitNamed =\n\t\t\tthis.options.namedOnly || names.length > 1 || first !== DEFAULT_WEBAPI_NAME;\n\t\tif (emitNamed) {\n\t\t\tfor (const name of names) {\n\t\t\t\tfiles.push({\n\t\t\t\t\tfilePath: `Dockerfile.${name}`,\n\t\t\t\t\tcontent: renderProductionDockerfile(name, `start:${name}`),\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn files;\n\t}\n}\n\nexport function renderProductionDockerfile(apiName: string, startScript: string): string {\n\tconst projectDir = webapiProjectDir(apiName);\n\tconst startCmd =\n\t\tstartScript === \"start\"\n\t\t\t? 'CMD [\"pnpm\", \"start\"]'\n\t\t\t: `CMD [\"pnpm\", \"run\", \"${startScript}\"]`;\n\tconst startEntry = webapiReleaseEntry(apiName);\n\tconst dockerfileFlag = startScript === \"start\" ? \"\" : `.${apiName}`;\n\n\treturn `# syntax=docker/dockerfile:1\n# Self-contained production image: install + forge build happen inside docker build.\n# Hosts (Railway/Fly/etc.) clone git and run \\`docker build\\` — they do not receive CI dist/.\n# Build from the repo root: docker build -f Dockerfile${dockerfileFlag} .\n#\n# Runtime node_modules are a production-only install (prod-deps). The build stage's\n# full install (Forge, TypeScript, Biome, Vitest) is not copied into the run image.\n#\n# Private @decohere/* packages: pass a BuildKit secret named npm_token (npm auth token), e.g.\n#   docker build --secret id=npm_token,env=NODE_AUTH_TOKEN .\n# Or set NODE_AUTH_TOKEN as a build-arg on hosts that only support build-args.\n\nFROM node:24-bookworm AS build\nWORKDIR /app\nRUN corepack enable && corepack prepare pnpm@10 --activate\n\nCOPY package.json ./\nCOPY pnpm-lock.yaml* ./\nCOPY tsconfig.json biome.json ./\nCOPY config ./config\nCOPY ${projectDir} ./${projectDir}\n\n${renderPnpmInstall(\"all\")}\n\nRUN pnpm run build\n\nFROM node:24-bookworm AS prod-deps\nWORKDIR /app\nENV NODE_ENV=production\nRUN corepack enable && corepack prepare pnpm@10 --activate\n\nCOPY package.json ./\nCOPY pnpm-lock.yaml* ./\nCOPY ${projectDir}/package.json ./${projectDir}/package.json\n\n${renderPnpmInstall(\"prod\")}\n\nFROM node:24-bookworm-slim AS run\nWORKDIR /app\nENV NODE_ENV=production\nRUN corepack enable && corepack prepare pnpm@10 --activate\n\nCOPY --from=prod-deps /app/package.json ./\nCOPY --from=prod-deps /app/pnpm-lock.yaml* ./\nCOPY --from=build /app/config ./config\nCOPY --from=build /app/dist ./dist\nCOPY --from=prod-deps /app/node_modules ./node_modules\nCOPY --from=prod-deps /app/${projectDir}/package.json ./${projectDir}/package.json\n\nEXPOSE 3000\n${startCmd}\n# Entry resolved by package.json \"${startScript}\" → node ${startEntry}\n`;\n}\n\n/** npm auth + pnpm install. Token is required again in prod-deps (separate stage, no store). */\nfunction renderPnpmInstall(mode: \"all\" | \"prod\"): string {\n\tconst flags = mode === \"prod\" ? \" --prod\" : \"\";\n\treturn `ARG NODE_AUTH_TOKEN=\nRUN --mount=type=secret,id=npm_token,required=false \\\\\n\tif [ -f /run/secrets/npm_token ]; then \\\\\n\t\tTOKEN=\"$(cat /run/secrets/npm_token)\"; \\\\\n\telse \\\\\n\t\tTOKEN=\"\\${NODE_AUTH_TOKEN}\"; \\\\\n\tfi; \\\\\n\tif [ -n \"$TOKEN\" ]; then \\\\\n\t\techo \"//registry.npmjs.org/:_authToken=\\${TOKEN}\" > .npmrc; \\\\\n\tfi; \\\\\n\tif [ -f pnpm-lock.yaml ]; then \\\\\n\t\tpnpm install --frozen-lockfile${flags}; \\\\\n\telse \\\\\n\t\tpnpm install${flags}; \\\\\n\tfi; \\\\\n\trm -f .npmrc`;\n}\n\nfunction dockerignoreContent(): string {\n\treturn [\n\t\t\"node_modules\",\n\t\t\"dist\",\n\t\t\".git\",\n\t\t\".devcontainer\",\n\t\t\".vscode\",\n\t\t\".github\",\n\t\t\"postman\",\n\t\t\".postman\",\n\t\t\".env\",\n\t\t\".env.*\",\n\t\t\"!.env.example\",\n\t\t\"coverage\",\n\t\t\"**/*.spec.ts\",\n\t\t\"**/*.test.ts\",\n\t\t\"\",\n\t].join(\"\\n\");\n}\n"],"names":["WELL_KNOWN_FILES","DEFAULT_WEBAPI_NAME","webapiProjectDir","webapiReleaseEntry","WebapiProductionDockerfile","key","PRODUCTION_DOCKERFILE","apiNames","options","files","names","length","first","namedOnly","push","filePath","content","dockerignoreContent","renderProductionDockerfile","emitNamed","name","apiName","startScript","projectDir","startCmd","startEntry","dockerfileFlag","renderPnpmInstall","mode","flags","join"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,wBAAwB;AAEzD,SAASC,mBAAmB,EAAEC,gBAAgB,EAAEC,kBAAkB,QAAQ,cAAc;AAOxF;;;;;;;;;CASC,GACD,OAAO,MAAMC;;;IACIC,MAAML,iBAAiBM,qBAAqB,CAAC;IAE7D,YACC,AAAiBC,WAA8B;QAACN;KAAoB,EACpE,AAAiBO,UAAuC,CAAC,CAAC,CACzD;aAFgBD,WAAAA;aACAC,UAAAA;IACf;IAEIC,QAAsB;QAC5B,MAAMC,QAAQ,IAAI,CAACH,QAAQ,CAACI,MAAM,GAAG,IAAI,IAAI,CAACJ,QAAQ,GAAG;YAACN;SAAoB;QAC9E,MAAMW,QAAQF,KAAK,CAAC,EAAE,IAAIT;QAC1B,MAAMQ,QAAsB,EAAE;QAE9B,IAAI,CAAC,IAAI,CAACD,OAAO,CAACK,SAAS,EAAE;YAC5BJ,MAAMK,IAAI,CAAC;gBACVC,UAAU;gBACVC,SAASC;YACV;YACAR,MAAMK,IAAI,CAAC;gBACVC,UAAU;gBACVC,SAASE,2BAA2BN,OAAO;YAC5C;QACD;QAEA,MAAMO,YACL,IAAI,CAACX,OAAO,CAACK,SAAS,IAAIH,MAAMC,MAAM,GAAG,KAAKC,UAAUX;QACzD,IAAIkB,WAAW;YACd,KAAK,MAAMC,QAAQV,MAAO;gBACzBD,MAAMK,IAAI,CAAC;oBACVC,UAAU,CAAC,WAAW,EAAEK,MAAM;oBAC9BJ,SAASE,2BAA2BE,MAAM,CAAC,MAAM,EAAEA,MAAM;gBAC1D;YACD;QACD;QAEA,OAAOX;IACR;AACD;AAEA,OAAO,SAASS,2BAA2BG,OAAe,EAAEC,WAAmB;IAC9E,MAAMC,aAAarB,iBAAiBmB;IACpC,MAAMG,WACLF,gBAAgB,UACb,0BACA,CAAC,qBAAqB,EAAEA,YAAY,EAAE,CAAC;IAC3C,MAAMG,aAAatB,mBAAmBkB;IACtC,MAAMK,iBAAiBJ,gBAAgB,UAAU,KAAK,CAAC,CAAC,EAAED,SAAS;IAEnE,OAAO,CAAC;;;sDAG6C,EAAEK,eAAe;;;;;;;;;;;;;;;;;KAiBlE,EAAEH,WAAW,GAAG,EAAEA,WAAW;;AAElC,EAAEI,kBAAkB,OAAO;;;;;;;;;;;KAWtB,EAAEJ,WAAW,gBAAgB,EAAEA,WAAW;;AAE/C,EAAEI,kBAAkB,QAAQ;;;;;;;;;;;;2BAYD,EAAEJ,WAAW,gBAAgB,EAAEA,WAAW;;;AAGrE,EAAEC,SAAS;kCACuB,EAAEF,YAAY,SAAS,EAAEG,WAAW;AACtE,CAAC;AACD;AAEA,8FAA8F,GAC9F,SAASE,kBAAkBC,IAAoB;IAC9C,MAAMC,QAAQD,SAAS,SAAS,YAAY;IAC5C,OAAO,CAAC;;;;;;;;;;;gCAWuB,EAAEC,MAAM;;cAE1B,EAAEA,MAAM;;aAET,CAAC;AACd;AAEA,SAASZ;IACR,OAAO;QACN;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACA,CAACa,IAAI,CAAC;AACR"}

package/es6/src/webapi/models/sample-files.model.js

@@ -1,8 +1,8 @@
 const SAMPLE_CONFIG_CONTENT = `export class SampleConfig {\n\tpublic greeting: string = "";\n}\n`;
 const SAMPLE_SERVICE_CONTENT = [
     `import { inject, injectable } from "@decohere/crucible/decorators";`,
-    `import { ConfigurationServiceToken } from "@decohere/core/configuration";`,
-    `import type { IConfigurationService } from "@decohere/core/configuration";`,
+    `import { ConfigurationServiceToken } from "@decohere/nexus/configuration";`,
+    `import type { IConfigurationService } from "@decohere/nexus/configuration";`,
     `import { SampleConfig } from "../sample.config.js";`,
     ``,
     `@injectable()`,
@@ -38,3 +38,5 @@ export class SampleServiceModel {
         ];
     }
 }
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/models/webapi-image.model.js

@@ -16,3 +16,5 @@ import { CREATE_VERSION, DEVCONTAINER_IMAGE_REPOSITORY } from "../../version.js"
         ];
     }
 }
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkvbW9kZWxzL3dlYmFwaS1pbWFnZS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEb2NrZXJmaWxlTW9kZWwgfSBmcm9tIFwiLi4vLi4vbW9kZWxzL2RvY2tlci1pbWFnZS5tb2RlbC5qc1wiO1xuaW1wb3J0IHsgQ1JFQVRFX1ZFUlNJT04sIERFVkNPTlRBSU5FUl9JTUFHRV9SRVBPU0lUT1JZIH0gZnJvbSBcIi4uLy4uL3ZlcnNpb24uanNcIjtcblxuLyoqXG4gKiBTY2FmZm9sZGVkIGFwcCBgLmRldmNvbnRhaW5lci9Eb2NrZXJmaWxlYCDigJQgdGhpbiBgRlJPTWAgdGhlIHB1Ymxpc2hlZCBiYXNlIGltYWdlLlxuICogT3B0aW9uYWwgZmVhdHVyZSBsYXllcnMgKGUuZy4gcG9zdGdyZXNxbC1jbGllbnQpIGFwcGVuZCB2aWEgYGFkZExheWVyYC5cbiAqL1xuZXhwb3J0IGNsYXNzIFdlYmFwaURldkNvbnRhaW5lciBleHRlbmRzIERvY2tlcmZpbGVNb2RlbCB7XG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihiYXNlSW1hZ2UgPSBgJHtERVZDT05UQUlORVJfSU1BR0VfUkVQT1NJVE9SWX06JHtDUkVBVEVfVkVSU0lPTn1gKSB7XG5cdFx0c3VwZXIoYmFzZUltYWdlKTtcblx0fVxuXG5cdHB1YmxpYyBmaWxlcygpIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCIuZGV2Y29udGFpbmVyL0RvY2tlcmZpbGVcIixcblx0XHRcdFx0Y29udGVudDogdGhpcy5idWlsZCgpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRG9ja2VyZmlsZU1vZGVsIiwiQ1JFQVRFX1ZFUlNJT04iLCJERVZDT05UQUlORVJfSU1BR0VfUkVQT1NJVE9SWSIsIldlYmFwaURldkNvbnRhaW5lciIsImJhc2VJbWFnZSIsImZpbGVzIiwiZmlsZVBhdGgiLCJjb250ZW50IiwiYnVpbGQiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGVBQWUsUUFBUSxxQ0FBcUM7QUFDckUsU0FBU0MsY0FBYyxFQUFFQyw2QkFBNkIsUUFBUSxtQkFBbUI7QUFFakY7OztDQUdDLEdBQ0QsT0FBTyxNQUFNQywyQkFBMkJIO0lBQ3ZDLFlBQW1CSSxZQUFZLEdBQUdGLDhCQUE4QixDQUFDLEVBQUVELGdCQUFnQixDQUFFO1FBQ3BGLEtBQUssQ0FBQ0c7SUFDUDtJQUVPQyxRQUFRO1FBQ2QsT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTLElBQUksQ0FBQ0MsS0FBSztZQUNwQjtTQUNBO0lBQ0Y7QUFDRCJ9

package/es6/src/webapi/postman/hello-openapi.js

@@ -164,3 +164,5 @@
         }
     };
 }
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/postman/local-view.js

@@ -165,3 +165,5 @@ function requestUrlForLocalView(request) {
 function sanitizeFileName(name) {
     return name.replace(/[^\w\s()-]+/g, "").trim() || "Request";
 }
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/postman/local-view.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport {\n\ttype Auth0Env,\n\topenApiPathParamsToColon,\n\ttype PostmanCollection,\n\ttype PostmanItem,\n\ttype PostmanRequest,\n} from \"./openapi-to-postman.js\";\n\nfunction yamlQuote(value: string): string {\n\tif (/[:#{}[\\],&*?|<>=!%@`]/.test(value) || value.includes(\"\\n\") || value === \"\") {\n\t\treturn JSON.stringify(value);\n\t}\n\treturn value;\n}\n\n/** Local View / Native Git environment (YAML). */\nexport function buildEnvironmentYaml(\n\tname: string,\n\tauth: Auth0Env | undefined,\n\toptions: { callbacks: readonly string[]; scopes: string },\n): string {\n\tconst values: Array<{ key: string; value: string }> = [\n\t\t{ key: \"baseUrl\", value: \"http://localhost:3000\" },\n\t];\n\tif (auth?.auth0Domain) {\n\t\tvalues.push(\n\t\t\t{ key: \"auth0Domain\", value: auth.auth0Domain },\n\t\t\t{ key: \"auth0Audience\", value: auth.auth0Audience ?? \"\" },\n\t\t\t{ key: \"auth0ClientId\", value: auth.auth0ClientId ?? \"\" },\n\t\t\t{\n\t\t\t\tkey: \"authUrl\",\n\t\t\t\tvalue: `https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? \"\"}`,\n\t\t\t},\n\t\t\t{\n\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\tvalue: `https://${auth.auth0Domain}/oauth/token`,\n\t\t\t},\n\t\t\t{ key: \"callbackUrl\", value: options.callbacks[0] },\n\t\t\t{ key: \"scope\", value: options.scopes },\n\t\t);\n\t}\n\n\tconst lines = [`name: ${yamlQuote(name)}`, \"values:\"];\n\tfor (const v of values) {\n\t\tlines.push(`  - key: ${v.key}`);\n\t\tlines.push(`    value: ${yamlQuote(v.value)}`);\n\t\tlines.push(\"    enabled: true\");\n\t}\n\treturn `${lines.join(\"\\n\")}\\n`;\n}\n\n/**\n * Build Postman Local View multi-file YAML from a v2.1 collection (routes)\n * plus hand-authored Auth0 overlay.\n */\nexport function buildLocalViewFilesFromCollection(\n\tcollection: PostmanCollection,\n\tprojectName: string,\n\tauth: Auth0Env | undefined,\n\toptions: { callbacks: readonly string[]; scopes: string },\n): Array<{ filePath: string; content: string }> {\n\tconst collectionDir = `postman/collections/${projectName} WebAPI`;\n\tconst files: Array<{ filePath: string; content: string }> = [];\n\n\tconst authBlock = auth?.auth0Domain\n\t\t? [\n\t\t\t\t\"auth:\",\n\t\t\t\t`  - id: ${randomUUID()}`,\n\t\t\t\t\"    type: oauth2\",\n\t\t\t\t\"    name: OAuth 2.0\",\n\t\t\t\t\"    credentials:\",\n\t\t\t\t\"      addTokenTo: header\",\n\t\t\t\t\"      grant_type: authorization_code_with_pkce\",\n\t\t\t\t`      authUrl: https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? \"\"}`,\n\t\t\t\t`      accessTokenUrl: https://${auth.auth0Domain}/oauth/token`,\n\t\t\t\t`      clientId: ${yamlQuote(auth.auth0ClientId ?? \"\")}`,\n\t\t\t\t`      scope: ${yamlQuote(options.scopes)}`,\n\t\t\t\t`      redirect_uri: ${options.callbacks[0]}`,\n\t\t\t\t\"      useBrowser: true\",\n\t\t\t\t\"      challengeAlgorithm: S256\",\n\t\t\t\t\"      client_authentication: body\",\n\t\t\t\t'      clientSecret: \"\"',\n\t\t\t\t`      tokenName: ${yamlQuote(`${projectName} Access Token`)}`,\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\")\n\t\t: \"\";\n\n\tfiles.push({\n\t\tfilePath: `${collectionDir}/.resources/definition.yaml`,\n\t\tcontent: [\n\t\t\t\"$kind: collection\",\n\t\t\t`name: ${yamlQuote(`${projectName} WebAPI`)}`,\n\t\t\t\"schemaVersion: '3.0'\",\n\t\t\t\"description: >-\",\n\t\t\t\"  Open this project root in Postman Local View (Files → Open folder).\",\n\t\t\t\"  Select the Local environment, then Authorization → Get New Access Token (PKCE).\",\n\t\t\t\"  Route requests are generated from OpenAPI; Auth0 overlay is hand-authored.\",\n\t\t\tauthBlock,\n\t\t]\n\t\t\t.filter((l) => l !== undefined)\n\t\t\t.join(\"\\n\")\n\t\t\t.replace(/\\n+$/, \"\\n\"),\n\t});\n\n\tlet folderOrder = 1000;\n\tfor (const folder of collection.item ?? []) {\n\t\tif (folder.item == null) {\n\t\t\tcontinue;\n\t\t}\n\t\tconst folderName = folder.name ?? \"Requests\";\n\t\tfiles.push({\n\t\t\tfilePath: `${collectionDir}/${folderName}/.resources/definition.yaml`,\n\t\t\tcontent: [\n\t\t\t\t\"$kind: folder\",\n\t\t\t\t`name: ${yamlQuote(folderName)}`,\n\t\t\t\t`order: ${folderOrder}`,\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t});\n\t\tfolderOrder += 1000;\n\n\t\tlet requestOrder = 1000;\n\t\tfor (const child of folder.item) {\n\t\t\tconst yaml = requestToLocalViewYaml(child, requestOrder);\n\t\t\tif (yaml == null) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst fileName = `${sanitizeFileName(child.name ?? \"Request\")}.request.yaml`;\n\t\t\tfiles.push({\n\t\t\t\tfilePath: `${collectionDir}/${folderName}/${fileName}`,\n\t\t\t\tcontent: yaml,\n\t\t\t});\n\t\t\trequestOrder += 1000;\n\t\t}\n\t}\n\n\treturn files;\n}\n\nfunction requestToLocalViewYaml(item: PostmanItem, order: number): string | null {\n\tconst request = item.request;\n\tif (request == null) {\n\t\treturn null;\n\t}\n\tconst method = (request.method ?? \"GET\").toUpperCase();\n\tconst url = requestUrlForLocalView(request);\n\tconst lines = [\n\t\t\"$kind: http-request\",\n\t\t`name: ${yamlQuote(item.name ?? method)}`,\n\t\t`method: ${method}`,\n\t\t`url: ${yamlQuote(url)}`,\n\t];\n\n\tif (request.auth?.type === \"noauth\") {\n\t\tlines.push(\"auth:\", \"  type: noauth\");\n\t}\n\n\tconst contentType = request.header?.find(\n\t\t(h) => h.key.toLowerCase() === \"content-type\",\n\t)?.value;\n\tconst rawBody = request.body?.raw?.trim();\n\tif (rawBody) {\n\t\tlines.push(\"headers:\");\n\t\tlines.push(`  Content-Type: ${contentType ?? \"application/json\"}`);\n\t\tlines.push(\"body:\");\n\t\tlines.push(\"  type: json\");\n\t\tlines.push(\"  content: |-\");\n\t\tfor (const bodyLine of rawBody.split(\"\\n\")) {\n\t\t\tlines.push(`    ${bodyLine}`);\n\t\t}\n\t}\n\n\tlines.push(`order: ${order}`, \"\");\n\treturn lines.join(\"\\n\");\n}\n\nfunction requestUrlForLocalView(request: PostmanRequest): string {\n\tconst url = request.url;\n\tif (typeof url === \"string\") {\n\t\treturn openApiPathParamsToColon(url);\n\t}\n\tif (url?.raw) {\n\t\treturn openApiPathParamsToColon(url.raw);\n\t}\n\tconst host = url?.host?.[0] ?? \"{{baseUrl}}\";\n\tconst path = (url?.path ?? [])\n\t\t.map((segment) => openApiPathParamsToColon(String(segment)))\n\t\t.join(\"/\");\n\treturn path ? `${host}/${path}` : host;\n}\n\nfunction sanitizeFileName(name: string): string {\n\treturn name.replace(/[^\\w\\s()-]+/g, \"\").trim() || \"Request\";\n}\n"],"names":["randomUUID","openApiPathParamsToColon","yamlQuote","value","test","includes","JSON","stringify","buildEnvironmentYaml","name","auth","options","values","key","auth0Domain","push","auth0Audience","auth0ClientId","callbacks","scopes","lines","v","join","buildLocalViewFilesFromCollection","collection","projectName","collectionDir","files","authBlock","filePath","content","filter","l","undefined","replace","folderOrder","folder","item","folderName","requestOrder","child","yaml","requestToLocalViewYaml","fileName","sanitizeFileName","order","request","method","toUpperCase","url","requestUrlForLocalView","type","contentType","header","find","h","toLowerCase","rawBody","body","raw","trim","bodyLine","split","host","path","map","segment","String"],"mappings":"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"}

package/es6/src/webapi/postman/openapi-to-postman.js

@@ -1,7 +1,5 @@
-async function convertAsync(data, options) {
-    // Loaded here, not at the top: the converter pulls in about 700 modules (lodash, faker, ajv,
-    // …), which every scaffolder run paid for even with `--postman none`.
-    const { default: converter } = await import("openapi-to-postmanv2");
+import converter from "openapi-to-postmanv2";
+function convertAsync(data, options) {
     return new Promise((resolve, reject)=>{
         converter.convert({
             type: "json",
@@ -177,3 +175,5 @@ function normalizePath(rawUrl) {
         path: segments
     };
 }
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/postman/openapi-to-postman.ts"],"sourcesContent":["import converter from \"openapi-to-postmanv2\";\nimport type { ScaffoldOpenApiDocument } from \"./hello-openapi.js\";\n\nexport type PostmanCollection = {\n\tinfo: {\n\t\t_postman_id?: string;\n\t\tname: string;\n\t\tschema: string;\n\t\tdescription?: string;\n\t};\n\tauth?: unknown;\n\titem?: PostmanItem[];\n\tvariable?: Array<{ key: string; value: string }>;\n\t[key: string]: unknown;\n};\n\nexport type PostmanItem = {\n\tname?: string;\n\titem?: PostmanItem[];\n\trequest?: PostmanRequest;\n\t[key: string]: unknown;\n};\n\nexport type PostmanRequest = {\n\tmethod?: string;\n\theader?: Array<{ key: string; value: string }>;\n\tbody?: { mode?: string; raw?: string };\n\turl?: string | { raw?: string; host?: string[]; path?: string[]; variable?: unknown[] };\n\tauth?: { type: string; [key: string]: unknown };\n\t[key: string]: unknown;\n};\n\nexport type Auth0Env = {\n\tauth0Domain?: string;\n\tauth0Audience?: string;\n\tauth0ClientId?: string;\n};\n\ntype ConvertResult = {\n\tresult: boolean;\n\treason?: string;\n\toutput?: Array<{ type: string; data: PostmanCollection }>;\n};\n\nfunction convertAsync(\n\tdata: ScaffoldOpenApiDocument,\n\toptions: Record<string, unknown>,\n): Promise<ConvertResult> {\n\treturn new Promise((resolve, reject) => {\n\t\tconverter.convert(\n\t\t\t{ type: \"json\", data },\n\t\t\toptions,\n\t\t\t(err: Error | null, result: ConvertResult) => {\n\t\t\t\tif (err) {\n\t\t\t\t\treject(err);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tresolve(result);\n\t\t\t},\n\t\t);\n\t});\n}\n\n/** Convert an OpenAPI document to a Postman Collection v2.1 via openapi-to-postmanv2. */\nexport async function openApiToPostmanCollection(\n\tdocument: ScaffoldOpenApiDocument,\n): Promise<PostmanCollection> {\n\tconst result = await convertAsync(document, {\n\t\tfolderStrategy: \"Tags\",\n\t\trequestNameSource: \"Fallback\",\n\t\tincludeAuthInfoInExample: false,\n\t});\n\tif (!result.result || result.output?.[0]?.data == null) {\n\t\tthrow new Error(result.reason ?? \"openapi-to-postmanv2 conversion failed\");\n\t}\n\treturn result.output[0].data;\n}\n\n/**\n * Overlay Auth0 OAuth2 (PKCE) collection auth and fix Local View-friendly URLs.\n * Route items come from OpenAPI; auth/env remain hand-authored.\n */\nexport function applyPostmanAuthOverlay(\n\tcollection: PostmanCollection,\n\tprojectName: string,\n\tauth: Auth0Env | undefined,\n\toptions: {\n\t\tcallbacks: readonly string[];\n\t\tscopes: string;\n\t\tdescription: string;\n\t},\n): PostmanCollection {\n\tconst next: PostmanCollection = {\n\t\t...collection,\n\t\tinfo: {\n\t\t\t...collection.info,\n\t\t\tname: `${projectName} WebAPI`,\n\t\t\tdescription: options.description,\n\t\t\tschema:\n\t\t\t\tcollection.info.schema ??\n\t\t\t\t\"https://schema.getpostman.com/json/collection/v2.1.0/collection.json\",\n\t\t},\n\t};\n\n\tif (auth?.auth0Domain) {\n\t\tnext.auth = {\n\t\t\ttype: \"oauth2\",\n\t\t\toauth2: [\n\t\t\t\t{ key: \"grant_type\", value: \"authorization_code_with_pkce\", type: \"string\" },\n\t\t\t\t{\n\t\t\t\t\tkey: \"authUrl\",\n\t\t\t\t\tvalue: \"https://{{auth0Domain}}/authorize?audience={{auth0Audience}}\",\n\t\t\t\t\ttype: \"string\",\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\t\tvalue: \"https://{{auth0Domain}}/oauth/token\",\n\t\t\t\t\ttype: \"string\",\n\t\t\t\t},\n\t\t\t\t{ key: \"clientId\", value: \"{{auth0ClientId}}\", type: \"string\" },\n\t\t\t\t{ key: \"scope\", value: options.scopes, type: \"string\" },\n\t\t\t\t{ key: \"redirect_uri\", value: options.callbacks[0], type: \"string\" },\n\t\t\t\t{ key: \"useBrowser\", value: \"true\", type: \"boolean\" },\n\t\t\t\t{ key: \"addTokenTo\", value: \"header\", type: \"string\" },\n\t\t\t\t{ key: \"challengeAlgorithm\", value: \"S256\", type: \"string\" },\n\t\t\t\t{ key: \"client_authentication\", value: \"body\", type: \"string\" },\n\t\t\t\t{ key: \"clientSecret\", value: \"\", type: \"string\" },\n\t\t\t\t{ key: \"tokenName\", value: `${projectName} Access Token`, type: \"string\" },\n\t\t\t],\n\t\t};\n\t}\n\n\tnext.item = rewriteCollectionItems(collection.item ?? [], {\n\t\tmarkListAnonymous: true,\n\t});\n\treturn next;\n}\n\nfunction rewriteCollectionItems(\n\titems: PostmanItem[],\n\topts: { markListAnonymous: boolean },\n): PostmanItem[] {\n\treturn items.map((item) => {\n\t\tif (item.item != null) {\n\t\t\treturn { ...item, item: rewriteCollectionItems(item.item, opts) };\n\t\t}\n\t\tconst request = item.request;\n\t\tif (request == null) {\n\t\t\treturn item;\n\t\t}\n\t\tconst method = (request.method ?? \"GET\").toUpperCase();\n\t\tconst rawUrl = requestUrlRaw(request);\n\t\tconst nextRequest: PostmanRequest = {\n\t\t\t...request,\n\t\t\turl: toPostmanUrl(rawUrl),\n\t\t};\n\t\t// List Hello stays anonymous (matches scaffold AllowAnonymous on GET /hello).\n\t\tif (\n\t\t\topts.markListAnonymous &&\n\t\t\tmethod === \"GET\" &&\n\t\t\tnormalizePath(rawUrl) === \"/hello\" &&\n\t\t\t!rawUrl.includes(\"/:\")\n\t\t) {\n\t\t\tnextRequest.auth = { type: \"noauth\" };\n\t\t}\n\t\treturn { ...item, request: nextRequest };\n\t});\n}\n\nfunction requestUrlRaw(request: PostmanRequest): string {\n\tconst url = request.url;\n\tif (typeof url === \"string\") {\n\t\treturn url;\n\t}\n\tif (url?.raw) {\n\t\treturn url.raw;\n\t}\n\tconst host = url?.host?.[0] ?? \"{{baseUrl}}\";\n\tconst path = (url?.path ?? []).join(\"/\");\n\treturn path ? `${host}/${path}` : host;\n}\n\n/** OpenAPI `{id}` → Postman `:id`, without touching `{{variables}}`. */\nexport function openApiPathParamsToColon(url: string): string {\n\treturn url.replace(/(?<!\\{)\\{([A-Za-z_][\\w]*)\\}(?!\\})/g, \":$1\");\n}\n\nfunction normalizePath(rawUrl: string): string {\n\tconst withoutBase = rawUrl.replace(/\\{\\{baseUrl\\}\\}/g, \"\").split(\"?\")[0] ?? \"\";\n\tconst withSlash = withoutBase.startsWith(\"/\") ? withoutBase : `/${withoutBase}`;\n\treturn openApiPathParamsToColon(withSlash);\n}\n\n/** Prefer Postman template URL shape used by existing Local View / API uploads. */\nfunction toPostmanUrl(rawUrl: string): PostmanRequest[\"url\"] {\n\tlet pathPart = rawUrl.replace(/\\{\\{baseUrl\\}\\}/g, \"\");\n\tif (!pathPart.startsWith(\"/\")) {\n\t\tpathPart = `/${pathPart}`;\n\t}\n\t// openapi-to-postman uses {id}; Local View / prior collections use :id\n\tpathPart = openApiPathParamsToColon(pathPart);\n\tconst segments = pathPart.split(\"/\").filter(Boolean);\n\treturn {\n\t\traw: `{{baseUrl}}${pathPart}`,\n\t\thost: [\"{{baseUrl}}\"],\n\t\tpath: segments,\n\t};\n}\n"],"names":["converter","convertAsync","data","options","Promise","resolve","reject","convert","type","err","result","openApiToPostmanCollection","document","folderStrategy","requestNameSource","includeAuthInfoInExample","output","Error","reason","applyPostmanAuthOverlay","collection","projectName","auth","next","info","name","description","schema","auth0Domain","oauth2","key","value","scopes","callbacks","item","rewriteCollectionItems","markListAnonymous","items","opts","map","request","method","toUpperCase","rawUrl","requestUrlRaw","nextRequest","url","toPostmanUrl","normalizePath","includes","raw","host","path","join","openApiPathParamsToColon","replace","withoutBase","split","withSlash","startsWith","pathPart","segments","filter","Boolean"],"mappings":"AAAA,OAAOA,eAAe,uBAAuB;AA4C7C,SAASC,aACRC,IAA6B,EAC7BC,OAAgC;IAEhC,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC5BN,UAAUO,OAAO,CAChB;YAAEC,MAAM;YAAQN;QAAK,GACrBC,SACA,CAACM,KAAmBC;YACnB,IAAID,KAAK;gBACRH,OAAOG;gBACP;YACD;YACAJ,QAAQK;QACT;IAEF;AACD;AAEA,uFAAuF,GACvF,OAAO,eAAeC,2BACrBC,QAAiC;IAEjC,MAAMF,SAAS,MAAMT,aAAaW,UAAU;QAC3CC,gBAAgB;QAChBC,mBAAmB;QACnBC,0BAA0B;IAC3B;IACA,IAAI,CAACL,OAAOA,MAAM,IAAIA,OAAOM,MAAM,EAAE,CAAC,EAAE,EAAEd,QAAQ,MAAM;QACvD,MAAM,IAAIe,MAAMP,OAAOQ,MAAM,IAAI;IAClC;IACA,OAAOR,OAAOM,MAAM,CAAC,EAAE,CAACd,IAAI;AAC7B;AAEA;;;CAGC,GACD,OAAO,SAASiB,wBACfC,UAA6B,EAC7BC,WAAmB,EACnBC,IAA0B,EAC1BnB,OAIC;IAED,MAAMoB,OAA0B;QAC/B,GAAGH,UAAU;QACbI,MAAM;YACL,GAAGJ,WAAWI,IAAI;YAClBC,MAAM,GAAGJ,YAAY,OAAO,CAAC;YAC7BK,aAAavB,QAAQuB,WAAW;YAChCC,QACCP,WAAWI,IAAI,CAACG,MAAM,IACtB;QACF;IACD;IAEA,IAAIL,MAAMM,aAAa;QACtBL,KAAKD,IAAI,GAAG;YACXd,MAAM;YACNqB,QAAQ;gBACP;oBAAEC,KAAK;oBAAcC,OAAO;oBAAgCvB,MAAM;gBAAS;gBAC3E;oBACCsB,KAAK;oBACLC,OAAO;oBACPvB,MAAM;gBACP;gBACA;oBACCsB,KAAK;oBACLC,OAAO;oBACPvB,MAAM;gBACP;gBACA;oBAAEsB,KAAK;oBAAYC,OAAO;oBAAqBvB,MAAM;gBAAS;gBAC9D;oBAAEsB,KAAK;oBAASC,OAAO5B,QAAQ6B,MAAM;oBAAExB,MAAM;gBAAS;gBACtD;oBAAEsB,KAAK;oBAAgBC,OAAO5B,QAAQ8B,SAAS,CAAC,EAAE;oBAAEzB,MAAM;gBAAS;gBACnE;oBAAEsB,KAAK;oBAAcC,OAAO;oBAAQvB,MAAM;gBAAU;gBACpD;oBAAEsB,KAAK;oBAAcC,OAAO;oBAAUvB,MAAM;gBAAS;gBACrD;oBAAEsB,KAAK;oBAAsBC,OAAO;oBAAQvB,MAAM;gBAAS;gBAC3D;oBAAEsB,KAAK;oBAAyBC,OAAO;oBAAQvB,MAAM;gBAAS;gBAC9D;oBAAEsB,KAAK;oBAAgBC,OAAO;oBAAIvB,MAAM;gBAAS;gBACjD;oBAAEsB,KAAK;oBAAaC,OAAO,GAAGV,YAAY,aAAa,CAAC;oBAAEb,MAAM;gBAAS;aACzE;QACF;IACD;IAEAe,KAAKW,IAAI,GAAGC,uBAAuBf,WAAWc,IAAI,IAAI,EAAE,EAAE;QACzDE,mBAAmB;IACpB;IACA,OAAOb;AACR;AAEA,SAASY,uBACRE,KAAoB,EACpBC,IAAoC;IAEpC,OAAOD,MAAME,GAAG,CAAC,CAACL;QACjB,IAAIA,KAAKA,IAAI,IAAI,MAAM;YACtB,OAAO;gBAAE,GAAGA,IAAI;gBAAEA,MAAMC,uBAAuBD,KAAKA,IAAI,EAAEI;YAAM;QACjE;QACA,MAAME,UAAUN,KAAKM,OAAO;QAC5B,IAAIA,WAAW,MAAM;YACpB,OAAON;QACR;QACA,MAAMO,SAAS,AAACD,CAAAA,QAAQC,MAAM,IAAI,KAAI,EAAGC,WAAW;QACpD,MAAMC,SAASC,cAAcJ;QAC7B,MAAMK,cAA8B;YACnC,GAAGL,OAAO;YACVM,KAAKC,aAAaJ;QACnB;QACA,8EAA8E;QAC9E,IACCL,KAAKF,iBAAiB,IACtBK,WAAW,SACXO,cAAcL,YAAY,YAC1B,CAACA,OAAOM,QAAQ,CAAC,OAChB;YACDJ,YAAYvB,IAAI,GAAG;gBAAEd,MAAM;YAAS;QACrC;QACA,OAAO;YAAE,GAAG0B,IAAI;YAAEM,SAASK;QAAY;IACxC;AACD;AAEA,SAASD,cAAcJ,OAAuB;IAC7C,MAAMM,MAAMN,QAAQM,GAAG;IACvB,IAAI,OAAOA,QAAQ,UAAU;QAC5B,OAAOA;IACR;IACA,IAAIA,KAAKI,KAAK;QACb,OAAOJ,IAAII,GAAG;IACf;IACA,MAAMC,OAAOL,KAAKK,MAAM,CAAC,EAAE,IAAI;IAC/B,MAAMC,OAAO,AAACN,CAAAA,KAAKM,QAAQ,EAAE,AAAD,EAAGC,IAAI,CAAC;IACpC,OAAOD,OAAO,GAAGD,KAAK,CAAC,EAAEC,MAAM,GAAGD;AACnC;AAEA,sEAAsE,GACtE,OAAO,SAASG,yBAAyBR,GAAW;IACnD,OAAOA,IAAIS,OAAO,CAAC,sCAAsC;AAC1D;AAEA,SAASP,cAAcL,MAAc;IACpC,MAAMa,cAAcb,OAAOY,OAAO,CAAC,oBAAoB,IAAIE,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI;IAC5E,MAAMC,YAAYF,YAAYG,UAAU,CAAC,OAAOH,cAAc,CAAC,CAAC,EAAEA,aAAa;IAC/E,OAAOF,yBAAyBI;AACjC;AAEA,iFAAiF,GACjF,SAASX,aAAaJ,MAAc;IACnC,IAAIiB,WAAWjB,OAAOY,OAAO,CAAC,oBAAoB;IAClD,IAAI,CAACK,SAASD,UAAU,CAAC,MAAM;QAC9BC,WAAW,CAAC,CAAC,EAAEA,UAAU;IAC1B;IACA,uEAAuE;IACvEA,WAAWN,yBAAyBM;IACpC,MAAMC,WAAWD,SAASH,KAAK,CAAC,KAAKK,MAAM,CAACC;IAC5C,OAAO;QACNb,KAAK,CAAC,WAAW,EAAEU,UAAU;QAC7BT,MAAM;YAAC;SAAc;QACrBC,MAAMS;IACP;AACD"}

package/es6/src/webapi/workspace-readme.js

@@ -29,8 +29,7 @@ import { apiNameFromProjectDir, listExistingApiNames } from "./api-name.js";
         "```bash",
         "pnpm dev              # Flux HMR (first API)",
         "pnpm start            # run the compiled first API",
-        "pnpm run build        # forge release build",
-        "pnpm run package      # release build + .package/ for each API (what Docker copies)"
+        "pnpm run build        # forge release build"
     ];
     for (const name of apis){
         lines.push(`pnpm run dev:${name}     # HMR for ${name}`);
@@ -41,10 +40,10 @@ import { apiNameFromProjectDir, listExistingApiNames } from "./api-name.js";
     if (hasPostgres) {
         lines.push("## Database", "", "Postgres runs via Dev Container Compose:", "", "```bash", "pnpm db:up", "pnpm db:down", "pnpm db:reset", "```", "");
     }
-    lines.push("## Deploy", "", "Each API has its own `projects/<name>/Dockerfile`. It copies `.package/`, which `forge package`", "writes before Docker runs: the API's compiled code, the workspace libraries it imports, and", "a plain `node_modules` of the third-party packages it uses (no symlinks). The image build", "installs nothing and needs no npm token.", "", "```bash", "pnpm run package         # release build, then .package/ in every API", `docker build -t ${projectName} projects/api`, "```", "", "One API: `pnpm run package:<name>`, then `docker build projects/<name>`.", "A host that builds from a git clone does not have `.package/`; build and push the image", "from CI instead (`forge docker` after `pnpm run package`).", "");
+    lines.push("## Deploy", "", "PaaS hosts (`docker build` from the repo root) use the scaffolded `Dockerfile`.", "The runtime image installs production dependencies only (`pnpm install --prod`);", "Forge, TypeScript, Biome, and Vitest stay in the build stage.", "", "```bash", `docker build -t ${projectName} .`, "```", "", "Extra APIs: `docker build -f Dockerfile.<name> .`", "");
     lines.push("## Add another API", "", "```bash", "decohere add api <name>", "```", "", "Example: `decohere add api billing`", "");
     if (hasAuth0) {
-        lines.push("## Auth0", "", "JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).", 'After you add a controller, `@Authorize("read", "Invoice")` becomes the Auth0 permission `read:Invoice`.', "Sync the Auth0 API, admin grants, and Postman token scopes without re-scaffolding:", "", "```bash", "npx @decohere/create auth0 login      # once / when the CLI token expires", "npx @decohere/create auth0 configure  # after new @Authorize decorators", "```", "");
+        lines.push("## Auth0", "", "JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).", "Set those values (or re-run scaffold with `--auth auth0`) before calling protected routes.", "");
     }
     if (hasPostman) {
         lines.push("## Postman", "", "Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.", "Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.", "");
@@ -86,3 +85,5 @@ function mergeApiNames(existing, added) {
         ...added.filter((name)=>!seen.has(name))
     ];
 }
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/workspace-readme.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { WELL_KNOWN_FILES } from \"../models/const.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 { apiNameFromProjectDir, listExistingApiNames } from \"./api-name.js\";\n\nexport type WorkspaceReadmeOptions = {\n\tadd?: boolean;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tauthProvider?: \"auth0\" | \"none\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n};\n\nexport type WorkspaceReadmeInput = {\n\tprojectName: string;\n\tapiNames: readonly string[];\n\thasPostgres: boolean;\n\thasAuth0: boolean;\n\thasPostman: boolean;\n};\n\n/** Pure renderer — keep feature sections short and copy-paste ready. */\nexport function renderWorkspaceReadme(input: WorkspaceReadmeInput): string {\n\tconst { projectName, apiNames, hasPostgres, hasAuth0, hasPostman } = input;\n\tconst apis = apiNames.length > 0 ? apiNames : [\"api\"];\n\tconst lines: string[] = [\n\t\t`# ${projectName}`,\n\t\t\"\",\n\t\t\"Decohere web API workspace. Scaffolded with [`@decohere/create`](https://www.npmjs.com/package/@decohere/create).\",\n\t\t\"\",\n\t\t\"## Get started\",\n\t\t\"\",\n\t\t\"1. Open this folder in VS Code / Cursor.\",\n\t\t\"2. **Reopen in Container** (or rebuild the Dev Container).\",\n\t\t\"   Host `initialize.sh` and container `post-start.sh` ask y/N (TTY only) before npm auth or codebase RAG MCP.\",\n\t\t\"   Skip or decline; missing TTY skips. RAG credentials land in `.cursor/` (gitignored).\",\n\t\t\"3. Install dependencies if needed:\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"pnpm install\",\n\t\t\"```\",\n\t\t\"\",\n\t\t\"## Develop\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"pnpm dev              # Flux HMR (first API)\",\n\t\t\"pnpm start            # run the compiled first API\",\n\t\t\"pnpm run build        # forge release build\",\n\t];\n\n\tfor (const name of apis) {\n\t\tlines.push(`pnpm run dev:${name}     # HMR for ${name}`);\n\t\tlines.push(`pnpm run start:${name}   # production entry for ${name}`);\n\t}\n\n\tlines.push(\"```\", \"\");\n\n\tlines.push(\n\t\t\"## Logging\",\n\t\t\"\",\n\t\t\"In development, Scribe uses pino-pretty and rolling files under `logs/` (gitignored).\",\n\t\t\"When `NODE_ENV=production`, the process writes structured JSON to stdout and does not rotate files.\",\n\t\t\"Ship and retain those streams outside the app (platform logs, a sidecar, or a log agent) so shipping can change without rebuilding.\",\n\t\t\"\",\n\t\t\"Override roll path and rotation without changing app code:\",\n\t\t\"`SCRIBE_LOG_FILE`, `SCRIBE_LOG_SIZE`, `SCRIBE_LOG_FREQUENCY`, `SCRIBE_LOG_KEEP`.\",\n\t\t\"\",\n\t\t'Opt into in-process pretty or roll in production only with `{ when: \"always\" }` on `scribe.withPinoPretty` / `scribe.withPinoRoll`.',\n\t\t\"\",\n\t);\n\n\tif (hasPostgres) {\n\t\tlines.push(\n\t\t\t\"## Database\",\n\t\t\t\"\",\n\t\t\t\"Postgres runs via Dev Container Compose:\",\n\t\t\t\"\",\n\t\t\t\"```bash\",\n\t\t\t\"pnpm db:up\",\n\t\t\t\"pnpm db:down\",\n\t\t\t\"pnpm db:reset\",\n\t\t\t\"```\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tlines.push(\n\t\t\"## Deploy\",\n\t\t\"\",\n\t\t\"PaaS hosts (`docker build` from the repo root) use the scaffolded `Dockerfile`.\",\n\t\t\"The runtime image installs production dependencies only (`pnpm install --prod`);\",\n\t\t\"Forge, TypeScript, Biome, and Vitest stay in the build stage.\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t`docker build -t ${projectName} .`,\n\t\t\"```\",\n\t\t\"\",\n\t\t\"Extra APIs: `docker build -f Dockerfile.<name> .`\",\n\t\t\"\",\n\t);\n\n\tlines.push(\n\t\t\"## Add another API\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"decohere add api <name>\",\n\t\t\"```\",\n\t\t\"\",\n\t\t\"Example: `decohere add api billing`\",\n\t\t\"\",\n\t);\n\n\tif (hasAuth0) {\n\t\tlines.push(\n\t\t\t\"## Auth0\",\n\t\t\t\"\",\n\t\t\t\"JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).\",\n\t\t\t\"Set those values (or re-run scaffold with `--auth auth0`) before calling protected routes.\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tif (hasPostman) {\n\t\tlines.push(\n\t\t\t\"## Postman\",\n\t\t\t\"\",\n\t\t\t\"Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.\",\n\t\t\t\"Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tlines.push(\n\t\t\"## More\",\n\t\t\"\",\n\t\t\"- Package docs: https://www.npmjs.com/package/@decohere/create\",\n\t\t\"- After `decohere add api`, this README is refreshed so scripts and APIs stay accurate.\",\n\t\t\"\",\n\t);\n\n\treturn `${lines.join(\"\\n\")}`;\n}\n\nexport function resolveWorkspaceReadmeInput(\n\tworkspace: WorkspaceScaffold,\n\toptions: WorkspaceReadmeOptions,\n): WorkspaceReadmeInput {\n\tconst newNames = workspace\n\t\t.getProjects()\n\t\t.map((project) => apiNameFromProjectDir(project.dir));\n\tconst apiNames = options.add\n\t\t? mergeApiNames(listExistingApiNames(workspace.targetDir), newNames)\n\t\t: newNames;\n\n\tconst pkg = workspace.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON);\n\tconst env = workspace.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE);\n\n\tconst hasPostgres =\n\t\toptions.databaseProvider === \"postgres/typeorm\" || Boolean(pkg?.hasScript(\"db:up\"));\n\tconst hasAuth0 =\n\t\toptions.authProvider === \"auth0\" || Boolean(env?.hasEntry(\"AUTH0_ISSUER_BASE_URL\"));\n\tconst hasPostman =\n\t\toptions.postmanProvider === \"local\" ||\n\t\toptions.postmanProvider === \"api\" ||\n\t\texistsSync(join(workspace.targetDir, \"postman\")) ||\n\t\texistsSync(join(workspace.targetDir, \".postman\"));\n\n\treturn {\n\t\tprojectName: workspace.name,\n\t\tapiNames,\n\t\thasPostgres,\n\t\thasAuth0,\n\t\thasPostman,\n\t};\n}\n\nexport function writeWorkspaceReadme(\n\tworkspace: WorkspaceScaffold,\n\toptions: WorkspaceReadmeOptions,\n): void {\n\tconst content = renderWorkspaceReadme(resolveWorkspaceReadmeInput(workspace, options));\n\tworkspace.addFile({\n\t\tfiles: () => [{ filePath: \"README.md\", content }],\n\t});\n}\n\nfunction mergeApiNames(existing: readonly string[], added: readonly string[]): string[] {\n\tconst seen = new Set(existing);\n\treturn [...existing, ...added.filter((name) => !seen.has(name))];\n}\n"],"names":["existsSync","join","WELL_KNOWN_FILES","apiNameFromProjectDir","listExistingApiNames","renderWorkspaceReadme","input","projectName","apiNames","hasPostgres","hasAuth0","hasPostman","apis","length","lines","name","push","resolveWorkspaceReadmeInput","workspace","options","newNames","getProjects","map","project","dir","add","mergeApiNames","targetDir","pkg","getModel","PACKAGE_JSON","env","ENV_FILE","databaseProvider","Boolean","hasScript","authProvider","hasEntry","postmanProvider","writeWorkspaceReadme","content","addFile","files","filePath","existing","added","seen","Set","filter","has"],"mappings":"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"}

package/es6/src/webapi.action.js

@@ -5,7 +5,7 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { injectable } from "@decohere/crucible/decorators";
-import { ActionResponse } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
 import { runScaffoldApi, toApiOptions } from "./webapi/cli-options.js";
 export class WebapiAction {
     async run(options) {
@@ -16,3 +16,5 @@ export class WebapiAction {
 WebapiAction = _ts_decorate([
     injectable()
 ], WebapiAction);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkuYWN0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdGFibGUgfSBmcm9tIFwiQGRlY29oZXJlL2NydWNpYmxlL2RlY29yYXRvcnNcIjtcbmltcG9ydCB7IHR5cGUgQWN0aW9uLCBBY3Rpb25SZXNwb25zZSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBydW5TY2FmZm9sZEFwaSwgdG9BcGlPcHRpb25zIH0gZnJvbSBcIi4vd2ViYXBpL2NsaS1vcHRpb25zLmpzXCI7XG5cbmV4cG9ydCB0eXBlIFdlYmFwaU9wdGlvbnMgPSB7XG5cdGRpcmVjdG9yeT86IHN0cmluZztcblx0ZD86IHN0cmluZztcblx0bmFtZT86IHN0cmluZyB8IHN0cmluZ1tdO1xuXHRkYXRhYmFzZT86IHN0cmluZztcblx0YXV0aD86IHN0cmluZztcblx0cG9zdG1hbj86IHN0cmluZztcblx0eWVzPzogYm9vbGVhbjtcblx0aW5zdGFsbD86IHN0cmluZztcbn07XG5cbkBpbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBXZWJhcGlBY3Rpb24gaW1wbGVtZW50cyBBY3Rpb248V2ViYXBpT3B0aW9ucz4ge1xuXHRwdWJsaWMgYXN5bmMgcnVuKG9wdGlvbnM6IFdlYmFwaU9wdGlvbnMpOiBQcm9taXNlPEFjdGlvblJlc3BvbnNlPiB7XG5cdFx0YXdhaXQgcnVuU2NhZmZvbGRBcGkodG9BcGlPcHRpb25zKG9wdGlvbnMuZGlyZWN0b3J5LCBvcHRpb25zKSk7XG5cdFx0cmV0dXJuIEFjdGlvblJlc3BvbnNlLlN1Y2Nlc3MoXCJ3ZWJhcGlcIik7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJpbmplY3RhYmxlIiwiQWN0aW9uUmVzcG9uc2UiLCJydW5TY2FmZm9sZEFwaSIsInRvQXBpT3B0aW9ucyIsIldlYmFwaUFjdGlvbiIsInJ1biIsIm9wdGlvbnMiLCJkaXJlY3RvcnkiLCJTdWNjZXNzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxTQUFTQSxVQUFVLFFBQVEsZ0NBQWdDO0FBQzNELFNBQXNCQyxjQUFjLFFBQVEsc0JBQXNCO0FBQ2xFLFNBQVNDLGNBQWMsRUFBRUMsWUFBWSxRQUFRLDBCQUEwQjtBQWN2RSxPQUFPLE1BQU1DO0lBQ1osTUFBYUMsSUFBSUMsT0FBc0IsRUFBMkI7UUFDakUsTUFBTUosZUFBZUMsYUFBYUcsUUFBUUMsU0FBUyxFQUFFRDtRQUNyRCxPQUFPTCxlQUFlTyxPQUFPLENBQUM7SUFDL0I7QUFDRCJ9

package/es6/src/webapi.command.js

@@ -1,4 +1,4 @@
-import { DecohereCommand } from "@decohere/devkit/cli";
+import { DecohereCommand } from "@decohere/nexus/cli";
 import { addWebapiFeatureOptions, collectName } from "./webapi/cli-options.js";
 import { WebapiAction } from "./webapi.action.js";
 export class WebapiCommand extends DecohereCommand {
@@ -9,7 +9,7 @@ export class WebapiCommand extends DecohereCommand {
     }
     constructor(name){
         super(name);
-        this.description("Scaffold a web API workspace");
+        this.description("Scaffold a Cortex web API workspace");
         this.argument("[directory]", "Target directory (default: -d or current directory)");
         this.option("-d <directory>", "Target directory (default: current directory)", ".");
         this.option("--name <slug>", "API name under projects/ (repeatable; default: api)", collectName, []);
@@ -31,3 +31,5 @@ export class WebapiCommand extends DecohereCommand {
         });
     }
 }
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,20 +1,11 @@
 {
   "name": "@decohere/scaffold",
-  "version": "0.0.1-dev.126",
+  "version": "0.0.1-dev.80",
   "description": "Decohere project scaffolder (runs inside ghcr.io/typesmiths/decohere/create)",
   "keywords": [
     "decohere",
     "scaffold"
   ],
-  "homepage": "https://github.com/typesmiths/decohere/tree/main/projects/scaffold#readme",
-  "bugs": {
-    "url": "https://github.com/typesmiths/decohere/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/typesmiths/decohere.git",
-    "directory": "projects/scaffold"
-  },
   "license": "ISC",
   "author": "Typesmiths",
   "type": "module",
@@ -31,11 +22,10 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/crucible": "0.0.1-dev.126",
-    "@decohere/devkit": "0.0.1-dev.126",
+    "@decohere/crucible": "0.0.1-dev.80",
+    "@decohere/nexus": "0.0.1-dev.80",
     "commander": "^13.1.0",
-    "openapi-to-postmanv2": "^5.0.0",
-    "yaml": "^2.9.1"
+    "openapi-to-postmanv2": "^5.0.0"
   },
   "devDependencies": {},
   "decohere": {

package/types/src/add-api.action.d.ts

@@ -1,4 +1,4 @@
-import { type Action, ActionResponse } from "@decohere/devkit/cli";
+import { type Action, ActionResponse } from "@decohere/nexus/cli";
 export type AddApiOptions = {
     apiName?: string;
     d?: string;

package/types/src/add-api.command.d.ts

@@ -1,4 +1,4 @@
-import { DecohereCommand } from "@decohere/devkit/cli";
+import { DecohereCommand } from "@decohere/nexus/cli";
 import { AddApiAction } from "./add-api.action.js";
 export declare class AddApiCommand extends DecohereCommand {
     get actions(): (typeof AddApiAction)[];

package/types/src/add.command.d.ts

@@ -1,5 +1,5 @@
-import type { Actions } from "@decohere/devkit/cli";
-import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/devkit/cli";
+import type { Actions } from "@decohere/nexus/cli";
+import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
 export declare class AddCommand extends DecohereCommand {
     constructor(commands: Record<string, CommandType>, handler: CommandHandler);
     run(_actions: Actions, _options: never): Promise<CommandResponse>;

package/types/src/add.module.d.ts

@@ -1,4 +1,4 @@
-import { ModuleManifest } from "@decohere/devkit/cli";
+import { ModuleManifest } from "@decohere/nexus/cli";
 import { AddCommand } from "./add.command.js";
 import { AddApiAction } from "./add-api.action.js";
 import { AddApiCommand } from "./add-api.command.js";

package/types/src/create.command.d.ts

@@ -1,5 +1,5 @@
-import type { Actions } from "@decohere/devkit/cli";
-import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/devkit/cli";
+import type { Actions } from "@decohere/nexus/cli";
+import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
 export declare class CreateCommand extends DecohereCommand {
     constructor(commands: Record<string, CommandType>, handler: CommandHandler);
     run(_actions: Actions, _options: never): Promise<CommandResponse>;

package/types/src/create.module.d.ts

@@ -1,4 +1,4 @@
-import { ModuleManifest } from "@decohere/devkit/cli";
+import { ModuleManifest } from "@decohere/nexus/cli";
 import { CreateCommand } from "./create.command.js";
 import { WebapiAction } from "./webapi.action.js";
 import { WebapiCommand } from "./webapi.command.js";

package/types/src/index.d.ts

@@ -1,10 +1,6 @@
 export { AddModule } from "./add.module.js";
 export type { AddApiOptions } from "./add-api.action.js";
 export { AddApiAction } from "./add-api.action.js";
-export { Auth0Module } from "./auth0.module.js";
-export type { Auth0ConfigureOptions } from "./auth0-configure.action.js";
-export { Auth0ConfigureAction } from "./auth0-configure.action.js";
-export { Auth0LoginAction } from "./auth0-login.action.js";
 export { CreateModule } from "./create.module.js";
 export { runCli } from "./program.js";
 export type { ApiOptions } from "./webapi/create-api.js";

package/types/src/models/compose.model.d.ts

@@ -39,8 +39,6 @@ export type ComposeNetwork = {
  * Live builder for `docker-compose.yml`.
  *
  * Features call `addService` / `addVolume` / `addNetwork` in their scaffold phases.
- * Loaded with `fromFile` (`decohere add api`), additions merge into the existing file:
- * services, networks and volumes already there are left untouched, comments kept.
  */
 export declare class DockerCompose implements KeyedModel {
     readonly key: string;
@@ -49,12 +47,6 @@ export declare class DockerCompose implements KeyedModel {
     private readonly _services;
     private readonly _volumes;
     private readonly _networks;
-    private readonly _envFiles;
-    private _existing;
-    /** Load an existing compose file so `decohere add api` can merge into it. */
-    static fromFile(absolutePath: string): DockerCompose;
-    /** True when the service is defined (in the loaded file or added since). */
-    hasService(name: string): boolean;
     /** Compose project name (`name:` top-level) — isolates containers/volumes. */
     setProjectName(name: string): this;
     /** File-level `#` comments rendered above `name:` / `services:`. */
@@ -69,5 +61,4 @@ export declare class DockerCompose implements KeyedModel {
     /** Append an env_file path to an existing service. */
     addEnvFile(serviceName: string, filePath: string): this;
     getContent(): string;
-    private mergeIntoExisting;
 }

package/types/src/models/dev-container.model.d.ts

@@ -16,24 +16,14 @@ export declare class DevContainer implements KeyedModel {
     private readonly _extensions;
     private readonly _ports;
     private readonly _portAttributes;
-    private _mounts;
-    private _workspaceFolder;
+    private readonly _mounts;
     private _postCreateCommand?;
     private _updateContentCommand?;
     private _postStartCommand?;
     private _initializeCommand?;
     private _remoteUser;
     private _useCompose;
-    private _existing;
-    /**
-     * Load an existing devcontainer.json so `decohere add api` can merge into it.
-     * Only extensions, forwarded ports and port attributes are merged; everything else is kept.
-     */
-    static fromFile(absolutePath: string): DevContainer;
     constructor();
-    /** In-container path Cursor/VS Code opens (Agents window uses the basename). */
-    setWorkspaceFolder(folder: string): this;
-    private bindMount;
     addExtension(...ids: string[]): this;
     forwardPort(...ports: number[]): this;
     setPortAttributes(port: number, attrs: PortAttributes): this;
@@ -44,6 +34,4 @@ export declare class DevContainer implements KeyedModel {
     setRemoteUser(user: string): this;
     useCompose(): this;
     files(): SourceFile[];
-    private mergeIntoExisting;
-    private build;
 }