build-strap 4.0.0 → 4.1.0-dev.60

package/src/git.js

@@ -0,0 +1,44 @@
+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, '-')
+        .trim();
+}
+export async function gitRevId() {
+    return (await git(['rev-parse', '--short=12', 'HEAD']))
+        .replace(/[+]/g, '')
+        .trim();
+}
+let info = null;
+export async function gitInfo(noCache = false) {
+    if (!info || noCache) {
+        info = {
+            branch: await gitBranch(),
+            revision: await gitRevId(),
+        };
+    }
+    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/{dist/src → src}/index.d.ts

@@ -10,10 +10,14 @@ 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 './macos.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/{dist/src → src}/index.js

@@ -10,10 +10,14 @@ 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 './macos.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/{dist/src → src}/npm.d.ts

@@ -1,3 +1,4 @@
+import { SpawnOptions, SpawnResult } from './cp.js';
 export declare type NpmCreds = {
     email?: string;
     password?: string;
@@ -11,8 +12,21 @@ export declare type NpmConfig = {
     registry?: string;
 };
 export declare function getNpmConfig(): NpmConfig;
-export declare function npmExec(args: string[], npmPath?: string): Promise<string>;
+export declare const envNpmCreds: null | NpmCreds;
+export interface NpmOptions {
+    args?: string[];
+    npmPath?: string;
+    spawnOptions?: SpawnOptions;
+}
+export declare function npm({ args, spawnOptions, npmPath, }?: NpmOptions): Promise<SpawnResult>;
 export declare function npmGetVersions(packageName: string, npmPath?: string): Promise<string[]>;
+interface NpmWriteRcOptions {
+    authToken?: string;
+    creds?: NpmCreds | null;
+    outPath: string;
+    registry?: string;
+}
+export declare function npmWriteRc({ authToken, creds, outPath, registry, }: NpmWriteRcOptions): Promise<void>;
 export interface NpmPublishOptions {
     npmAuthToken?: string;
     npmConfig?: NpmConfig;
@@ -22,9 +36,8 @@ export interface NpmPublishOptions {
     skipExisting?: boolean;
     tag?: string;
     workDir?: string;
-    writeNpmrc?: boolean;
 }
-export declare function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath, skipExisting, tag, workDir: passedWorkDir, writeNpmrc, }?: NpmPublishOptions): Promise<boolean>;
+export declare function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath, skipExisting, tag, workDir: passedWorkDir, }?: NpmPublishOptions): Promise<boolean>;
 interface NpmPackOptions {
     destination?: string;
     npmConfig?: NpmConfig;

package/src/npm.js

@@ -0,0 +1,143 @@
+import fs from 'fs-extra';
+import { platform } from 'os';
+import path from 'path';
+import { spawn } from './cp.js';
+import { getCfg, getPkgName } from './pkg.js';
+import { buildLog } from './run.js';
+import { getDevBranch, getVersion } from './version.js';
+export function getNpmConfig() {
+    return getCfg().npm || {};
+}
+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, } = {}) {
+    const localNpm = path.join(path.dirname(process.execPath), 'lib/node_modules/npm/bin/npm-cli.js');
+    const spawnOpts = {
+        env: process.env,
+        shell: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    };
+    return npmPath
+        ? spawn(npmPath, args, spawnOpts)
+        : (await fs.pathExists(localNpm))
+            ? // prefer to use local copy of npm
+                spawn(process.execPath, [localNpm, ...args], spawnOpts)
+            : // fall back to globally installed npm
+                spawn(npmExe(), args, spawnOpts);
+}
+export async function npmGetVersions(packageName, npmPath) {
+    try {
+        return JSON.parse((await npm({
+            args: ['show', packageName, 'versions', '--json'],
+            npmPath,
+            spawnOptions: {
+                captureOutput: true,
+                stdio: 'pipe',
+            },
+        })).stdout.trim());
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            buildLog(`warning: failed to find existing package for ${packageName} in npm registry: ${err.message}`);
+        }
+        return [];
+    }
+}
+export async function npmWriteRc({ authToken, creds, outPath, registry, }) {
+    // Write out .npmrc with credentials
+    const theRegistry = registry || 'https://registry.npmjs.org/';
+    const [, host] = /^(?:http(?:s)?:\/\/)?(.+)$/.exec(theRegistry) || [];
+    await fs.mkdirp(path.dirname(outPath));
+    await fs.writeFile(outPath, `registry=${theRegistry}
+${authToken ? `//${host}:_authToken=${authToken}` : ''}
+${creds
+        ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString('base64')}
+always-auth=true
+email=${creds.email}`
+        : ''}`);
+}
+export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, } = {}) {
+    const creds = npmCreds || envNpmCreds;
+    const authToken = npmAuthToken || process.env.NPM_TOKEN;
+    const name = getPkgName();
+    const { access, dryRun, publish, registry } = npmConfig || getNpmConfig();
+    if (!publish) {
+        buildLog('npm publish info missing from package.json, skipping npm publish');
+        return false;
+    }
+    const resolvedPath = path.resolve(publishPath);
+    const workDir = passedWorkDir ||
+        ((await fs.stat(resolvedPath)).isDirectory()
+            ? resolvedPath
+            : path.dirname(resolvedPath));
+    if (!(await fs.pathExists(path.join(workDir, 'package.json')))) {
+        buildLog(`warning: no package.json found in ${workDir}, skipping npm publish`);
+        return false;
+    }
+    if (creds || registry || authToken) {
+        // Write out .npmrc with credentials
+        await npmWriteRc({
+            authToken: authToken ? `\${NPM_TOKEN}` : undefined,
+            creds,
+            outPath: path.join(workDir, '.npmrc'),
+            registry,
+        });
+    }
+    const existing = await npmGetVersions(name, npmPath);
+    const { branch, isRelease, npm: npmVersion } = await getVersion();
+    if (existing.includes(npmVersion)) {
+        if (skipExisting) {
+            buildLog('npm package with this same version already exists. Skipping publish...');
+            return false;
+        }
+        throw new Error('Failed to publish npm package, this version already exists!');
+    }
+    await npm({
+        args: [
+            'publish',
+            resolvedPath,
+            '--tag',
+            tag ||
+                (isRelease
+                    ? 'latest'
+                    : branch === (await getDevBranch())
+                        ? 'next'
+                        : 'branch'),
+            ...(access ? ['--access', access] : []),
+            ...(dryRun ? ['--dry-run'] : []),
+            '--color=always',
+        ],
+        npmPath,
+        spawnOptions: {
+            cwd: workDir,
+            env: {
+                ...process.env,
+                NPM_TOKEN: authToken,
+            },
+        },
+    });
+    return true;
+}
+export async function npmPack({ destination, npmConfig, npmPath, workDir = '.', }) {
+    const { dryRun } = npmConfig || getNpmConfig();
+    if (destination) {
+        await fs.ensureDir(destination);
+    }
+    const { stdout } = await npm({
+        args: [
+            'pack',
+            ...(dryRun ? ['--dry-run'] : []),
+            ...(destination ? ['--pack-destination', path.resolve(destination)] : []),
+            '--color=always',
+        ],
+        npmPath,
+        spawnOptions: {
+            captureOutput: true,
+            cwd: path.resolve(workDir),
+            pipeOutput: true,
+            stdio: 'pipe',
+        },
+    });
+    return path.resolve(destination || '.', stdout.trim());
+}

