@decohere/create 0.0.1-dev.42 → 0.0.1-dev.44

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

@@ -1,4 +1,6 @@
+import { readFileSync } from "node:fs";
 import { CREATE_VERSION } from "../version.js";
+import { DEFAULT_WEBAPI_NAME, webapiPackageName, webapiPort, webapiReleaseEntry } from "../webapi/const.js";
 import { WELL_KNOWN_FILES } from "./const.js";
 /**
  * Builder for the root `package.json`.
@@ -12,18 +14,31 @@ import { WELL_KNOWN_FILES } from "./const.js";
     _dependencies;
     _devDependencies;
     _scripts;
+    _version = "0.0.1";
+    _type = "module";
+    _rest = {};
     constructor(name, options){
         this.name = name;
-        const startEntry = options?.startEntry ?? "dist/release/projects/api/es6/src/main.js";
+        const apiNames = options?.apiNames ?? [
+            DEFAULT_WEBAPI_NAME
+        ];
+        const first = apiNames[0] ?? DEFAULT_WEBAPI_NAME;
+        const startEntry = options?.startEntry ?? webapiReleaseEntry(first);
+        const workspaceName = options?.workspaceName ?? stripApiSuffix(name);
+        const namedOrMany = apiNames.length > 1 || first !== DEFAULT_WEBAPI_NAME;
         this._scripts = {
             build: "forge build --configuration release",
             "build:watch": "forge build --watch",
             start: `node ${startEntry}`,
-            dev: "flux serve",
+            dev: namedOrMany ? fluxDevScript(workspaceName, first, webapiPort(0)) : "flux serve",
             "lint:check": "biome check .",
             typecheck: "tsc --noEmit",
             test: "vitest run --passWithNoTests"
         };
+        for (const [index, apiName] of apiNames.entries()){
+            this._scripts[`start:${apiName}`] = `node ${webapiReleaseEntry(apiName)}`;
+            this._scripts[`dev:${apiName}`] = fluxDevScript(workspaceName, apiName, webapiPort(index));
+        }
         this._dependencies = {
             "@decohere/cortex": CREATE_VERSION,
             "@decohere/crucible": CREATE_VERSION,
@@ -40,6 +55,33 @@ import { WELL_KNOWN_FILES } from "./const.js";
             vitest: "^3.2.4"
         };
     }
+    /** Load an existing root package.json so `webapi add` can merge scripts/deps. */ static fromFile(filePath) {
+        const raw = JSON.parse(readFileSync(filePath, "utf8"));
+        const pkg = new PackageJson(typeof raw.name === "string" ? raw.name : "app", {
+            apiNames: []
+        });
+        pkg._version = typeof raw.version === "string" ? raw.version : "0.0.1";
+        pkg._type = typeof raw.type === "string" ? raw.type : "module";
+        pkg._scripts = {
+            ...asStringMap(raw.scripts)
+        };
+        pkg._dependencies = {
+            ...asStringMap(raw.dependencies)
+        };
+        pkg._devDependencies = {
+            ...asStringMap(raw.devDependencies)
+        };
+        const reserved = new Set([
+            "name",
+            "version",
+            "type",
+            "scripts",
+            "dependencies",
+            "devDependencies"
+        ]);
+        pkg._rest = Object.fromEntries(Object.entries(raw).filter(([key])=>!reserved.has(key)));
+        return pkg;
+    }
     addDependency(name, version) {
         this._dependencies[name] = version;
         return this;
@@ -58,8 +100,9 @@ import { WELL_KNOWN_FILES } from "./const.js";
                 filePath: "package.json",
                 content: JSON.stringify({
                     name: this.name,
-                    version: "0.0.1",
-                    type: "module",
+                    version: this._version,
+                    type: this._type,
+                    ...this._rest,
                     scripts: this._scripts,
                     dependencies: this._dependencies,
                     devDependencies: this._devDependencies
@@ -68,5 +111,19 @@ import { WELL_KNOWN_FILES } from "./const.js";
         ];
     }
 }
