build-strap 4.0.0-dev.56 → 4.1.0-dev.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-strap",
-  "version": "4.0.0-dev.56",
+  "version": "4.1.0-dev.59",
   "description": "Node scripts for building things",
   "license": "MIT",
   "authors": [

package/src/brew.d.ts

@@ -0,0 +1,6 @@
+import { SpawnOptions } from './cp.js';
+export declare const ensureBrewInstalled: () => Promise<void>;
+export declare const brew: (args: string[], options?: SpawnOptions | undefined) => Promise<import("./cp.js").SpawnResult>;
+export declare const brewBundleCheck: (brewFile: string) => Promise<boolean>;
+export declare const brewBundleInstall: (brewFile: string) => Promise<void>;
+export declare const ensureBrewfileInstalled: (brewFile: string) => Promise<void>;

package/src/brew.js

@@ -0,0 +1,74 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { spawn } from './cp.js';
+import { cmdExists } from './env.js';
+import { appendIfMissing } from './fs.js';
+const brewPath = async () => {
+    for (const testPath of [
+        '/opt/homebrew/bin/brew',
+        '/usr/local/bin/brew',
+        '/home/linuxbrew/.linuxbrew/bin/brew',
+        `${os.homedir()}/.linuxbrew/bin/brew`,
+    ]) {
+        if (await fs.pathExists(testPath)) {
+            return testPath;
+        }
+    }
+    throw new Error('brew not found in default install path');
+};
+const brewPathExists = async () => {
+    try {
+        return !!(await brewPath());
+    }
+    catch {
+        return false;
+    }
+};
+const appendBrewShellEnv = async () => {
+    const brewDir = path.dirname(await brewPath());
+    await appendIfMissing(path.join(os.homedir(), '.zprofile'), `\neval "$(${brewDir}/brew shellenv)"`);
+    if (!process.env.PATH?.includes(brewDir)) {
+        process.env.PATH = `${brewDir}:${process.env.PATH}`;
+    }
+};
+export const ensureBrewInstalled = async () => {
+    if (!(await cmdExists('brew'))) {
+        // handle the case where we have previously run `./bs` but have not yet
+        // restarted shell.
+        if (await brewPathExists()) {
+            await appendBrewShellEnv();
+            return;
+        }
+        await spawn('/bin/bash', [
+            '-c',
+            '$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)',
+        ], { stdio: 'inherit' });
+        if (!(await cmdExists('brew'))) {
+            if (!(await brewPathExists())) {
+                throw new Error('Could not find brew executable, add it to your path manually');
+            }
+            await appendBrewShellEnv();
+        }
+    }
+};
+export const brew = async (args, options) => spawn(await brewPath(), args, options);
+export const brewBundleCheck = async (brewFile) => {
+    try {
+        await brew(['bundle', 'check', '--file', brewFile]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const brewBundleInstall = async (brewFile) => {
+    await brew(['bundle', 'install', '--file', brewFile], {
+        stdio: 'inherit',
+    });
+};
+export const ensureBrewfileInstalled = async (brewFile) => {
+    if (!(await brewBundleCheck(brewFile))) {
+        await brewBundleInstall(brewFile);
+    }
+};

package/src/cp.js

@@ -63,6 +63,7 @@ export async function spawn(command, args, opts) {
             p.on('close', handleExit);
             p.on('exit', handleExit);
             // only fires if we failed to spawn
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             p.on('error', (err) => {
                 // Here we have a workaround that reverses a "feature" of cross-spawn on Windows. See:
                 // https://github.com/moxystudio/node-cross-spawn/blob/master/lib/enoent.js#L23

package/src/docker.d.ts

@@ -64,5 +64,8 @@ export interface CopyFilesFromDockerImageConfig {
     ignoreErrors?: boolean;
     imageId: string;
 }
-export declare function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageId, }: CopyFilesFromDockerImageConfig): Promise<any>;
+export declare function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageId, }: CopyFilesFromDockerImageConfig): Promise<void>;
+export declare const dockerIsRunning: () => Promise<boolean>;
+export declare const ensureDockerRunning: (timeoutSeconds?: number) => Promise<void>;
+export declare const ensureDockerInstalled: () => Promise<void>;
 export {};

package/src/docker.js

@@ -1,10 +1,15 @@
 import bytes from 'bytes';
+import fs from 'fs-extra';
 import isReachable from 'is-reachable';
 import moment from 'moment';
+import os from 'os';
 import path from 'path';
 import { spawn } from './cp.js';
 import { dockerContainerKill, dockerContainerRunDaemon, } from './docker.container.js';
 import { dockerNetworkConnect } from './docker.network.js';
+import { cmdExists, isArm, isMac } from './env.js';
+import { downloadFile } from './fetch.js';
+import { mountDmg, unmountDmg } from './macos.js';
 import { getCfg, getPkgName, getPkgScope } from './pkg.js';
 import { buildLog } from './run.js';
 import { getDevBranch, getVersion } from './version.js';
@@ -140,7 +145,9 @@ export async function dockerPullAndRunContainer(options) {
         await dockerPull({ image, offline, testUrl });
     }
     catch (err) {
-        buildLog(`docker pull failed (${err.message}), attempting to continue...`);
+        if (err instanceof Error) {
+            buildLog(`docker pull failed (${err.message}), attempting to continue...`);
+        }
     }
     const { id } = await dockerContainerRunDaemon({ cmd, image, runArgs });
     if (network) {
@@ -186,3 +193,73 @@ export async function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageI
         throw new Error('Some files failed to copy');
     }
 }
+export const dockerIsRunning = async () => {
+    try {
+        const result = (await spawn('docker', ['info'], {
+            captureOutput: true,
+        })).output;
+        return !result.toLowerCase().includes('error');
+    }
+    catch {
+        return false;
+    }
+};
+export const ensureDockerRunning = async (timeoutSeconds = 600) => {
+    if (!(await dockerIsRunning())) {
+        if (isMac()) {
+            buildLog('docker is not running, starting it...');
+            await spawn('open', ['-a', '/Applications/Docker.app']);
+            let attempts = 0;
+            while (!(await dockerIsRunning())) {
+                attempts += 1;
+                if (attempts % 5 === 0) {
+                    process.stdout.write('.');
+                }
+                if (attempts > timeoutSeconds) {
+                    throw new Error('Timeout starting docker');
+                }
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 1000);
+                });
+            }
+            if (attempts >= 5) {
+                process.stdout.write('\n');
+            }
+        }
+        else {
+            throw new Error('Docker is not running, please start it manually');
+        }
+    }
+};
+export const ensureDockerInstalled = async () => {
+    if (!(await cmdExists('docker'))) {
+        if (isMac()) {
+            const dockerUrl = `https://desktop.docker.com/mac/main/${isArm() ? 'arm64' : 'amd64'}/Docker.dmg`;
+            const dockerDmg = path.join(os.tmpdir(), 'Docker.dmg');
+            buildLog(`docker not found, downloading (${isArm() ? 'arm' : 'intel'})...`);
+            await downloadFile(dockerUrl, dockerDmg);
+            const dockerVolume = path.join(os.tmpdir(), 'Docker.volume');
+            const dockerApp = path.join(dockerVolume, 'Docker.app');
+            try {
+                buildLog('Mounting Docker.dmg...');
+                await mountDmg(dockerDmg, dockerVolume);
+                const dockerAppInstalled = path.resolve('/Applications', 'Docker.app');
+                buildLog('Copying to applications...');
+                await fs.copy(dockerApp, dockerAppInstalled);
+            }
+            catch (err) {
+                buildLog('Failed to install docker automatically. Get it at https://docs.docker.com/get-docker/ and install manually.');
+                throw err;
+            }
+            finally {
+                buildLog('Unmounting Docker.dmg...');
+                await unmountDmg(dockerVolume);
+                await fs.remove(dockerDmg);
+            }
+            buildLog('Docker installed!');
+        }
+        else {
+            throw new Error('docker is not installed. Get it at https://docs.docker.com/get-docker/');
+        }
+    }
+};