package/{dist/src → src}/pkg.d.ts

@@ -22,8 +22,13 @@ export interface PackageJson {
     name: string;
     peerDependencies?: Record<string, string>;
     private?: boolean;
-    repository?: string;
+    repository?: string | {
+        type: string;
+        url: string;
+    };
     scripts?: Record<string, string>;
+    type?: string;
+    types?: string;
     version: string;
 }
 export declare function getPkg(): PackageJson;

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;
+};

package/{dist/src → src}/version.js

@@ -38,7 +38,7 @@ export async function getRepoInfo() {
 }
 export async function getDevBranch() {
     const { devBranch } = getCfg();
-    return devBranch || (await getRepoType()) === 'hg' ? 'default' : 'dev';
+    return devBranch || ((await getRepoType()) === 'hg' ? 'default' : 'dev');
 }
 export async function getIsRelease(passedBranch = null, releaseOverride = null) {
     const branch = passedBranch || (await getRepoInfo()).branch;

package/{dist/src → src}/yarn.d.ts

@@ -1,4 +1,5 @@
 import { SpawnOptions, SpawnResult } from './cp.js';
+import { NpmConfig, NpmCreds } from './npm.js';
 export interface YarnOptions {
     args?: string[];
     spawnOptions?: SpawnOptions;
@@ -24,3 +25,20 @@ export interface YarnUpgradeOptions {
     outdated?: boolean;
 }
 export declare function yarnUpgrade({ all, outdated, }?: YarnUpgradeOptions): Promise<void>;
+export interface YarnPublishOptions {
+    npmAuthToken?: string;
+    npmConfig?: NpmConfig;
+    npmCreds?: NpmCreds;
+    npmPath?: string;
+    publishPath?: string;
+    skipExisting?: boolean;
+    tag?: string;
+    workDir?: string;
+}
+export declare function yarnPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath, skipExisting, tag, workDir: passedWorkDir, }?: YarnPublishOptions): Promise<boolean>;
+interface YarnPackOptions {
+    destination: string;
+    workDir?: string;
+}
+export declare function yarnPack({ destination, workDir, }: YarnPackOptions): Promise<string>;
+export {};