+function stripApiSuffix(name) {
+    return name.endsWith(".api") ? name.slice(0, -".api".length) : name;
+}
+function asStringMap(value) {
+    if (value == null || typeof value !== "object") return {};
+    const result = {};
+    for (const [key, entry] of Object.entries(value)){
+        if (typeof entry === "string") result[key] = entry;
+    }
+    return result;
+}
+function fluxDevScript(workspaceName, apiName, port) {
+    return `PORT=${port} flux serve --project ${webapiPackageName(workspaceName, apiName)}`;
+}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/package-json.model.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { CREATE_VERSION } from \"../version.js\";\nimport {\n\tDEFAULT_WEBAPI_NAME,\n\twebapiPackageName,\n\twebapiPort,\n\twebapiReleaseEntry,\n} from \"../webapi/const.js\";\nimport { WELL_KNOWN_FILES } from \"./const.js\";\nimport type { KeyedModel, SourceFile } from \"./source-file.js\";\n\nexport type PackageJsonOptions = {\n\tstartEntry?: string;\n\t/** API slugs in this workspace. Drives `start:<name>` / `dev:<name>`. */\n\tapiNames?: readonly string[];\n\t/** Host workspace name used in `@<workspace>/<api>` for flux `--project`. */\n\tworkspaceName?: string;\n};\n\n/**\n * Builder for the root `package.json`.\n *\n * Starts with the core API dependencies. Features call `addDependency` /\n * `addDevDependency` during their scaffold phase to inject their own deps\n * before `files()` is called at render time.\n */\nexport class PackageJson implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.PACKAGE_JSON;\n\n\tprivate _dependencies: Record<string, string>;\n\tprivate _devDependencies: Record<string, string>;\n\tprivate _scripts: Record<string, string>;\n\tprivate _version = \"0.0.1\";\n\tprivate _type = \"module\";\n\tprivate _rest: Record<string, unknown> = {};\n\n\tpublic constructor(\n\t\tprivate readonly name: string,\n\t\toptions?: PackageJsonOptions,\n\t) {\n\t\tconst apiNames = options?.apiNames ?? [DEFAULT_WEBAPI_NAME];\n\t\tconst first = apiNames[0] ?? DEFAULT_WEBAPI_NAME;\n\t\tconst startEntry = options?.startEntry ?? webapiReleaseEntry(first);\n\t\tconst workspaceName = options?.workspaceName ?? stripApiSuffix(name);\n\t\tconst namedOrMany = apiNames.length > 1 || first !== DEFAULT_WEBAPI_NAME;\n\n\t\tthis._scripts = {\n\t\t\tbuild: \"forge build --configuration release\",\n\t\t\t\"build:watch\": \"forge build --watch\",\n\t\t\tstart: `node ${startEntry}`,\n\t\t\tdev: namedOrMany ? fluxDevScript(workspaceName, first, webapiPort(0)) : \"flux serve\",\n\t\t\t\"lint:check\": \"biome check .\",\n\t\t\ttypecheck: \"tsc --noEmit\",\n\t\t\ttest: \"vitest run --passWithNoTests\",\n\t\t};\n\t\tfor (const [index, apiName] of apiNames.entries()) {\n\t\t\tthis._scripts[`start:${apiName}`] = `node ${webapiReleaseEntry(apiName)}`;\n\t\t\tthis._scripts[`dev:${apiName}`] = fluxDevScript(\n\t\t\t\tworkspaceName,\n\t\t\t\tapiName,\n\t\t\t\twebapiPort(index),\n\t\t\t);\n\t\t}\n\t\tthis._dependencies = {\n\t\t\t\"@decohere/cortex\": CREATE_VERSION,\n\t\t\t\"@decohere/crucible\": CREATE_VERSION,\n\t\t\t\"@decohere/nexus\": CREATE_VERSION,\n\t\t\t\"@decohere/protocol\": CREATE_VERSION,\n\t\t\t\"@decohere/scribe\": CREATE_VERSION,\n\t\t\t\"@decohere/scribe-pino\": CREATE_VERSION,\n\t\t\t\"pino-pretty\": \"^13.0.0\",\n\t\t};\n\t\tthis._devDependencies = {\n\t\t\t\"@decohere/terminal\": CREATE_VERSION,\n\t\t\ttypescript: \"^6.0.3\",\n\t\t\t\"@biomejs/biome\": \"^2.0.0\",\n\t\t\tvitest: \"^3.2.4\",\n\t\t};\n\t}\n\n\t/** Load an existing root package.json so `webapi add` can merge scripts/deps. */\n\tpublic static fromFile(filePath: string): PackageJson {\n\t\tconst raw = JSON.parse(readFileSync(filePath, \"utf8\")) as Record<string, unknown>;\n\t\tconst pkg = new PackageJson(typeof raw.name === \"string\" ? raw.name : \"app\", {\n\t\t\tapiNames: [],\n\t\t});\n\t\tpkg._version = typeof raw.version === \"string\" ? raw.version : \"0.0.1\";\n\t\tpkg._type = typeof raw.type === \"string\" ? raw.type : \"module\";\n\t\tpkg._scripts = { ...asStringMap(raw.scripts) };\n\t\tpkg._dependencies = { ...asStringMap(raw.dependencies) };\n\t\tpkg._devDependencies = { ...asStringMap(raw.devDependencies) };\n\t\tconst reserved = new Set([\n\t\t\t\"name\",\n\t\t\t\"version\",\n\t\t\t\"type\",\n\t\t\t\"scripts\",\n\t\t\t\"dependencies\",\n\t\t\t\"devDependencies\",\n\t\t]);\n\t\tpkg._rest = Object.fromEntries(Object.entries(raw).filter(([key]) => !reserved.has(key)));\n\t\treturn pkg;\n\t}\n\n\tpublic addDependency(name: string, version: string): this {\n\t\tthis._dependencies[name] = version;\n\t\treturn this;\n\t}\n\n\tpublic addDevDependency(name: string, version: string): this {\n\t\tthis._devDependencies[name] = version;\n\t\treturn this;\n\t}\n\n\tpublic addScript(name: string, command: string): this {\n\t\tthis._scripts[name] = command;\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"package.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\tname: this.name,\n\t\t\t\t\t\tversion: this._version,\n\t\t\t\t\t\ttype: this._type,\n\t\t\t\t\t\t...this._rest,\n\t\t\t\t\t\tscripts: this._scripts,\n\t\t\t\t\t\tdependencies: this._dependencies,\n\t\t\t\t\t\tdevDependencies: this._devDependencies,\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t];\n\t}\n}\n\nfunction stripApiSuffix(name: string): string {\n\treturn name.endsWith(\".api\") ? name.slice(0, -\".api\".length) : name;\n}\n\nfunction asStringMap(value: unknown): Record<string, string> {\n\tif (value == null || typeof value !== \"object\") return {};\n\tconst result: Record<string, string> = {};\n\tfor (const [key, entry] of Object.entries(value)) {\n\t\tif (typeof entry === \"string\") result[key] = entry;\n\t}\n\treturn result;\n}\n\nfunction fluxDevScript(workspaceName: string, apiName: string, port: number): string {\n\treturn `PORT=${port} flux serve --project ${webapiPackageName(workspaceName, apiName)}`;\n}\n"],"names":["readFileSync","CREATE_VERSION","DEFAULT_WEBAPI_NAME","webapiPackageName","webapiPort","webapiReleaseEntry","WELL_KNOWN_FILES","PackageJson","key","PACKAGE_JSON","_dependencies","_devDependencies","_scripts","_version","_type","_rest","name","options","apiNames","first","startEntry","workspaceName","stripApiSuffix","namedOrMany","length","build","start","dev","fluxDevScript","typecheck","test","index","apiName","entries","typescript","vitest","fromFile","filePath","raw","JSON","parse","pkg","version","type","asStringMap","scripts","dependencies","devDependencies","reserved","Set","Object","fromEntries","filter","has","addDependency","addDevDependency","addScript","command","files","content","stringify","endsWith","slice","value","result","entry","port"],"mappings":"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"}

package/es6/src/models/project.model.js