package/src/dockerCompose.d.ts

@@ -151,4 +151,5 @@ export interface DockerContainerInfo extends UpResult {
     url?: null | string;
 }
 export declare function dockerComposeRunService(key: string, upOptions?: UpOptions, dockerCompose?: null | string | DockerCompose): Promise<DockerContainerInfo>;
+export declare const ensureDockerComposeInstalled: () => Promise<void>;
 export {};

package/src/dockerCompose.js

@@ -18,6 +18,7 @@ import { dockerContainerFind, dockerContainerRunDaemon, } from './docker.contain
 import { dockerPull } from './docker.js';
 import { dockerNetworkCreate, dockerNetworkDelete, } from './docker.network.js';
 import { dockerVolumeCreate, dockerVolumeRm, } from './docker.volume.js';
+import { cmdExists } from './env.js';
 import { mapValuesAsync } from './maps.js';
 import { buildLog } from './run.js';
 export const dockerComposeCreateResourceTracker = () => ({
@@ -405,7 +406,9 @@ export async function dockerComposeTeardown({ includeDefaults = false, includeVo
                             await dockerNetworkDelete(name);
                         }
                         catch (err) {
-                            buildLog(`Error deleting network '${name}': ${err.message}`);
+                            if (err instanceof Error) {
+                                buildLog(`Error deleting network '${name}': ${err.message}`);
+                            }
                         }
                     }));
                 }
