build-strap 4.0.0 → 4.1.0-dev.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-strap",
-  "version": "4.0.0",
+  "version": "4.1.0-dev.60",
   "description": "Node scripts for building things",
   "license": "MIT",
   "authors": [
@@ -11,26 +11,11 @@
     "url": "https://github.com/murrayju/build-strap"
   },
   "type": "module",
-  "module": "dist/index.js",
-  "types": "dist/index.d.js",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
   "engines": {
     "node": ">=16"
   },
-  "buildStrap": {
-    "nodeVersion": "16.13.1",
-    "yarnVersion": "1.22.17",
-    "repoType": "git",
-    "copyright": "Justin Murray",
-    "releaseBranch": "master",
-    "devBranch": "dev",
-    "npm": {
-      "publish": true
-    },
-    "docker": {
-      "repository": "murrayju",
-      "registry": "ghcr.io"
-    }
-  },
   "dependencies": {
     "bytes": "^3.1.1",
     "chokidar": "^3.5.2",
@@ -43,43 +28,8 @@
     "lodash-es": "^4.17.21",
     "moment": "^2.29.1",
     "node-fetch": "^3.1.0",
+    "rimraf": "^3.0.2",
     "stream-counter": "1",
-    "tar": "^6.1.11",
-    "url-join": "^4.0.1"
-  },
-  "devDependencies": {
-    "@tsconfig/node16": "^1.0.2",
-    "@types/bytes": "^3.1.1",
-    "@types/cross-spawn": "^6.0.2",
-    "@types/eslint": "^8.2.1",
-    "@types/fs-extra": "^9.0.13",
-    "@types/glob": "^7.2.0",
-    "@types/js-yaml": "^4.0.5",
-    "@types/lodash-es": "^4.17.5",
-    "@types/rimraf": "^3.0.2",
-    "@types/tar": "^6.1.1",
-    "@typescript-eslint/eslint-plugin": "^5.8.0",
-    "@typescript-eslint/parser": "^5.8.0",
-    "camelcase": "^6.2.0",
-    "eslint": "^8.5.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-import-resolver-node": "^0.3.6",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jsx-a11y": "^6.4.1",
-    "eslint-plugin-prettier": "^4.0.0",
-    "eslint-plugin-react": "^7.22.0",
-    "eslint-plugin-sort-destructure-keys": "^1.4.0",
-    "eslint-plugin-sort-keys-fix": "^1.1.2",
-    "eslint-plugin-typescript-sort-keys": "^2.1.0",
-    "prettier": "^2.2.1",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.5.4"
-  },
-  "scripts": {
-    "target": "node --loader ts-node/esm ./targets/run.ts"
-  },
-  "files": [
-    "dist/src"
-  ]
-}
+    "tar": "^6.1.11"
+  }
+}

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/{dist/src → 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/{dist/src → 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/{dist/src → 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/{dist/src → 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/{dist/src → 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/{dist/src → 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

@@ -0,0 +1,76 @@
+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));
+});
+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);
+        const to = path.resolve(target, dir);
+        await fs.ensureDir(path.dirname(to));
+        await fs.rename(from, to);
+    }));
+};
+export const copyDir = async (source, target, fileGlob = '**/*.*', globOptions = null, renameFn = (n) => n) => {
+    const paths = await readDir(fileGlob, {
+        cwd: source,
+        dot: true,
+        nodir: true,
+        nosort: true,
+        ...globOptions,
+    });
+    await Promise.all(paths.map(async (p) => {
+        const from = path.resolve(source, p);
+        const to = path.resolve(target, renameFn(p));
+        await fs.ensureDir(path.dirname(to));
+        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 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

@@ -0,0 +1,14 @@
+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 = {
+    branch: string;
+    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 {};