@@ -68,6 +68,9 @@ export class MonoRepoScaffold extends WorkspaceScaffold {
     /** Retrieve a previously-registered project by its directory path. */ getProject(dir) {
         return this._projects.find((p)=>p.dir === dir);
     }
+    /** All registered projects, in registration order. */ getProjects() {
+        return this._projects;
+    }
     /** Register a named model at workspace level. */ addModel(model) {
         this._models.set(model.key, model);
         return model;
@@ -113,4 +116,4 @@ export class MonoRepoScaffold extends WorkspaceScaffold {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/project.model.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, dirname, join } from \"node:path\";\nimport type { KeyedModel, SourceFile, SourceFileProvider } from \"./source-file.js\";\n\n/**\n * A sub-unit of the monorepo (e.g. `projects/api`).\n *\n * Models and files registered here produce paths relative to `dir`. The parent\n * `MonoRepoScaffold` calls `files()` and prepends `dir/` to every path, so\n * models remain unaware of where they live in the repo.\n */\nexport class ProjectScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _files: SourceFile[] = [];\n\n\tpublic constructor(public readonly dir: string) {}\n\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis._files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\treturn this._models.get(key) as T | undefined;\n\t}\n\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [...this._models.values()].filter((m): m is T => m instanceof ctor);\n\t}\n\n\t/** Returns all files with `dir/` prepended to each path. */\n\tpublic files(): SourceFile[] {\n\t\tconst all = [...this._files, ...[...this._models.values()].flatMap((m) => m.files())];\n\t\treturn all.map((f) => ({ filePath: `${this.dir}/${f.filePath}`, content: f.content }));\n\t}\n}\n\nexport abstract class WorkspaceScaffold {\n\tpublic readonly files: SourceFile[] = [];\n\tpublic targetDir: string = process.cwd();\n\tprivate _name: string | undefined;\n\n\t/** Project name — host directory basename, not the in-container mount path. */\n\tpublic get name(): string {\n\t\treturn this._name ?? basename(this.targetDir);\n\t}\n\n\tpublic setName(name: string): this {\n\t\tthis._name = name;\n\t\treturn this;\n\t}\n\n\t/** Add an ad-hoc file provider whose output is included at render time. */\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis.files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic abstract addModel<T extends KeyedModel>(model: T): T;\n\tpublic abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;\n\tpublic abstract getModels<T extends SourceFileProvider>(\n\t\tctor: new (...args: never[]) => T,\n\t): T[];\n\tpublic abstract getProject(dir: string): ProjectScaffold | undefined;\n\tpublic abstract scaffold(): Promise<void> | void;\n}\n\nexport class MonoRepoScaffold extends WorkspaceScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _projects: ProjectScaffold[] = [];\n\n\t/** Register a named project. */\n\tpublic addProject(project: ProjectScaffold): ProjectScaffold {\n\t\tthis._projects.push(project);\n\t\treturn project;\n\t}\n\n\t/** Retrieve a previously-registered project by its directory path. */\n\tpublic getProject(dir: string): ProjectScaffold | undefined {\n\t\treturn this._projects.find((p) => p.dir === dir);\n\t}\n\n\t/** Register a named model at workspace level. */\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\t/**\n\t * Retrieve a model by key. Searches workspace models first, then all\n\t * registered projects in order.\n\t */\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\tconst m = this._models.get(key) as T | undefined;\n\t\tif (m !== undefined) return m;\n\t\tfor (const project of this._projects) {\n\t\t\tconst pm = project.getModel<T>(key);\n\t\t\tif (pm !== undefined) return pm;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Retrieve all models of a given type. Searches workspace models and all\n\t * projects, so features can discover controllers across multiple projects.\n\t */\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [\n\t\t\t...[...this._models.values()].filter((m): m is T => m instanceof ctor),\n\t\t\t...this._projects.flatMap((p) => p.getModels(ctor)),\n\t\t];\n\t}\n\n\t/** Render all models and projects into files, then write everything to disk. */\n\tpublic async scaffold(): Promise<void> {\n\t\tconst allFiles = [\n\t\t\t...this.files,\n\t\t\t...[...this._models.values()].flatMap((m) => m.files()),\n\t\t\t...this._projects.flatMap((p) => p.files()),\n\t\t];\n\n\t\tawait Promise.all(\n\t\t\tallFiles.map(async (file) => {\n\t\t\t\tconst fullPath = join(this.targetDir, file.filePath);\n\t\t\t\tawait mkdir(dirname(fullPath), { recursive: true });\n\t\t\t\tawait writeFile(fullPath, file.content);\n\t\t\t}),\n\t\t);\n\t}\n}\n"],"names":["mkdir","writeFile","basename","dirname","join","ProjectScaffold","_models","Map","_files","dir","addModel","model","set","key","addFile","provider","push","files","getModel","get","getModels","ctor","values","filter","m","all","flatMap","map","f","filePath","content","WorkspaceScaffold","targetDir","process","cwd","_name","name","setName","MonoRepoScaffold","_projects","addProject","project","getProject","find","p","undefined","pm","scaffold","allFiles","Promise","file","fullPath","recursive"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/project.model.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, dirname, join } from \"node:path\";\nimport type { KeyedModel, SourceFile, SourceFileProvider } from \"./source-file.js\";\n\n/**\n * A sub-unit of the monorepo (e.g. `projects/api`).\n *\n * Models and files registered here produce paths relative to `dir`. The parent\n * `MonoRepoScaffold` calls `files()` and prepends `dir/` to every path, so\n * models remain unaware of where they live in the repo.\n */\nexport class ProjectScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _files: SourceFile[] = [];\n\n\tpublic constructor(public readonly dir: string) {}\n\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis._files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\treturn this._models.get(key) as T | undefined;\n\t}\n\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [...this._models.values()].filter((m): m is T => m instanceof ctor);\n\t}\n\n\t/** Returns all files with `dir/` prepended to each path. */\n\tpublic files(): SourceFile[] {\n\t\tconst all = [...this._files, ...[...this._models.values()].flatMap((m) => m.files())];\n\t\treturn all.map((f) => ({ filePath: `${this.dir}/${f.filePath}`, content: f.content }));\n\t}\n}\n\nexport abstract class WorkspaceScaffold {\n\tpublic readonly files: SourceFile[] = [];\n\tpublic targetDir: string = process.cwd();\n\tprivate _name: string | undefined;\n\n\t/** Project name — host directory basename, not the in-container mount path. */\n\tpublic get name(): string {\n\t\treturn this._name ?? basename(this.targetDir);\n\t}\n\n\tpublic setName(name: string): this {\n\t\tthis._name = name;\n\t\treturn this;\n\t}\n\n\t/** Add an ad-hoc file provider whose output is included at render time. */\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis.files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic abstract addModel<T extends KeyedModel>(model: T): T;\n\tpublic abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;\n\tpublic abstract getModels<T extends SourceFileProvider>(\n\t\tctor: new (...args: never[]) => T,\n\t): T[];\n\tpublic abstract getProject(dir: string): ProjectScaffold | undefined;\n\tpublic abstract getProjects(): readonly ProjectScaffold[];\n\tpublic abstract scaffold(): Promise<void> | void;\n}\n\nexport class MonoRepoScaffold extends WorkspaceScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _projects: ProjectScaffold[] = [];\n\n\t/** Register a named project. */\n\tpublic addProject(project: ProjectScaffold): ProjectScaffold {\n\t\tthis._projects.push(project);\n\t\treturn project;\n\t}\n\n\t/** Retrieve a previously-registered project by its directory path. */\n\tpublic getProject(dir: string): ProjectScaffold | undefined {\n\t\treturn this._projects.find((p) => p.dir === dir);\n\t}\n\n\t/** All registered projects, in registration order. */\n\tpublic getProjects(): readonly ProjectScaffold[] {\n\t\treturn this._projects;\n\t}\n\n\t/** Register a named model at workspace level. */\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\t/**\n\t * Retrieve a model by key. Searches workspace models first, then all\n\t * registered projects in order.\n\t */\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\tconst m = this._models.get(key) as T | undefined;\n\t\tif (m !== undefined) return m;\n\t\tfor (const project of this._projects) {\n\t\t\tconst pm = project.getModel<T>(key);\n\t\t\tif (pm !== undefined) return pm;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Retrieve all models of a given type. Searches workspace models and all\n\t * projects, so features can discover controllers across multiple projects.\n\t */\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [\n\t\t\t...[...this._models.values()].filter((m): m is T => m instanceof ctor),\n\t\t\t...this._projects.flatMap((p) => p.getModels(ctor)),\n\t\t];\n\t}\n\n\t/** Render all models and projects into files, then write everything to disk. */\n\tpublic async scaffold(): Promise<void> {\n\t\tconst allFiles = [\n\t\t\t...this.files,\n\t\t\t...[...this._models.values()].flatMap((m) => m.files()),\n\t\t\t...this._projects.flatMap((p) => p.files()),\n\t\t];\n\n\t\tawait Promise.all(\n\t\t\tallFiles.map(async (file) => {\n\t\t\t\tconst fullPath = join(this.targetDir, file.filePath);\n\t\t\t\tawait mkdir(dirname(fullPath), { recursive: true });\n\t\t\t\tawait writeFile(fullPath, file.content);\n\t\t\t}),\n\t\t);\n\t}\n}\n"],"names":["mkdir","writeFile","basename","dirname","join","ProjectScaffold","_models","Map","_files","dir","addModel","model","set","key","addFile","provider","push","files","getModel","get","getModels","ctor","values","filter","m","all","flatMap","map","f","filePath","content","WorkspaceScaffold","targetDir","process","cwd","_name","name","setName","MonoRepoScaffold","_projects","addProject","project","getProject","find","p","getProjects","undefined","pm","scaffold","allFiles","Promise","file","fullPath","recursive"],"mappings":"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"}