@@ -437,3 +440,8 @@ export async function dockerComposeRunService(key, upOptions = {}, dockerCompose
         url,
     };
 }
+export const ensureDockerComposeInstalled = async () => {
+    if (!(await cmdExists('docker-compose'))) {
+        throw new Error('docker-compose is not installed. Get it a https://docs.docker.com/compose/install/');
+    }
+};

package/src/env.d.ts

@@ -0,0 +1,19 @@
+export declare const isMac: () => boolean;
+export declare const isLinux: () => boolean;
+export declare const isWindows: () => boolean;
+export declare const isArm: () => boolean;
+export declare const isAppleSilicon: () => boolean;
+export declare const shellType: () => string | null;
+export declare const shellEnvFile: () => string | null;
+export declare const whichCmd: (cmd: string) => Promise<null | string>;
+export declare const cmdExists: (cmd: string) => Promise<boolean>;
+interface ReadShellEnvVarOptions {
+    envFile?: string | null;
+    refreshEnv?: boolean;
+    shell?: string;
+}
+export declare const readShellEnvVar: (name: string, { refreshEnv, envFile, shell, }?: ReadShellEnvVarOptions) => Promise<string | null>;
+export declare const appendEnvVarToProfile: (name: string, value: string, { envFile }?: ReadShellEnvVarOptions) => Promise<void>;
+export declare const ensureEnvVarValue: (name: string, value: string, opts?: ReadShellEnvVarOptions | undefined) => Promise<void>;
+export declare const ensureEnvVarSet: (name: string, getValue: () => Promise<string>) => Promise<void>;
+export {};

package/src/env.js

