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

package/es6/src/models/dev-container.model.js

@@ -0,0 +1,106 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class DevContainer {
+    key = WELL_KNOWN_FILES.DEVCONTAINER_JSON;
+    _extensions = [];
+    _ports = [];
+    _portAttributes = new Map();
+    _mounts;
+    _postCreateCommand;
+    _updateContentCommand;
+    _postStartCommand;
+    _initializeCommand;
+    _remoteUser = "node";
+    _useCompose = false;
+    constructor(){
+        this._mounts = [
+            "source=..,target=/workspace,type=bind,consistency=cached"
+        ];
+    }
+    addExtension(...ids) {
+        this._extensions.push(...ids);
+        return this;
+    }
+    forwardPort(...ports) {
+        this._ports.push(...ports);
+        return this;
+    }
+    setPortAttributes(port, attrs) {
+        this._portAttributes.set(port, attrs);
+        return this;
+    }
+    setPostCreateCommand(cmd) {
+        this._postCreateCommand = cmd;
+        return this;
+    }
+    setUpdateContentCommand(cmd) {
+        this._updateContentCommand = cmd;
+        return this;
+    }
+    setPostStartCommand(cmd) {
+        this._postStartCommand = cmd;
+        return this;
+    }
+    setInitializeCommand(cmd) {
+        this._initializeCommand = cmd;
+        return this;
+    }
+    setRemoteUser(user) {
+        this._remoteUser = user;
+        return this;
+    }
+    useCompose() {
+        this._useCompose = true;
+        return this;
+    }
+    files() {
+        const config = {};
+        if (this._useCompose) {
+            config.dockerComposeFile = "docker-compose.yml";
+            config.service = "devcontainer";
+            config.workspaceFolder = "/workspace";
+        }
+        if (this._initializeCommand) {
+            config.initializeCommand = this._initializeCommand;
+        }
+        if (this._mounts) {
+            config.mounts = this._mounts;
+        }
+        if (this._extensions.length > 0) {
+            config.customizations = {
+                vscode: {
+                    extensions: this._extensions
+                }
+            };
+        }
+        if (this._ports.length > 0) {
+            config.forwardPorts = this._ports;
+        }
+        if (this._portAttributes.size > 0) {
+            const portsAttributes = {};
+            for (const [port, attrs] of this._portAttributes){
+                portsAttributes[String(port)] = attrs;
+            }
+            config.portsAttributes = portsAttributes;
+        }
+        if (this._postCreateCommand) {
+            config.postCreateCommand = this._postCreateCommand;
+        }
+        if (this._updateContentCommand) {
+            config.updateContentCommand = this._updateContentCommand;
+        }
+        if (this._postStartCommand) {
+            config.postStartCommand = this._postStartCommand;
+        }
+        if (this._remoteUser) {
+            config.remoteUser = this._remoteUser;
+        }
+        return [
+            {
+                filePath: ".devcontainer/devcontainer.json",
+                content: JSON.stringify(config, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/models/dev-container.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"./const.js\";\nimport type { KeyedModel, SourceFile } from \"./source-file.js\";\n\n/**\n * Model for `.devcontainer/devcontainer.json`.\n *\n * Features call builder methods (`addExtension`, `forwardPort`, etc.) during\n * their configure phase. `MonoRepoScaffold` calls `files()` at render time.\n */\n\nexport type PortAttributes = {\n\tlabel?: string;\n\t/** When true, host port must match the container port (no random remap). */\n\trequireLocalPort?: boolean;\n\tonAutoForward?: \"notify\" | \"openBrowser\" | \"openPreview\" | \"silent\" | \"ignore\";\n};\n\nexport class DevContainer implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.DEVCONTAINER_JSON;\n\tprivate readonly _extensions: string[] = [];\n\tprivate readonly _ports: number[] = [];\n\tprivate readonly _portAttributes = new Map<number, PortAttributes>();\n\tprivate readonly _mounts: string[];\n\tprivate _postCreateCommand?: string;\n\tprivate _updateContentCommand?: string;\n\tprivate _postStartCommand?: string;\n\tprivate _initializeCommand?: string;\n\tprivate _remoteUser = \"node\";\n\tprivate _useCompose = false;\n\n\tpublic constructor() {\n\t\tthis._mounts = [\"source=..,target=/workspace,type=bind,consistency=cached\"];\n\t}\n\n\tpublic addExtension(...ids: string[]): this {\n\t\tthis._extensions.push(...ids);\n\t\treturn this;\n\t}\n\n\tpublic forwardPort(...ports: number[]): this {\n\t\tthis._ports.push(...ports);\n\t\treturn this;\n\t}\n\n\tpublic setPortAttributes(port: number, attrs: PortAttributes): this {\n\t\tthis._portAttributes.set(port, attrs);\n\t\treturn this;\n\t}\n\n\tpublic setPostCreateCommand(cmd: string): this {\n\t\tthis._postCreateCommand = cmd;\n\t\treturn this;\n\t}\n\n\tpublic setUpdateContentCommand(cmd: string): this {\n\t\tthis._updateContentCommand = cmd;\n\t\treturn this;\n\t}\n\n\tpublic setPostStartCommand(cmd: string): this {\n\t\tthis._postStartCommand = cmd;\n\t\treturn this;\n\t}\n\n\tpublic setInitializeCommand(cmd: string): this {\n\t\tthis._initializeCommand = cmd;\n\t\treturn this;\n\t}\n\n\tpublic setRemoteUser(user: string): this {\n\t\tthis._remoteUser = user;\n\t\treturn this;\n\t}\n\n\tpublic useCompose(): this {\n\t\tthis._useCompose = true;\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\tconst config: Record<string, unknown> = {};\n\n\t\tif (this._useCompose) {\n\t\t\tconfig.dockerComposeFile = \"docker-compose.yml\";\n\t\t\tconfig.service = \"devcontainer\";\n\t\t\tconfig.workspaceFolder = \"/workspace\";\n\t\t}\n\n\t\tif (this._initializeCommand) {\n\t\t\tconfig.initializeCommand = this._initializeCommand;\n\t\t}\n\n\t\tif (this._mounts) {\n\t\t\tconfig.mounts = this._mounts;\n\t\t}\n\n\t\tif (this._extensions.length > 0) {\n\t\t\tconfig.customizations = { vscode: { extensions: this._extensions } };\n\t\t}\n\n\t\tif (this._ports.length > 0) {\n\t\t\tconfig.forwardPorts = this._ports;\n\t\t}\n\n\t\tif (this._portAttributes.size > 0) {\n\t\t\tconst portsAttributes: Record<string, PortAttributes> = {};\n\t\t\tfor (const [port, attrs] of this._portAttributes) {\n\t\t\t\tportsAttributes[String(port)] = attrs;\n\t\t\t}\n\t\t\tconfig.portsAttributes = portsAttributes;\n\t\t}\n\n\t\tif (this._postCreateCommand) {\n\t\t\tconfig.postCreateCommand = this._postCreateCommand;\n\t\t}\n\n\t\tif (this._updateContentCommand) {\n\t\t\tconfig.updateContentCommand = this._updateContentCommand;\n\t\t}\n\n\t\tif (this._postStartCommand) {\n\t\t\tconfig.postStartCommand = this._postStartCommand;\n\t\t}\n\n\t\tif (this._remoteUser) {\n\t\t\tconfig.remoteUser = this._remoteUser;\n\t\t}\n\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \".devcontainer/devcontainer.json\",\n\t\t\t\tcontent: JSON.stringify(config, null, 2),\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["WELL_KNOWN_FILES","DevContainer","key","DEVCONTAINER_JSON","_extensions","_ports","_portAttributes","Map","_mounts","_postCreateCommand","_updateContentCommand","_postStartCommand","_initializeCommand","_remoteUser","_useCompose","addExtension","ids","push","forwardPort","ports","setPortAttributes","port","attrs","set","setPostCreateCommand","cmd","setUpdateContentCommand","setPostStartCommand","setInitializeCommand","setRemoteUser","user","useCompose","files","config","dockerComposeFile","service","workspaceFolder","initializeCommand","mounts","length","customizations","vscode","extensions","forwardPorts","size","portsAttributes","String","postCreateCommand","updateContentCommand","postStartCommand","remoteUser","filePath","content","JSON","stringify"],"mappings":"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"}

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

@@ -0,0 +1,217 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class DockerStep {
+    key;
+    content;
+    order;
+    constructor(key, content, order = 0){
+        this.key = key;
+        this.content = content;
+        this.order = order;
+    }
+    static run(key, command, order = 0) {
+        return new DockerStep(key, `RUN ${command}`, order);
+    }
+    static raw(key, content, order = 0) {
+        return new DockerStep(key, content, order);
+    }
+    static entrypoint(key, value, order = 0) {
+        const content = typeof value === "string" ? `ENTRYPOINT ${value}` : `ENTRYPOINT ${JSON.stringify(value)}`;
+        return new DockerStep(key, content, order);
+    }
+}
+const StepOrder = {
+    base: 1_000,
+    features: 5_000,
+    user: 9_000,
+    entrypoint: 10_000
+};
+const VSCODE_BOOTLOADER_FIX_BASH_SNIPPET = `if [[ -n "\${NODE_OPTIONS:-}" && "\${NODE_OPTIONS}" == *"bootloader.js"* ]]; then
+    _bootloader_path="$(printf '%s\\n' "$NODE_OPTIONS" | sed -n 's/.*--require[= ]\\([^[:space:]]*bootloader\\.js\\).*/\\1/p')"
+    if [[ -n "\${_bootloader_path}" && ! -f "\${_bootloader_path}" ]]; then
+        _stable_bootloader="$(find /vscode/vscode-server /home/node/.vscode-server/extensions -name "bootloader.js" -path "*/ms-vscode.js-debug/*" 2>/dev/null | head -1)"
+        if [[ -n "\${_stable_bootloader}" ]]; then
+            NODE_OPTIONS="\${NODE_OPTIONS//\${_bootloader_path}/\${_stable_bootloader}}"
+        else
+            NODE_OPTIONS="$(printf '%s\\n' "$NODE_OPTIONS" | sed -E 's#(^| )--require(=| )[[:graph:]]*bootloader\\.js( |$)# #g; s#  +# #g; s#^ ##; s# $##')"
+            unset VSCODE_INSPECTOR_OPTIONS
+        fi
+        export NODE_OPTIONS
+        if [[ -z "$NODE_OPTIONS" ]]; then
+            unset NODE_OPTIONS
+        fi
+    fi
+    unset _bootloader_path _stable_bootloader
+fi`;
+/** Named volume + paths for interactive bash history in app Dev Containers. */ export const commandHistory = {
+    volumeName: "bashhistory",
+    dir: "/commandhistory",
+    fileName: ".bash_history",
+    histFile: "/commandhistory/.bash_history"
+};
+export function withCommandHistory(options) {
+    const historyDir = options?.historyDir ?? commandHistory.dir;
+    const historyFileName = options?.historyFileName ?? commandHistory.fileName;
+    const username = options?.username ?? "node";
+    const order = options?.order ?? StepOrder.base;
+    const historyFile = `${historyDir}/${historyFileName}`;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.run("history-dir", `mkdir -p ${historyDir} && touch ${historyFile} && chown -R ${username} ${historyDir}`, order)).addStep(DockerStep.raw("history-env", `ENV HISTFILE=${historyFile}`, order + 1)).addStep(DockerStep.raw("history-bashrc", `RUN SNIPPET="export PROMPT_COMMAND='history -a' && export HISTFILE=${historyFile}" \\\n\t&& echo "$SNIPPET" >> "/home/${username}/.bashrc"`, order + 2));
+    };
+}
+export function withNodeUser(options) {
+    const username = options?.username ?? "node";
+    const includeUserInstruction = options?.includeUserInstruction ?? true;
+    const order = options?.order ?? StepOrder.features;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("arg-username", `ARG USERNAME=${username}`, order));
+        if (includeUserInstruction) {
+            dockerfile.addStep(DockerStep.raw("user", "USER ${USERNAME}", StepOrder.user));
+        }
+    };
+}
+export function withPnpm(options) {
+    const version = options?.version ?? "10";
+    const usernameExpr = options?.usernameExpr ?? "${USERNAME}";
+    const order = options?.order ?? StepOrder.features + 100;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.run("pnpm-install", `npm install --global npm@latest && npm add --global pnpm@${version}`, order)).addStep(DockerStep.run("pnpm-config", `mkdir -p /home/${usernameExpr}/.config/pnpm /home/${usernameExpr}/.pnpm-store && chown -R ${usernameExpr}:${usernameExpr} /home/${usernameExpr}/.config /home/${usernameExpr}/.pnpm-store && printf "store-dir=/home/${usernameExpr}/.pnpm-store\\n" > /home/${usernameExpr}/.config/pnpm/rc`, order + 1));
+    };
+}
+/**
+ * Client-only (`psql`, etc.). Escalates to root so this also works when layered on
+ * a published base image that already switched to `USER node`.
+ */ export function withPostgresqlClient(options) {
+    const order = options?.order ?? StepOrder.features + 150;
+    const username = options?.username ?? "node";
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("postgresql-client-root", "USER root", order)).addStep(DockerStep.run("postgresql-client", "apt-get update && apt-get install -y --no-install-recommends postgresql-client && rm -rf /var/lib/apt/lists/*", order + 1)).addStep(DockerStep.raw("postgresql-client-user", `USER ${username}`, order + 2));
+    };
+}
+/** GitHub CLI — install before USER switches away from root. */ export function withGithubCli(options) {
+    const order = options?.order ?? StepOrder.features + 140;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.run("github-cli", "apt-get update && apt-get install -y --no-install-recommends gh && rm -rf /var/lib/apt/lists/*", order));
+    };
+}
+export function withWorkspaceNodeModulesOwnership(options) {
+    const workspaceDir = options?.workspaceDir ?? "/workspace";
+    const usernameExpr = options?.usernameExpr ?? "${USERNAME}";
+    const order = options?.order ?? StepOrder.features + 200;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("workspace-node-modules", `RUN mkdir -p ${workspaceDir}/node_modules && chown ${usernameExpr}:${usernameExpr} ${workspaceDir}/node_modules`, order));
+    };
+}
+export function withVsCodeJsDebugBootloaderFix(options) {
+    const bashrcPath = options?.bashrcPath ?? "/home/${USERNAME}/.bashrc";
+    const order = options?.order ?? StepOrder.features + 300;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("vscode-bootloader-fix", [
+            "# VS Code / Cursor js-debug Auto Attach injects --require …/bootloader.js into",
+            "# NODE_OPTIONS. On a fresh Dev Container that path often does not exist yet",
+            "# (workspaceStorage file is only created after toggling Auto Attach), which crashes",
+            "# every Node command. If the injected path is missing, prefer the stable",
+            "# bootloader from the server extension install; otherwise strip the bad require.",
+            `RUN cat <<'EOF' >> "${bashrcPath}"`,
+            VSCODE_BOOTLOADER_FIX_BASH_SNIPPET,
+            "EOF"
+        ].join("\n"), order));
+    };
+}
+export class DockerfileModel {
+    key = WELL_KNOWN_FILES.DOCKERFILE;
+    _steps = new Map();
+    _layerWriters = [];
+    _fromImage;
+    _layerCounter = 0;
+    constructor(baseImage){
+        this._fromImage = baseImage;
+        this.registerBaseLayers();
+    }
+    from(baseImage) {
+        this._fromImage = baseImage;
+        return this;
+    }
+    addLayer(layer, order = StepOrder.features) {
+        if (typeof layer === "string") {
+            const idx = ++this._layerCounter;
+            const key = `layer-run-${idx}`;
+            this._layerWriters.push((dockerfile)=>{
+                dockerfile.addStep(DockerStep.run(key, layer, order + idx));
+            });
+            return this;
+        }
+        this._layerWriters.push(layer);
+        return this;
+    }
+    addStep(step) {
+        this._steps.set(step.key, step);
+        return this;
+    }
+    removeStep(key) {
+        this._steps.delete(key);
+        return this;
+    }
+    entrypoint(value, order = StepOrder.entrypoint) {
+        this.addStep(DockerStep.entrypoint("entrypoint", value, order));
+        return this;
+    }
+    addRunStep(cmd) {
+        return this.addLayer(cmd);
+    }
+    build() {
+        for (const layerWriter of this._layerWriters){
+            layerWriter(this);
+        }
+        const lines = [
+            `FROM ${this._fromImage}`
+        ];
+        const sortedSteps = [
+            ...this._steps.values()
+        ].sort((left, right)=>{
+            if (left.order !== right.order) {
+                return left.order - right.order;
+            }
+            return left.key.localeCompare(right.key, "en");
+        });
+        for (const step of sortedSteps){
+            lines.push("", step.content);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+    registerBaseLayers() {
+    // Generic base model intentionally has no default layers.
+    }
+    files() {
+        return [
+            {
+                filePath: "./Dockerfile",
+                content: this.build()
+            }
+        ];
+    }
+}
+/**
+ * Shared layers for the published `ghcr.io/typesmiths/decohere/devcontainer` image.
+ * Checked in at `projects/devcontainer/Dockerfile` — keep in sync via the unit test.
+ */ export class AppDevContainerBaseImage extends DockerfileModel {
+    registerBaseLayers() {
+        super.registerBaseLayers();
+        this.addLayer(withCommandHistory()).addLayer(withNodeUser()).addLayer(withPnpm()).addLayer(withGithubCli()).addLayer(withWorkspaceNodeModulesOwnership()).addLayer(withVsCodeJsDebugBootloaderFix());
+    }
+}
+/** Generic Dev Container image helpers (history + bootloader) without webapi defaults. */ export class DevContainerImageModel extends DockerfileModel {
+    registerBaseLayers() {
+        super.registerBaseLayers();
+        this.addLayer(withCommandHistory()).addLayer(withVsCodeJsDebugBootloaderFix());
+    }
+    files() {
+        return [
+            {
+                filePath: ".devcontainer/Dockerfile",
+                content: this.build()
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/models/docker-image.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"./const.js\";\nimport type { KeyedModel, SourceFile } from \"./source-file.js\";\n\nexport type LayerWriter = (dockerfile: DockerfileModel) => void;\n\nexport class DockerStep {\n\tpublic constructor(\n\t\tpublic readonly key: string,\n\t\tpublic readonly content: string,\n\t\tpublic readonly order = 0,\n\t) {}\n\n\tpublic static run(key: string, command: string, order = 0) {\n\t\treturn new DockerStep(key, `RUN ${command}`, order);\n\t}\n\n\tpublic static raw(key: string, content: string, order = 0) {\n\t\treturn new DockerStep(key, content, order);\n\t}\n\n\tpublic static entrypoint(key: string, value: string | readonly string[], order = 0) {\n\t\tconst content =\n\t\t\ttypeof value === \"string\"\n\t\t\t\t? `ENTRYPOINT ${value}`\n\t\t\t\t: `ENTRYPOINT ${JSON.stringify(value)}`;\n\t\treturn new DockerStep(key, content, order);\n\t}\n}\n\nconst StepOrder = {\n\tbase: 1_000,\n\tfeatures: 5_000,\n\tuser: 9_000,\n\tentrypoint: 10_000,\n} as const;\n\nconst VSCODE_BOOTLOADER_FIX_BASH_SNIPPET = `if [[ -n \"\\${NODE_OPTIONS:-}\" && \"\\${NODE_OPTIONS}\" == *\"bootloader.js\"* ]]; then\n    _bootloader_path=\"$(printf '%s\\\\n' \"$NODE_OPTIONS\" | sed -n 's/.*--require[= ]\\\\([^[:space:]]*bootloader\\\\.js\\\\).*/\\\\1/p')\"\n    if [[ -n \"\\${_bootloader_path}\" && ! -f \"\\${_bootloader_path}\" ]]; then\n        _stable_bootloader=\"$(find /vscode/vscode-server /home/node/.vscode-server/extensions -name \"bootloader.js\" -path \"*/ms-vscode.js-debug/*\" 2>/dev/null | head -1)\"\n        if [[ -n \"\\${_stable_bootloader}\" ]]; then\n            NODE_OPTIONS=\"\\${NODE_OPTIONS//\\${_bootloader_path}/\\${_stable_bootloader}}\"\n        else\n            NODE_OPTIONS=\"$(printf '%s\\\\n' \"$NODE_OPTIONS\" | sed -E 's#(^| )--require(=| )[[:graph:]]*bootloader\\\\.js( |$)# #g; s#  +# #g; s#^ ##; s# $##')\"\n            unset VSCODE_INSPECTOR_OPTIONS\n        fi\n        export NODE_OPTIONS\n        if [[ -z \"$NODE_OPTIONS\" ]]; then\n            unset NODE_OPTIONS\n        fi\n    fi\n    unset _bootloader_path _stable_bootloader\nfi`;\n\n/** Named volume + paths for interactive bash history in app Dev Containers. */\nexport const commandHistory = {\n\tvolumeName: \"bashhistory\",\n\tdir: \"/commandhistory\",\n\tfileName: \".bash_history\",\n\thistFile: \"/commandhistory/.bash_history\",\n} as const;\n\nexport function withCommandHistory(options?: {\n\thistoryDir?: string;\n\thistoryFileName?: string;\n\tusername?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst historyDir = options?.historyDir ?? commandHistory.dir;\n\tconst historyFileName = options?.historyFileName ?? commandHistory.fileName;\n\tconst username = options?.username ?? \"node\";\n\tconst order = options?.order ?? StepOrder.base;\n\tconst historyFile = `${historyDir}/${historyFileName}`;\n\n\treturn (dockerfile) => {\n\t\tdockerfile\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\n\t\t\t\t\t\"history-dir\",\n\t\t\t\t\t`mkdir -p ${historyDir} && touch ${historyFile} && chown -R ${username} ${historyDir}`,\n\t\t\t\t\torder,\n\t\t\t\t),\n\t\t\t)\n\t\t\t.addStep(DockerStep.raw(\"history-env\", `ENV HISTFILE=${historyFile}`, order + 1))\n\t\t\t.addStep(\n\t\t\t\tDockerStep.raw(\n\t\t\t\t\t\"history-bashrc\",\n\t\t\t\t\t`RUN SNIPPET=\"export PROMPT_COMMAND='history -a' && export HISTFILE=${historyFile}\" \\\\\\n\\t&& echo \"$SNIPPET\" >> \"/home/${username}/.bashrc\"`,\n\t\t\t\t\torder + 2,\n\t\t\t\t),\n\t\t\t);\n\t};\n}\n\nexport function withNodeUser(options?: {\n\tusername?: string;\n\tincludeUserInstruction?: boolean;\n\torder?: number;\n}): LayerWriter {\n\tconst username = options?.username ?? \"node\";\n\tconst includeUserInstruction = options?.includeUserInstruction ?? true;\n\tconst order = options?.order ?? StepOrder.features;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(DockerStep.raw(\"arg-username\", `ARG USERNAME=${username}`, order));\n\n\t\tif (includeUserInstruction) {\n\t\t\tdockerfile.addStep(DockerStep.raw(\"user\", \"USER ${USERNAME}\", StepOrder.user));\n\t\t}\n\t};\n}\n\nexport function withPnpm(options?: {\n\tversion?: string;\n\tusernameExpr?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst version = options?.version ?? \"10\";\n\tconst usernameExpr = options?.usernameExpr ?? \"${USERNAME}\";\n\tconst order = options?.order ?? StepOrder.features + 100;\n\n\treturn (dockerfile) => {\n\t\tdockerfile\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\n\t\t\t\t\t\"pnpm-install\",\n\t\t\t\t\t`npm install --global npm@latest && npm add --global pnpm@${version}`,\n\t\t\t\t\torder,\n\t\t\t\t),\n\t\t\t)\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\n\t\t\t\t\t\"pnpm-config\",\n\t\t\t\t\t`mkdir -p /home/${usernameExpr}/.config/pnpm /home/${usernameExpr}/.pnpm-store && chown -R ${usernameExpr}:${usernameExpr} /home/${usernameExpr}/.config /home/${usernameExpr}/.pnpm-store && printf \"store-dir=/home/${usernameExpr}/.pnpm-store\\\\n\" > /home/${usernameExpr}/.config/pnpm/rc`,\n\t\t\t\t\torder + 1,\n\t\t\t\t),\n\t\t\t);\n\t};\n}\n\n/**\n * Client-only (`psql`, etc.). Escalates to root so this also works when layered on\n * a published base image that already switched to `USER node`.\n */\nexport function withPostgresqlClient(options?: {\n\torder?: number;\n\tusername?: string;\n}): LayerWriter {\n\tconst order = options?.order ?? StepOrder.features + 150;\n\tconst username = options?.username ?? \"node\";\n\n\treturn (dockerfile) => {\n\t\tdockerfile\n\t\t\t.addStep(DockerStep.raw(\"postgresql-client-root\", \"USER root\", order))\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\n\t\t\t\t\t\"postgresql-client\",\n\t\t\t\t\t\"apt-get update && apt-get install -y --no-install-recommends postgresql-client && rm -rf /var/lib/apt/lists/*\",\n\t\t\t\t\torder + 1,\n\t\t\t\t),\n\t\t\t)\n\t\t\t.addStep(DockerStep.raw(\"postgresql-client-user\", `USER ${username}`, order + 2));\n\t};\n}\n\n/** GitHub CLI — install before USER switches away from root. */\nexport function withGithubCli(options?: { order?: number }): LayerWriter {\n\tconst order = options?.order ?? StepOrder.features + 140;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(\n\t\t\tDockerStep.run(\n\t\t\t\t\"github-cli\",\n\t\t\t\t\"apt-get update && apt-get install -y --no-install-recommends gh && rm -rf /var/lib/apt/lists/*\",\n\t\t\t\torder,\n\t\t\t),\n\t\t);\n\t};\n}\n\nexport function withWorkspaceNodeModulesOwnership(options?: {\n\tworkspaceDir?: string;\n\tusernameExpr?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst workspaceDir = options?.workspaceDir ?? \"/workspace\";\n\tconst usernameExpr = options?.usernameExpr ?? \"${USERNAME}\";\n\tconst order = options?.order ?? StepOrder.features + 200;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(\n\t\t\tDockerStep.raw(\n\t\t\t\t\"workspace-node-modules\",\n\t\t\t\t`RUN mkdir -p ${workspaceDir}/node_modules && chown ${usernameExpr}:${usernameExpr} ${workspaceDir}/node_modules`,\n\t\t\t\torder,\n\t\t\t),\n\t\t);\n\t};\n}\n\nexport function withVsCodeJsDebugBootloaderFix(options?: {\n\tbashrcPath?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst bashrcPath = options?.bashrcPath ?? \"/home/${USERNAME}/.bashrc\";\n\tconst order = options?.order ?? StepOrder.features + 300;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(\n\t\t\tDockerStep.raw(\n\t\t\t\t\"vscode-bootloader-fix\",\n\t\t\t\t[\n\t\t\t\t\t\"# VS Code / Cursor js-debug Auto Attach injects --require …/bootloader.js into\",\n\t\t\t\t\t\"# NODE_OPTIONS. On a fresh Dev Container that path often does not exist yet\",\n\t\t\t\t\t\"# (workspaceStorage file is only created after toggling Auto Attach), which crashes\",\n\t\t\t\t\t\"# every Node command. If the injected path is missing, prefer the stable\",\n\t\t\t\t\t\"# bootloader from the server extension install; otherwise strip the bad require.\",\n\t\t\t\t\t`RUN cat <<'EOF' >> \"${bashrcPath}\"`,\n\t\t\t\t\tVSCODE_BOOTLOADER_FIX_BASH_SNIPPET,\n\t\t\t\t\t\"EOF\",\n\t\t\t\t].join(\"\\n\"),\n\t\t\t\torder,\n\t\t\t),\n\t\t);\n\t};\n}\n\nexport class DockerfileModel implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.DOCKERFILE;\n\tprivate readonly _steps = new Map<string, DockerStep>();\n\tprivate readonly _layerWriters: LayerWriter[] = [];\n\tprivate _fromImage: string;\n\tprivate _layerCounter = 0;\n\n\tpublic constructor(baseImage: string) {\n\t\tthis._fromImage = baseImage;\n\t\tthis.registerBaseLayers();\n\t}\n\n\tpublic from(baseImage: string): this {\n\t\tthis._fromImage = baseImage;\n\t\treturn this;\n\t}\n\n\tpublic addLayer(layer: LayerWriter | string, order = StepOrder.features): this {\n\t\tif (typeof layer === \"string\") {\n\t\t\tconst idx = ++this._layerCounter;\n\t\t\tconst key = `layer-run-${idx}`;\n\t\t\tthis._layerWriters.push((dockerfile) => {\n\t\t\t\tdockerfile.addStep(DockerStep.run(key, layer, order + idx));\n\t\t\t});\n\t\t\treturn this;\n\t\t}\n\n\t\tthis._layerWriters.push(layer);\n\t\treturn this;\n\t}\n\n\tpublic addStep(step: DockerStep): this {\n\t\tthis._steps.set(step.key, step);\n\t\treturn this;\n\t}\n\n\tpublic removeStep(key: string): this {\n\t\tthis._steps.delete(key);\n\t\treturn this;\n\t}\n\n\tpublic entrypoint(value: string | readonly string[], order = StepOrder.entrypoint): this {\n\t\tthis.addStep(DockerStep.entrypoint(\"entrypoint\", value, order));\n\t\treturn this;\n\t}\n\n\tpublic addRunStep(cmd: string): this {\n\t\treturn this.addLayer(cmd);\n\t}\n\n\tpublic build(): string {\n\t\tfor (const layerWriter of this._layerWriters) {\n\t\t\tlayerWriter(this);\n\t\t}\n\n\t\tconst lines = [`FROM ${this._fromImage}`];\n\t\tconst sortedSteps = [...this._steps.values()].sort((left, right) => {\n\t\t\tif (left.order !== right.order) {\n\t\t\t\treturn left.order - right.order;\n\t\t\t}\n\t\t\treturn left.key.localeCompare(right.key, \"en\");\n\t\t});\n\n\t\tfor (const step of sortedSteps) {\n\t\t\tlines.push(\"\", step.content);\n\t\t}\n\n\t\treturn `${lines.join(\"\\n\")}\\n`;\n\t}\n\n\tprotected registerBaseLayers(): void {\n\t\t// Generic base model intentionally has no default layers.\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"./Dockerfile\",\n\t\t\t\tcontent: this.build(),\n\t\t\t},\n\t\t];\n\t}\n}\n\n/**\n * Shared layers for the published `ghcr.io/typesmiths/decohere/devcontainer` image.\n * Checked in at `projects/devcontainer/Dockerfile` — keep in sync via the unit test.\n */\nexport class AppDevContainerBaseImage extends DockerfileModel {\n\tprotected override registerBaseLayers(): void {\n\t\tsuper.registerBaseLayers();\n\t\tthis.addLayer(withCommandHistory())\n\t\t\t.addLayer(withNodeUser())\n\t\t\t.addLayer(withPnpm())\n\t\t\t.addLayer(withGithubCli())\n\t\t\t.addLayer(withWorkspaceNodeModulesOwnership())\n\t\t\t.addLayer(withVsCodeJsDebugBootloaderFix());\n\t}\n}\n\n/** Generic Dev Container image helpers (history + bootloader) without webapi defaults. */\nexport class DevContainerImageModel extends DockerfileModel {\n\tprotected override registerBaseLayers(): void {\n\t\tsuper.registerBaseLayers();\n\t\tthis.addLayer(withCommandHistory()).addLayer(withVsCodeJsDebugBootloaderFix());\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \".devcontainer/Dockerfile\",\n\t\t\t\tcontent: this.build(),\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["WELL_KNOWN_FILES","DockerStep","key","content","order","run","command","raw","entrypoint","value","JSON","stringify","StepOrder","base","features","user","VSCODE_BOOTLOADER_FIX_BASH_SNIPPET","commandHistory","volumeName","dir","fileName","histFile","withCommandHistory","options","historyDir","historyFileName","username","historyFile","dockerfile","addStep","withNodeUser","includeUserInstruction","withPnpm","version","usernameExpr","withPostgresqlClient","withGithubCli","withWorkspaceNodeModulesOwnership","workspaceDir","withVsCodeJsDebugBootloaderFix","bashrcPath","join","DockerfileModel","DOCKERFILE","_steps","Map","_layerWriters","_fromImage","_layerCounter","baseImage","registerBaseLayers","from","addLayer","layer","idx","push","step","set","removeStep","delete","addRunStep","cmd","build","layerWriter","lines","sortedSteps","values","sort","left","right","localeCompare","files","filePath","AppDevContainerBaseImage","DevContainerImageModel"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,aAAa;AAK9C,OAAO,MAAMC;;;;IACZ,YACC,AAAgBC,GAAW,EAC3B,AAAgBC,OAAe,EAC/B,AAAgBC,QAAQ,CAAC,CACxB;aAHeF,MAAAA;aACAC,UAAAA;aACAC,QAAAA;IACd;IAEH,OAAcC,IAAIH,GAAW,EAAEI,OAAe,EAAEF,QAAQ,CAAC,EAAE;QAC1D,OAAO,IAAIH,WAAWC,KAAK,CAAC,IAAI,EAAEI,SAAS,EAAEF;IAC9C;IAEA,OAAcG,IAAIL,GAAW,EAAEC,OAAe,EAAEC,QAAQ,CAAC,EAAE;QAC1D,OAAO,IAAIH,WAAWC,KAAKC,SAASC;IACrC;IAEA,OAAcI,WAAWN,GAAW,EAAEO,KAAiC,EAAEL,QAAQ,CAAC,EAAE;QACnF,MAAMD,UACL,OAAOM,UAAU,WACd,CAAC,WAAW,EAAEA,OAAO,GACrB,CAAC,WAAW,EAAEC,KAAKC,SAAS,CAACF,QAAQ;QACzC,OAAO,IAAIR,WAAWC,KAAKC,SAASC;IACrC;AACD;AAEA,MAAMQ,YAAY;IACjBC,MAAM;IACNC,UAAU;IACVC,MAAM;IACNP,YAAY;AACb;AAEA,MAAMQ,qCAAqC,CAAC;;;;;;;;;;;;;;;;EAgB1C,CAAC;AAEH,6EAA6E,GAC7E,OAAO,MAAMC,iBAAiB;IAC7BC,YAAY;IACZC,KAAK;IACLC,UAAU;IACVC,UAAU;AACX,EAAW;AAEX,OAAO,SAASC,mBAAmBC,OAKlC;IACA,MAAMC,aAAaD,SAASC,cAAcP,eAAeE,GAAG;IAC5D,MAAMM,kBAAkBF,SAASE,mBAAmBR,eAAeG,QAAQ;IAC3E,MAAMM,WAAWH,SAASG,YAAY;IACtC,MAAMtB,QAAQmB,SAASnB,SAASQ,UAAUC,IAAI;IAC9C,MAAMc,cAAc,GAAGH,WAAW,CAAC,EAAEC,iBAAiB;IAEtD,OAAO,CAACG;QACPA,WACEC,OAAO,CACP5B,WAAWI,GAAG,CACb,eACA,CAAC,SAAS,EAAEmB,WAAW,UAAU,EAAEG,YAAY,aAAa,EAAED,SAAS,CAAC,EAAEF,YAAY,EACtFpB,QAGDyB,OAAO,CAAC5B,WAAWM,GAAG,CAAC,eAAe,CAAC,aAAa,EAAEoB,aAAa,EAAEvB,QAAQ,IAC7EyB,OAAO,CACP5B,WAAWM,GAAG,CACb,kBACA,CAAC,mEAAmE,EAAEoB,YAAY,qCAAqC,EAAED,SAAS,SAAS,CAAC,EAC5ItB,QAAQ;IAGZ;AACD;AAEA,OAAO,SAAS0B,aAAaP,OAI5B;IACA,MAAMG,WAAWH,SAASG,YAAY;IACtC,MAAMK,yBAAyBR,SAASQ,0BAA0B;IAClE,MAAM3B,QAAQmB,SAASnB,SAASQ,UAAUE,QAAQ;IAElD,OAAO,CAACc;QACPA,WAAWC,OAAO,CAAC5B,WAAWM,GAAG,CAAC,gBAAgB,CAAC,aAAa,EAAEmB,UAAU,EAAEtB;QAE9E,IAAI2B,wBAAwB;YAC3BH,WAAWC,OAAO,CAAC5B,WAAWM,GAAG,CAAC,QAAQ,oBAAoBK,UAAUG,IAAI;QAC7E;IACD;AACD;AAEA,OAAO,SAASiB,SAAST,OAIxB;IACA,MAAMU,UAAUV,SAASU,WAAW;IACpC,MAAMC,eAAeX,SAASW,gBAAgB;IAC9C,MAAM9B,QAAQmB,SAASnB,SAASQ,UAAUE,QAAQ,GAAG;IAErD,OAAO,CAACc;QACPA,WACEC,OAAO,CACP5B,WAAWI,GAAG,CACb,gBACA,CAAC,yDAAyD,EAAE4B,SAAS,EACrE7B,QAGDyB,OAAO,CACP5B,WAAWI,GAAG,CACb,eACA,CAAC,eAAe,EAAE6B,aAAa,oBAAoB,EAAEA,aAAa,yBAAyB,EAAEA,aAAa,CAAC,EAAEA,aAAa,OAAO,EAAEA,aAAa,eAAe,EAAEA,aAAa,wCAAwC,EAAEA,aAAa,yBAAyB,EAAEA,aAAa,gBAAgB,CAAC,EAC9R9B,QAAQ;IAGZ;AACD;AAEA;;;CAGC,GACD,OAAO,SAAS+B,qBAAqBZ,OAGpC;IACA,MAAMnB,QAAQmB,SAASnB,SAASQ,UAAUE,QAAQ,GAAG;IACrD,MAAMY,WAAWH,SAASG,YAAY;IAEtC,OAAO,CAACE;QACPA,WACEC,OAAO,CAAC5B,WAAWM,GAAG,CAAC,0BAA0B,aAAaH,QAC9DyB,OAAO,CACP5B,WAAWI,GAAG,CACb,qBACA,iHACAD,QAAQ,IAGTyB,OAAO,CAAC5B,WAAWM,GAAG,CAAC,0BAA0B,CAAC,KAAK,EAAEmB,UAAU,EAAEtB,QAAQ;IAChF;AACD;AAEA,8DAA8D,GAC9D,OAAO,SAASgC,cAAcb,OAA4B;IACzD,MAAMnB,QAAQmB,SAASnB,SAASQ,UAAUE,QAAQ,GAAG;IAErD,OAAO,CAACc;QACPA,WAAWC,OAAO,CACjB5B,WAAWI,GAAG,CACb,cACA,kGACAD;IAGH;AACD;AAEA,OAAO,SAASiC,kCAAkCd,OAIjD;IACA,MAAMe,eAAef,SAASe,gBAAgB;IAC9C,MAAMJ,eAAeX,SAASW,gBAAgB;IAC9C,MAAM9B,QAAQmB,SAASnB,SAASQ,UAAUE,QAAQ,GAAG;IAErD,OAAO,CAACc;QACPA,WAAWC,OAAO,CACjB5B,WAAWM,GAAG,CACb,0BACA,CAAC,aAAa,EAAE+B,aAAa,uBAAuB,EAAEJ,aAAa,CAAC,EAAEA,aAAa,CAAC,EAAEI,aAAa,aAAa,CAAC,EACjHlC;IAGH;AACD;AAEA,OAAO,SAASmC,+BAA+BhB,OAG9C;IACA,MAAMiB,aAAajB,SAASiB,cAAc;IAC1C,MAAMpC,QAAQmB,SAASnB,SAASQ,UAAUE,QAAQ,GAAG;IAErD,OAAO,CAACc;QACPA,WAAWC,OAAO,CACjB5B,WAAWM,GAAG,CACb,yBACA;YACC;YACA;YACA;YACA;YACA;YACA,CAAC,oBAAoB,EAAEiC,WAAW,CAAC,CAAC;YACpCxB;YACA;SACA,CAACyB,IAAI,CAAC,OACPrC;IAGH;AACD;AAEA,OAAO,MAAMsC;IACIxC,MAAMF,iBAAiB2C,UAAU,CAAC;IACjCC,SAAS,IAAIC,MAA0B;IACvCC,gBAA+B,EAAE,CAAC;IAC3CC,WAAmB;IACnBC,gBAAgB,EAAE;IAE1B,YAAmBC,SAAiB,CAAE;QACrC,IAAI,CAACF,UAAU,GAAGE;QAClB,IAAI,CAACC,kBAAkB;IACxB;IAEOC,KAAKF,SAAiB,EAAQ;QACpC,IAAI,CAACF,UAAU,GAAGE;QAClB,OAAO,IAAI;IACZ;IAEOG,SAASC,KAA2B,EAAEjD,QAAQQ,UAAUE,QAAQ,EAAQ;QAC9E,IAAI,OAAOuC,UAAU,UAAU;YAC9B,MAAMC,MAAM,EAAE,IAAI,CAACN,aAAa;YAChC,MAAM9C,MAAM,CAAC,UAAU,EAAEoD,KAAK;YAC9B,IAAI,CAACR,aAAa,CAACS,IAAI,CAAC,CAAC3B;gBACxBA,WAAWC,OAAO,CAAC5B,WAAWI,GAAG,CAACH,KAAKmD,OAAOjD,QAAQkD;YACvD;YACA,OAAO,IAAI;QACZ;QAEA,IAAI,CAACR,aAAa,CAACS,IAAI,CAACF;QACxB,OAAO,IAAI;IACZ;IAEOxB,QAAQ2B,IAAgB,EAAQ;QACtC,IAAI,CAACZ,MAAM,CAACa,GAAG,CAACD,KAAKtD,GAAG,EAAEsD;QAC1B,OAAO,IAAI;IACZ;IAEOE,WAAWxD,GAAW,EAAQ;QACpC,IAAI,CAAC0C,MAAM,CAACe,MAAM,CAACzD;QACnB,OAAO,IAAI;IACZ;IAEOM,WAAWC,KAAiC,EAAEL,QAAQQ,UAAUJ,UAAU,EAAQ;QACxF,IAAI,CAACqB,OAAO,CAAC5B,WAAWO,UAAU,CAAC,cAAcC,OAAOL;QACxD,OAAO,IAAI;IACZ;IAEOwD,WAAWC,GAAW,EAAQ;QACpC,OAAO,IAAI,CAACT,QAAQ,CAACS;IACtB;IAEOC,QAAgB;QACtB,KAAK,MAAMC,eAAe,IAAI,CAACjB,aAAa,CAAE;YAC7CiB,YAAY,IAAI;QACjB;QAEA,MAAMC,QAAQ;YAAC,CAAC,KAAK,EAAE,IAAI,CAACjB,UAAU,EAAE;SAAC;QACzC,MAAMkB,cAAc;eAAI,IAAI,CAACrB,MAAM,CAACsB,MAAM;SAAG,CAACC,IAAI,CAAC,CAACC,MAAMC;YACzD,IAAID,KAAKhE,KAAK,KAAKiE,MAAMjE,KAAK,EAAE;gBAC/B,OAAOgE,KAAKhE,KAAK,GAAGiE,MAAMjE,KAAK;YAChC;YACA,OAAOgE,KAAKlE,GAAG,CAACoE,aAAa,CAACD,MAAMnE,GAAG,EAAE;QAC1C;QAEA,KAAK,MAAMsD,QAAQS,YAAa;YAC/BD,MAAMT,IAAI,CAAC,IAAIC,KAAKrD,OAAO;QAC5B;QAEA,OAAO,GAAG6D,MAAMvB,IAAI,CAAC,MAAM,EAAE,CAAC;IAC/B;IAEUS,qBAA2B;IACpC,0DAA0D;IAC3D;IAEOqB,QAAsB;QAC5B,OAAO;YACN;gBACCC,UAAU;gBACVrE,SAAS,IAAI,CAAC2D,KAAK;YACpB;SACA;IACF;AACD;AAEA;;;CAGC,GACD,OAAO,MAAMW,iCAAiC/B;IAC1BQ,qBAA2B;QAC7C,KAAK,CAACA;QACN,IAAI,CAACE,QAAQ,CAAC9B,sBACZ8B,QAAQ,CAACtB,gBACTsB,QAAQ,CAACpB,YACToB,QAAQ,CAAChB,iBACTgB,QAAQ,CAACf,qCACTe,QAAQ,CAACb;IACZ;AACD;AAEA,wFAAwF,GACxF,OAAO,MAAMmC,+BAA+BhC;IACxBQ,qBAA2B;QAC7C,KAAK,CAACA;QACN,IAAI,CAACE,QAAQ,CAAC9B,sBAAsB8B,QAAQ,CAACb;IAC9C;IAEOgC,QAAsB;QAC5B,OAAO;YACN;gBACCC,UAAU;gBACVrE,SAAS,IAAI,CAAC2D,KAAK;YACpB;SACA;IACF;AACD"}

package/es6/src/models/env-file.model.js

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { WELL_KNOWN_FILES } from "./const.js";
+/**
+ * Accumulates key=value pairs and renders them as a `.env` file.
+ *
+ * Register once in the workspace; features call `addEntry` during their
+ * scaffold phase to contribute environment variables. The final file is
+ * written at render time when `workspace.scaffold()` is called.
+ */ export class EnvFile {
+    key = WELL_KNOWN_FILES.ENV_FILE;
+    _entries = new Map();
+    addEntry(key, value) {
+        this._entries.set(key, value);
+        return this;
+    }
+    hasEntry(key) {
+        return this._entries.has(key);
+    }
+    static fromFile(absolutePath) {
+        const env = new EnvFile();
+        const raw = readFileSync(absolutePath, "utf8");
+        for (const line of raw.split("\n")){
+            const trimmed = line.trim();
+            if (trimmed === "" || trimmed.startsWith("#")) continue;
+            const eq = line.indexOf("=");
+            if (eq <= 0) continue;
+            env.addEntry(line.slice(0, eq).trim(), line.slice(eq + 1));
+        }
+        return env;
+    }
+    files() {
+        if (this._entries.size === 0) return [];
+        const body = [
+            ...this._entries.entries()
+        ].map(([k, v])=>`${k}=${v}`).join("\n");
+        const content = `${body}\n`;
+        return [
+            {
+                filePath: ".env",
+                content
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class Gitignore {
+    key = WELL_KNOWN_FILES.GITIGNORE;
+    ignoreList = [
+        "node_modules",
+        "dist",
+        ".pnpm-store",
+        ".env",
+        ".devcontainer/gh.env",
+        ".cursor/codebase-rag.env",
+        ".cursor/mcp.json",
+        ".DS_Store",
+        "logs"
+    ];
+    add(...patterns) {
+        for (const pattern of patterns){
+            if (!this.ignoreList.includes(pattern)) {
+                this.ignoreList.push(pattern);
+            }
+        }
+        return this;
+    }
+    files() {
+        return [
+            {
+                filePath: ".gitignore",
+                content: `${this.ignoreList.join("\n")}\n`
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class LaunchJson {
+    apiNames;
+    key = WELL_KNOWN_FILES.LAUNCH_JSON;
+    constructor(apiNames = [
+        "api"
+    ]){
+        this.apiNames = apiNames;
+    }
+    files() {
+        const configurations = [
+            {
+                name: "Build",
+                type: "node",
+                request: "launch",
+                runtimeExecutable: "pnpm",
+                runtimeArgs: [
+                    "build"
+                ],
+                console: "integratedTerminal",
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+                cwd: "${workspaceFolder}"
+            }
+        ];
+        const first = this.apiNames[0] ?? "api";
+        const defaultDevArgs = first === "api" && this.apiNames.length === 1 ? [
+            "dev"
+        ] : [
+            "run",
+            `dev:${first}`
+        ];
+        configurations.push(serveConfig("Serve / Dev", defaultDevArgs));
+        for (const apiName of this.apiNames){
+            if (apiName === first && this.apiNames.length === 1 && apiName === "api") continue;
+            configurations.push(serveConfig(`Serve / Dev (${apiName})`, [
+                "run",
+                `dev:${apiName}`
+            ]));
+        }
+        return [
+            {
+                filePath: ".vscode/launch.json",
+                content: JSON.stringify({
+                    version: "0.2.0",
+                    configurations
+                }, null, 2)
+            }
+        ];
+    }
+}
+function serveConfig(name, runtimeArgs) {
+    return {
+        name,
+        type: "node",
+        request: "launch",
+        runtimeExecutable: "pnpm",
+        runtimeArgs,
+        console: "integratedTerminal",
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+        cwd: "${workspaceFolder}"
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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