package/es6/src/program.js

@@ -1,31 +1,58 @@
 import { Command, CommanderError } from "commander";
 import { resolveTargetDir } from "./resolve-target-dir.js";
 import { runInBuilder } from "./runner.js";
+import { CreateCliError, parseApiNames } from "./webapi/api-name.js";
 import { scaffoldApi } from "./webapi/create-api.js";
+function collectName(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function addWebapiFeatureOptions(cmd) {
+    return cmd.option("--database <provider>", "Database provider: none | postgres/typeorm").option("--auth <provider>", "Auth provider: none | auth0").option("--postman <provider>", "Postman provider: none | local | api").option("-y, --yes", "Install dependencies without prompting").option("--install <mode>", "Dependency install mode: ask | yes | no", "ask");
+}
+function toApiOptions(directory, opts, extra = {}) {
+    const installMode = String(opts.install ?? "ask").toLowerCase();
+    const names = Array.isArray(opts.name) ? opts.name : typeof opts.name === "string" ? [
+        opts.name
+    ] : extra.names;
+    return {
+        d: resolveTargetDir(directory, typeof opts.d === "string" ? opts.d : undefined),
+        databaseProvider: opts.database,
+        authProvider: opts.auth,
+        postmanProvider: opts.postman,
+        installDependencies: opts.yes === true ? "yes" : installMode === "yes" || installMode === "no" ? installMode : undefined,
+        names,
+        ...extra
+    };
+}
+async function runWebapi(normalized) {
+    parseApiNames(normalized.names);
+    if (process.env.DECOHERE_BUILDER !== "1") {
+        runInBuilder(normalized);
+        return;
+    }
+    const { closePrompt } = await import("./domain/prompt.js");
+    try {
+        await scaffoldApi(normalized);
+    } finally{
+        closePrompt();
+    }
+}
 export function createProgram() {
     const program = new Command();
     program.exitOverride();
     program.name("decohere").description("Scaffold a new Decohere project").option("-d <directory>", "Target directory (default: current directory)", ".");
-    program.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--database <provider>", "Database provider: none | postgres/typeorm").option("--auth <provider>", "Auth provider: none | auth0").option("--postman <provider>", "Postman provider: none | local | api").option("-y, --yes", "Install dependencies without prompting").option("--install <mode>", "Dependency install mode: ask | yes | no", "ask").action(async (directory, _opts, cmd)=>{
-        const opts = cmd.optsWithGlobals();
-        const installMode = String(opts.install ?? "ask").toLowerCase();
-        const normalized = {
-            d: resolveTargetDir(directory, typeof opts.d === "string" ? opts.d : undefined),
-            databaseProvider: opts.database,
-            authProvider: opts.auth,
-            postmanProvider: opts.postman,
-            installDependencies: opts.yes === true ? "yes" : installMode === "yes" || installMode === "no" ? installMode : undefined
-        };
-        if (process.env.DECOHERE_BUILDER !== "1") {
-            runInBuilder(normalized);
-            return;
-        }
-        const { closePrompt } = await import("./domain/prompt.js");
-        try {
-            await scaffoldApi(normalized);
-        } finally{
-            closePrompt();
-        }
+    const webapi = addWebapiFeatureOptions(program.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--name <slug>", "API name under projects/ (repeatable; default: api)", collectName, []));
+    webapi.action(async (directory, _opts, cmd)=>{
+        await runWebapi(toApiOptions(directory, cmd.optsWithGlobals()));
+    });
+    addWebapiFeatureOptions(webapi.command("add").argument("<name>", "API name under projects/")).action(async (name, _opts, cmd)=>{
+        await runWebapi(toApiOptions(undefined, cmd.optsWithGlobals(), {
+            names: [
+                name
+            ],
+            add: true
+        }));
     });
     return program;
 }
@@ -36,10 +63,14 @@ export async function runCli(argv = process.argv) {
         if (err instanceof CommanderError) {
             process.exit(err.exitCode);
         }
+        if (err instanceof CreateCliError) {
+            console.error(`\n  ${err.message}\n`);
+            process.exit(1);
+        }
         console.error(err);
         process.exit(1);
     }
     process.exit(process.exitCode ?? 0);
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/program.ts"],"sourcesContent":["import { Command, CommanderError } from \"commander\";\nimport { resolveTargetDir } from \"./resolve-target-dir.js\";\nimport { runInBuilder } from \"./runner.js\";\nimport { CreateCliError, parseApiNames } from \"./webapi/api-name.js\";\nimport type { ApiOptions } from \"./webapi/create-api.js\";\nimport { scaffoldApi } from \"./webapi/create-api.js\";\n\nfunction collectName(value: string, previous: string[]): string[] {\n\tprevious.push(value);\n\treturn previous;\n}\n\nfunction addWebapiFeatureOptions(cmd: Command): Command {\n\treturn cmd\n\t\t.option(\"--database <provider>\", \"Database provider: none | postgres/typeorm\")\n\t\t.option(\"--auth <provider>\", \"Auth provider: none | auth0\")\n\t\t.option(\"--postman <provider>\", \"Postman provider: none | local | api\")\n\t\t.option(\"-y, --yes\", \"Install dependencies without prompting\")\n\t\t.option(\"--install <mode>\", \"Dependency install mode: ask | yes | no\", \"ask\");\n}\n\nfunction toApiOptions(\n\tdirectory: string | undefined,\n\topts: Record<string, unknown>,\n\textra: Partial<ApiOptions> = {},\n): ApiOptions {\n\tconst installMode = String(opts.install ?? \"ask\").toLowerCase();\n\tconst names = Array.isArray(opts.name)\n\t\t? (opts.name as string[])\n\t\t: typeof opts.name === \"string\"\n\t\t\t? [opts.name]\n\t\t\t: extra.names;\n\treturn {\n\t\td: resolveTargetDir(directory, typeof opts.d === \"string\" ? opts.d : undefined),\n\t\tdatabaseProvider: opts.database as ApiOptions[\"databaseProvider\"],\n\t\tauthProvider: opts.auth as ApiOptions[\"authProvider\"],\n\t\tpostmanProvider: opts.postman as ApiOptions[\"postmanProvider\"],\n\t\tinstallDependencies:\n\t\t\topts.yes === true\n\t\t\t\t? \"yes\"\n\t\t\t\t: installMode === \"yes\" || installMode === \"no\"\n\t\t\t\t\t? installMode\n\t\t\t\t\t: undefined,\n\t\tnames,\n\t\t...extra,\n\t};\n}\n\nasync function runWebapi(normalized: ApiOptions): Promise<void> {\n\tparseApiNames(normalized.names);\n\tif (process.env.DECOHERE_BUILDER !== \"1\") {\n\t\trunInBuilder(normalized);\n\t\treturn;\n\t}\n\n\tconst { closePrompt } = await import(\"./domain/prompt.js\");\n\ttry {\n\t\tawait scaffoldApi(normalized);\n\t} finally {\n\t\tclosePrompt();\n\t}\n}\n\nexport function createProgram(): Command {\n\tconst program = new Command();\n\tprogram.exitOverride();\n\tprogram\n\t\t.name(\"decohere\")\n\t\t.description(\"Scaffold a new Decohere project\")\n\t\t.option(\"-d <directory>\", \"Target directory (default: current directory)\", \".\");\n\n\tconst webapi = addWebapiFeatureOptions(\n\t\tprogram\n\t\t\t.command(\"webapi\")\n\t\t\t.argument(\"[directory]\", \"Target directory (default: -d or current directory)\")\n\t\t\t.option(\n\t\t\t\t\"--name <slug>\",\n\t\t\t\t\"API name under projects/ (repeatable; default: api)\",\n\t\t\t\tcollectName,\n\t\t\t\t[] as string[],\n\t\t\t),\n\t);\n\twebapi.action(async (directory: string | undefined, _opts: unknown, cmd: Command) => {\n\t\tawait runWebapi(toApiOptions(directory, cmd.optsWithGlobals()));\n\t});\n\n\taddWebapiFeatureOptions(\n\t\twebapi.command(\"add\").argument(\"<name>\", \"API name under projects/\"),\n\t).action(async (name: string, _opts: unknown, cmd: Command) => {\n\t\tawait runWebapi(\n\t\t\ttoApiOptions(undefined, cmd.optsWithGlobals(), { names: [name], add: true }),\n\t\t);\n\t});\n\n\treturn program;\n}\n\nexport async function runCli(argv: string[] = process.argv): Promise<void> {\n\ttry {\n\t\tawait createProgram().parseAsync(argv);\n\t} catch (err) {\n\t\tif (err instanceof CommanderError) {\n\t\t\tprocess.exit(err.exitCode);\n\t\t}\n\t\tif (err instanceof CreateCliError) {\n\t\t\tconsole.error(`\\n  ${err.message}\\n`);\n\t\t\tprocess.exit(1);\n\t\t}\n\t\tconsole.error(err);\n\t\tprocess.exit(1);\n\t}\n\tprocess.exit(process.exitCode ?? 0);\n}\n"],"names":["Command","CommanderError","resolveTargetDir","runInBuilder","CreateCliError","parseApiNames","scaffoldApi","collectName","value","previous","push","addWebapiFeatureOptions","cmd","option","toApiOptions","directory","opts","extra","installMode","String","install","toLowerCase","names","Array","isArray","name","d","undefined","databaseProvider","database","authProvider","auth","postmanProvider","postman","installDependencies","yes","runWebapi","normalized","process","env","DECOHERE_BUILDER","closePrompt","createProgram","program","exitOverride","description","webapi","command","argument","action","_opts","optsWithGlobals","add","runCli","argv","parseAsync","err","exit","exitCode","console","error","message"],"mappings":"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"}

