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

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

@@ -9,13 +9,13 @@ function _ts_metadata(k, v) {
 }
 import path from "node:path";
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { Docker as DockerInterop } from "@decohere/nexus/interop";
-import { io } from "@decohere/nexus/io";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Docker as DockerInterop } from "@decohere/devkit/interop";
+import { io } from "@decohere/core/io";
 import { scribe } from "@decohere/scribe";
 import { ForgeError, formatUnknownError } from "../errors.js";
+import { deployable, PACKAGE_DIR } from "../packaging/deployable.js";
 export class Docker {
     workspace;
     #logger = scribe.logger(Docker.name);
@@ -27,10 +27,12 @@ export class Docker {
     async run(options) {
         const projects = await this.getDockerProjects(this.workspace.getProjects(options.configuration));
         if (projects.length === 0) {
-            throw new ForgeError(`No projects found with a Dockerfile`);
+            this.#logger.info("No projects found with a Dockerfile — nothing to dockerize");
+            return 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 ActionResponse.Error(Docker.name, responses);
@@ -40,60 +42,76 @@ export class Docker {
     async getDockerProjects(projects) {
         const result = [];
         for (const project of projects){
-            const dockerfile = project.dockerConfig?.dockerfile ?? "Dockerfile";
-            const dockerfilePath = path.join(project.projectRoot, dockerfile);
-            if (!await io.fileExists(dockerfilePath)) {
-                this.#logger.info(`Skipping ${project.name}: missing ${dockerfile}`);
+            if (!await deployable.isDeployable(project)) {
+                this.#logger.info(`Skipping ${project.name}: missing ${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.readFile(deployable.dockerfilePath(project)).catch(()=>"");
+        if (!dockerfile.includes(PACKAGE_DIR)) {
+            return;
+        }
+        const packaged = path.join(project.projectRoot, PACKAGE_DIR, "package.json");
+        if (!await io.fileExists(packaged)) {
+            throw new ForgeError(`${project.name}: its Dockerfile copies ${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: path.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: path.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 = formatUnknownError(reason);
@@ -115,8 +133,30 @@ export 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("/");
@@ -125,6 +165,14 @@ export 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 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() === "") {
@@ -144,5 +192,3 @@ Docker = _ts_decorate([
         typeof Workspace === "undefined" ? Object : 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":["path","injectable","Workspace","ActionResponse","Docker","DockerInterop","io","scribe","ForgeError","formatUnknownError","logger","name","docker","process","env","FORGE_DOCKER_REGISTRY","trim","workspace","run","options","projects","getDockerProjects","getProjects","configuration","length","version","getVersion","responses","Promise","all","map","project","buildProject","failed","filter","response","succeeded","Error","Success","result","dockerfile","dockerConfig","dockerfilePath","join","projectRoot","fileExists","info","push","envBuildArgs","parseJsonEnv","envSecrets","envTags","image","defaultImageName","tags","buildArgs","interpolateBuildArgs","secrets","dryRun","build","cwd","tag","projectName","message","reason","error","versionPlaceholder","key","value","Object","entries","split","normalizeDockerRepository","repository","replace","segment","toLowerCase","Boolean","fallback","JSON","parse"],"mappings":"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"}

package/es6/src/actions/index.js

@@ -6,11 +6,12 @@ export * from "./dependency-report.action.js";
 export * from "./dependency-sync.action.js";
 export * from "./docker.action.js";
 export * from "./link.action.js";
+export * from "./package.action.js";
+export * from "./paths.action.js";
 export * from "./publish.action.js";
 export * from "./sync-lock-file.action.js";
 export * from "./tag.action.js";
+export * from "./typecheck.action.js";
 export * from "./unlink.action.js";
 export * from "./version.action.js";
 export * from "./watch.action.js";
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9hY3Rpb25zL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2J1aWxkLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xlYW4uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21taXQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3B5LmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVwZW5kZW5jeS1yZXBvcnQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXN5bmMuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kb2NrZXIuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saW5rLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHVibGlzaC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N5bmMtbG9jay1maWxlLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGFnLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdW5saW5rLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmVyc2lvbi5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3dhdGNoLmFjdGlvbi5qc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CO0FBQ2xDLGNBQWMsb0JBQW9CO0FBQ2xDLGNBQWMscUJBQXFCO0FBQ25DLGNBQWMsbUJBQW1CO0FBQ2pDLGNBQWMsZ0NBQWdDO0FBQzlDLGNBQWMsOEJBQThCO0FBQzVDLGNBQWMscUJBQXFCO0FBQ25DLGNBQWMsbUJBQW1CO0FBQ2pDLGNBQWMsc0JBQXNCO0FBQ3BDLGNBQWMsNkJBQTZCO0FBQzNDLGNBQWMsa0JBQWtCO0FBQ2hDLGNBQWMscUJBQXFCO0FBQ25DLGNBQWMsc0JBQXNCO0FBQ3BDLGNBQWMsb0JBQW9CIn0=

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

@@ -10,9 +10,8 @@ function _ts_metadata(k, v) {
 import fs from "node:fs/promises";
 import path from "node:path";
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
 import { scribe } from "@decohere/scribe";
 import "../extensions/project.extensions.js";
 import { ForgeError } from "../errors.js";
@@ -127,5 +126,3 @@ Link = _ts_decorate([
         typeof Workspace === "undefined" ? Object : 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":["fs","path","injectable","Workspace","ActionResponse","scribe","ForgeError","LINK_MANIFEST","DEFAULT_LINK_CONFIGURATION","Link","logger","name","workspace","run","options","targetDir","resolve","nodeModulesDir","join","stat","catch","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","Success"],"mappings":"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"}

package/es6/src/actions/package.action.js

@@ -0,0 +1,219 @@
+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);
+}
+import fs from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Npm } from "@decohere/devkit/interop";
+import { io } from "@decohere/core/io";
+import { scribe } from "@decohere/scribe";
+import { ForgeError, formatUnknownError } from "../errors.js";
+import { DependencyPinner } from "../packaging/dependency-pinner.service.js";
+import { deployable, PACKAGE_DIR } from "../packaging/deployable.js";
+import { ImportGraph } from "../packaging/import-graph.service.js";
+import { releaseExports } from "../packaging/release-exports.js";
+import { uiAssets } from "../packaging/ui-assets.js";
+import { Release } from "../workspace.config.js";
+export class PackageDeployable {
+    workspace;
+    importGraph;
+    pinner;
+    #logger = scribe.logger(PackageDeployable.name);
+    npm = new Npm();
+    constructor(workspace, importGraph, pinner){
+        this.workspace = workspace;
+        this.importGraph = importGraph;
+        this.pinner = pinner;
+    }
+    async run(options) {
+        const projects = this.workspace.getProjects(Release.name);
+        const selected = await this.select(projects, options.project);
+        if (typeof selected === "string") {
+            return ActionResponse.Error(PackageDeployable.name, selected);
+        }
+        if (selected.length === 0) {
+            this.#logger.info("No projects found with a Dockerfile — nothing to package");
+            return 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) ? ActionResponse.Error(PackageDeployable.name, responses) : 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.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.isDeployable(project)) {
+            return `${requested} has no ${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: path.resolve(project.projectRoot),
+                    releaseDir: path.resolve(project.getOutDir())
+                }
+            ];
+        }));
+        return new Map(entries);
+    }
+    async packageProject(project, releaseProjects, projects) {
+        const outDir = path.join(path.resolve(project.projectRoot), PACKAGE_DIR);
+        const base = {
+            projectName: project.name,
+            outDir,
+            workspacePackages: [],
+            dependencies: {}
+        };
+        try {
+            const entry = releaseProjects.get(project.name);
+            if (!await io.directoryExists(path.join(entry.releaseDir, "es6"))) {
+                throw new ForgeError(`No release build for ${project.name}. Run \`forge build --configuration release\` first.`);
+            }
+            const ui = await 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: path.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 = formatUnknownError(reason);
+            return {
+                ...base,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    async write(entry, libraries, dependencies, outDir, ui) {
+        await fs.rm(outDir, {
+            recursive: true,
+            force: true
+        });
+        await fs.mkdir(outDir, {
+            recursive: true
+        });
+        await this.writeJson(path.join(outDir, "package.json"), {
+            name: entry.name.replace(/^@/, "").replace("/", "-"),
+            version: entry.pkg.version,
+            private: true,
+            type: "module",
+            scripts: {
+                start: `node es6/${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(path.join(entry.releaseDir, "es6"), path.join(outDir, "es6"));
+        const config = path.join(path.resolve(this.workspace.rootDir), "config");
+        if (await io.directoryExists(config)) {
+            await this.copyTree(config, path.join(outDir, "config"));
+        }
+        if (ui != null) {
+            await this.copyTree(ui.from, path.join(outDir, ui.to));
+        }
+        for (const library of libraries){
+            const target = path.join(outDir, "node_modules", ...library.name.split("/"));
+            await this.copyTree(path.join(library.releaseDir, "es6"), path.join(target, "es6"));
+            await this.writeJson(path.join(target, "package.json"), {
+                name: library.name,
+                version: library.pkg.version,
+                type: "module",
+                exports: 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 fs.cp(from, to, {
+            recursive: true,
+            dereference: true
+        });
+    }
+    async writeJson(filePath, value) {
+        await io.writeFile(filePath, `${JSON.stringify(value, null, "\t")}\n`, {
+            mkdir: true,
+            encoding: "utf8"
+        });
+    }
+    async assertNoSymlinks(dir) {
+        for (const entry of (await fs.readdir(dir, {
+            withFileTypes: true
+        }))){
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isSymbolicLink()) {
+                throw new ForgeError(`The packaged output must hold no symlinks, but found ${entryPath}`);
+            }
+            if (entry.isDirectory()) {
+                await this.assertNoSymlinks(entryPath);
+            }
+        }
+    }
+}
+PackageDeployable = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace,
+        typeof ImportGraph === "undefined" ? Object : ImportGraph,
+        typeof DependencyPinner === "undefined" ? Object : DependencyPinner
+    ])
+], PackageDeployable);

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

@@ -0,0 +1,97 @@
+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);
+}
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { packageAliases, Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { scribe } from "@decohere/scribe";
+export const PATHS_FILE = "tsconfig.paths.json";
+export class Paths {
+    workspace;
+    #logger = scribe.logger(Paths.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const file = path.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 ActionResponse.Success(Paths.name, [
+                {
+                    file,
+                    changed: false,
+                    succeeded: true
+                }
+            ]);
+        }
+        const content = Paths.render(this.workspace);
+        const current = existsSync(file) ? await readFile(file, "utf8") : null;
+        const changed = current !== content;
+        if (options.check) {
+            if (!changed) {
+                return 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 ActionResponse.Error(Paths.name, [
+                {
+                    file,
+                    changed,
+                    succeeded: false,
+                    error
+                }
+            ]);
+        }
+        if (changed) {
+            await writeFile(file, content);
+            this.#logger.info(`Wrote ${PATHS_FILE}`);
+        }
+        return 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 = path.resolve(workspace.rootDir);
+        const { paths } = 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([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Paths);

package/es6/src/actions/publish.action.js

@@ -8,10 +8,9 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { Npm } from "@decohere/nexus/interop";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Npm } from "@decohere/devkit/interop";
 import { scribe } from "@decohere/scribe";
 import { ForgeError, formatUnknownError } from "../errors.js";
 export class Publish {
@@ -143,5 +142,3 @@ Publish = _ts_decorate([
         typeof Workspace === "undefined" ? Object : Workspace
     ])
 ], Publish);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/publish.action.ts"],"sourcesContent":["import { 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 { Npm } from \"@decohere/nexus/interop\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type PublishOptions = {\n\tconfiguration: string;\n\tchannel?: string;\n\tdryRun?: boolean;\n\ttoken?: string;\n\totp?: string;\n\tpromptAuth?: boolean;\n\tpromptOtp?: boolean;\n};\n\nexport type PublishResponse = ResultStatus & {\n\tprojectName: string;\n\tmessage: string;\n\tpackageName?: string;\n};\n\n@injectable()\nexport class Publish implements Action<PublishOptions> {\n\t// TODO: probably best to inject npm\n\tprivate readonly npm = new Npm();\n\t#logger = scribe.logger(Publish.name);\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic async run(options: PublishOptions): Promise<ActionResponse<PublishResponse>> {\n\t\tconst projects = this.workspace.getProjects(options.configuration);\n\t\tconst token = await this.resolveToken(options);\n\t\tconst otp = await this.resolveOtp(options);\n\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found to publish`);\n\t\t}\n\t\tconst publishResponses = await this.publishProjects(projects, {\n\t\t\t...options,\n\t\t\ttoken,\n\t\t\totp,\n\t\t});\n\t\tconst failed = publishResponses.filter((r) => !r.succeeded);\n\t\tif (failed.length) {\n\t\t\treturn ActionResponse.Error(Publish.name, publishResponses);\n\t\t}\n\t\treturn ActionResponse.Success(Publish.name, publishResponses);\n\t}\n\n\tpublic async publishProjects(projects: readonly Project[], options: PublishOptions) {\n\t\treturn await Promise.all(\n\t\t\tprojects\n\t\t\t\t.filter((project) => {\n\t\t\t\t\tif (project.isPrivate) {\n\t\t\t\t\t\tthis.#logger.info(`Skipping private package: ${project.name}`);\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t\treturn true;\n\t\t\t\t})\n\t\t\t\t.map(async (project) => await this.publishProject(project, options)),\n\t\t);\n\t}\n\n\tprivate async publishProject(\n\t\tproject: Project,\n\t\toptions: PublishOptions,\n\t): Promise<PublishResponse> {\n\t\tconst { channel, dryRun, token, otp } = options;\n\t\tconst outDir = project.getOutDir();\n\t\tthis.#logger.info(`${dryRun ? \"[dry-run] \" : \"\"}Publishing ${project.name}`);\n\n\t\ttry {\n\t\t\tconst response = await this.npm.publish(outDir, {\n\t\t\t\tchannel,\n\t\t\t\tdryRun,\n\t\t\t\tauthToken: token,\n\t\t\t\totp,\n\t\t\t\tskipIfPublished: true,\n\t\t\t});\n\n\t\t\tconst packageName = response.data?.join(\"\");\n\t\t\tthis.#logger.trace(`${project.name} → ${packageName ?? response.message}`);\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\tsucceeded: true,\n\t\t\t\tmessage: response.message,\n\t\t\t\tpackageName,\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\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 async resolveToken(options: PublishOptions): Promise<string | undefined> {\n\t\tif (options.token?.trim()) {\n\t\t\treturn options.token.trim();\n\t\t}\n\n\t\tif (options.promptAuth) {\n\t\t\treturn await this.promptSecret(\"npm access token: \");\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tprivate async resolveOtp(options: PublishOptions): Promise<string | undefined> {\n\t\tif (options.otp?.trim()) {\n\t\t\treturn options.otp.trim();\n\t\t}\n\n\t\tif (options.promptAuth || options.promptOtp) {\n\t\t\treturn await this.promptSecret(\"npm OTP: \");\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tprivate async promptSecret(label: string): Promise<string | undefined> {\n\t\tif (!process.stdin.isTTY || !process.stdout.isTTY) {\n\t\t\tthrow new ForgeError(`Cannot prompt for secret without an interactive TTY`);\n\t\t}\n\n\t\tprocess.stdout.write(label);\n\t\tconst stdin = process.stdin;\n\t\tstdin.setEncoding(\"utf8\");\n\t\tstdin.resume();\n\t\tstdin.setRawMode?.(true);\n\n\t\tlet value = \"\";\n\n\t\treturn await new Promise<string>((resolve, reject) => {\n\t\t\tconst cleanup = () => {\n\t\t\t\tstdin.setRawMode?.(false);\n\t\t\t\tstdin.pause();\n\t\t\t\tstdin.removeListener(\"data\", onData);\n\t\t\t\tprocess.stdout.write(\"\\n\");\n\t\t\t};\n\n\t\t\tconst onData = (chunk: string) => {\n\t\t\t\tconst char = chunk;\n\t\t\t\tif (char === \"\\u0003\") {\n\t\t\t\t\tcleanup();\n\t\t\t\t\treject(new ForgeError(\"Input cancelled\"));\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (char === \"\\r\" || char === \"\\n\") {\n\t\t\t\t\tcleanup();\n\t\t\t\t\tresolve(value.trim());\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (char === \"\\u0008\" || char === \"\\u007f\") {\n\t\t\t\t\tvalue = value.slice(0, -1);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvalue += char;\n\t\t\t};\n\n\t\t\tstdin.on(\"data\", onData);\n\t\t});\n\t}\n}\n"],"names":["injectable","Workspace","ActionResponse","Npm","scribe","ForgeError","formatUnknownError","Publish","npm","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","publishResponses","publishProjects","failed","filter","r","succeeded","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","error","trim","promptAuth","promptSecret","undefined","promptOtp","label","process","stdin","isTTY","stdout","write","setEncoding","resume","setRawMode","value","resolve","reject","cleanup","pause","removeListener","onData","chunk","char","slice","on"],"mappings":"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"}