package/src/yarn.js

@@ -0,0 +1,155 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { spawn } from './cp.js';
+import { readDir } from './fs.js';
+import { envNpmCreds, getNpmConfig, npmGetVersions, npmWriteRc, } from './npm.js';
+import { getPkg, getPkgName } from './pkg.js';
+import { buildLog } from './run.js';
+import { generateFileHash } from './tgz.js';
+import { getDevBranch, getVersion } from './version.js';
+export async function yarn({ args = [], spawnOptions, } = {}) {
+    const localYarn = path.join(path.dirname(process.execPath), '/node_modules/yarn/bin/yarn.js');
+    const spawnOpts = {
+        env: process.env,
+        shell: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    };
+    return (await fs.pathExists(localYarn))
+        ? // prefer to use local copy of yarn
+            spawn(process.execPath, [localYarn, ...args], spawnOpts)
+        : // fall back to globally installed yarn
+            spawn('yarn', args, spawnOpts);
+}
+export const yarnFiles = ['./package.json', './yarn.lock'];
+// Smart yarn invocation, only if package changed
+export async function yarnInstall({ force = false, hashFilePath = './download/buildHash_yarn.md5', nodeModulesPath = './node_modules', } = {}) {
+    await fs.ensureDir(nodeModulesPath);
+    const currentHash = (await Promise.all(yarnFiles.map(async (f) => generateFileHash(f, 'md5')))).join('|');
+    await fs.ensureFile(hashFilePath);
+    const prevHash = await fs.readFile(hashFilePath, 'utf8');
+    if (currentHash !== prevHash) {
+        buildLog('node package definition changed since last build, invoking yarn.');
+    }
+    else if (!(await readDir(`${nodeModulesPath}/**/*.js`)).length) {
+        buildLog('node packages missing, invoking yarn.');
+    }
+    else if (force) {
+        buildLog('node packages unchanged, but yarn forced on command line...');
+    }
+    else {
+        buildLog('node packages unchanged since last build, skipping yarn.');
+        return;
+    }
+    await yarn();
+    await fs.writeFile(hashFilePath, currentHash);
+}
+export async function yarnUpgrade({ all = false, outdated = false, } = {}) {
+    if (outdated) {
+        const { code, stdout } = await yarn({
+            args: ['outdated'],
+            spawnOptions: {
+                captureOutput: true,
+                rejectOnErrorCode: false,
+                stdio: 'pipe',
+            },
+        });
+        if (code === 0) {
+            buildLog('No outdated packages.');
+        }
+        else {
+            const { dependencies = {}, devDependencies = {} } = getPkg();
+            const packages = stdout
+                .split('\n')
+                .slice(5, -1)
+                .map((l) => l.split(/\s+/)[0])
+                .filter((p) => all || !/^\d/.test(dependencies[p] || devDependencies[p] || ''));
+            if (packages.length) {
+                await yarn({ args: ['add', ...packages] });
+                buildLog(`Upgraded: ${packages.join(', ')}`);
+            }
+            else {
+                buildLog('No eligible outdated packages');
+            }
+        }
+    }
+    await yarn({ args: ['upgrade'] });
+}
+export async function yarnPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, } = {}) {
+    const creds = npmCreds || envNpmCreds;
+    const authToken = npmAuthToken || process.env.NPM_TOKEN;
+    const name = getPkgName();
+    const { access, publish, registry } = npmConfig || getNpmConfig();
+    if (!publish) {
+        buildLog('npm publish info missing from package.json, skipping npm publish');
+        return false;
+    }
+    const resolvedPath = path.resolve(publishPath);
+    const workDir = passedWorkDir ||
+        ((await fs.stat(resolvedPath)).isDirectory()
+            ? resolvedPath
+            : path.dirname(resolvedPath));
+    if (!(await fs.pathExists(path.join(workDir, 'package.json')))) {
+        buildLog(`warning: no package.json found in ${workDir}, skipping npm publish`);
+        return false;
+    }
+    if (creds || registry || authToken) {
+        // Write out .npmrc with credentials
+        await npmWriteRc({
+            authToken: authToken ? `\${NPM_TOKEN}` : undefined,
+            creds,
+            outPath: path.join(workDir, '.npmrc'),
+            registry,
+        });
+    }
+    const existing = await npmGetVersions(name, npmPath);
+    const { branch, isRelease, npm: npmVersion } = await getVersion();
+    if (existing.includes(npmVersion)) {
+        if (skipExisting) {
+            buildLog('npm package with this same version already exists. Skipping publish...');
+            return false;
+        }
+        throw new Error('Failed to publish npm package, this version already exists!');
+    }
+    await yarn({
+        args: [
+            'publish',
+            resolvedPath,
+            '--new-version',
+            npmVersion,
+            '--tag',
+            tag ||
+                (isRelease
+                    ? 'latest'
+                    : branch === (await getDevBranch())
+                        ? 'next'
+                        : 'branch'),
+            ...(access ? ['--access', access] : []),
+        ],
+        spawnOptions: {
+            cwd: workDir,
+            env: {
+                ...process.env,
+                FORCE_COLOR: 'true',
+                NPM_TOKEN: authToken,
+            },
+            shell: true,
+            stdio: 'inherit',
+        },
+    });
+    return true;
+}
+export async function yarnPack({ destination, workDir = '.', }) {
+    await fs.ensureDir(destination);
+    const version = await getVersion();
+    const name = getPkgName();
+    const filename = path.resolve(destination, `${name}-${version.npm}.tgz`);
+    await yarn({
+        args: ['pack', ...(destination ? ['--filename', filename] : [])],
+        spawnOptions: {
+            cwd: path.resolve(workDir),
+            pipeOutput: true,
+        },
+    });
+    return filename;
+}

package/dist/src/fs.js

@@ -1,38 +0,0 @@
-import fs from 'fs-extra';
-import glob from 'glob';
-import path from 'path';
-import rimraf from 'rimraf';
-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());
-});

package/dist/src/git.d.ts

@@ -1,9 +0,0 @@
-export declare function git(args: string[]): 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 {};