package/es6/src/runner.js

@@ -87,11 +87,22 @@ const BUILDER_IMAGE = `${CREATE_IMAGE_REPOSITORY}:${CREATE_VERSION}`;
         envArgs.push("-e", `HOST_UID=${hostUid}`);
         if (hostGid != null) envArgs.push("-e", `HOST_GID=${hostGid}`);
     }
-    const commandArgs = [
+    const commandArgs = opts.add ? [
+        "webapi",
+        "add",
+        opts.names?.[0] ?? "",
+        "-d",
+        "."
+    ] : [
         "webapi",
         "-d",
         "."
     ];
+    if (!opts.add) {
+        for (const name of opts.names ?? []){
+            commandArgs.push("--name", name);
+        }
+    }
     if (opts.databaseProvider != null) {
         commandArgs.push("--database", opts.databaseProvider);
     }
@@ -132,4 +143,4 @@ const BUILDER_IMAGE = `${CREATE_IMAGE_REPOSITORY}:${CREATE_VERSION}`;
     process.exit(result.status ?? 0);
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/runner.ts"],"sourcesContent":["import { execFileSync, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { basename, resolve } from \"node:path\";\nimport { CREATE_IMAGE_REPOSITORY, CREATE_VERSION } from \"./version.js\";\nimport type { ApiOptions } from \"./webapi/create-api.js\";\n\nconst BUILDER_IMAGE = `${CREATE_IMAGE_REPOSITORY}:${CREATE_VERSION}`;\n\n/**\n * Run the scaffold inside a pre-built Docker builder image.\n *\n * Called when `DECOHERE_BUILDER` is not set — i.e. the CLI is running on the\n * host, outside the container. Mounts the target directory as `/workspace` so\n * the scaffolded files are written back to the host filesystem.\n *\n * The container runs as the host uid/gid whenever possible so scaffolded files\n * are never root-owned (post-hoc `chown` is unreliable across Docker setups).\n *\n * Host `~/.config/auth0` is mounted when present so the Auth0 CLI can reuse\n * credentials (required for Postman SPA / auth0ClientId).\n */\nexport function runInBuilder(opts: ApiOptions): never {\n\tconst targetDir = resolve(opts.d ?? \".\");\n\tconst projectName = basename(targetDir);\n\tmkdirSync(targetDir, { recursive: true });\n\t// Host-owned so initializeCommand can always write here even if something\n\t// else in .devcontainer ends up oddly owned.\n\tmkdirSync(resolve(targetDir, \".devcontainer\", \"npm-auth\"), { recursive: true });\n\n\t// Ensure Docker is available.\n\ttry {\n\t\texecFileSync(\"docker\", [\"info\"], { stdio: \"pipe\" });\n\t} catch {\n\t\tconsole.error(\n\t\t\t\"\\n  Docker is required to scaffold a Decohere project.\\n\" +\n\t\t\t\t\"  Install Docker Desktop: https://www.docker.com/products/docker-desktop\\n\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\tconst hostUid = process.getuid?.();\n\tconst hostGid = process.getgid?.() ?? hostUid;\n\tconst runAsHostUser = hostUid != null && hostGid != null;\n\n\t// Anonymous root-owned volumes are not writable when we drop privileges.\n\tconst npmCacheDir = resolve(homedir(), \".cache/decohere-create/npm\");\n\tmkdirSync(npmCacheDir, { recursive: true });\n\n\t// Isolated HOME so --user host-uid can write without a matching /etc/passwd entry.\n\tconst builderHome = \"/tmp/decohere-create-home\";\n\n\tconst volumes: string[] = [\n\t\t\"-v\",\n\t\t`${targetDir}:/workspace`,\n\t\t\"-v\",\n\t\t`${npmCacheDir}:/npm-cache`,\n\t];\n\n\tconst envArgs: string[] = [\n\t\t\"-e\",\n\t\t\"DECOHERE_BUILDER=1\",\n\t\t// Host dir basename — container cwd is /workspace so basename would be wrong.\n\t\t\"-e\",\n\t\t`DECOHERE_PROJECT_NAME=${projectName}`,\n\t\t\"-e\",\n\t\t\"NPM_CONFIG_CACHE=/npm-cache\",\n\t\t\"-e\",\n\t\t\"NPM_CONFIG_PREFER_OFFLINE=true\",\n\t\t\"-e\",\n\t\t`HOME=${builderHome}`,\n\t];\n\n\t// Mount host .npmrc where the non-root process can read it.\n\tconst npmrcPath = resolve(homedir(), \".npmrc\");\n\tif (existsSync(npmrcPath)) {\n\t\tvolumes.push(\"-v\", `${npmrcPath}:/tmp/host-npmrc:ro`);\n\t\tenvArgs.push(\"-e\", \"NPM_CONFIG_USERCONFIG=/tmp/host-npmrc\");\n\t}\n\n\t// Auth0 CLI reads credentials from $HOME/.config/auth0 — without this mount,\n\t// ensureSpaApp fails and Postman gets an empty auth0ClientId.\n\tconst auth0ConfigDir = resolve(homedir(), \".config/auth0\");\n\tif (existsSync(auth0ConfigDir)) {\n\t\tvolumes.push(\"-v\", `${auth0ConfigDir}:${builderHome}/.config/auth0`);\n\t}\n\n\tconst userArgs: string[] = [];\n\tif (runAsHostUser) {\n\t\tuserArgs.push(\"--user\", `${hostUid}:${hostGid}`);\n\t} else if (hostUid != null) {\n\t\t// Fallback for environments without getgid: keep legacy chown path.\n\t\tenvArgs.push(\"-e\", `HOST_UID=${hostUid}`);\n\t\tif (hostGid != null) envArgs.push(\"-e\", `HOST_GID=${hostGid}`);\n\t}\n\n\tconst commandArgs: string[] = [\"webapi\", \"-d\", \".\"];\n\tif (opts.databaseProvider != null) {\n\t\tcommandArgs.push(\"--database\", opts.databaseProvider);\n\t}\n\tif (opts.authProvider != null) {\n\t\tcommandArgs.push(\"--auth\", opts.authProvider);\n\t}\n\tif (opts.postmanProvider != null) {\n\t\tcommandArgs.push(\"--postman\", opts.postmanProvider);\n\t}\n\tif (opts.installDependencies != null) {\n\t\tcommandArgs.push(\"--install\", opts.installDependencies);\n\t}\n\n\tconsole.log(\"  Running scaffolding in a sandboxed container...\\n\");\n\n\t// Only allocate a TTY when stdin is itself a TTY — avoids a hung process\n\t// in non-interactive environments (pipes, CI, scripts).\n\tconst ttyFlags = process.stdin.isTTY ? [\"-it\"] : [\"-i\"];\n\n\tconst result = spawnSync(\n\t\t\"docker\",\n\t\t[\n\t\t\t\"run\",\n\t\t\t\"--rm\",\n\t\t\t...ttyFlags,\n\t\t\t...userArgs,\n\t\t\t...volumes,\n\t\t\t...envArgs,\n\t\t\t\"-w\",\n\t\t\t\"/workspace\",\n\t\t\tBUILDER_IMAGE,\n\t\t\t...commandArgs,\n\t\t],\n\t\t{ stdio: \"inherit\" },\n\t);\n\n\tif (result.status === 0) {\n\t\tconsole.log(`\\n  Scaffold complete!\\n\\n  Open your project:\\n\\n    code ${targetDir}\\n`);\n\t}\n\n\tprocess.exit(result.status ?? 0);\n}\n"],"names":["execFileSync","spawnSync","existsSync","mkdirSync","homedir","basename","resolve","CREATE_IMAGE_REPOSITORY","CREATE_VERSION","BUILDER_IMAGE","runInBuilder","opts","targetDir","d","projectName","recursive","stdio","console","error","process","exit","hostUid","getuid","hostGid","getgid","runAsHostUser","npmCacheDir","builderHome","volumes","envArgs","npmrcPath","push","auth0ConfigDir","userArgs","commandArgs","databaseProvider","authProvider","postmanProvider","installDependencies","log","ttyFlags","stdin","isTTY","result","status"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/runner.ts"],"sourcesContent":["import { execFileSync, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { basename, resolve } from \"node:path\";\nimport { CREATE_IMAGE_REPOSITORY, CREATE_VERSION } from \"./version.js\";\nimport type { ApiOptions } from \"./webapi/create-api.js\";\n\nconst BUILDER_IMAGE = `${CREATE_IMAGE_REPOSITORY}:${CREATE_VERSION}`;\n\n/**\n * Run the scaffold inside a pre-built Docker builder image.\n *\n * Called when `DECOHERE_BUILDER` is not set — i.e. the CLI is running on the\n * host, outside the container. Mounts the target directory as `/workspace` so\n * the scaffolded files are written back to the host filesystem.\n *\n * The container runs as the host uid/gid whenever possible so scaffolded files\n * are never root-owned (post-hoc `chown` is unreliable across Docker setups).\n *\n * Host `~/.config/auth0` is mounted when present so the Auth0 CLI can reuse\n * credentials (required for Postman SPA / auth0ClientId).\n */\nexport function runInBuilder(opts: ApiOptions): never {\n\tconst targetDir = resolve(opts.d ?? \".\");\n\tconst projectName = basename(targetDir);\n\tmkdirSync(targetDir, { recursive: true });\n\t// Host-owned so initializeCommand can always write here even if something\n\t// else in .devcontainer ends up oddly owned.\n\tmkdirSync(resolve(targetDir, \".devcontainer\", \"npm-auth\"), { recursive: true });\n\n\t// Ensure Docker is available.\n\ttry {\n\t\texecFileSync(\"docker\", [\"info\"], { stdio: \"pipe\" });\n\t} catch {\n\t\tconsole.error(\n\t\t\t\"\\n  Docker is required to scaffold a Decohere project.\\n\" +\n\t\t\t\t\"  Install Docker Desktop: https://www.docker.com/products/docker-desktop\\n\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\tconst hostUid = process.getuid?.();\n\tconst hostGid = process.getgid?.() ?? hostUid;\n\tconst runAsHostUser = hostUid != null && hostGid != null;\n\n\t// Anonymous root-owned volumes are not writable when we drop privileges.\n\tconst npmCacheDir = resolve(homedir(), \".cache/decohere-create/npm\");\n\tmkdirSync(npmCacheDir, { recursive: true });\n\n\t// Isolated HOME so --user host-uid can write without a matching /etc/passwd entry.\n\tconst builderHome = \"/tmp/decohere-create-home\";\n\n\tconst volumes: string[] = [\n\t\t\"-v\",\n\t\t`${targetDir}:/workspace`,\n\t\t\"-v\",\n\t\t`${npmCacheDir}:/npm-cache`,\n\t];\n\n\tconst envArgs: string[] = [\n\t\t\"-e\",\n\t\t\"DECOHERE_BUILDER=1\",\n\t\t// Host dir basename — container cwd is /workspace so basename would be wrong.\n\t\t\"-e\",\n\t\t`DECOHERE_PROJECT_NAME=${projectName}`,\n\t\t\"-e\",\n\t\t\"NPM_CONFIG_CACHE=/npm-cache\",\n\t\t\"-e\",\n\t\t\"NPM_CONFIG_PREFER_OFFLINE=true\",\n\t\t\"-e\",\n\t\t`HOME=${builderHome}`,\n\t];\n\n\t// Mount host .npmrc where the non-root process can read it.\n\tconst npmrcPath = resolve(homedir(), \".npmrc\");\n\tif (existsSync(npmrcPath)) {\n\t\tvolumes.push(\"-v\", `${npmrcPath}:/tmp/host-npmrc:ro`);\n\t\tenvArgs.push(\"-e\", \"NPM_CONFIG_USERCONFIG=/tmp/host-npmrc\");\n\t}\n\n\t// Auth0 CLI reads credentials from $HOME/.config/auth0 — without this mount,\n\t// ensureSpaApp fails and Postman gets an empty auth0ClientId.\n\tconst auth0ConfigDir = resolve(homedir(), \".config/auth0\");\n\tif (existsSync(auth0ConfigDir)) {\n\t\tvolumes.push(\"-v\", `${auth0ConfigDir}:${builderHome}/.config/auth0`);\n\t}\n\n\tconst userArgs: string[] = [];\n\tif (runAsHostUser) {\n\t\tuserArgs.push(\"--user\", `${hostUid}:${hostGid}`);\n\t} else if (hostUid != null) {\n\t\t// Fallback for environments without getgid: keep legacy chown path.\n\t\tenvArgs.push(\"-e\", `HOST_UID=${hostUid}`);\n\t\tif (hostGid != null) envArgs.push(\"-e\", `HOST_GID=${hostGid}`);\n\t}\n\n\tconst commandArgs: string[] = opts.add\n\t\t? [\"webapi\", \"add\", opts.names?.[0] ?? \"\", \"-d\", \".\"]\n\t\t: [\"webapi\", \"-d\", \".\"];\n\tif (!opts.add) {\n\t\tfor (const name of opts.names ?? []) {\n\t\t\tcommandArgs.push(\"--name\", name);\n\t\t}\n\t}\n\tif (opts.databaseProvider != null) {\n\t\tcommandArgs.push(\"--database\", opts.databaseProvider);\n\t}\n\tif (opts.authProvider != null) {\n\t\tcommandArgs.push(\"--auth\", opts.authProvider);\n\t}\n\tif (opts.postmanProvider != null) {\n\t\tcommandArgs.push(\"--postman\", opts.postmanProvider);\n\t}\n\tif (opts.installDependencies != null) {\n\t\tcommandArgs.push(\"--install\", opts.installDependencies);\n\t}\n\n\tconsole.log(\"  Running scaffolding in a sandboxed container...\\n\");\n\n\t// Only allocate a TTY when stdin is itself a TTY — avoids a hung process\n\t// in non-interactive environments (pipes, CI, scripts).\n\tconst ttyFlags = process.stdin.isTTY ? [\"-it\"] : [\"-i\"];\n\n\tconst result = spawnSync(\n\t\t\"docker\",\n\t\t[\n\t\t\t\"run\",\n\t\t\t\"--rm\",\n\t\t\t...ttyFlags,\n\t\t\t...userArgs,\n\t\t\t...volumes,\n\t\t\t...envArgs,\n\t\t\t\"-w\",\n\t\t\t\"/workspace\",\n\t\t\tBUILDER_IMAGE,\n\t\t\t...commandArgs,\n\t\t],\n\t\t{ stdio: \"inherit\" },\n\t);\n\n\tif (result.status === 0) {\n\t\tconsole.log(`\\n  Scaffold complete!\\n\\n  Open your project:\\n\\n    code ${targetDir}\\n`);\n\t}\n\n\tprocess.exit(result.status ?? 0);\n}\n"],"names":["execFileSync","spawnSync","existsSync","mkdirSync","homedir","basename","resolve","CREATE_IMAGE_REPOSITORY","CREATE_VERSION","BUILDER_IMAGE","runInBuilder","opts","targetDir","d","projectName","recursive","stdio","console","error","process","exit","hostUid","getuid","hostGid","getgid","runAsHostUser","npmCacheDir","builderHome","volumes","envArgs","npmrcPath","push","auth0ConfigDir","userArgs","commandArgs","add","names","name","databaseProvider","authProvider","postmanProvider","installDependencies","log","ttyFlags","stdin","isTTY","result","status"],"mappings":"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"}

package/es6/src/webapi/api-name.js

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_WEBAPI_NAME } from "./const.js";
+/** Lowercase npm-safe directory slug: `billing`, `admin-api`. */ export const API_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+export class CreateCliError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "CreateCliError";
+    }
+}
+export function assertValidApiName(name) {
+    if (!API_NAME_PATTERN.test(name)) {
+        throw new CreateCliError(`Invalid API name "${name}". Use a lowercase slug starting with a letter, then letters, digits, or hyphens (e.g. billing).`);
+    }
+}
+/** Default `["api"]` when the caller omitted `--name`. Rejects duplicates and invalid slugs. */ export function parseApiNames(raw) {
+    const names = raw != null && raw.length > 0 ? [
+        ...raw
+    ] : [
+        DEFAULT_WEBAPI_NAME
+    ];
+    const seen = new Set();
+    for (const name of names){
+        assertValidApiName(name);
+        if (seen.has(name)) {
+            throw new CreateCliError(`Duplicate API name "${name}".`);
+        }
+        seen.add(name);
+    }
+    return names;
+}
+export function isDecohereWorkspace(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        const build = pkg.scripts?.build;
+        return typeof build === "string" && build.includes("forge");
+    } catch  {
+        return false;
+    }
+}
+/** Directory names under `projects/` that already have a `package.json`. */ export function listExistingApiNames(dir) {
+    const projectsDir = join(dir, "projects");
+    try {
+        return readdirSync(projectsDir, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory() && existsSync(join(projectsDir, entry.name, "package.json"))).map((entry)=>entry.name).sort();
+    } catch  {
+        return [];
+    }
+}
+/** `billing` → `BILLING`, `admin-api` → `ADMIN_API` — prefix for `{PREFIX}_DB_HOST`. */ export function apiEnvPrefix(apiName) {
+    return apiName.replace(/-/g, "_").toUpperCase();
+}
+export function apiNameFromProjectDir(dir) {
+    const slash = dir.lastIndexOf("/");
+    return slash >= 0 ? dir.slice(slash + 1) : dir;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/const.js

@@ -1,7 +1,20 @@
-/** Relative path of the scaffolded API project inside the monorepo. */ export const WEBAPI_PROJECT_DIR = "projects/api";
+/** Default API project slug when `--name` is omitted. */ export const DEFAULT_WEBAPI_NAME = "api";
+/** Relative path of an API project inside the monorepo. */ export function webapiProjectDir(name) {
+    return `projects/${name}`;
+}
 /**
- * Forge release entry for the scaffolded API (`pack: true` → per-target outDir).
- * Keep in sync with root `package.json` `"start"` and the production Dockerfile.
- */ export const WEBAPI_RELEASE_ENTRY = `dist/release/${WEBAPI_PROJECT_DIR}/es6/src/main.js`;
+ * Forge release entry for a scaffolded API (`pack: true` → per-target outDir).
+ * Keep in sync with root `package.json` `"start"` / `"start:<name>"` and Dockerfiles.
+ */ export function webapiReleaseEntry(name) {
+    return `dist/release/${webapiProjectDir(name)}/es6/src/main.js`;
+}
+/** npm package name for a scaffolded API (`flux serve --project`). */ export function webapiPackageName(workspaceName, apiName) {
+    return `@${workspaceName}/${apiName}`;
+}
+/** Local listen port for the nth API (0-based). Production uses `PORT`. */ export function webapiPort(index) {
+    return 3000 + index;
+}
+/** @deprecated Use `webapiProjectDir(name)`. Default path for the first API. */ export const WEBAPI_PROJECT_DIR = webapiProjectDir(DEFAULT_WEBAPI_NAME);
+/** @deprecated Use `webapiReleaseEntry(name)`. Default start entry for the first API. */ export const WEBAPI_RELEASE_ENTRY = webapiReleaseEntry(DEFAULT_WEBAPI_NAME);
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvd2ViYXBpL2NvbnN0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBSZWxhdGl2ZSBwYXRoIG9mIHRoZSBzY2FmZm9sZGVkIEFQSSBwcm9qZWN0IGluc2lkZSB0aGUgbW9ub3JlcG8uICovXG5leHBvcnQgY29uc3QgV0VCQVBJX1BST0pFQ1RfRElSID0gXCJwcm9qZWN0cy9hcGlcIjtcblxuLyoqXG4gKiBGb3JnZSByZWxlYXNlIGVudHJ5IGZvciB0aGUgc2NhZmZvbGRlZCBBUEkgKGBwYWNrOiB0cnVlYCDihpIgcGVyLXRhcmdldCBvdXREaXIpLlxuICogS2VlcCBpbiBzeW5jIHdpdGggcm9vdCBgcGFja2FnZS5qc29uYCBgXCJzdGFydFwiYCBhbmQgdGhlIHByb2R1Y3Rpb24gRG9ja2VyZmlsZS5cbiAqL1xuZXhwb3J0IGNvbnN0IFdFQkFQSV9SRUxFQVNFX0VOVFJZID0gYGRpc3QvcmVsZWFzZS8ke1dFQkFQSV9QUk9KRUNUX0RJUn0vZXM2L3NyYy9tYWluLmpzYDtcbiJdLCJuYW1lcyI6WyJXRUJBUElfUFJPSkVDVF9ESVIiLCJXRUJBUElfUkVMRUFTRV9FTlRSWSJdLCJtYXBwaW5ncyI6IkFBQUEscUVBQXFFLEdBQ3JFLE9BQU8sTUFBTUEscUJBQXFCLGVBQWU7QUFFakQ7OztDQUdDLEdBQ0QsT0FBTyxNQUFNQyx1QkFBdUIsQ0FBQyxhQUFhLEVBQUVELG1CQUFtQixnQkFBZ0IsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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