rman 1.2.5 → 2.0.0-beta.2

package/services/change-hash.service.d.ts

@@ -24,7 +24,7 @@ export declare namespace ChangeHashService {
          *
          * The keyword used to be `"npm"`, which named a *source* - and the wrong one: auto-detection is
          * mostly git, and the registry it may consult is now the ecosystem's business (see
-         * `ManifestProvider.publishedVersion`). What is being chosen here is a *mode*, so it is spelled
+         * `Plugin.publishedVersion`). What is being chosen here is a *mode*, so it is spelled
          * as one. **A rename, not an alias**: `--from npm` now means a ref literally called `npm`,
          * which is what it should have meant all along.
          */
@@ -76,7 +76,7 @@ export declare namespace ChangeHashService {
      * so all three commands agree on "since when" for any repo whose tags are the ones `rman version`
      * actually created; (2) failing that (no tag at all yet - e.g. onboarding `rman` onto a repo with
      * real release history but no `rman`-created tags), whatever this package's **own ecosystem**
-     * reports as its published version (`ManifestProvider.publishedVersion`), mapped to a git tag via
+     * reports as its published version (`Plugin.publishedVersion`), mapped to a git tag via
      * `.rmanrc changelog.tagPattern` and used only if that tag actually exists. Either way, if
      * `catchUpFile` is given and exists, the result is widened to also cover anything that file
      * hasn't caught up on yet (see its doc comment). Returns `undefined` when nothing can be resolved

package/services/change-hash.service.js

@@ -77,7 +77,7 @@ export var ChangeHashService;
      * so all three commands agree on "since when" for any repo whose tags are the ones `rman version`
      * actually created; (2) failing that (no tag at all yet - e.g. onboarding `rman` onto a repo with
      * real release history but no `rman`-created tags), whatever this package's **own ecosystem**
-     * reports as its published version (`ManifestProvider.publishedVersion`), mapped to a git tag via
+     * reports as its published version (`Plugin.publishedVersion`), mapped to a git tag via
      * `.rmanrc changelog.tagPattern` and used only if that tag actually exists. Either way, if
      * `catchUpFile` is given and exists, the result is widened to also cover anything that file
      * hasn't caught up on yet (see its doc comment). Returns `undefined` when nothing can be resolved
@@ -91,7 +91,7 @@ export var ChangeHashService;
         let tagHash = await findLatestTag(git, pkg);
         if (!tagHash) {
             /** Through the package's own ecosystem, not through npm: which registry (if any) knows about
-             *  this package is the `ManifestProvider`'s answer, and in a polyglot repository it differs
+             *  this package is the `Plugin`'s manifest members's answer, and in a polyglot repository it differs
              *  per package. A repository naming no plugin gets `undefined` here and git tags decide
              *  alone. */
             const publishedVersion = await Manifest.publishedVersion(pkg);

package/services/changelog.service.d.ts

@@ -1,20 +1,74 @@
 import type { Package } from '../core/package.js';
-import type { Repository } from '../core/repository.js';
+import { Service } from '../core/service.js';
 import { type PackageFilterOptions } from '../utils/package-filter.js';
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had. `repository` left the signature because the application carries it.
+ */
+export declare class ChangelogService extends Service {
+    /**
+     * Same as `getEntries`, and additionally - for every returned entry, when `options.write` is
+     * set - prepends `entry.content` into that package's own changelog file (see `ChangelogService.Entry.filePath`).
+     * Still pure with respect to console output: writing a file is a real, callable-for-its-own-
+     * sake side effect (a "save this" request), not presentation, so it stays here rather than in
+     * the CLI command - printing what happened is the command's job.
+     */
+    generateToFile(options?: ChangelogService.Options): Promise<ChangelogService.Entry[]>;
+    /**
+     * Computes a changelog entry per package (root included) from real commits only - either
+     * everything since a given `--from <hash>` (applied the same way to every package), or, by
+     * default, auto-detected per package instead (see `detectChangeHash`). Pure: returns the
+     * entries, never prints or touches `CHANGELOG.md` - see `generate` for that.
+     *
+     * A commit is attributed to every package its files fall under (root included, for anything
+     * outside every package) - unless it's broad enough to count as a repo-wide change (see
+     * `BROAD_COMMIT_THRESHOLD`/`ownersOf`), in which case it goes to root alone instead of being
+     * repeated verbatim across most of the repository. Subject lines are grouped ✨ Features/🐛 Bug
+     * Fixes/🔧 Other Changes on a best-effort Conventional Commits read; anything that doesn't parse
+     * just lands in Other Changes as-is, so a repo that doesn't follow that convention still gets a
+     * usable list. `.rmanrc changelog.ignoreTypes` (cascaded, e.g. `[chore, dev]`) drops commits of
+     * those types entirely instead - see `ignoreTypesConfig`. A release marker - a bare version-bump
+     * commit (`"6.0.1"`), or any of the messages `version` itself writes - is always dropped
+     * outright, regardless of `ignoreTypes`; see `isReleaseCommit`.
+     *
+     * By default (or with `--from npm` explicitly), the boundary is auto-detected per package
+     * instead of one shared one - see `detectChangeHash`. A package that can't be resolved this way
+     * (unpublished, no network, no matching tag) has never been released at all, so its whole
+     * history counts as unreleased - the same view `version` takes, so a first-ever release still
+     * produces a real changelog. Packages that end up resolving to
+     * the same hash (an explicit one, or several packages sharing one tag under fixed versioning)
+     * only have their commits fetched once, not once per package.
+     *
+     * Formatting comes from `.rmanrc changelog.template` - a *path* to a template file (not the
+     * template text itself, to keep `.rmanrc` readable), with `{{package}}`/`{{version}}`/
+     * `{{date}}`/`{{commits}}` (the full grouped block) and `{{features}}`/`{{fixes}}`/`{{other}}`
+     * (their bullet lists alone, for templates that want their own headings/order) - see
+     * `resolveTemplate`. `{{package}}` for the repository root is `"<repo dir name> repository"`
+     * (e.g. "sqb repository"), not its raw package.json name - which is often a private,
+     * non-published placeholder (`"sqb.v4"`) that reads like a stray version marker rather than a
+     * recognizable label. `{{version}}` comes from git tags, not package.json (which can drift out
+     * of sync with what's actually been released) - see `resolveVersion`/`.rmanrc
+     * changelog.tagPattern`.
+     *
+     * Run from inside a single package's own directory, it only covers that package unless
+     * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
+     */
+    getEntries(options?: ChangelogService.Options): Promise<ChangelogService.Entry[]>;
+}
 export declare namespace ChangelogService {
     interface Options extends PackageFilterOptions {
         /** Generate the changelog since this commit/hash - applied the same way to every package.
          *  Default (also `"auto"` explicitly): auto-detect it per package instead, from that package's
          *  own most recent release tag first - the same lookup `VersionService`/`changed` use, so this
          *  never disagrees with them - falling back to whatever its own ecosystem's registry reports
-         *  only when it has no tag yet (`ManifestProvider.publishedVersion`, and only ever to guess a
+         *  only when it has no tag yet (`Plugin.publishedVersion`, and only ever to guess a
          *  tag name - see `detectChangeHash`); a package this can't be resolved for either way (never
          *  tagged, unpublished, no plugin) has never been released at all, so its whole history counts
          *  as unreleased - the same view `version` takes. */
         from?: string;
         /** Generate for the whole repository even when the current directory is inside a single
          *  package (which otherwise scopes it to just that package) - see `Repository.currentPackage`. */
-        root?: boolean;
+        fromRoot?: boolean;
         /** Where a package's changelog file lives, relative to *that package's own* directory -
          *  default `'CHANGELOG.md'`. Applies the same way to every package; for a package that wants
          *  its own filename instead, use `.rmanrc changelog.filePath` (cascaded, per-package
@@ -55,52 +109,9 @@ export declare namespace ChangelogService {
          *  package's own directory - see `GetOptions.filePath`. */
         filePath: string;
     }
-    /**
-     * Same as `getEntries`, and additionally - for every returned entry, when `options.write` is
-     * set - prepends `entry.content` into that package's own changelog file (see `Entry.filePath`).
-     * Still pure with respect to console output: writing a file is a real, callable-for-its-own-
-     * sake side effect (a "save this" request), not presentation, so it stays here rather than in
-     * the CLI command - printing what happened is the command's job.
-     */
-    function generateToFile(repository: Repository, options?: Options): Promise<Entry[]>;
-    /**
-     * Computes a changelog entry per package (root included) from real commits only - either
-     * everything since a given `--from <hash>` (applied the same way to every package), or, by
-     * default, auto-detected per package instead (see `detectChangeHash`). Pure: returns the
-     * entries, never prints or touches `CHANGELOG.md` - see `generate` for that.
-     *
-     * A commit is attributed to every package its files fall under (root included, for anything
-     * outside every package) - unless it's broad enough to count as a repo-wide change (see
-     * `BROAD_COMMIT_THRESHOLD`/`ownersOf`), in which case it goes to root alone instead of being
-     * repeated verbatim across most of the repository. Subject lines are grouped ✨ Features/🐛 Bug
-     * Fixes/🔧 Other Changes on a best-effort Conventional Commits read; anything that doesn't parse
-     * just lands in Other Changes as-is, so a repo that doesn't follow that convention still gets a
-     * usable list. `.rmanrc changelog.ignoreTypes` (cascaded, e.g. `[chore, dev]`) drops commits of
-     * those types entirely instead - see `ignoreTypesConfig`. A release marker - a bare version-bump
-     * commit (`"6.0.1"`), or any of the messages `version` itself writes - is always dropped
-     * outright, regardless of `ignoreTypes`; see `isReleaseCommit`.
-     *
-     * By default (or with `--from npm` explicitly), the boundary is auto-detected per package
-     * instead of one shared one - see `detectChangeHash`. A package that can't be resolved this way
-     * (unpublished, no network, no matching tag) has never been released at all, so its whole
-     * history counts as unreleased - the same view `version` takes, so a first-ever release still
-     * produces a real changelog. Packages that end up resolving to
-     * the same hash (an explicit one, or several packages sharing one tag under fixed versioning)
-     * only have their commits fetched once, not once per package.
-     *
-     * Formatting comes from `.rmanrc changelog.template` - a *path* to a template file (not the
-     * template text itself, to keep `.rmanrc` readable), with `{{package}}`/`{{version}}`/
-     * `{{date}}`/`{{commits}}` (the full grouped block) and `{{features}}`/`{{fixes}}`/`{{other}}`
-     * (their bullet lists alone, for templates that want their own headings/order) - see
-     * `resolveTemplate`. `{{package}}` for the repository root is `"<repo dir name> repository"`
-     * (e.g. "sqb repository"), not its raw package.json name - which is often a private,
-     * non-published placeholder (`"sqb.v4"`) that reads like a stray version marker rather than a
-     * recognizable label. `{{version}}` comes from git tags, not package.json (which can drift out
-     * of sync with what's actually been released) - see `resolveVersion`/`.rmanrc
-     * changelog.tagPattern`.
-     *
-     * Run from inside a single package's own directory, it only covers that package unless
-     * `options.root` says otherwise (see `Repository.currentPackage`).
-     */
-    function getEntries(repository: Repository, options?: Options): Promise<Entry[]>;
+}
+declare module '../core/service.js' {
+    interface ServiceMap {
+        changelog: ChangelogService;
+    }
 }

package/services/changelog.service.js

@@ -1,25 +1,28 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { Service } from '../core/service.js';
 import { GitHelper } from '../utils/git.js';
 import { filterPackages } from '../utils/package-filter.js';
 import { ChangeHashService } from './change-hash.service.js';
 import { ConventionalCommitsService } from './conventional-commits.service.js';
-export var ChangelogService;
-(function (ChangelogService) {
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had. `repository` left the signature because the application carries it.
+ */
+export class ChangelogService extends Service {
     /**
      * Same as `getEntries`, and additionally - for every returned entry, when `options.write` is
-     * set - prepends `entry.content` into that package's own changelog file (see `Entry.filePath`).
+     * set - prepends `entry.content` into that package's own changelog file (see `ChangelogService.Entry.filePath`).
      * Still pure with respect to console output: writing a file is a real, callable-for-its-own-
      * sake side effect (a "save this" request), not presentation, so it stays here rather than in
      * the CLI command - printing what happened is the command's job.
      */
-    async function generateToFile(repository, options = {}) {
-        const entries = await getEntries(repository, options);
+    async generateToFile(options = {}) {
+        const entries = await this.getEntries(options);
         for (const entry of entries)
             prependToChangelogFile(entry.package, entry.filePath, entry.content);
         return entries;
     }
-    ChangelogService.generateToFile = generateToFile;
     /**
      * Computes a changelog entry per package (root included) from real commits only - either
      * everything since a given `--from <hash>` (applied the same way to every package), or, by
@@ -57,10 +60,11 @@ export var ChangelogService;
      * changelog.tagPattern`.
      *
      * Run from inside a single package's own directory, it only covers that package unless
-     * `options.root` says otherwise (see `Repository.currentPackage`).
+     * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
      */
-    async function getEntries(repository, options = {}) {
-        const cwdScope = options.root ? undefined : repository.currentPackage;
+    async getEntries(options = {}) {
+        const repository = this.repository;
+        const cwdScope = options.fromRoot ? undefined : repository.currentPackage;
         const packages = repository.getPackages().filter(p => p !== repository.rootPackage);
         const targets = (cwdScope ? [cwdScope] : filterPackages([repository.rootPackage, ...packages], options)).filter(pkg => options.includeSkipped || !pkg.config.publish?.skip);
         const git = new GitHelper({ cwd: repository.dirname });
@@ -118,8 +122,7 @@ export var ChangelogService;
         }
         return entries;
     }
-    ChangelogService.getEntries = getEntries;
-})(ChangelogService || (ChangelogService = {}));
+}
 /** `.rmanrc changelog.ignoreTypes` (cascaded, per-package overridable) - Conventional Commits
  *  `type`s to drop entirely (e.g. `[chore, dev]`), not just fold into "Other Changes". Only
  *  applies to commits that actually parse as `type: ...` - a non-conventional message always

package/services/docker-publish.service.d.ts

@@ -1,31 +1,19 @@
-import type { Package } from '../core/package.js';
-import type { Repository } from '../core/repository.js';
+import { type PublishTarget } from '../core/publish-target.js';
+import { Service } from '../core/service.js';
 import { type PackageFilterOptions } from '../utils/package-filter.js';
-export declare namespace DockerPublishService {
-    /** Injectable "does this tag already exist" check - mainly for tests, so they don't depend on
-     *  network access or a real Docker daemon. Same shape as `PublishService.Deps.npmViewVersion`. */
-    interface Deps {
-        imageExists?: (image: string, tag: string) => Promise<boolean>;
-    }
-    interface Options extends PackageFilterOptions {
-        /** A package with uncommitted local changes is excluded (status `'skip'`) instead of aborting
-         *  the whole plan (status `'error'`) - same as `version`/`publish --target npm`'s own option. */
-        ignoreDirty?: boolean;
-        /** Prefixed onto a bare (no `/`) `publish.docker.image` - falls back to the
-         *  `DOCKERHUB_NAMESPACE` environment variable. */
-        namespace?: string;
-    }
-    type ApplyOptions = Options;
-    /** One package's outcome in a docker-publish plan - see `getPlan`. */
-    interface Entry {
-        package: Package;
-        version: string;
-        status: 'publish' | 'skip' | 'up-to-date' | 'error';
-        /** The fully-qualified `<namespace>/<image>` this entry publishes to - unset only when the
-         *  package's own `publish.docker.image` config is missing entirely (an `'error'` entry). */
-        image?: string;
-        reason?: string;
-    }
+/**
+ * The name this target answers to in `publish.target` and `--target`.
+ *
+ * Declared beside the implementation rather than in `publish-target.ts`: the seam is general and
+ * must not know any one target's name, and the adapter in `targets/docker.target.ts` reads it from
+ * here, which keeps the dependency pointing one way.
+ */
+export declare const DOCKER_TARGET = "docker";
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had. `repository` left the signature because the application carries it.
+ */
+export declare class DockerPublishService extends Service {
     /**
      * Computes what `publish --target docker` *would* do. Unlike the npm side (opt-out via
      * `"private"`), the docker target is opt-in: only packages whose own (cascaded) `.rmanrc
@@ -39,7 +27,7 @@ export declare namespace DockerPublishService {
      * already exists on the registry (via `docker manifest inspect`, queried concurrently) decides
      * the rest: `'up-to-date'` if so, `'publish'` if not.
      */
-    function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
+    getPlan(options?: DockerPublishService.Options, deps?: DockerPublishService.Deps): Promise<DockerPublishService.Entry[]>;
     /**
      * Publishes every `'publish'` entry in `plan`: one `docker login` and one `docker buildx create`
      * up front (each package's own build reuses them), then per package a single `docker buildx
@@ -48,5 +36,38 @@ export declare namespace DockerPublishService {
      * `DOCKER_README.md`), if present, updates the DockerHub repo description afterward. A package's
      * own failure doesn't stop unrelated packages elsewhere in the plan.
      */
-    function applyPlan(repository: Repository, plan: Entry[]): Promise<Entry[]>;
+    applyPlan(plan: DockerPublishService.Entry[]): Promise<DockerPublishService.Entry[]>;
+}
+export declare namespace DockerPublishService {
+    /** Injectable "does this tag already exist" check - mainly for tests, so they don't depend on
+     *  network access or a real Docker daemon. Same shape as `PublishService.Deps.npmViewVersion`. */
+    interface Deps {
+        imageExists?: (image: string, tag: string) => Promise<boolean>;
+    }
+    interface Options extends PackageFilterOptions {
+        /** A package with uncommitted local changes is excluded (status `'skip'`) instead of aborting
+         *  the whole plan (status `'error'`) - same as `version`/`publish --target npm`'s own option. */
+        ignoreDirty?: boolean;
+        /** Prefixed onto a bare (no `/`) `publish.docker.image` - falls back to the
+         *  `DOCKERHUB_NAMESPACE` environment variable. */
+        namespace?: string;
+    }
+    type ApplyOptions = Options;
+    /**
+     * One package's outcome in a docker-publish plan - see `getPlan`.
+     *
+     * A `PublishTarget.Entry` with one field of its own, which is the shape that interface expects: a
+     * target knows things about its own registry that no other target has a word for, and `detail` is
+     * where it puts whatever the command should print beside the package.
+     */
+    interface Entry extends PublishTarget.Entry {
+        /** The fully-qualified `<namespace>/<image>` this entry publishes to - unset only when the
+         *  package's own `publish.docker.image` config is missing entirely (an `'error'` entry). */
+        image?: string;
+    }
+}
+declare module '../core/service.js' {
+    interface ServiceMap {
+        dockerPublish: DockerPublishService;
+    }
 }

package/services/docker-publish.service.js

@@ -2,11 +2,24 @@ import { execFile } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { targetsOf } from '../core/publish-target.js';
+import { Service } from '../core/service.js';
 import { exec } from '../utils/exec.js';
 import { GitHelper } from '../utils/git.js';
 import { filterPackages } from '../utils/package-filter.js';
-export var DockerPublishService;
-(function (DockerPublishService) {
+/**
+ * The name this target answers to in `publish.target` and `--target`.
+ *
+ * Declared beside the implementation rather than in `publish-target.ts`: the seam is general and
+ * must not know any one target's name, and the adapter in `targets/docker.target.ts` reads it from
+ * here, which keeps the dependency pointing one way.
+ */
+export const DOCKER_TARGET = 'docker';
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had. `repository` left the signature because the application carries it.
+ */
+export class DockerPublishService extends Service {
     /**
      * Computes what `publish --target docker` *would* do. Unlike the npm side (opt-out via
      * `"private"`), the docker target is opt-in: only packages whose own (cascaded) `.rmanrc
@@ -20,9 +33,14 @@ export var DockerPublishService;
      * already exists on the registry (via `docker manifest inspect`, queried concurrently) decides
      * the rest: `'up-to-date'` if so, `'publish'` if not.
      */
-    async function getPlan(repository, options = {}, deps = {}) {
+    async getPlan(options = {}, deps = {}) {
+        const repository = this.repository;
         const git = new GitHelper({ cwd: repository.dirname });
-        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(pkg => targetsDocker(pkg) && !pkg.config.publish?.skip);
+        /** Which packages are the docker target's is the one question `PublishTarget` answers for every
+         *  target alike (`publish.target`, or `claims` when a package declares none) - asked through
+         *  `targetsOf` rather than re-read here, so `publish` and `list --json` cannot disagree about
+         *  where a package ships. */
+        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(pkg => targetsOf(this.app, pkg).some(t => t.name === DOCKER_TARGET) && !pkg.config.publish?.skip);
         const dirtyFiles = await git.listDirtyFiles({ absolute: true });
         const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
         const imageExists = deps.imageExists ?? defaultImageExists;
@@ -52,6 +70,7 @@ export var DockerPublishService;
                     package: pkg,
                     version: pkg.version,
                     image,
+                    detail: image,
                     status: options.ignoreDirty ? 'skip' : 'error',
                     reason: 'uncommitted local changes',
                 });
@@ -65,13 +84,13 @@ export var DockerPublishService;
                 package: pkg,
                 version: pkg.version,
                 image,
+                detail: image,
                 status: exists ? 'up-to-date' : 'publish',
                 reason: exists ? `registry already has ${image}:${pkg.version}` : 'never published',
             });
         }));
         return packages.map(pkg => entries.get(pkg.name));
     }
