@decohere/forge 0.0.1-dev.20 → 0.0.1-dev.20261105.54

package/commonjs/src/actions/docker.action.js

@@ -10,12 +10,13 @@ Object.defineProperty(exports, "Docker", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _decorators = require("@decohere/crucible/decorators");
-const _mesh = require("@decohere/mesh");
-const _cli = require("@decohere/nexus/cli");
-const _interop = require("@decohere/nexus/interop");
-const _io = require("@decohere/nexus/io");
+const _workspace = require("@decohere/workspace");
+const _cli = require("@decohere/devkit/cli");
+const _interop = require("@decohere/devkit/interop");
+const _io = require("@decohere/core/io");
 const _scribe = require("@decohere/scribe");
 const _errors = require("../errors.js");
+const _deployable = require("../packaging/deployable.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -41,10 +42,12 @@ class Docker {
     async run(options) {
         const projects = await this.getDockerProjects(this.workspace.getProjects(options.configuration));
         if (projects.length === 0) {
-            throw new _errors.ForgeError(`No projects found with a Dockerfile`);
+            this.#logger.info("No projects found with a Dockerfile — nothing to dockerize");
+            return _cli.ActionResponse.Success(Docker.name, []);
         }
+        const workspacePackageJson = await this.workspace.getPackageJson();
         const version = await this.workspace.getVersion();
-        const responses = await Promise.all(projects.map(async (project)=>await this.buildProject(project, version, options)));
+        const responses = await Promise.all(projects.map(async (project)=>await this.buildProject(project, workspacePackageJson, version, options)));
         const failed = responses.filter((response)=>!response.succeeded);
         if (failed.length > 0) {
             return _cli.ActionResponse.Error(Docker.name, responses);
@@ -54,60 +57,76 @@ class Docker {
     async getDockerProjects(projects) {
         const result = [];
         for (const project of projects){
-            const dockerfile = project.dockerConfig?.dockerfile ?? "Dockerfile";
-            const dockerfilePath = _nodepath.default.join(project.projectRoot, dockerfile);
-            if (!await _io.io.fileExists(dockerfilePath)) {
-                this.#logger.info(`Skipping ${project.name}: missing ${dockerfile}`);
+            if (!await _deployable.deployable.isDeployable(project)) {
+                this.#logger.info(`Skipping ${project.name}: missing ${_deployable.deployable.dockerfileName(project)}`);
                 continue;
             }
             result.push(project);
         }
         return result;
     }
-    async buildProject(project, version, options) {
+    /**
+	 * A Dockerfile that copies `.package/` needs `forge package` to have run. Fail before the
+	 * build with that instruction rather than with Docker's "not found" from deep in a layer.
+	 */ async assertPackaged(project) {
+        const dockerfile = await _io.io.readFile(_deployable.deployable.dockerfilePath(project)).catch(()=>"");
+        if (!dockerfile.includes(_deployable.PACKAGE_DIR)) {
+            return;
+        }
+        const packaged = _nodepath.default.join(project.projectRoot, _deployable.PACKAGE_DIR, "package.json");
+        if (!await _io.io.fileExists(packaged)) {
+            throw new _errors.ForgeError(`${project.name}: its Dockerfile copies ${_deployable.PACKAGE_DIR}/, which does not exist. ` + `Run \`forge build --configuration release\` and \`forge package ${project.name}\` first.`);
+        }
+    }
+    async buildProject(project, workspacePackageJson, version, options) {
         const dockerConfig = project.dockerConfig ?? {};
         const envBuildArgs = this.parseJsonEnv("FORGE_DOCKER_BUILD_ARGS_JSON", {});
         const envSecrets = this.parseJsonEnv("FORGE_DOCKER_SECRETS_JSON", {});
         const envTags = this.parseJsonEnv("FORGE_DOCKER_EXTRA_TAGS_JSON", []);
-        const image = dockerConfig.image ?? this.defaultImageName(project.name);
+        const image = dockerConfig.image ?? this.defaultImageName(project.name, workspacePackageJson);
         const dockerfile = dockerConfig.dockerfile ?? "Dockerfile";
-        const tags = [
-            `${image}:${version}`,
+        const extraTags = this.extraTagsForImage(image, [
             ...dockerConfig.tags ?? [],
             ...envTags
+        ]);
+        const tags = [
+            `${image}:${version}`,
+            ...extraTags
         ];
         const buildArgs = this.interpolateBuildArgs({
-            ...dockerConfig.buildArgs ?? {},
+            ...dockerConfig.buildArgs,
             ...envBuildArgs
         }, version);
         const secrets = {
-            ...dockerConfig.secrets ?? {},
+            ...dockerConfig.secrets,
             ...envSecrets
         };
         this.#logger.info(`${options.dryRun ? "[dry-run] " : ""}Building ${project.name}`);
         try {
-            if (!options.dryRun) {
-                await this.docker.build(project.projectRoot, {
-                    cwd: project.projectRoot,
-                    dockerfile: _nodepath.default.join(project.projectRoot, dockerfile),
-                    tags,
-                    buildArgs,
-                    secrets
-                });
-                if (options.push || dockerConfig.push) {
-                    for (const tag of tags){
-                        await this.docker.push(tag, {
-                            cwd: project.projectRoot
-                        });
-                    }
+            await this.assertPackaged(project);
+            await this.docker.build(project.projectRoot, {
+                cwd: project.projectRoot,
+                dockerfile: _nodepath.default.join(project.projectRoot, dockerfile),
+                tags,
+                buildArgs,
+                secrets
+            });
+            const shouldPush = options.push || dockerConfig.push;
+            if (shouldPush && !options.dryRun) {
+                for (const tag of tags){
+                    await this.docker.push(tag, {
+                        cwd: project.projectRoot
+                    });
                 }
+            } else if (shouldPush && options.dryRun) {
+                this.#logger.info(`[dry-run] Skipping push for ${project.name}`);
             }
             return {
                 projectName: project.name,
                 image,
                 tags,
                 succeeded: true,
-                message: options.dryRun ? "Dry run" : `Built ${image}`
+                message: options.dryRun ? `Built ${image} (not pushed)` : `Built ${image}`
             };
         } catch (reason) {
             const message = (0, _errors.formatUnknownError)(reason);
@@ -129,8 +148,30 @@ class Docker {
         }
         return result;
     }
-    defaultImageName(projectName) {
-        return `${this.#defaultRegistry}/${this.normalizeDockerRepository(projectName)}`;
+    /**
+	 * Keep FORGE_DOCKER_EXTRA_TAGS_JSON scoped to this image so multi-image
+	 * publishes do not stamp create:latest onto the app Dev Container (and vice versa).
+	 */ extraTagsForImage(image, tags) {
+        const prefix = `${image}:`;
+        const seen = new Set();
+        const result = [];
+        for (const tag of tags){
+            if (tag === image || tag.startsWith(prefix)) {
+                if (!seen.has(tag)) {
+                    seen.add(tag);
+                    result.push(tag);
+                }
+            }
+        }
+        return result;
+    }
+    defaultImageName(projectName, workspacePackageJson) {
+        const repositoryPath = process.env.FORGE_DOCKER_NAMESPACE?.trim() || workspacePackageJson.getRepositoryFullName() || this.normalizeDockerRepository(projectName);
+        const projectSlug = this.normalizeProjectSlug(projectName);
+        if (repositoryPath.includes("/") && projectSlug !== "") {
+            return `${this.#defaultRegistry}/${repositoryPath}/${projectSlug}`;
+        }
+        return `${this.#defaultRegistry}/${repositoryPath}`;
     }
     normalizeDockerRepository(name) {
         const repository = name.replace(/^@/, "").split("/").map((segment)=>segment.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")).filter(Boolean).join("/");
@@ -139,6 +180,14 @@ class Docker {
         }
         return repository;
     }
+    normalizeProjectSlug(name) {
+        const unscoped = name.includes("/") ? name.split("/").at(-1) ?? name : name;
+        const slug = unscoped.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        if (slug === "") {
+            throw new _errors.ForgeError(`Could not derive a Docker project slug from project name "${name}"`);
+        }
+        return slug;
+    }
     parseJsonEnv(name, fallback) {
         const value = process.env[name];
         if (value == null || value.trim() === "") {
@@ -155,8 +204,6 @@ Docker = _ts_decorate([
     (0, _decorators.injectable)(),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+        typeof _workspace.Workspace === "undefined" ? Object : _workspace.Workspace
     ])
 ], Docker);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/docker.action.ts"],"sourcesContent":["import path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action, ResultStatus } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Docker as DockerInterop } from \"@decohere/nexus/interop\";\nimport { io } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type DockerOptions = {\n\tconfiguration: string;\n\tdryRun?: boolean;\n\tpush?: boolean;\n};\n\nexport type DockerResponse = ResultStatus & {\n\tprojectName: string;\n\timage: string;\n\ttags: string[];\n\tmessage: string;\n};\n\n@injectable()\nexport class Docker implements Action<DockerOptions> {\n\t#logger = scribe.logger(Docker.name);\n\tprivate readonly docker = new DockerInterop();\n\treadonly #defaultRegistry = process.env.FORGE_DOCKER_REGISTRY?.trim() || \"ghcr.io\";\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic async run(options: DockerOptions): Promise<ActionResponse<DockerResponse>> {\n\t\tconst projects = await this.getDockerProjects(\n\t\t\tthis.workspace.getProjects(options.configuration),\n\t\t);\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found with a Dockerfile`);\n\t\t}\n\n\t\tconst version = await this.workspace.getVersion();\n\t\tconst responses = await Promise.all(\n\t\t\tprojects.map(async (project) => await this.buildProject(project, version, options)),\n\t\t);\n\t\tconst failed = responses.filter((response) => !response.succeeded);\n\t\tif (failed.length > 0) {\n\t\t\treturn ActionResponse.Error(Docker.name, responses);\n\t\t}\n\t\treturn ActionResponse.Success(Docker.name, responses);\n\t}\n\n\tprivate async getDockerProjects(projects: readonly Project[]) {\n\t\tconst result: Project[] = [];\n\t\tfor (const project of projects) {\n\t\t\tconst dockerfile = project.dockerConfig?.dockerfile ?? \"Dockerfile\";\n\t\t\tconst dockerfilePath = path.join(project.projectRoot, dockerfile);\n\t\t\tif (!(await io.fileExists(dockerfilePath))) {\n\t\t\t\tthis.#logger.info(`Skipping ${project.name}: missing ${dockerfile}`);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tresult.push(project);\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate async buildProject(\n\t\tproject: Project,\n\t\tversion: string,\n\t\toptions: DockerOptions,\n\t): Promise<DockerResponse> {\n\t\tconst dockerConfig = project.dockerConfig ?? {};\n\t\tconst envBuildArgs = this.parseJsonEnv<Record<string, string>>(\n\t\t\t\"FORGE_DOCKER_BUILD_ARGS_JSON\",\n\t\t\t{},\n\t\t);\n\t\tconst envSecrets = this.parseJsonEnv<Record<string, string>>(\n\t\t\t\"FORGE_DOCKER_SECRETS_JSON\",\n\t\t\t{},\n\t\t);\n\t\tconst envTags = this.parseJsonEnv<string[]>(\"FORGE_DOCKER_EXTRA_TAGS_JSON\", []);\n\n\t\tconst image = dockerConfig.image ?? this.defaultImageName(project.name);\n\t\tconst dockerfile = dockerConfig.dockerfile ?? \"Dockerfile\";\n\t\tconst tags = [`${image}:${version}`, ...(dockerConfig.tags ?? []), ...envTags];\n\t\tconst buildArgs = this.interpolateBuildArgs(\n\t\t\t{ ...(dockerConfig.buildArgs ?? {}), ...envBuildArgs },\n\t\t\tversion,\n\t\t);\n\t\tconst secrets = { ...(dockerConfig.secrets ?? {}), ...envSecrets };\n\n\t\tthis.#logger.info(`${options.dryRun ? \"[dry-run] \" : \"\"}Building ${project.name}`);\n\t\ttry {\n\t\t\tif (!options.dryRun) {\n\t\t\t\tawait this.docker.build(project.projectRoot, {\n\t\t\t\t\tcwd: project.projectRoot,\n\t\t\t\t\tdockerfile: path.join(project.projectRoot, dockerfile),\n\t\t\t\t\ttags,\n\t\t\t\t\tbuildArgs,\n\t\t\t\t\tsecrets,\n\t\t\t\t});\n\n\t\t\t\tif (options.push || dockerConfig.push) {\n\t\t\t\t\tfor (const tag of tags) {\n\t\t\t\t\t\tawait this.docker.push(tag, { cwd: project.projectRoot });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\timage,\n\t\t\t\ttags,\n\t\t\t\tsucceeded: true,\n\t\t\t\tmessage: options.dryRun ? \"Dry run\" : `Built ${image}`,\n\t\t\t};\n\t\t} catch (reason) {\n\t\t\tconst message = formatUnknownError(reason);\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\timage,\n\t\t\t\ttags,\n\t\t\t\tsucceeded: false,\n\t\t\t\tmessage,\n\t\t\t\terror: `${project.name}: ${message}`,\n\t\t\t};\n\t\t}\n\t}\n\n\tprivate interpolateBuildArgs(\n\t\tbuildArgs: Record<string, string> | undefined,\n\t\tversion: string,\n\t) {\n\t\tconst result: Record<string, string> = {};\n\t\tconst versionPlaceholder = \"$\" + \"{version}\";\n\t\tfor (const [key, value] of Object.entries(buildArgs ?? {})) {\n\t\t\tresult[key] = value.split(versionPlaceholder).join(version);\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate defaultImageName(projectName: string) {\n\t\treturn `${this.#defaultRegistry}/${this.normalizeDockerRepository(projectName)}`;\n\t}\n\n\tprivate normalizeDockerRepository(name: string) {\n\t\tconst repository = name\n\t\t\t.replace(/^@/, \"\")\n\t\t\t.split(\"/\")\n\t\t\t.map((segment) =>\n\t\t\t\tsegment\n\t\t\t\t\t.toLowerCase()\n\t\t\t\t\t.replace(/[^a-z0-9]+/g, \"-\")\n\t\t\t\t\t.replace(/^-+|-+$/g, \"\"),\n\t\t\t)\n\t\t\t.filter(Boolean)\n\t\t\t.join(\"/\");\n\n\t\tif (repository === \"\") {\n\t\t\tthrow new ForgeError(`Could not derive a Docker repository from project name \"${name}\"`);\n\t\t}\n\n\t\treturn repository;\n\t}\n\n\tprivate parseJsonEnv<T>(name: string, fallback: T): T {\n\t\tconst value = process.env[name];\n\t\tif (value == null || value.trim() === \"\") {\n\t\t\treturn fallback;\n\t\t}\n\n\t\ttry {\n\t\t\treturn JSON.parse(value) as T;\n\t\t} catch (reason) {\n\t\t\tthrow new ForgeError(`Invalid JSON in ${name}: ${formatUnknownError(reason)}`);\n\t\t}\n\t}\n}\n"],"names":["Docker","scribe","logger","name","docker","DockerInterop","process","env","FORGE_DOCKER_REGISTRY","trim","workspace","run","options","projects","getDockerProjects","getProjects","configuration","length","ForgeError","version","getVersion","responses","Promise","all","map","project","buildProject","failed","filter","response","succeeded","ActionResponse","Error","Success","result","dockerfile","dockerConfig","dockerfilePath","path","join","projectRoot","io","fileExists","info","push","envBuildArgs","parseJsonEnv","envSecrets","envTags","image","defaultImageName","tags","buildArgs","interpolateBuildArgs","secrets","dryRun","build","cwd","tag","projectName","message","reason","formatUnknownError","error","versionPlaceholder","key","value","Object","entries","split","normalizeDockerRepository","repository","replace","segment","toLowerCase","Boolean","fallback","JSON","parse"],"mappings":"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"}

package/commonjs/src/actions/index.js

@@ -10,9 +10,12 @@ _export_star(require("./dependency-report.action.js"), exports);
 _export_star(require("./dependency-sync.action.js"), exports);
 _export_star(require("./docker.action.js"), exports);
 _export_star(require("./link.action.js"), exports);
+_export_star(require("./package.action.js"), exports);
+_export_star(require("./paths.action.js"), exports);
 _export_star(require("./publish.action.js"), exports);
 _export_star(require("./sync-lock-file.action.js"), exports);
 _export_star(require("./tag.action.js"), exports);
+_export_star(require("./typecheck.action.js"), exports);
 _export_star(require("./unlink.action.js"), exports);
 _export_star(require("./version.action.js"), exports);
 _export_star(require("./watch.action.js"), exports);
@@ -29,5 +32,3 @@ function _export_star(from, to) {
     });
     return from;
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9hY3Rpb25zL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2J1aWxkLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xlYW4uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21taXQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3B5LmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVwZW5kZW5jeS1yZXBvcnQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXN5bmMuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kb2NrZXIuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saW5rLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHVibGlzaC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N5bmMtbG9jay1maWxlLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGFnLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdW5saW5rLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmVyc2lvbi5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3dhdGNoLmFjdGlvbi5qc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWM7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0EifQ==

package/commonjs/src/actions/link.action.js

@@ -22,8 +22,8 @@ _export(exports, {
 const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _decorators = require("@decohere/crucible/decorators");
-const _mesh = require("@decohere/mesh");
-const _cli = require("@decohere/nexus/cli");
+const _workspace = require("@decohere/workspace");
+const _cli = require("@decohere/devkit/cli");
 const _scribe = require("@decohere/scribe");
 require("../extensions/project.extensions.js");
 const _errors = require("../errors.js");
@@ -149,8 +149,6 @@ Link = _ts_decorate([
     (0, _decorators.injectable)(),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+        typeof _workspace.Workspace === "undefined" ? Object : _workspace.Workspace
     ])
 ], Link);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/link.action.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { scribe } from \"@decohere/scribe\";\nimport \"../extensions/project.extensions.js\";\nimport { ForgeError } from \"../errors.js\";\n\nexport const LINK_MANIFEST = \".forge-link.json\";\n\nexport type LinkOptions = {\n\tconfiguration: string;\n\ttargetDir: string;\n};\n\nexport const DEFAULT_LINK_CONFIGURATION = \"link\";\n\nexport type LinkManifest = {\n\tworkspaceRoot: string;\n\tpeerNodeModulesDir?: string;\n\tlinks: Array<{ packageName: string; symlinkPath: string; originalPath: string | null }>;\n};\n\n@injectable()\nexport class Link implements Action<LinkOptions> {\n\t#logger = scribe.logger(Link.name);\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic run = async (options: LinkOptions): Promise<ActionResponse> => {\n\t\tconst targetDir = path.resolve(options.targetDir);\n\t\tconst nodeModulesDir = path.join(targetDir, \"node_modules\");\n\n\t\tconst stat = await fs.stat(nodeModulesDir).catch(() => null);\n\t\tif (stat == null) {\n\t\t\tthrow new ForgeError(\n\t\t\t\t`node_modules not found in \"${targetDir}\". Run pnpm install first.`,\n\t\t\t);\n\t\t}\n\n\t\tconst projects = this.workspace.getProjects(options.configuration);\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found for configuration \"${options.configuration}\"`);\n\t\t}\n\n\t\t// Load any existing manifest so originalPath values are preserved on re-link\n\t\tconst manifestPath = path.join(targetDir, LINK_MANIFEST);\n\t\tconst existingManifestText = await fs.readFile(manifestPath, \"utf8\").catch(() => null);\n\t\tconst existingManifest: LinkManifest | null =\n\t\t\texistingManifestText != null ? JSON.parse(existingManifestText) : null;\n\n\t\tconst manifest: LinkManifest = {\n\t\t\tworkspaceRoot: this.workspace.rootDir,\n\t\t\tlinks: [],\n\t\t};\n\n\t\tfor (const project of projects) {\n\t\t\tconst pkg = await project.getPackageJson();\n\t\t\tconst packageName = pkg.name;\n\t\t\tif (!packageName) {\n\t\t\t\tthis.#logger.trace(`Skipping project \"${project.name}\" — no package name`);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Resolve the build output directory (no target arg — debug config is not packed)\n\t\t\tconst outDir = project.getOutDir();\n\t\t\tconst absoluteOutDir = path.resolve(outDir);\n\n\t\t\t// Pre-create the output dir so the symlink is valid even before a build completes.\n\t\t\tawait fs.mkdir(absoluteOutDir, { recursive: true });\n\n\t\t\t// Compute symlink path inside target node_modules\n\t\t\tconst symlinkPath = path.join(nodeModulesDir, ...packageName.split(\"/\"));\n\t\t\tconst symlinkParent = path.dirname(symlinkPath);\n\n\t\t\t// Capture any existing entry so we can restore it on unlink.\n\t\t\t// If a manifest already exists for this package, preserve its originalPath —\n\t\t\t// the current symlink is our own and must not be treated as the original.\n\t\t\tlet originalPath: string | null = null;\n\t\t\tconst existingStat = await fs.lstat(symlinkPath).catch(() => null);\n\t\t\tif (existingStat != null) {\n\t\t\t\tconst existingEntry = existingManifest?.links.find(\n\t\t\t\t\t(l) => l.packageName === packageName,\n\t\t\t\t);\n\t\t\t\tif (existingEntry != null) {\n\t\t\t\t\t// Already linked — preserve the recorded originalPath and replace the symlink\n\t\t\t\t\toriginalPath = existingEntry.originalPath;\n\t\t\t\t\tif (existingStat.isSymbolicLink()) {\n\t\t\t\t\t\tawait fs.unlink(symlinkPath);\n\t\t\t\t\t}\n\t\t\t\t} else if (existingStat.isSymbolicLink()) {\n\t\t\t\t\toriginalPath = await fs.readlink(symlinkPath);\n\t\t\t\t\tawait fs.unlink(symlinkPath);\n\t\t\t\t} else {\n\t\t\t\t\t// Real directory — back it up by renaming\n\t\t\t\t\toriginalPath = `${symlinkPath}.__forge_backup__`;\n\t\t\t\t\tawait fs.rename(symlinkPath, originalPath);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tawait fs.mkdir(symlinkParent, { recursive: true });\n\t\t\tawait fs.symlink(absoluteOutDir, symlinkPath, \"dir\");\n\n\t\t\tmanifest.links.push({ packageName, symlinkPath, originalPath });\n\t\t\tthis.#logger.info(`Linked ${packageName} → ${absoluteOutDir}`);\n\t\t}\n\n\t\t// Create a peer node_modules at the build output root so Node can resolve\n\t\t// bare specifiers from the real (non-symlink) paths of linked packages.\n\t\tif (manifest.links.length > 0) {\n\t\t\tconst buildRoot = path.resolve(projects[0].getRootOut());\n\t\t\tconst peerNodeModulesDir = path.join(buildRoot, \"node_modules\");\n\t\t\tawait fs.rm(peerNodeModulesDir, { recursive: true, force: true });\n\t\t\tfor (const project of projects) {\n\t\t\t\tconst pkg = await project.getPackageJson();\n\t\t\t\tif (!pkg.name) continue;\n\t\t\t\tconst outDir = path.resolve(project.getOutDir());\n\t\t\t\tconst peerSymlink = path.join(peerNodeModulesDir, ...pkg.name.split(\"/\"));\n\t\t\t\tawait fs.mkdir(path.dirname(peerSymlink), { recursive: true });\n\t\t\t\tawait fs.symlink(outDir, peerSymlink, \"dir\");\n\t\t\t\tthis.#logger.trace(`Peer-linked ${pkg.name} → ${outDir}`);\n\t\t\t}\n\t\t\tmanifest.peerNodeModulesDir = peerNodeModulesDir;\n\t\t\tthis.#logger.info(`Created peer node_modules at ${peerNodeModulesDir}`);\n\t\t}\n\n\t\tawait fs.writeFile(path.join(targetDir, LINK_MANIFEST), JSON.stringify(manifest, null, 2));\n\n\t\treturn ActionResponse.Success(Link.name);\n\t};\n}\n"],"names":["DEFAULT_LINK_CONFIGURATION","LINK_MANIFEST","Link","scribe","logger","name","workspace","run","options","targetDir","path","resolve","nodeModulesDir","join","stat","fs","catch","ForgeError","projects","getProjects","configuration","length","manifestPath","existingManifestText","readFile","existingManifest","JSON","parse","manifest","workspaceRoot","rootDir","links","project","pkg","getPackageJson","packageName","trace","outDir","getOutDir","absoluteOutDir","mkdir","recursive","symlinkPath","split","symlinkParent","dirname","originalPath","existingStat","lstat","existingEntry","find","l","isSymbolicLink","unlink","readlink","rename","symlink","push","info","buildRoot","getRootOut","peerNodeModulesDir","rm","force","peerSymlink","writeFile","stringify","ActionResponse","Success"],"mappings":"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"}

package/commonjs/src/actions/package.action.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PackageDeployable", {
+    enumerable: true,
+    get: function() {
+        return PackageDeployable;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _workspace = require("@decohere/workspace");
+const _cli = require("@decohere/devkit/cli");
+const _interop = require("@decohere/devkit/interop");
+const _io = require("@decohere/core/io");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+const _dependencypinnerservice = require("../packaging/dependency-pinner.service.js");
+const _deployable = require("../packaging/deployable.js");
+const _importgraphservice = require("../packaging/import-graph.service.js");
+const _releaseexports = require("../packaging/release-exports.js");
+const _uiassets = require("../packaging/ui-assets.js");
+const _workspaceconfig = require("../workspace.config.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class PackageDeployable {
+    workspace;
+    importGraph;
+    pinner;
+    #logger = _scribe.scribe.logger(PackageDeployable.name);
+    npm = new _interop.Npm();
+    constructor(workspace, importGraph, pinner){
+        this.workspace = workspace;
+        this.importGraph = importGraph;
+        this.pinner = pinner;
+    }
+    async run(options) {
+        const projects = this.workspace.getProjects(_workspaceconfig.Release.name);
+        const selected = await this.select(projects, options.project);
+        if (typeof selected === "string") {
+            return _cli.ActionResponse.Error(PackageDeployable.name, selected);
+        }
+        if (selected.length === 0) {
+            this.#logger.info("No projects found with a Dockerfile — nothing to package");
+            return _cli.ActionResponse.Success(PackageDeployable.name, []);
+        }
+        const releaseProjects = await this.releaseProjects(projects);
+        const responses = [];
+        for (const project of selected){
+            responses.push(await this.packageProject(project, releaseProjects, projects));
+        }
+        return responses.some((response)=>!response.succeeded) ? _cli.ActionResponse.Error(PackageDeployable.name, responses) : _cli.ActionResponse.Success(PackageDeployable.name, responses);
+    }
+    /** The deployables to package, or the reason a named project cannot be one. */ async select(projects, requested) {
+        if (requested == null || requested === "") {
+            const found = [];
+            for (const project of projects){
+                if (await _deployable.deployable.isDeployable(project)) {
+                    found.push(project);
+                }
+            }
+            return found;
+        }
+        const project = projects.find((candidate)=>candidate.name === requested);
+        if (project == null) {
+            return `${requested} is not a workspace project. Known projects: ${projects.map((p)=>p.name).join(", ")}`;
+        }
+        if (!await _deployable.deployable.isDeployable(project)) {
+            return `${requested} has no ${_deployable.deployable.dockerfileName(project)}, so it is a library, not a deployable. ` + "Libraries are packaged into the deployables that import them.";
+        }
+        return [
+            project
+        ];
+    }
+    async releaseProjects(projects) {
+        const entries = await Promise.all(projects.map(async (project)=>{
+            const pkg = await project.getPackageJson();
+            return [
+                project.name,
+                {
+                    name: project.name,
+                    pkg,
+                    projectRoot: _nodepath.default.resolve(project.projectRoot),
+                    releaseDir: _nodepath.default.resolve(project.getOutDir())
+                }
+            ];
+        }));
+        return new Map(entries);
+    }
+    async packageProject(project, releaseProjects, projects) {
+        const outDir = _nodepath.default.join(_nodepath.default.resolve(project.projectRoot), _deployable.PACKAGE_DIR);
+        const base = {
+            projectName: project.name,
+            outDir,
+            workspacePackages: [],
+            dependencies: {}
+        };
+        try {
+            const entry = releaseProjects.get(project.name);
+            if (!await _io.io.directoryExists(_nodepath.default.join(entry.releaseDir, "es6"))) {
+                throw new _errors.ForgeError(`No release build for ${project.name}. Run \`forge build --configuration release\` first.`);
+            }
+            const ui = await _uiassets.uiAssets.resolve(project, projects);
+            const reached = await this.importGraph.walk(entry, releaseProjects);
+            const libraries = [
+                ...reached.workspace
+            ].filter((name)=>name !== project.name).sort().map((name)=>releaseProjects.get(name));
+            const dependencies = await this.pinner.pin(reached.thirdParty, [
+                entry,
+                ...libraries
+            ], releaseProjects, {
+                dir: _nodepath.default.resolve(this.workspace.rootDir),
+                pkg: await this.workspace.getPackageJson()
+            });
+            await this.write(entry, libraries, dependencies, outDir, ui);
+            const workspacePackages = [
+                ...reached.workspace
+            ].sort();
+            this.#logger.info(`Packaged ${project.name} to ${outDir}`, {
+                workspace: workspacePackages,
+                thirdParty: Object.keys(dependencies)
+            });
+            return {
+                projectName: project.name,
+                outDir,
+                workspacePackages,
+                dependencies,
+                succeeded: true,
+                message: `Packaged ${project.name} to ${outDir}`
+            };
+        } catch (reason) {
+            const message = (0, _errors.formatUnknownError)(reason);
+            return {
+                ...base,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    async write(entry, libraries, dependencies, outDir, ui) {
+        await _promises.default.rm(outDir, {
+            recursive: true,
+            force: true
+        });
+        await _promises.default.mkdir(outDir, {
+            recursive: true
+        });
+        await this.writeJson(_nodepath.default.join(outDir, "package.json"), {
+            name: entry.name.replace(/^@/, "").replace("/", "-"),
+            version: entry.pkg.version,
+            private: true,
+            type: "module",
+            scripts: {
+                start: `node es6/${_releaseexports.releaseExports.toJs(entry.pkg.main ?? "src/index.ts")}`
+            },
+            dependencies
+        });
+        // npm writes real folders. It also removes anything in node_modules it does not know,
+        // so the workspace libraries are copied in only after it has run.
+        if (Object.keys(dependencies).length > 0) {
+            await this.npm.installProduction({
+                cwd: outDir
+            });
+        }
+        await this.copyTree(_nodepath.default.join(entry.releaseDir, "es6"), _nodepath.default.join(outDir, "es6"));
+        const config = _nodepath.default.join(_nodepath.default.resolve(this.workspace.rootDir), "config");
+        if (await _io.io.directoryExists(config)) {
+            await this.copyTree(config, _nodepath.default.join(outDir, "config"));
+        }
+        if (ui != null) {
+            await this.copyTree(ui.from, _nodepath.default.join(outDir, ui.to));
+        }
+        for (const library of libraries){
+            const target = _nodepath.default.join(outDir, "node_modules", ...library.name.split("/"));
+            await this.copyTree(_nodepath.default.join(library.releaseDir, "es6"), _nodepath.default.join(target, "es6"));
+            await this.writeJson(_nodepath.default.join(target, "package.json"), {
+                name: library.name,
+                version: library.pkg.version,
+                type: "module",
+                exports: _releaseexports.releaseExports.build(library.pkg)
+            });
+        }
+        await this.assertNoSymlinks(outDir);
+    }
+    /** Copies file contents, never links: a symlink in the output would break outside the image. */ async copyTree(from, to) {
+        await _promises.default.cp(from, to, {
+            recursive: true,
+            dereference: true
+        });
+    }
+    async writeJson(filePath, value) {
+        await _io.io.writeFile(filePath, `${JSON.stringify(value, null, "\t")}\n`, {
+            mkdir: true,
+            encoding: "utf8"
+        });
+    }
+    async assertNoSymlinks(dir) {
+        for (const entry of (await _promises.default.readdir(dir, {
+            withFileTypes: true
+        }))){
+            const entryPath = _nodepath.default.join(dir, entry.name);
+            if (entry.isSymbolicLink()) {
+                throw new _errors.ForgeError(`The packaged output must hold no symlinks, but found ${entryPath}`);
+            }
+            if (entry.isDirectory()) {
+                await this.assertNoSymlinks(entryPath);
+            }
+        }
+    }
+}
+PackageDeployable = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _workspace.Workspace === "undefined" ? Object : _workspace.Workspace,
+        typeof _importgraphservice.ImportGraph === "undefined" ? Object : _importgraphservice.ImportGraph,
+        typeof _dependencypinnerservice.DependencyPinner === "undefined" ? Object : _dependencypinnerservice.DependencyPinner
+    ])
+], PackageDeployable);

package/commonjs/src/actions/paths.action.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PATHS_FILE () {
+        return PATHS_FILE;
+    },
+    get Paths () {
+        return Paths;
+    }
+});
+const _nodefs = require("node:fs");
+const _promises = require("node:fs/promises");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _workspace = require("@decohere/workspace");
+const _cli = require("@decohere/devkit/cli");
+const _scribe = require("@decohere/scribe");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const PATHS_FILE = "tsconfig.paths.json";
+class Paths {
+    workspace;
+    #logger = _scribe.scribe.logger(Paths.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const file = _nodepath.default.join(this.workspace.rootDir, PATHS_FILE);
+        if (this.workspace.isStandalone) {
+            // One project has no other projects to import from source.
+            this.#logger.info(`Standalone project: no ${PATHS_FILE} needed`);
+            return _cli.ActionResponse.Success(Paths.name, [
+                {
+                    file,
+                    changed: false,
+                    succeeded: true
+                }
+            ]);
+        }
+        const content = Paths.render(this.workspace);
+        const current = (0, _nodefs.existsSync)(file) ? await (0, _promises.readFile)(file, "utf8") : null;
+        const changed = current !== content;
+        if (options.check) {
+            if (!changed) {
+                return _cli.ActionResponse.Success(Paths.name, [
+                    {
+                        file,
+                        changed,
+                        succeeded: true
+                    }
+                ]);
+            }
+            const error = `${PATHS_FILE} is out of date. Run \`forge paths\` to update it.`;
+            this.#logger.error(error);
+            return _cli.ActionResponse.Error(Paths.name, [
+                {
+                    file,
+                    changed,
+                    succeeded: false,
+                    error
+                }
+            ]);
+        }
+        if (changed) {
+            await (0, _promises.writeFile)(file, content);
+            this.#logger.info(`Wrote ${PATHS_FILE}`);
+        }
+        return _cli.ActionResponse.Success(Paths.name, [
+            {
+                file,
+                changed,
+                succeeded: true
+            }
+        ]);
+    }
+    /** The file's content: convention and exported subpaths only, never the tsconfig's own paths. */ static render(workspace) {
+        const rootDir = _nodepath.default.resolve(workspace.rootDir);
+        const { paths } = _workspace.packageAliases.build(workspace.getProjects("debug"), {
+            baseUrl: rootDir
+        });
+        const sorted = Object.fromEntries(Object.keys(paths).sort().map((key)=>[
+                key,
+                (paths[key] ?? []).map((target)=>`./${target}`)
+            ]));
+        const json = {
+            $comment: "Generated by `forge paths` from the workspace packages. Do not edit.",
+            compilerOptions: {
+                paths: sorted
+            }
+        };
+        return `${JSON.stringify(json, null, 2)}\n`;
+    }
+}
+Paths = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _workspace.Workspace === "undefined" ? Object : _workspace.Workspace
+    ])
+], Paths);