build-strap 5.0.7-dev.116 → 5.1.0-dev.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-strap",
-  "version": "5.0.7-dev.116",
+  "version": "5.1.0-dev.118",
   "description": "Node scripts for building things",
   "license": "MIT",
   "authors": [
@@ -14,22 +14,22 @@
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "dependencies": {
     "bytes": "^3.1.1",
-    "chokidar": "^3.5.2",
+    "chokidar": "^3.6.0",
     "cross-spawn": "^7.0.3",
-    "fs-extra": "^11.1.0",
-    "get-port": "^6.0.0",
-    "glob": "^8.0.1",
+    "fs-extra": "^11.2.0",
+    "get-port": "^7.1.0",
+    "glob": "^10.3.14",
     "is-reachable": "^5.1.1",
     "js-yaml": "^4.1.0",
     "lodash-es": "^4.17.21",
-    "moment": "^2.29.1",
-    "node-fetch": "^3.1.0",
-    "rimraf": "^3.0.2",
+    "moment": "^2.30.1",
+    "node-fetch": "^3.3.2",
+    "rimraf": "^5.0.5",
     "stream-counter": "1",
-    "tar": "^6.1.11"
+    "tar": "^7.1.0"
   }
 }

package/src/ant.js

@@ -5,7 +5,7 @@ import { spawn } from './cp.js';
  * @param {AntSpawnOptions} options
  */
 export async function ant(target, opts) {
-    const { properties = [], args = [], spawnOptions } = opts || {};
+    const { args = [], properties = [], spawnOptions } = opts || {};
     await spawn('ant', [
         target,
         ...args,

package/src/clean.js

@@ -6,6 +6,5 @@ export async function clean(globs = ['dist/*', 'out/*', 'build/*']) {
     await Promise.all(globs.map((glob) => cleanDir(glob, {
         dot: true,
         ignore: ['.git', '.hg'],
-        nosort: true,
     })));
 }

package/src/copy.d.ts

@@ -4,4 +4,4 @@ export interface CopySrcOptions {
     to: string;
     watch?: boolean;
 }
-export declare function copySrc({ from, to, watch, cbFn, }: CopySrcOptions): Promise<void>;
+export declare function copySrc({ cbFn, from, to, watch, }: CopySrcOptions): Promise<void>;

package/src/copy.js

@@ -18,7 +18,7 @@ async function throttledCallback(cbFn) {
         cbFn();
     }, 200);
 }
-export async function copySrc({ from, to, watch = process.argv.includes('--watch'), cbFn, }) {
+export async function copySrc({ cbFn, from, to, watch = process.argv.includes('--watch'), }) {
     await copyDir(from, to);
     if (cbFn)
         await cbFn();
@@ -38,7 +38,7 @@ export async function copySrc({ from, to, watch = process.argv.includes('--watch
                     break;
                 case 'unlink':
                 case 'unlinkDir':
-                    cleanDir(dest, { dot: true, nosort: true });
+                    cleanDir(dest, { dot: true });
                     break;
                 default:
                     return;

package/src/docker.container.d.ts

@@ -59,8 +59,8 @@ interface DockerContainerRunDaemonArgs {
 interface DockerContainerRunArgs extends DockerContainerRunDaemonArgs {
     spawnOptions?: SpawnOptions | null;
 }
-export declare function dockerContainerRun({ image, runArgs, cmd, spawnOptions, }: DockerContainerRunArgs): Promise<string>;
-export declare function dockerContainerRunDaemon({ image, runArgs, cmd, waitAttempts, waitDuration, }: DockerContainerRunDaemonArgs): Promise<DockerContainer>;
+export declare function dockerContainerRun({ cmd, image, runArgs, spawnOptions, }: DockerContainerRunArgs): Promise<string>;
+export declare function dockerContainerRunDaemon({ cmd, image, runArgs, waitAttempts, waitDuration, }: DockerContainerRunDaemonArgs): Promise<DockerContainer>;
 /**
  * Waits for the given container to be fully started. Checks that the container is
  * running, and test with the provided testFn every second until it returns true.

package/src/docker.container.js

@@ -170,14 +170,14 @@ export async function unthrottledDockerContainerInspect(id) {
 export const dockerContainerInspect = throttle(unthrottledDockerContainerInspect, 500, {
     trailing: false,
 });
-export async function dockerContainerRun({ image, runArgs = [], cmd = [], spawnOptions, }) {
+export async function dockerContainerRun({ cmd = [], image, runArgs = [], spawnOptions, }) {
     return (await spawn('docker', ['container', 'run', ...runArgs, image, ...cmd], {
         pipeOutput: true,
         stdio: 'inherit',
         ...spawnOptions,
     })).output;
 }
-export async function dockerContainerRunDaemon({ image, runArgs = [], cmd = [], waitAttempts = 10, waitDuration = 501, }) {
+export async function dockerContainerRunDaemon({ cmd = [], image, runArgs = [], waitAttempts = 10, waitDuration = 501, }) {
     const id = (await dockerContainerRun({
         cmd,
         image,

package/src/docker.js

@@ -140,7 +140,7 @@ export function getDockerRepo() {
     return `${registry ? `${registry}/` : ''}${repository}/${name}`;
 }
 export async function dockerPullAndRunContainer(options) {
-    const { image, runArgs = [], cmd = [], network, alias, offline = process.argv.includes('--offline'), testUrl, } = options;
+    const { alias, cmd = [], image, network, offline = process.argv.includes('--offline'), runArgs = [], testUrl, } = options;
     try {
         await dockerPull({ image, offline, testUrl });
     }

package/src/docker.network.d.ts

@@ -27,7 +27,7 @@ export interface DockerNetworkCreateOptions {
     labels?: string[];
     subnets?: string[];
 }
-export declare function dockerNetworkCreate(networkName: string, { driver, driverOpts, ipRange, gateways, subnets, auxAddresses, ingress, internal, ipv6, labels, }?: DockerNetworkCreateOptions): Promise<DockerNetwork | null>;
+export declare function dockerNetworkCreate(networkName: string, { auxAddresses, driver, driverOpts, gateways, ingress, internal, ipRange, ipv6, labels, subnets, }?: DockerNetworkCreateOptions): Promise<DockerNetwork | null>;
 /**
  * Removes a network by id
  * @param {string} id The id of the network

package/src/docker.network.js

@@ -31,7 +31,7 @@ export const dockerNetworkLs = throttle(unthrottledDockerNetworkLs, 500, {
 export async function dockerNetworkFind(networkName, options) {
     return ((await dockerNetworkLs(options))?.find((n) => n.name === networkName || n.id === networkName) || null);
 }
-export async function dockerNetworkCreate(networkName, { driver, driverOpts = {}, ipRange, gateways = [], subnets = [], auxAddresses = [], ingress, internal, ipv6, labels = [], } = {}) {
+export async function dockerNetworkCreate(networkName, { auxAddresses = [], driver, driverOpts = {}, gateways = [], ingress, internal, ipRange, ipv6, labels = [], subnets = [], } = {}) {
     const existing = await dockerNetworkFind(networkName);
     if (existing)
         return existing;

package/src/docker.volume.d.ts

@@ -19,7 +19,7 @@ export interface DockerVolumeCreateOptions {
     driverOpts?: Record<string, string>;
     labels?: string[];
 }
-export declare function dockerVolumeCreate(name: string, { labels, driver, driverOpts }?: DockerVolumeCreateOptions): Promise<null | DockerVolume>;
+export declare function dockerVolumeCreate(name: string, { driver, driverOpts, labels }?: DockerVolumeCreateOptions): Promise<null | DockerVolume>;
 export declare function dockerVolumeRm(id: string | string[], ignoreErrors?: boolean): Promise<void>;
 export declare function unthrottledDockerVolumeInspect(id: string | string[]): Promise<DockerVolumeInspectOutput[]>;
 export declare const dockerVolumeInspect: (id: string | string[]) => undefined | Promise<DockerVolumeInspectOutput[]>;

package/src/docker.volume.js

@@ -28,7 +28,7 @@ export const dockerVolumeLs = throttle(unthrottledDockerVolumeLs, 500, {
 export async function dockerVolumeFind(search, options) {
     return ((await dockerVolumeLs(options))?.find((v) => v.name === search || v.name.startsWith(search)) ?? null);
 }
-export async function dockerVolumeCreate(name, { labels = [], driver, driverOpts = {} } = {}) {
+export async function dockerVolumeCreate(name, { driver, driverOpts = {}, labels = [] } = {}) {
     const existing = await dockerVolumeFind(name);
     if (existing)
         return existing;

package/src/dockerCleanup.d.ts

@@ -28,7 +28,7 @@ interface DockerImageCleanupOptions extends CommonDockerCleanupOptions {
 /**
  * Purge docker images created during build process
  */
-export declare const dockerImageCleanup: ({ repos, buildImageIds, images, purgeAll, purgeOld, dryRun, }?: DockerImageCleanupOptions) => Promise<void>;
+export declare const dockerImageCleanup: ({ buildImageIds, dryRun, images, purgeAll, purgeOld, repos, }?: DockerImageCleanupOptions) => Promise<void>;
 interface DockerCleanupOptions extends DockerImageCleanupOptions, CommonDockerCleanupOptions {
 }
 /**

package/src/dockerCleanup.js

@@ -38,7 +38,7 @@ export const dockerContainerCleanup = async ({ dryRun = process.argv.includes('-
 /**
  * Purge docker images created during build process
  */
-export const dockerImageCleanup = async ({ repos = [getDockerRepo()], buildImageIds = [], images = [], purgeAll = process.argv.includes('--purge-all'), purgeOld = !process.argv.includes('--keep-old'), dryRun = process.argv.includes('--dry-run'), } = {}) => {
+export const dockerImageCleanup = async ({ buildImageIds = [], dryRun = process.argv.includes('--dry-run'), images = [], purgeAll = process.argv.includes('--purge-all'), purgeOld = !process.argv.includes('--keep-old'), repos = [getDockerRepo()], } = {}) => {
     // only match images without a :latest tag
     const filterLatest = (m) => purgeAll || !m.tag.match(/^latest(-\w+)?$/);
     // only match images more than an hour old, AND without a :latest* tag

package/src/dockerCompose.d.ts

@@ -124,7 +124,7 @@ export declare class DockerComposeService {
     getBaseRunArgs(): Promise<string[]>;
     assembleRunArgs(containerName?: string, aliases?: string[], additionalArgs?: null | string[]): Promise<string[]>;
     getRunArgs(avoidConflicts?: boolean, mapLocalPorts?: boolean): Promise<string[]>;
-    up({ healthCheck, avoidConflicts, mapVolumes, mapPorts, cmd, tracker, }?: UpOptions): Promise<UpResult>;
+    up({ avoidConflicts, cmd, healthCheck, mapPorts, mapVolumes, tracker, }?: UpOptions): Promise<UpResult>;
     down({ includeDefaults, includeNetworks, includeVolumes, }?: {
         includeDefaults?: boolean;
         includeNetworks?: boolean;
@@ -134,7 +134,7 @@ export declare class DockerComposeService {
     static getUrls(ports: PortMap[], alias: string): UrlMap[];
 }
 export declare function dockerComposeGetAllServices(dockerCompose?: null | (string | DockerCompose)): Promise<Record<string, null | DockerComposeService>>;
-export declare function dockerComposeTeardown({ includeDefaults, includeVolumes, includeNetworks, dockerCompose, tracker, }?: {
+export declare function dockerComposeTeardown({ dockerCompose, includeDefaults, includeNetworks, includeVolumes, tracker, }?: {
     dockerCompose?: null | (string | DockerCompose);
     includeDefaults?: boolean;
     includeNetworks?: boolean;

package/src/dockerCompose.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _DockerComposeService_name, _DockerComposeService_svcDef, _DockerComposeService_dockerCompose, _DockerComposeService_tracker, _DockerComposeService_parsedPorts, _DockerComposeService_parsedNetworks, _DockerComposeService_parsedVolumes, _DockerComposeService_baseRunArgs;
 import fs from 'fs-extra';
 import getPort from 'get-port';
 import yaml from 'js-yaml';
@@ -127,37 +115,37 @@ export const dockerComposeCreateVolumes = async (names, dockerCompose, tracker =
     }));
 };
 export class DockerComposeService {
+    #name;
+    #svcDef;
+    #dockerCompose;
+    #tracker = dockerComposeCreateResourceTracker();
+    // lazily computed
+    #parsedPorts = null;
+    #parsedNetworks = null;
+    #parsedVolumes = null;
+    #baseRunArgs = null;
     constructor(name, serviceDef, dockerCompose) {
-        _DockerComposeService_name.set(this, void 0);
-        _DockerComposeService_svcDef.set(this, void 0);
-        _DockerComposeService_dockerCompose.set(this, void 0);
-        _DockerComposeService_tracker.set(this, dockerComposeCreateResourceTracker());
-        // lazily computed
-        _DockerComposeService_parsedPorts.set(this, null);
-        _DockerComposeService_parsedNetworks.set(this, null);
-        _DockerComposeService_parsedVolumes.set(this, null);
-        _DockerComposeService_baseRunArgs.set(this, null);
-        __classPrivateFieldSet(this, _DockerComposeService_name, name, "f");
-        __classPrivateFieldSet(this, _DockerComposeService_svcDef, serviceDef, "f");
-        __classPrivateFieldSet(this, _DockerComposeService_dockerCompose, dockerCompose || null, "f");
+        this.#name = name;
+        this.#svcDef = serviceDef;
+        this.#dockerCompose = dockerCompose || null;
     }
     get name() {
-        return __classPrivateFieldGet(this, _DockerComposeService_name, "f");
+        return this.#name;
     }
     get serviceDef() {
-        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f");
+        return this.#svcDef;
     }
     get image() {
-        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").image || null;
+        return this.#svcDef.image || null;
     }
     get defaultContainerName() {
-        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").container_name || __classPrivateFieldGet(this, _DockerComposeService_name, "f");
+        return this.#svcDef.container_name || this.#name;
     }
     get cmd() {
-        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").command || [];
+        return this.#svcDef.command || [];
     }
     get envArgs() {
-        return parseEnv(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").environment);
+        return parseEnv(this.#svcDef.environment);
     }
     /**
      * Find (available) container name and alias(es)
@@ -183,13 +171,13 @@ export class DockerComposeService {
     }
     // Get (available) port mappings
     async getPorts(avoidConflicts = false, mapLocal = true) {
-        return parsePorts(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").ports, avoidConflicts, mapLocal);
+        return parsePorts(this.#svcDef.ports, avoidConflicts, mapLocal);
     }
     async getDefaultPortInfo() {
-        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedPorts, "f")) {
-            __classPrivateFieldSet(this, _DockerComposeService_parsedPorts, await this.getPorts(), "f");
+        if (!this.#parsedPorts) {
+            this.#parsedPorts = await this.getPorts();
         }
-        return __classPrivateFieldGet(this, _DockerComposeService_parsedPorts, "f");
+        return this.#parsedPorts;
     }
     async getDefaultPorts() {
         const { ports } = await this.getDefaultPortInfo();
@@ -203,10 +191,10 @@ export class DockerComposeService {
         return DockerComposeService.getUrls(await this.getDefaultPorts(), this.defaultContainerName);
     }
     async getDefaultNetworkInfo() {
-        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedNetworks, "f")) {
-            __classPrivateFieldSet(this, _DockerComposeService_parsedNetworks, await parseNetworks(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").networks), "f");
+        if (!this.#parsedNetworks) {
+            this.#parsedNetworks = await parseNetworks(this.#svcDef.networks);
         }
-        return __classPrivateFieldGet(this, _DockerComposeService_parsedNetworks, "f");
+        return this.#parsedNetworks;
     }
     async getDefaultNetworks() {
         const { networks } = await this.getDefaultNetworkInfo();
@@ -217,10 +205,10 @@ export class DockerComposeService {
         return runArgs;
     }
     async getDefaultVolumeInfo() {
-        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedVolumes, "f")) {
-            __classPrivateFieldSet(this, _DockerComposeService_parsedVolumes, await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").networks), "f");
+        if (!this.#parsedVolumes) {
+            this.#parsedVolumes = await parseVolumes(this.#svcDef.networks);
         }
-        return __classPrivateFieldGet(this, _DockerComposeService_parsedVolumes, "f");
+        return this.#parsedVolumes;
     }
     async getDefaultVolumes() {
         const { volumes } = await this.getDefaultVolumeInfo();
@@ -237,13 +225,13 @@ export class DockerComposeService {
         await dockerPull({ image: this.image });
     }
     async getBaseRunArgs() {
-        if (!__classPrivateFieldGet(this, _DockerComposeService_baseRunArgs, "f")) {
-            const envArgs = parseEnv(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").environment);
-            const ulArgs = parseULimits(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").ulimits);
+        if (!this.#baseRunArgs) {
+            const envArgs = parseEnv(this.#svcDef.environment);
+            const ulArgs = parseULimits(this.#svcDef.ulimits);
             const netArgs = await this.getDefaultNetworkArgs();
-            __classPrivateFieldSet(this, _DockerComposeService_baseRunArgs, ['--rm', ...envArgs, ...netArgs, ...ulArgs], "f");
+            this.#baseRunArgs = ['--rm', ...envArgs, ...netArgs, ...ulArgs];
         }
-        return __classPrivateFieldGet(this, _DockerComposeService_baseRunArgs, "f");
+        return this.#baseRunArgs;
     }
     async assembleRunArgs(containerName = this.defaultContainerName, aliases = [this.name], additionalArgs = null) {
         const additional = additionalArgs || [
@@ -260,21 +248,21 @@ export class DockerComposeService {
     async getRunArgs(avoidConflicts = false, mapLocalPorts = true) {
         const { aliases, name: cName, suffix, } = await this.getNames(avoidConflicts);
         const { runArgs: pArgs } = await this.getPorts(avoidConflicts, mapLocalPorts);
-        const { runArgs: vArgs } = await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").volumes, suffix);
+        const { runArgs: vArgs } = await parseVolumes(this.#svcDef.volumes, suffix);
         return this.assembleRunArgs(cName, aliases, [...pArgs, ...vArgs]);
     }
-    async up({ healthCheck, avoidConflicts = false, mapVolumes = true, mapPorts = true, cmd = this.cmd, tracker = defaultTracker, } = {}) {
+    async up({ avoidConflicts = false, cmd = this.cmd, healthCheck, mapPorts = true, mapVolumes = true, tracker = defaultTracker, } = {}) {
         const { image } = this;
         if (!image) {
             throw new Error(`Cannot bring up service '${this.name}', no image defined.`);
         }
-        if (__classPrivateFieldGet(this, _DockerComposeService_tracker, "f").containers.size) {
+        if (this.#tracker.containers.size) {
             buildLog(`Warning: up called on service '${this.name}' with already running container`);
         }
         const { aliases, name: containerName, suffix, } = await this.getNames(avoidConflicts);
         const { ports, runArgs: pArgs } = await this.getPorts(avoidConflicts, mapPorts);
         const { runArgs: vArgs, volumes } = mapVolumes
-            ? await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").volumes, suffix)
+            ? await parseVolumes(this.#svcDef.volumes, suffix)
             : { runArgs: [], volumes: [] };
         let container = await dockerContainerFind(containerName, { all: true });
         if (container && !(await container.isRunning())) {
@@ -282,8 +270,8 @@ export class DockerComposeService {
         }
         if (!container) {
             await this.pull();
-            await dockerComposeCreateNetworks(await this.getDefaultNetworks(), __classPrivateFieldGet(this, _DockerComposeService_dockerCompose, "f"), __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"));
-            await dockerComposeCreateVolumes(volumes, __classPrivateFieldGet(this, _DockerComposeService_dockerCompose, "f"), __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"));
+            await dockerComposeCreateNetworks(await this.getDefaultNetworks(), this.#dockerCompose, this.#tracker);
+            await dockerComposeCreateVolumes(volumes, this.#dockerCompose, this.#tracker);
             const runArgs = await this.assembleRunArgs(containerName, aliases, [
                 ...pArgs,
                 ...vArgs,
@@ -298,7 +286,7 @@ export class DockerComposeService {
             buildLog(`Reusing existing container for '${this.name}' service.`);
         }
         // This service tracks the things it created
-        __classPrivateFieldGet(this, _DockerComposeService_tracker, "f").containers.set(containerName, container);
+        this.#tracker.containers.set(containerName, container);
         // The passed tracker needs to track this service
         tracker.services.set(this.name, this);
         const idAlias = container.id.slice(0, 12);
@@ -321,7 +309,7 @@ export class DockerComposeService {
         await dockerComposeTeardown({
             includeNetworks,
             includeVolumes,
-            tracker: __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"),
+            tracker: this.#tracker,
         });
         if (includeDefaults) {
             const container = await dockerContainerFind(this.defaultContainerName);
@@ -341,12 +329,11 @@ export class DockerComposeService {
         }));
     }
 }
-_DockerComposeService_name = new WeakMap(), _DockerComposeService_svcDef = new WeakMap(), _DockerComposeService_dockerCompose = new WeakMap(), _DockerComposeService_tracker = new WeakMap(), _DockerComposeService_parsedPorts = new WeakMap(), _DockerComposeService_parsedNetworks = new WeakMap(), _DockerComposeService_parsedVolumes = new WeakMap(), _DockerComposeService_baseRunArgs = new WeakMap();
 export async function dockerComposeGetAllServices(dockerCompose) {
     const { services } = await dockerComposeResolve(dockerCompose);
     return mapValuesAsync(services, (s, name) => DockerComposeService.parse(name));
 }
-export async function dockerComposeTeardown({ includeDefaults = false, includeVolumes = false, includeNetworks = false, dockerCompose, tracker = defaultTracker, } = {}) {
+export async function dockerComposeTeardown({ dockerCompose, includeDefaults = false, includeNetworks = false, includeVolumes = false, tracker = defaultTracker, } = {}) {
     if (!tracker.cleaning) {
         // eslint-disable-next-line no-param-reassign
         tracker.cleaning = (async () => {
@@ -426,7 +413,7 @@ export async function dockerComposeRunService(key, upOptions = {}, dockerCompose
     }
     buildLog(`Starting <${service.name}> service...`);
     const upResult = await service.up(upOptions);
-    const { container, urls, urls: [{ docker: dockerUrl, local: url }], ports: [{ docker: dockerPort, local: port }], } = upResult;
+    const { container, ports: [{ docker: dockerPort, local: port }], urls, urls: [{ docker: dockerUrl, local: url }], } = upResult;
     const { id, image, name } = container;
     urls.forEach(({ local }) => local && buildLog(`<${service.name}> accessible at ${local}`));
     return {

package/src/env.d.ts

@@ -12,9 +12,9 @@ export declare const cmdExists: (cmd: string) => Promise<boolean>;
 interface ReadShellEnvVarOptions {
     envFile?: string | null;
     refreshEnv?: boolean;
-    shell?: string;
+    shell?: string | null;
 }
-export declare const readShellEnvVar: (name: string, { refreshEnv, envFile, shell, }?: ReadShellEnvVarOptions) => Promise<string | null>;
+export declare const readShellEnvVar: (name: string, { envFile, refreshEnv, shell, }?: ReadShellEnvVarOptions) => Promise<string | null>;
 export interface AppendToEnvOptions {
     envFile?: string | null;
     testContent?: string | StringGenFn;

package/src/env.js

@@ -25,7 +25,7 @@ const cacheString = (key, fn) => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return stringCache.get(key);
 };
-export const shellType = () => cacheString('shellType', () => os.userInfo().shell.split('/').pop() || null);
+export const shellType = () => cacheString('shellType', () => os.userInfo().shell?.split('/').pop() || null);
 export const shellEnvFile = () => cacheString('shellEnvFile', () => {
     switch (shellType()) {
         case 'zsh':
@@ -61,10 +61,13 @@ export const whichCmd = async (cmd) => {
     return binPath;
 };
 export const cmdExists = async (cmd) => !!(await whichCmd(cmd));
-export const readShellEnvVar = async (name, { refreshEnv = true, envFile = shellEnvFile(), shell = os.userInfo().shell, } = {}) => {
+export const readShellEnvVar = async (name, { envFile = shellEnvFile(), refreshEnv = true, shell = os.userInfo().shell, } = {}) => {
     if (refreshEnv && (!envFile || !(await fs.pathExists(envFile)))) {
         throw new Error(`Could not find shell env file: ${envFile}`);
     }
+    if (!shell) {
+        throw new Error('Could not determine shell');
+    }
     try {
         return (await spawn(shell, [
             '-c',

package/src/fs.d.ts

@@ -1,8 +1,8 @@
-import glob from 'glob';
-export declare const readDir: (pattern: string, options?: glob.IOptions) => Promise<string[]>;
+import { GlobOptions, GlobOptionsWithFileTypesUnset } from 'glob';
+export declare const readDir: (pattern: string, options?: GlobOptionsWithFileTypesUnset) => Promise<string[]>;
 export declare const moveDir: (source: string, target: string) => Promise<void>;
-export declare const copyDir: (source: string, target: string, fileGlob?: string, globOptions?: null | glob.IOptions, renameFn?: (name: string) => string) => Promise<void>;
-export declare const cleanDir: (pattern: string, globOptions?: glob.IOptions | false) => Promise<void>;
+export declare const copyDir: (source: string, target: string, fileGlob?: string, globOptions?: null | GlobOptionsWithFileTypesUnset, renameFn?: (name: string) => string) => Promise<void>;
+export declare const cleanDir: (pattern: string, globOptions?: GlobOptions | false) => Promise<boolean>;
 export declare const producedPathExists: (producer: () => Promise<string>) => Promise<boolean>;
 export declare const copyIfMissing: (src: string, dest: string) => Promise<void>;
 export type StringGenFn = () => string | Promise<string>;

package/src/fs.js

@@ -1,17 +1,14 @@
 import fs from 'fs-extra';
-import glob from 'glob';
+import { glob } from 'glob';
 import path from 'path';
-import rimraf from 'rimraf';
+import { rimraf } from 'rimraf';
 import { resolveOnce } from './promise.js';
 import { buildLog } from './run.js';
-export const readDir = async (pattern, options) => new Promise((resolve, reject) => {
-    glob(pattern, options || {}, (err, result) => err ? reject(err) : resolve(result));
-});
+export const readDir = async (pattern, options) => glob(pattern, options);
 export const moveDir = async (source, target) => {
     const dirs = await readDir('**/*.*', {
         cwd: source,
         dot: true,
-        nosort: true,
     });
     await Promise.all(dirs.map(async (dir) => {
         const from = path.resolve(source, dir);
@@ -25,7 +22,6 @@ export const copyDir = async (source, target, fileGlob = '**/*.*', globOptions =
         cwd: source,
         dot: true,
         nodir: true,
-        nosort: true,
         ...globOptions,
     });
     await Promise.all(paths.map(async (p) => {
@@ -35,9 +31,7 @@ export const copyDir = async (source, target, fileGlob = '**/*.*', globOptions =
         await fs.copyFile(from, to);
     }));
 };
-export const cleanDir = async (pattern, globOptions) => new Promise((resolve, reject) => {
-    rimraf(pattern, { glob: globOptions }, (err) => err ? reject(err) : resolve());
-});
+export const cleanDir = async (pattern, globOptions) => rimraf(pattern, { glob: globOptions });
 export const producedPathExists = async (producer) => {
     try {
         const result = (await producer()).trim();

package/src/gh.d.ts

@@ -2,17 +2,17 @@ import { SpawnOptions } from './cp.js';
 export declare const gh: (args: string[], options?: SpawnOptions) => Promise<import("./cp.js").SpawnResult>;
 export declare const ghRepoClone: (repo: string, repoDir: string) => Promise<void>;
 export declare const ensureGhRepo: (repo: string, { rootDir, targetDir, targetName, }?: {
-    rootDir?: string | undefined;
-    targetDir?: string | undefined;
-    targetName?: string | undefined;
+    rootDir?: string;
+    targetDir?: string;
+    targetName?: string;
 }) => Promise<void>;
 export declare const ensureGhAuthLogin: ({ host, scopes, }?: {
-    host?: string | undefined;
-    scopes?: string | undefined;
+    host?: string;
+    scopes?: string;
 }) => Promise<void>;
 export declare const ensureGhSshKeyAdded: ({ keyTitle, privateKeyPath, }?: {
-    keyTitle?: string | undefined;
-    privateKeyPath?: string | undefined;
+    keyTitle?: string;
+    privateKeyPath?: string;
 }) => Promise<void>;
 export declare const ensureGhConfig: (key: string, value: string, host?: string) => Promise<void>;
 export declare const ensureGhConfigSshGitProtocol: (host?: string) => Promise<void>;

package/src/maps.d.ts

@@ -4,7 +4,7 @@
  * @param {Function} map the mapping operation
  * @returns {ObjMap} a new object
  */
-export declare const mapValues: <K extends string, V, R>(obj: Record<K, V> | null | undefined, map: (value: V, key: K, map: Record<K, V>) => R) => Record<K, R>;
+export declare const mapValues: <K extends string, V, R>(obj: null | undefined | Record<K, V>, map: (value: V, key: K, map: Record<K, V>) => R) => Record<K, R>;
 /**
  * Given a `ObjMap`, iterate over each entry and run it through the given async `map` function.
  * The promise returned by the `map` is awaited, such that the resulting `ObjMap` values are
@@ -13,7 +13,7 @@ export declare const mapValues: <K extends string, V, R>(obj: Record<K, V> | nul
  * @param {Function} map the async mapping operation
  * @returns {Promise} a promise for a new object
  */
-export declare const mapValuesAsync: <K extends string, V, R>(obj: Record<K, V> | null | undefined, map: (value: V, key: K, objMap: Record<K, V>) => Promise<R>) => Promise<Record<K, R>>;
+export declare const mapValuesAsync: <K extends string, V, R>(obj: null | undefined | Record<K, V>, map: (value: V, key: K, objMap: Record<K, V>) => Promise<R>) => Promise<Record<K, R>>;
 /**
  * Given a `ObjMap`, iterate over each entry and run it through the given `filter` function.
  * Any entry for which the `filter` returns `false` is removed from the resulting `ObjMap`.
@@ -23,7 +23,7 @@ export declare const mapValuesAsync: <K extends string, V, R>(obj: Record<K, V>
  * @param {Function} filter the filter operation
  * @returns {ObjMap} a new object, a subset of the input
  */
-export declare const filterKeys: <V, K extends string = string>(obj: Record<K, V> | null | undefined, filter?: (value: V, key: K, objMap: Record<K, V>) => boolean) => Partial<Record<K, V>>;
+export declare const filterKeys: <V, K extends string = string>(obj: null | undefined | Record<K, V>, filter?: (value: V, key: K, objMap: Record<K, V>) => boolean) => Partial<Record<K, V>>;
 /**
  * Given an object, removes any top level keys with a nullish value.
  * The type system should preserve the incoming object type, with all such keys typed as `empty`.

package/src/npm.d.ts

@@ -18,7 +18,7 @@ export interface NpmOptions {
     npmPath?: string;
     spawnOptions?: SpawnOptions;
 }
-export declare function npm({ args, spawnOptions, npmPath, }?: NpmOptions): Promise<SpawnResult>;
+export declare function npm({ args, npmPath, spawnOptions, }?: NpmOptions): Promise<SpawnResult>;
 export declare function npmGetVersions(packageName: string, npmPath?: string): Promise<string[]>;
 interface NpmWriteRcOptions {
     authToken?: string;

package/src/npm.js

@@ -10,7 +10,7 @@ export function getNpmConfig() {
 }
 export const envNpmCreds = (process.env.NPM_CREDS && JSON.parse(process.env.NPM_CREDS)) || null;
 const npmExe = (npmPath) => npmPath || (platform() === 'win32' ? 'npm.cmd' : 'npm');
-export async function npm({ args = [], spawnOptions, npmPath, } = {}) {
+export async function npm({ args = [], npmPath, spawnOptions, } = {}) {
     const localNpm = path.join(path.dirname(process.execPath), 'lib/node_modules/npm/bin/npm-cli.js');
     const spawnOpts = {
         env: process.env,

package/src/promise.d.ts

@@ -4,4 +4,4 @@
  * @param producer a function that produces a promise, will be invoked at most once
  * @returns a function that returns a promise
  */
-export declare const resolveOnce: <T>(producer: () => Promise<T>) => () => Promise<T>;
+export declare const resolveOnce: <T>(producer: () => Promise<T>) => (() => Promise<T>);

package/src/run.d.ts

@@ -10,4 +10,4 @@ export interface RunCliOptions<Args extends string[], Result> {
     passthroughArgv?: Args | boolean;
     resolveFn?: (path: string) => Promise<RunnableModule<Args, Result>> | RunnableModule<Args, Result>;
 }
-export declare function runCli<Args extends string[], Result>({ resolveFn, defaultAction, argv, passthroughArgv, }?: RunCliOptions<Args, Result>): Promise<Result>;
+export declare function runCli<Args extends string[], Result>({ argv, defaultAction, passthroughArgv, resolveFn, }?: RunCliOptions<Args, Result>): Promise<Result>;

package/src/run.js

@@ -24,7 +24,7 @@ export async function run(fn, ...options) {
     buildLog(`Finished '${task.name}' after ${time} ms`, end);
     return result;
 }
-export async function runCli({ resolveFn = async (path) => import(`./${path}.js`), defaultAction = 'build', argv = process.argv, passthroughArgv = false, } = {}) {
+export async function runCli({ argv = process.argv, defaultAction = 'build', passthroughArgv = false, resolveFn = async (path) => import(`./${path}.js`), } = {}) {
     const module = argv.length > 2
         ? await resolveFn(argv[2])
         : typeof defaultAction === 'string'

package/src/tgz.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Readable } from 'stream';
-import tar from 'tar';
+import { TarOptionsWithAliases } from 'tar/dist/commonjs/options.js';
 export type ArtifactInfo = {
     contentType?: string;
     md5: string;
@@ -9,5 +9,5 @@ export type ArtifactInfo = {
     size: number;
 };
 export declare const generateFileHash: (filePath: string, type: 'md5' | 'sha1' | 'sha512') => Promise<string>;
-export declare function getArtifactInfo(artifact: string | Readable): Promise<ArtifactInfo>;
-export declare function tgzDir(srcDir: string, outPath: string, options?: tar.CreateOptions): Promise<ArtifactInfo>;
+export declare function getArtifactInfo(artifact: string | Pick<Readable, 'pipe'>): Promise<ArtifactInfo>;
+export declare function tgzDir(srcDir: string, outPath: string, options?: TarOptionsWithAliases): Promise<ArtifactInfo>;

package/src/tgz.js

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import fs from 'fs-extra';
 import path from 'path';
 import StreamCounter from 'stream-counter';
-import tar from 'tar';
+import { create } from 'tar';
 import { buildLog } from './run.js';
 const generateHash = async (stream, type) => new Promise((resolve, reject) => {
     stream
@@ -49,7 +49,7 @@ export async function getArtifactInfo(artifact) {
 // Creates a gzipped tarball of a directory, returns sha1 + md5 hash and size of resulting file
 export async function tgzDir(srcDir, outPath, options) {
     await fs.ensureDir(path.dirname(outPath));
-    const tgzStream = tar.c({
+    const tgzStream = create({
         cwd: srcDir,
         gzip: true,
         portable: true,