@decohere/forge 0.0.1-dev.10

package/commonjs/src/actions/dependency-sync.action.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SyncDependencies", {
+    enumerable: true,
+    get: function() {
+        return SyncDependencies;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+const _dependencyresolverservice = require("../services/dependency-resolver.service.js");
+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 SyncDependencies {
+    workspace;
+    resolver;
+    #logger = _scribe.scribe.logger(SyncDependencies.name);
+    constructor(workspace, resolver){
+        this.workspace = workspace;
+        this.resolver = resolver;
+    }
+    async run(options) {
+        const { configuration, logDiff } = options;
+        const projects = this.workspace.getProjects(configuration);
+        const workspacePackages = await this.resolver.getWorkspacePackages(this.workspace, projects);
+        const computed = await Promise.all(projects.map((project)=>this.computeDependenciesFor(project, workspacePackages)));
+        const results = computed.map((c)=>c.syncResult);
+        if (results.some((r)=>!r.succeeded)) {
+            return _cli.ActionResponse.Error(SyncDependencies.name, results);
+        }
+        const succeeded = computed.filter((c)=>c.succeeded);
+        await Promise.all(succeeded.map((c)=>c.project.persistPackageJson(c.updatedPackage)));
+        const syncResults = succeeded.map((c)=>{
+            const drift = this.resolver.computeDrift(c.originalPackage, c.updatedPackage);
+            if (drift && logDiff) {
+                this.#logger.warn(`Dependency drift synced in '${c.syncResult.projectName}'`, drift);
+            }
+            return {
+                ...c.syncResult,
+                drift
+            };
+        });
+        const failedResults = results.filter((r)=>!r.succeeded);
+        return _cli.ActionResponse.Success(SyncDependencies.name, [
+            ...syncResults,
+            ...failedResults
+        ]);
+    }
+    async computeDependenciesFor(project, workspacePackages) {
+        try {
+            const originalPackage = await project.getPackageJson();
+            const { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(project, workspacePackages);
+            for (const warning of warnings){
+                this.#logger.warn(`${warning.file}:${warning.line}: ${warning.message}`);
+            }
+            return {
+                succeeded: true,
+                syncResult: {
+                    projectName: project.name,
+                    succeeded: true
+                },
+                project,
+                originalPackage,
+                updatedPackage
+            };
+        } catch (error) {
+            const message = (0, _errors.formatUnknownError)(error);
+            return {
+                succeeded: false,
+                syncResult: {
+                    projectName: project.name,
+                    error: `${project.name}: ${message}`,
+                    succeeded: false
+                }
+            };
+        }
+    }
+}
+SyncDependencies = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace,
+        typeof _dependencyresolverservice.DependencyResolver === "undefined" ? Object : _dependencyresolverservice.DependencyResolver
+    ])
+], SyncDependencies);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/dependency-sync.action.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project } from \"@decohere/mesh\";\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 { formatUnknownError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { DependencyResolver } from \"../services/dependency-resolver.service.js\";\nimport type { Package, SyncprojectResult } from \"../types/dependency.types.js\";\n\nexport type DependenciesOptions = {\n\tconfiguration: string;\n\tlogDiff?: boolean;\n};\n\ntype SyncComputed =\n\t| { succeeded: false; syncResult: SyncprojectResult }\n\t| {\n\t\t\tsucceeded: true;\n\t\t\tsyncResult: SyncprojectResult;\n\t\t\tproject: Project;\n\t\t\toriginalPackage: PackageJson;\n\t\t\tupdatedPackage: PackageJson;\n\t  };\n\n@injectable()\nexport class SyncDependencies implements Action<DependenciesOptions> {\n\t#logger = scribe.logger(SyncDependencies.name);\n\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\tprivate readonly resolver: DependencyResolver,\n\t) {}\n\n\tpublic async run(options: DependenciesOptions): Promise<ActionResponse<SyncprojectResult>> {\n\t\tconst { configuration, logDiff } = options;\n\n\t\tconst projects = this.workspace.getProjects(configuration);\n\t\tconst workspacePackages = await this.resolver.getWorkspacePackages(\n\t\t\tthis.workspace,\n\t\t\tprojects,\n\t\t);\n\n\t\tconst computed = await Promise.all(\n\t\t\tprojects.map((project) => this.computeDependenciesFor(project, workspacePackages)),\n\t\t);\n\n\t\tconst results = computed.map((c) => c.syncResult);\n\t\tif (results.some((r) => !r.succeeded)) {\n\t\t\treturn ActionResponse.Error(SyncDependencies.name, results);\n\t\t}\n\n\t\tconst succeeded = computed.filter(\n\t\t\t(c): c is SyncComputed & { succeeded: true } => c.succeeded,\n\t\t);\n\n\t\tawait Promise.all(succeeded.map((c) => c.project.persistPackageJson(c.updatedPackage)));\n\n\t\tconst syncResults = succeeded.map((c) => {\n\t\t\tconst drift = this.resolver.computeDrift(c.originalPackage, c.updatedPackage);\n\t\t\tif (drift && logDiff) {\n\t\t\t\tthis.#logger.warn(`Dependency drift synced in '${c.syncResult.projectName}'`, drift);\n\t\t\t}\n\t\t\treturn { ...c.syncResult, drift };\n\t\t});\n\n\t\tconst failedResults = results.filter((r) => !r.succeeded);\n\n\t\treturn ActionResponse.Success(SyncDependencies.name, [...syncResults, ...failedResults]);\n\t}\n\n\tprivate async computeDependenciesFor(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<SyncComputed> {\n\t\ttry {\n\t\t\tconst originalPackage = await project.getPackageJson();\n\t\t\tconst { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(\n\t\t\t\tproject,\n\t\t\t\tworkspacePackages,\n\t\t\t);\n\t\t\tfor (const warning of warnings) {\n\t\t\t\tthis.#logger.warn(`${warning.file}:${warning.line}: ${warning.message}`);\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tsucceeded: true,\n\t\t\t\tsyncResult: { projectName: project.name, succeeded: true },\n\t\t\t\tproject,\n\t\t\t\toriginalPackage,\n\t\t\t\tupdatedPackage,\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tconst message = formatUnknownError(error);\n\t\t\treturn {\n\t\t\t\tsucceeded: false,\n\t\t\t\tsyncResult: {\n\t\t\t\t\tprojectName: project.name,\n\t\t\t\t\terror: `${project.name}: ${message}`,\n\t\t\t\t\tsucceeded: false,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["SyncDependencies","scribe","logger","name","workspace","resolver","run","options","configuration","logDiff","projects","getProjects","workspacePackages","getWorkspacePackages","computed","Promise","all","map","project","computeDependenciesFor","results","c","syncResult","some","r","succeeded","ActionResponse","Error","filter","persistPackageJson","updatedPackage","syncResults","drift","computeDrift","originalPackage","warn","projectName","failedResults","Success","getPackageJson","warnings","computeProjectDependencies","warning","file","line","message","error","formatUnknownError"],"mappings":";;;;+BA4BaA;;;eAAAA;;;4BA5Bc;sBAGD;qBAEK;wBACR;wBACY;2CAEA;;;;;;;;;;AAmB5B,MAAMA;;;IACZ,CAAA,MAAO,GAAGC,cAAM,CAACC,MAAM,CAACF,iBAAiBG,IAAI,EAAE;IAE/C,YACC,AAAiBC,SAAoB,EACrC,AAAiBC,QAA4B,CAC5C;aAFgBD,YAAAA;aACAC,WAAAA;IACf;IAEH,MAAaC,IAAIC,OAA4B,EAA8C;QAC1F,MAAM,EAAEC,aAAa,EAAEC,OAAO,EAAE,GAAGF;QAEnC,MAAMG,WAAW,IAAI,CAACN,SAAS,CAACO,WAAW,CAACH;QAC5C,MAAMI,oBAAoB,MAAM,IAAI,CAACP,QAAQ,CAACQ,oBAAoB,CACjE,IAAI,CAACT,SAAS,EACdM;QAGD,MAAMI,WAAW,MAAMC,QAAQC,GAAG,CACjCN,SAASO,GAAG,CAAC,CAACC,UAAY,IAAI,CAACC,sBAAsB,CAACD,SAASN;QAGhE,MAAMQ,UAAUN,SAASG,GAAG,CAAC,CAACI,IAAMA,EAAEC,UAAU;QAChD,IAAIF,QAAQG,IAAI,CAAC,CAACC,IAAM,CAACA,EAAEC,SAAS,GAAG;YACtC,OAAOC,mBAAc,CAACC,KAAK,CAAC3B,iBAAiBG,IAAI,EAAEiB;QACpD;QAEA,MAAMK,YAAYX,SAASc,MAAM,CAChC,CAACP,IAA+CA,EAAEI,SAAS;QAG5D,MAAMV,QAAQC,GAAG,CAACS,UAAUR,GAAG,CAAC,CAACI,IAAMA,EAAEH,OAAO,CAACW,kBAAkB,CAACR,EAAES,cAAc;QAEpF,MAAMC,cAAcN,UAAUR,GAAG,CAAC,CAACI;YAClC,MAAMW,QAAQ,IAAI,CAAC3B,QAAQ,CAAC4B,YAAY,CAACZ,EAAEa,eAAe,EAAEb,EAAES,cAAc;YAC5E,IAAIE,SAASvB,SAAS;gBACrB,IAAI,CAAC,CAAA,MAAO,CAAC0B,IAAI,CAAC,CAAC,4BAA4B,EAAEd,EAAEC,UAAU,CAACc,WAAW,CAAC,CAAC,CAAC,EAAEJ;YAC/E;YACA,OAAO;gBAAE,GAAGX,EAAEC,UAAU;gBAAEU;YAAM;QACjC;QAEA,MAAMK,gBAAgBjB,QAAQQ,MAAM,CAAC,CAACJ,IAAM,CAACA,EAAEC,SAAS;QAExD,OAAOC,mBAAc,CAACY,OAAO,CAACtC,iBAAiBG,IAAI,EAAE;eAAI4B;eAAgBM;SAAc;IACxF;IAEA,MAAclB,uBACbD,OAAgB,EAChBN,iBAAuC,EACf;QACxB,IAAI;YACH,MAAMsB,kBAAkB,MAAMhB,QAAQqB,cAAc;YACpD,MAAM,EAAET,cAAc,EAAEU,QAAQ,EAAE,GAAG,MAAM,IAAI,CAACnC,QAAQ,CAACoC,0BAA0B,CAClFvB,SACAN;YAED,KAAK,MAAM8B,WAAWF,SAAU;gBAC/B,IAAI,CAAC,CAAA,MAAO,CAACL,IAAI,CAAC,GAAGO,QAAQC,IAAI,CAAC,CAAC,EAAED,QAAQE,IAAI,CAAC,EAAE,EAAEF,QAAQG,OAAO,EAAE;YACxE;YACA,OAAO;gBACNpB,WAAW;gBACXH,YAAY;oBAAEc,aAAalB,QAAQf,IAAI;oBAAEsB,WAAW;gBAAK;gBACzDP;gBACAgB;gBACAJ;YACD;QACD,EAAE,OAAOgB,OAAO;YACf,MAAMD,UAAUE,IAAAA,0BAAkB,EAACD;YACnC,OAAO;gBACNrB,WAAW;gBACXH,YAAY;oBACXc,aAAalB,QAAQf,IAAI;oBACzB2C,OAAO,GAAG5B,QAAQf,IAAI,CAAC,EAAE,EAAE0C,SAAS;oBACpCpB,WAAW;gBACZ;YACD;QACD;IACD;AACD"}