-    DockerPublishService.getPlan = getPlan;
     /**
      * Publishes every `'publish'` entry in `plan`: one `docker login` and one `docker buildx create`
      * up front (each package's own build reuses them), then per package a single `docker buildx
@@ -80,12 +99,18 @@ export var DockerPublishService;
      * `DOCKER_README.md`), if present, updates the DockerHub repo description afterward. A package's
      * own failure doesn't stop unrelated packages elsewhere in the plan.
      */
-    async function applyPlan(repository, plan) {
+    async applyPlan(plan) {
+        const repository = this.repository;
         const toPublish = plan.filter(e => e.status === 'publish');
         if (!toPublish.length)
             return plan;
-        await dockerLogin(repository.dirname);
-        await exec('docker buildx create --use', { cwd: repository.dirname, stdio: 'inherit', throwOnError: false });
+        await dockerLogin(repository.app, repository.dirname);
+        await exec('docker buildx create --use', {
+            cwd: repository.dirname,
+            app: repository.app,
+            stdio: 'inherit',
+            throwOnError: false,
+        });
         const result = [];
         for (const entry of plan) {
             if (entry.status !== 'publish') {
@@ -103,12 +128,11 @@ export var DockerPublishService;
         }
         return result;
     }
-    DockerPublishService.applyPlan = applyPlan;
-})(DockerPublishService || (DockerPublishService = {}));
+}
 const execFileAsync = promisify(execFile);
 /** `docker manifest inspect <image>:<tag>` - `false` for any failure (tag doesn't exist yet, no
- *  network, not logged in, ...), same catch-everything shape as `PublishService`'s own
- *  `defaultNpmViewVersion`. */
+ *  network, not logged in, ...), the same catch-everything shape every target's registry check has:
+ *  "is this version out there" must never fail the run for a reason that is not an answer. */
 async function defaultImageExists(image, tag) {
     try {
         await execFileAsync('docker', ['manifest', 'inspect', `${image}:${tag}`]);
@@ -118,11 +142,6 @@ async function defaultImageExists(image, tag) {
         return false;
     }
 }
-function targetsDocker(pkg) {
-    const target = pkg.config.publish?.target;
-    const targets = Array.isArray(target) ? target : target ? [target] : ['npm'];
-    return targets.includes('docker');
-}
 function resolveImageRef(image, namespaceOverride) {
     if (image.includes('/'))
         return image;
@@ -138,13 +157,17 @@ function expandEnvValue(value) {
     const match = /^\$([A-Za-z_][A-Za-z0-9_]*)$/.exec(value);
     return match ? (process.env[match[1]] ?? '') : value;
 }
-async function dockerLogin(cwd) {
+async function dockerLogin(app, cwd) {
     const username = process.env.DOCKERHUB_USERNAME;
     const password = process.env.DOCKERHUB_PASSWORD;
     if (!username || !password) {
         throw new Error('DOCKERHUB_USERNAME/DOCKERHUB_PASSWORD environment variables are required to publish to Docker');
     }
-    await exec(`echo "${password}" | docker login --username "${username}" --password-stdin`, { cwd, stdio: 'inherit' });
+    await exec(`echo "${password}" | docker login --username "${username}" --password-stdin`, {
+        cwd,
+        app,
+        stdio: 'inherit',
+    });
 }
 async function buildAndPush(repository, entry) {
     const pkg = entry.package;
@@ -160,7 +183,7 @@ async function buildAndPush(repository, entry) {
         args.push('--build-arg', `${name}="${expandEnvValue(value)}"`);
     }
     args.push('-f', `"${dockerfile}"`, '-t', `"${entry.image}:${entry.version}"`, '-t', `"${entry.image}:latest"`, '--push', '.');
-    await exec(`docker ${args.join(' ')}`, { cwd, stdio: 'inherit' });
+    await exec(`docker ${args.join(' ')}`, { cwd, app: repository.app, stdio: 'inherit' });
 }
 async function updateDescription(entry) {
     const pkg = entry.package;

package/services/exec.service.d.ts

@@ -1,6 +1,22 @@
-import type { Repository } from '../core/repository.js';
+import { Service } from '../core/service.js';
 import { type LogLevel } from '../utils/logger.js';
 import { type PackageFilterOptions } from '../utils/package-filter.js';
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had. `repository` left the signature because the application carries it.
+ */
+export declare class ExecService extends Service {
+    /**
+     * `exec`: runs `command` (an arbitrary shell command, not an npm script) directly in every
+     * matching package's own directory - unlike `run`, there's no `package.json` script to resolve
+     * and no `pre<script>`/`post<script>` npm lifecycle convention to honor, since the command isn't
+     * tied to any script name at all. Everything else about how packages are selected and scheduled
+     * matches `run`: topological order and per-package bail by default, the same live progress panel
+     * (falling back to a classic one-line-per-package log when it's off), and the same
+     * `--scope`/`--ignore`/`--deps`/`--dependents`/`--changed` package filtering.
+     */
+    exec(command: string, options?: ExecService.Options): Promise<void>;
+}
 export declare namespace ExecService {
     interface Options extends PackageFilterOptions {
         /** Max packages at once: `true`/omitted = CPU count, a number = that many, `false` = serial (1). */
@@ -20,16 +36,11 @@ export declare namespace ExecService {
         /** Run across the whole repository even when the current directory is inside a single package
          *  (which otherwise scopes the run to just that package). Has no effect when already at the
          *  repository root, or outside any known package. */
-        root?: boolean;
+        fromRoot?: boolean;
+    }
+}
+declare module '../core/service.js' {
+    interface ServiceMap {
+        exec: ExecService;
     }
-    /**
-     * `exec`: runs `command` (an arbitrary shell command, not an npm script) directly in every
-     * matching package's own directory - unlike `run`, there's no `package.json` script to resolve
-     * and no `pre<script>`/`post<script>` npm lifecycle convention to honor, since the command isn't
-     * tied to any script name at all. Everything else about how packages are selected and scheduled
-     * matches `run`: topological order and per-package bail by default, the same live progress panel
-     * (falling back to a classic one-line-per-package log when it's off), and the same
-     * `--scope`/`--ignore`/`--deps`/`--dependents`/`--changed` package filtering.
-     */
-    function exec(repository: Repository, command: string, options?: Options): Promise<void>;
 }

package/services/exec.service.js

@@ -1,12 +1,16 @@
 import os from 'node:os';
 import colors from 'ansi-colors';
 import { Task } from 'power-tasks';
+import { Service } from '../core/service.js';
 import { exec as execCommand } from '../utils/exec.js';
 import { Logger, resolveRootLogLevel } from '../utils/logger.js';
 import { filterPackages } from '../utils/package-filter.js';
 import { ProgressPanel } from '../utils/progress-panel.js';
-export var ExecService;
-(function (ExecService) {
+/**
+ * A service class - see `ListService` for the shape and `Service` for the three measured
+ * consequences a namespace had. `repository` left the signature because the application carries it.
+ */
+export class ExecService extends Service {
     /**
      * `exec`: runs `command` (an arbitrary shell command, not an npm script) directly in every
      * matching package's own directory - unlike `run`, there's no `package.json` script to resolve
@@ -16,10 +20,11 @@ export var ExecService;
      * (falling back to a classic one-line-per-package log when it's off), and the same
      * `--scope`/`--ignore`/`--deps`/`--dependents`/`--changed` package filtering.
      */
-    async function exec(repository, command, options = {}) {
+    async exec(command, options = {}) {
+        const repository = this.repository;
         const logLevelDefault = resolveRootLogLevel(repository);
         const logger = new Logger(options.logLevel ?? logLevelDefault);
-        const cwdScope = options.root ? undefined : repository.currentPackage;
+        const cwdScope = options.fromRoot ? undefined : repository.currentPackage;
         const topo = options.topo ?? true;
         let packages = repository.getPackages({ toposort: topo, scope: cwdScope?.name });
         if (!topo)
@@ -48,7 +53,7 @@ export var ExecService;
         const children = packages.map(pkg => {
             const ctx = panel.addItem(pkg.name);
             const dependencies = topo ? pkg.dependencies.filter(d => names.has(d.name)).map(d => d.name) : [];
-            return new Task(() => execForPackage(ctx, panel.enabled, pkg.dirname, command, logger, bail ? () => rootTask?.abort() : () => { }), { name: pkg.name, dependencies });
+            return new Task(() => execForPackage(this.app, ctx, panel.enabled, pkg.dirname, command, logger, bail ? () => rootTask?.abort() : () => { }), { name: pkg.name, dependencies });
         });
         panel.start();
         let failed = false;
@@ -73,15 +78,15 @@ export var ExecService;
             throw err;
         }
     }
-    ExecService.exec = exec;
-})(ExecService || (ExecService = {}));
-async function execForPackage(ctx, panelEnabled, cwd, command, logger, abort) {
+}
+async function execForPackage(app, ctx, panelEnabled, cwd, command, logger, abort) {
     ctx.status = 'running';
     ctx.startedAt = Date.now();
     try {
         if (panelEnabled) {
             await execCommand(command, {
                 cwd,
+                app,
                 stdio: 'pipe',
                 onLine: line => {
                     ctx.log.push(line);
@@ -93,7 +98,7 @@ async function execForPackage(ctx, panelEnabled, cwd, command, logger, abort) {
             logger.info(colors.cyan('exec'), colors.cyan(ctx.name), command);
             const t = Date.now();
             try {
-                await execCommand(command, { cwd, stdio: 'inherit' });
+                await execCommand(command, { cwd, app, stdio: 'inherit' });
                 logger.info(colors.green('success'), colors.cyan(ctx.name), colors.yellow(`(${Date.now() - t} ms)`));
             }
             catch (e) {