@@ -0,0 +1,80 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { spawn } from './cp.js';
+import { appendIfMissing } from './fs.js';
+const boolCache = new Map();
+const cacheBool = (key, fn) => {
+    if (!boolCache.has(key)) {
+        boolCache.set(key, fn());
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return boolCache.get(key);
+};
+export const isMac = () => cacheBool('isMac', () => os.platform() === 'darwin');
+export const isLinux = () => cacheBool('isLinux', () => os.platform() === 'linux');
+export const isWindows = () => cacheBool('isWindows', () => os.platform() === 'win32');
+export const isArm = () => cacheBool('isArm', () => os.arch() === 'arm64' ||
+    (isMac() && os.cpus().some((cpu) => cpu.model.includes(' M1 '))));
+export const isAppleSilicon = () => cacheBool('isAppleSilicon', () => isMac() && isArm());
+const stringCache = new Map();
+const cacheString = (key, fn) => {
+    if (!stringCache.has(key)) {
+        stringCache.set(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 shellEnvFile = () => cacheString('shellEnvFile', () => {
+    switch (shellType()) {
+        case 'zsh':
+            return path.join(os.homedir(), '.zprofile');
+        case 'bash':
+            return path.join(os.homedir(), '.bash_profile');
+        default:
+            return null;
+    }
+});
+export const whichCmd = async (cmd) => {
+    const binPath = (await spawn('which', [cmd], { captureOutput: true })).output.trim();
+    if (!binPath || !(await fs.pathExists(binPath))) {
+        return null;
+    }
+    return binPath;
+};
+export const cmdExists = async (cmd) => !!whichCmd(cmd);
+export const readShellEnvVar = async (name, { refreshEnv = false, envFile = shellEnvFile(), shell = os.userInfo().shell, } = {}) => {
+    if (refreshEnv && (!envFile || !(await fs.pathExists(envFile)))) {
+        throw new Error(`Could not find shell env file: ${envFile}`);
+    }
+    try {
+        return (await spawn(shell, ['-c', `${refreshEnv ? `source ${envFile} && ` : ''}printenv ${name}`], {
+            captureOutput: true,
+        })).stdout.trim();
+    }
+    catch {
+        return null;
+    }
+};
+export const appendEnvVarToProfile = async (name, value, { envFile = shellEnvFile() } = {}) => {
+    if (!envFile) {
+        throw new Error('envFile must be set');
+    }
+    await appendIfMissing(path.join(os.homedir(), envFile), `\nexport ${name}=${value}`);
+};
+export const ensureEnvVarValue = async (name, value, opts) => {
+    const currentValue = await readShellEnvVar(name, opts);
+    if (currentValue !== value) {
+        await appendEnvVarToProfile(name, value, opts);
+    }
+    process.env[name] = value;
+};
+export const ensureEnvVarSet = async (name, getValue) => {
+    const currentValue = await readShellEnvVar(name);
+    if (!currentValue) {
+        const newValue = await getValue();
+        await appendEnvVarToProfile(name, newValue);
+        process.env[name] = newValue;
+    }
+};

package/src/fetch.d.ts

@@ -0,0 +1 @@
+export declare const downloadFile: (url: string, saveAs: string, overwrite?: boolean) => Promise<void>;

package/src/fetch.js

@@ -0,0 +1,20 @@
+import fs from 'fs-extra';
+import fetch from 'node-fetch';
+import path from 'path';
+export const downloadFile = async (url, saveAs, overwrite = true) => {
+    const res = await fetch(url);
+    const { body, ok } = res;
+    if (!ok || !body) {
+        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+    }
+    await fs.ensureDir(path.dirname(saveAs));
+    if (overwrite) {
+        await fs.remove(saveAs);
+    }
+    const fileStream = fs.createWriteStream(saveAs);
+    await new Promise((resolve, reject) => {
+        body.pipe(fileStream);
+        body.on('error', reject);
+        fileStream.on('finish', resolve);
+    });
+};

package/src/fs.d.ts

@@ -3,3 +3,9 @@ export declare const readDir: (pattern: string, options?: glob.IOptions | undefi
 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?: false | glob.IOptions | undefined) => Promise<void>;
+export declare const producedPathExists: (producer: () => Promise<string>) => Promise<boolean>;
+export declare const copyIfMissing: (src: string, dest: string) => Promise<void>;
+declare type StringGenFn = () => string | Promise<string>;
+export declare const writeIfMissing: (dest: string, content: string | StringGenFn) => Promise<boolean>;
+export declare const appendIfMissing: (dest: string, content: string | StringGenFn, testContent?: string | StringGenFn | undefined) => Promise<void>;
+export {};

package/src/fs.js

@@ -2,6 +2,8 @@ import fs from 'fs-extra';
 import glob from 'glob';
 import path from 'path';
 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));
 });