package/commonjs/src/actions/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./build.action.js"), exports);
+_export_star(require("./clean.action.js"), exports);
+_export_star(require("./commit.action.js"), exports);
+_export_star(require("./copy.action.js"), exports);
+_export_star(require("./dependency-report.action.js"), exports);
+_export_star(require("./dependency-sync.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("./version.action.js"), exports);
+_export_star(require("./watch.action.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9hY3Rpb25zL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2J1aWxkLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xlYW4uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21taXQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3B5LmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVwZW5kZW5jeS1yZXBvcnQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXN5bmMuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wdWJsaXNoLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3luYy1sb2NrLWZpbGUuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90YWcuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92ZXJzaW9uLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vd2F0Y2guYWN0aW9uLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQSJ9

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Publish", {
+    enumerable: true,
+    get: function() {
+        return Publish;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+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 Publish {
+    workspace;
+    // TODO: probably best to inject npm
+    npm = new _interop.Npm();
+    #logger = _scribe.scribe.logger(Publish.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const projects = this.workspace.getProjects(options.configuration);
+        const token = await this.resolveToken(options);
+        const otp = await this.resolveOtp(options);
+        if (projects.length === 0) {
+            throw new _errors.ForgeError(`No projects found to publish`);
+        }
+        const publishResponses = await this.publishProjects(projects, {
+            ...options,
+            token,
+            otp
+        });
+        const failed = publishResponses.filter((r)=>!r.succeeded);
+        if (failed.length) {
+            return _cli.ActionResponse.Error(Publish.name, publishResponses);
+        }
+        return _cli.ActionResponse.Success(Publish.name, publishResponses);
+    }
+    async publishProjects(projects, options) {
+        return await Promise.all(projects.filter((project)=>{
+            if (project.isPrivate) {
+                this.#logger.info(`Skipping private package: ${project.name}`);
+                return false;
+            }
+            return true;
+        }).map(async (project)=>await this.publishProject(project, options)));
+    }
+    async publishProject(project, options) {
+        const { channel, dryRun, token, otp } = options;
+        const outDir = project.getOutDir();
+        this.#logger.info(`${dryRun ? "[dry-run] " : ""}Publishing ${project.name}`);
+        try {
+            const response = await this.npm.publish(outDir, {
+                channel,
+                dryRun,
+                authToken: token,
+                otp,
+                skipIfPublished: true
+            });
+            const packageName = response.data?.join("");
+            this.#logger.trace(`${project.name} → ${packageName ?? response.message}`);
+            return {
+                projectName: project.name,
+                succeeded: true,
+                message: response.message,
+                packageName
+            };
+        } catch (reason) {
+            const message = (0, _errors.formatUnknownError)(reason);
+            return {
+                projectName: project.name,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    async resolveToken(options) {
+        if (options.token?.trim()) {
+            return options.token.trim();
+        }
+        if (options.promptAuth) {
+            return await this.promptSecret("npm access token: ");
+        }
+        return undefined;
+    }
+    async resolveOtp(options) {
+        if (options.otp?.trim()) {
+            return options.otp.trim();
+        }
+        if (options.promptAuth || options.promptOtp) {
+            return await this.promptSecret("npm OTP: ");
+        }
+        return undefined;
+    }
+    async promptSecret(label) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new _errors.ForgeError(`Cannot prompt for secret without an interactive TTY`);
+        }
+        process.stdout.write(label);
+        const stdin = process.stdin;
+        stdin.setEncoding("utf8");
+        stdin.resume();
+        stdin.setRawMode?.(true);
+        let value = "";
+        return await new Promise((resolve, reject)=>{
+            const cleanup = ()=>{
+                stdin.setRawMode?.(false);
+                stdin.pause();
+                stdin.removeListener("data", onData);
+                process.stdout.write("\n");
+            };
+            const onData = (chunk)=>{
+                const char = chunk;
+                if (char === "\u0003") {
+                    cleanup();
+                    reject(new _errors.ForgeError("Input cancelled"));
+                    return;
+                }
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    resolve(value.trim());
+                    return;
+                }
+                if (char === "\u0008" || char === "\u007f") {
+                    value = value.slice(0, -1);
+                    return;
+                }
+                value += char;
+            };
+            stdin.on("data", onData);
+        });
+    }
+}
+Publish = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.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":["Publish","npm","Npm","scribe","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","ForgeError","publishResponses","publishProjects","failed","filter","r","succeeded","ActionResponse","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","formatUnknownError","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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"}

package/commonjs/src/actions/sync-lock-file.action.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SyncLockFile", {
+    enumerable: true,
+    get: function() {
+        return SyncLockFile;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+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;
+}
+class SyncLockFile {
+    #logger = _scribe.scribe.logger(SyncLockFile.name);
+    #pnpm = new _interop.Pnpm();
+    async run(options) {
+        const shouldSync = options.sync ?? true;
+        if (options.dryRun || !shouldSync) {
+            this.#logger.info(options.dryRun ? "[dry-run] Skipping lockfile sync" : "Skipping lockfile sync");
+            return _cli.ActionResponse.Skipped(SyncLockFile.name);
+        }
+        try {
+            await this.#pnpm.syncLockFile();
+        } catch (reason) {
+            return _cli.ActionResponse.Error(SyncLockFile.name, `Failed syncing lockfile: ${(0, _errors.formatUnknownError)(reason)}`);
+        }
+        return _cli.ActionResponse.Success(SyncLockFile.name);
+    }
+}
+SyncLockFile = _ts_decorate([
+    (0, _decorators.injectable)()
+], SyncLockFile);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Tag", {
+    enumerable: true,
+    get: function() {
+        return Tag;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+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 Tag {
+    workspace;
+    #logger = _scribe.scribe.logger(Tag.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        try {
+            const version = await this.workspace.getVersion();
+            const prefix = options.prefix ?? "v";
+            const tag = `${prefix}${version}`;
+            if (options.dryRun) {
+                this.#logger.info(`[dry-run] ${tag}`);
+                return _cli.ActionResponse.Success(Tag.name, [
+                    {
+                        tag,
+                        succeeded: true
+                    }
+                ]);
+            }
+            this.#logger.info(`Creating tag: ${tag}`);
+            const git = new _interop.Git();
+            await git.tag(tag);
+            if (options.push) {
+                const branch = await git.getBranchName();
+                this.#logger.info(`Pushing branch: ${branch}`);
+                await git.push(branch);
+                this.#logger.info(`Pushing tag: ${tag}`);
+                await git.pushTag(tag);
+            }
+            return _cli.ActionResponse.Success(Tag.name, [
+                {
+                    tag,
+                    succeeded: true
+                }
+            ]);
+        } catch (reason) {
+            const error = (0, _errors.formatUnknownError)(reason);
+            throw new _errors.ForgeError(`Failed to create tag: ${error}`);
+        }
+    }
+}
+Tag = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Tag);
+
+//# sourceMappingURL=data:application/json;base64,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