@@ -36,3 +38,39 @@ export const copyDir = async (source, target, fileGlob = '**/*.*', globOptions =
 export const cleanDir = async (pattern, globOptions) => new Promise((resolve, reject) => {
     rimraf(pattern, { glob: globOptions }, (err) => err ? reject(err) : resolve());
 });
+export const producedPathExists = async (producer) => {
+    try {
+        const result = (await producer()).trim();
+        return !!result && fs.pathExists(result);
+    }
+    catch {
+        return false;
+    }
+};
+export const copyIfMissing = async (src, dest) => {
+    if (!(await fs.pathExists(dest))) {
+        buildLog(`${dest} not found, copying...`);
+        await fs.ensureDir(path.dirname(dest));
+        await fs.copy(src, dest);
+    }
+};
+const resolveStringGen = async (content) => (typeof content === 'function' ? content() : content);
+export const writeIfMissing = async (dest, content) => {
+    if (!(await fs.pathExists(dest))) {
+        buildLog(`${dest} not found, writing...`);
+        await fs.ensureDir(path.dirname(dest));
+        await fs.writeFile(dest, await resolveStringGen(content));
+        return true;
+    }
+    return false;
+};
+export const appendIfMissing = async (dest, content, testContent) => {
+    if (!(await writeIfMissing(dest, content))) {
+        const existingContent = await fs.readFile(dest, 'utf8');
+        const getContent = resolveOnce(() => resolveStringGen(content));
+        if (!existingContent.includes(await (testContent ? resolveStringGen(testContent) : getContent()))) {
+            buildLog(`${dest} not yet updated, appending...`);
+            await fs.appendFile(dest, await getContent());
+        }
+    }
+};

package/src/gh.d.ts

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

package/src/gh.js

@@ -0,0 +1,51 @@
+import fs from 'fs-extra';
+import { spawn } from './cp.js';
+import { buildLog } from './run.js';
+import { ensureSshKeyGenerated } from './ssh.js';
+export const gh = async (args, options) => spawn('gh', args, options);
+export const ghRepoClone = async (repo, repoDir) => {
+    await gh(['repo', 'clone', repo, repoDir], {
+        stdio: 'inherit',
+    });
+};
+export const ensureGhAuthLogin = async (host = 'github.com', scopes = null) => {
+    const configured = (await gh(['auth', 'status'], { rejectOnErrorCode: false })).code === 0;
+    if (!configured) {
+        buildLog('Logging in to GitHub...');
+        await gh(['auth', 'login', '-h', host, '-w', ...(scopes ? ['-s', scopes] : [])], {
+            stdio: 'inherit',
+        });
+    }
+};
+export const ensureGhSshKeyAdded = async (privateKeyPath, keyTitle) => {
+    let listResult = await gh(['ssh-key', 'list'], {
+        captureOutput: true,
+        rejectOnErrorCode: false,
+    });
+    if (listResult.code !== 0) {
+        // Probably don't have the scope
+        buildLog('Adding admin:public_key scope to GitHub cli...');
+        await gh(['auth', 'refresh', '-s', 'admin:public_key'], {
+            stdio: 'inherit',
+        });
+        listResult = await gh(['ssh-key', 'list'], {
+            captureOutput: true,
+        });
+    }
+    const pubKeyPath = `${await ensureSshKeyGenerated(privateKeyPath)}.pub`;
+    const pubKey = await fs.readFile(pubKeyPath, 'utf8');
+    const existing = listResult.output.split('\n').find((line) => {
+        const [, key] = line.split('\t');
+        return pubKey.includes(key);
+    });
+    if (!existing) {
+        buildLog('Adding SSH key to GitHub...');
+        await spawn('gh', ['ssh-key', 'add', pubKeyPath, ...(keyTitle ? ['-t', keyTitle] : [])], {
+            stdio: 'inherit',
+        });
+    }
+};
+export const ensureGhConfig = async (key, value, host = 'github.com') => {
+    await gh(['config', 'set', '-h', host, key, value]);
+};
+export const ensureGhConfigSshGitProtocol = async (host = 'github.com') => ensureGhConfig('git_protocol', 'ssh', host);

package/src/git.d.ts

@@ -1,4 +1,5 @@
-export declare function git(args: string[]): Promise<string>;
+import { SpawnOptions } from './cp.js';
+export declare const git: (args: string[], opts?: SpawnOptions | undefined) => Promise<string>;
 export declare function gitBranch(): Promise<string>;
 export declare function gitRevId(): Promise<string>;
 declare type GitInfo = {
@@ -6,4 +7,8 @@ declare type GitInfo = {
     revision: string;
 };
 export declare function gitInfo(noCache?: boolean): Promise<GitInfo>;
+export declare const ensureGitLfsInstalled: () => Promise<void>;
+export declare const gitConfigRead: (key: string, global?: boolean) => Promise<string>;
+export declare const gitConfigWrite: (key: string, value: string, global?: boolean) => Promise<void>;
+export declare const ensureGitConfigUserEmail: (emailRegex?: RegExp, emailPrompt?: string, global?: boolean) => Promise<void>;
 export {};

package/src/git.js

@@ -1,7 +1,7 @@
-import { exec } from './cp.js';
-export async function git(args) {
-    return (await exec(`git ${args.join(' ')}`)).stdout.toString();
-}
+import { spawn } from './cp.js';
+import { userQuestion } from './prompt.js';
+import { buildLog } from './run.js';
+export const git = async (args, opts) => (await spawn('git', args, { captureOutput: true, ...opts })).stdout.trim();
 export async function gitBranch() {
     return (await git(['symbolic-ref', '--short', 'HEAD']))
         .replace(/[_+/]/g, '-')
@@ -22,3 +22,23 @@ export async function gitInfo(noCache = false) {
     }
     return info;
 }
+export const ensureGitLfsInstalled = async () => {
+    await git(['lfs', 'install'], { stdio: 'inherit' });
+};
+export const gitConfigRead = async (key, global = true) => git(['config', ...(global ? ['--global'] : []), key], {
+    rejectOnErrorCode: false,
+});
+export const gitConfigWrite = async (key, value, global = true) => {
+    await git(['config', ...(global ? ['--global'] : []), key, value]);
+};
+export const ensureGitConfigUserEmail = async (emailRegex = /.+@.+/, emailPrompt = 'Enter your email address: ', global = true) => {
+    const existing = await gitConfigRead('user.email', global);
+    if (emailRegex.test(existing)) {
+        return;
+    }
+    buildLog('Setting up git user config...');
+    const name = await userQuestion('Enter your full name: ');
+    await gitConfigWrite('user.name', name, global);
+    const email = await userQuestion(emailPrompt, (input) => emailRegex.test(input));
+    await gitConfigWrite('user.email', email, global);
+};

package/src/index.d.ts

@@ -10,10 +10,13 @@ export * from './docker.volume.js';
 export * from './dockerCleanup.js';
 export * from './dockerCompose.js';
 export * from './fs.js';
+export * from './gh.js';
 export * from './git.js';
 export * from './npm.js';
 export * from './pkg.js';
 export * from './publish.js';
+export * from './promise.js';
+export * from './prompt.js';
 export * from './run.js';
 export * from './tgz.js';
 export * from './version.js';

package/src/index.js

@@ -10,10 +10,13 @@ export * from './docker.volume.js';
 export * from './dockerCleanup.js';
 export * from './dockerCompose.js';
 export * from './fs.js';
+export * from './gh.js';
 export * from './git.js';
 export * from './npm.js';
 export * from './pkg.js';
 export * from './publish.js';
+export * from './promise.js';
+export * from './prompt.js';
 export * from './run.js';
 export * from './tgz.js';
 export * from './version.js';

package/src/macos.d.ts

@@ -0,0 +1,3 @@
+export declare const mountDmg: (dmgPath: string, mountPath: string) => Promise<void>;
+export declare const unmountDmg: (mountPath: string) => Promise<void>;
+export declare const ensureXcodeCmdInstalled: (ignoreNonMac?: boolean) => Promise<void>;

package/src/macos.js

@@ -0,0 +1,36 @@
+import fs from 'fs-extra';
+import { spawn } from './cp.js';
+import { cmdExists, isMac } from './env.js';
+import { producedPathExists } from './fs.js';
+import { buildLog } from './run.js';
+export const mountDmg = async (dmgPath, mountPath) => {
+    await fs.ensureDir(mountPath);
+    await spawn('hdiutil', [
+        'attach',
+        dmgPath,
+        '-mountpoint',
+        mountPath,
+        '-nobrowse',
+        '-quiet',
+    ]);
+};
+export const unmountDmg = async (mountPath) => {
+    await spawn('hdiutil', ['detach', mountPath, '-force', '-quiet']);
+};
+export const ensureXcodeCmdInstalled = async (ignoreNonMac = true) => {
+    if (isMac()) {
+        if (!ignoreNonMac) {
+            throw new Error('Cannot install Xcode on non-macOS');
+        }
+        return;
+    }
+    if (!(await cmdExists('xcode-select'))) {
+        throw new Error('XCode is not installed, get from the app store.');
+    }
+    if (!(await producedPathExists(async () => (await spawn('xcode-select', ['-p'], { captureOutput: true })).output))) {
+        buildLog('Installing XCode Command Line Tools...');
+        await spawn('sudo', ['xcode-select', '--install'], {
+            stdio: 'inherit',
+        });
+    }
+};

package/src/npm.js

@@ -38,7 +38,9 @@ export async function npmGetVersions(packageName, npmPath) {
         })).stdout.trim());
     }
     catch (err) {
-        buildLog(`warning: failed to find existing package for ${packageName} in npm registry: ${err.message}`);
+        if (err instanceof Error) {
+            buildLog(`warning: failed to find existing package for ${packageName} in npm registry: ${err.message}`);
+        }
         return [];
     }
 }

package/src/promise.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This generates a function that, when invoked, will only invoke the producer once.
+ * On subsequent calls, the previously produced value will be returned.
+ * @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>;

package/src/promise.js

@@ -0,0 +1,15 @@
+/**
+ * This generates a function that, when invoked, will only invoke the producer once.
+ * On subsequent calls, the previously produced value will be returned.
+ * @param producer a function that produces a promise, will be invoked at most once
+ * @returns a function that returns a promise
+ */
+export const resolveOnce = (producer) => {
+    let promisedResult;
+    return async () => {
+        if (!promisedResult) {
+            promisedResult = producer();
+        }
+        return promisedResult;
+    };
+};

package/src/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const ask: (question: string) => Promise<string>;
+export declare const userQuestion: (question: string, test?: (input: string) => boolean | Promise<boolean>) => Promise<string>;

package/src/prompt.js

@@ -0,0 +1,19 @@
+import { stdin as input, stdout as output } from 'process';
+import readline from 'readline';
+export const ask = async (question) => {
+    // Once we move to Node 18+, can replace this with a builtin Promise interface
+    const rl = readline.createInterface({ input, output });
+    return new Promise((resolve) => {
+        rl.question(question, (value) => {
+            rl.close();
+            resolve(value.trim());
+        });
+    });
+};
+export const userQuestion = async (question, test = (v) => !!v) => {
+    let answer;
+    do {
+        answer = await ask(question);
+    } while (!(await test(answer)));
+    return answer;
+};

package/src/ssh.d.ts

@@ -0,0 +1 @@
+export declare const ensureSshKeyGenerated: (keyPath?: string | undefined) => Promise<string>;

package/src/ssh.js

@@ -0,0 +1,13 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { spawn } from './cp.js';
+import { buildLog } from './run.js';
+export const ensureSshKeyGenerated = async (keyPath) => {
+    const sshKeyPath = keyPath || path.join(os.homedir(), '.ssh', 'id_ed25519');
+    if (!(await fs.pathExists(sshKeyPath))) {
+        buildLog('Generating SSH key (passphrase is optional)...');
+        await spawn('ssh-keygen', ['-t', 'ed25519', '-f', sshKeyPath]);
+    }
+    return sshKeyPath;
+};