@_linked/cli 1.46.2 → 1.47.1

package/lib/esm/cli-methods.js

@@ -12,18 +12,22 @@ import { exec } from 'child_process';
 import depcheck from 'depcheck';
 import { getEnvFile } from 'env-cmd/dist/get-env-vars.js';
 import fs from 'fs-extra';
-import path, { dirname } from 'path';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { createInterface } from 'readline';
 import { debugInfo, execp, execPromise, getFileImports, getFiles, getLastCommitTime, getPackageJSON, isImportOutsideOfPackage, isInternalLinkedImport, needsRebuilding, } from './utils.js';
 import { renameShippedDotfiles } from './utils/shippedDotfiles.js';
+import { findWorkspaceRoot } from './localize/app-root.js';
 import { planPackageSetup } from './utils/packageSetup.js';
-import { bareName, CreatePackageError, decideCreatePackageTarget, ensureRelinkPostinstall, ensureWorkspaceGlob, findLinkedAppRoot, RELINK_COMMAND, repositoryUrlFor, } from './utils/createPackageLocation.js';
+import { bareName, CreatePackageError, decideCreatePackageTarget, ensureWorkspaceGlob, findLinkedAppRoot, repositoryUrlFor, } from './utils/createPackageLocation.js';
 import { detectPackageManager, execBinCommand, runScriptCommand, } from './utils/packageManager.js';
 import { rewriteExtensionlessImports } from './utils/esmSpecifiers.js';
 import { checkShapeNames } from './utils/shapeNames.js';
 import { checkShapeReferences, inspectShapeReferences, } from './utils/shapeReferences.js';
 import { checkShapesIndex, checkShapesSideEffects } from './utils/shapesIndex.js';
-import { spawn as spawnChild, spawnSync } from 'child_process';
+import { spawnSync } from 'child_process';
+import { spawnCommand } from './utils/spawn.js';
+import { importFile, withEolOf } from './utils/platform.js';
 import { findNearestPackageJson } from 'find-nearest-package-json';
 import { statSync } from 'fs';
 // import pkg from 'lincd/utils/LinkedFileStorage';
@@ -35,10 +39,9 @@ import { packagePublishesCjs } from './package-manifest.js';
 import { asNamespace, defaultOntologyNamespace } from './utils/ontologyNamespace.js';
 import { decidePackageKind, ontologySlugFor, packageNameFor, scaffoldKinds, PACKAGE_TEMPLATE_DIRS, SHARED_TEMPLATE_FILES, } from './utils/packageKind.js';
 import { resolvePackageBaseUri, withBaseUri } from './utils/packageBaseUri.js';
-let dirname__ = typeof __dirname !== 'undefined'
-    ? __dirname
-    : //@ts-ignore
-        dirname(import.meta.url).replace('file:/', '');
+// This module's directory. fileURLToPath, not the URL with `file:/` cut off,
+// which on Windows leaves `//C:/...`.
+let dirname__ = path.dirname(fileURLToPath(import.meta.url));
 /**
  * A folder under this package's `defaults/`. The built module sits in `lib/esm/`
  * and the source in `src/`, so the templates are two or one level up.
@@ -198,11 +201,11 @@ export const createApp = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...ar
             spinner: 'dots',
         }).start();
         const { stdout, stderr, failed } = yield new Promise((resolve) => {
-            exec(`cd ${hyphenName} && ${installCommand}`, { maxBuffer: 50 * 1024 * 1024 }, (error, out, err) => {
-                var _a, _b;
+            // The folder as cwd, not `cd <dir> &&`: cmd.exe's `cd` does not change drives.
+            exec(installCommand, { cwd: targetFolder, maxBuffer: 50 * 1024 * 1024 }, (error, out, err) => {
                 resolve({
-                    stdout: typeof out === 'string' ? out : (_a = out === null || out === void 0 ? void 0 : out.toString()) !== null && _a !== void 0 ? _a : '',
-                    stderr: typeof err === 'string' ? err : (_b = err === null || err === void 0 ? void 0 : err.toString()) !== null && _b !== void 0 ? _b : '',
+                    stdout: out !== null && out !== void 0 ? out : '',
+                    stderr: err !== null && err !== void 0 ? err : '',
                     failed: !!error,
                 });
             });
@@ -703,52 +706,6 @@ function hasDependency(pkg, childPkg, dependencies, depth = 1) {
     console.log('going up');
     return false;
 }
-/**
- * Finds the topmost package.json that could be an APP_ROOT
- * Returns null if no app root is found (standalone repo case)
- */
-function findAppRoot(startPath = process.cwd()) {
-    let currentPath = startPath;
-    let candidateRoots = [];
-    // Walk up the directory tree
-    for (let i = 0; i < 10; i++) {
-        const packageJsonPath = path.join(currentPath, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-            candidateRoots.push({
-                path: currentPath,
-                hasWorkspaces: !!packageJson.workspaces,
-                isLinked: packageJson.linkedPackage === true,
-            });
-        }
-        const parentPath = path.join(currentPath, '..');
-        // If we've reached the root or haven't moved up
-        if (parentPath === currentPath) {
-            break;
-        }
-        currentPath = parentPath;
-    }
-    // Find the topmost package.json that has workspaces
-    // Prefer non-linked packages (app roots) over linked packages
-    let appRoot = null;
-    for (let i = candidateRoots.length - 1; i >= 0; i--) {
-        const candidate = candidateRoots[i];
-        if (candidate.hasWorkspaces && !candidate.isLinked) {
-            appRoot = candidate.path;
-            break;
-        }
-    }
-    // If no non-linked workspace found, use the topmost workspace
-    if (!appRoot) {
-        for (let i = candidateRoots.length - 1; i >= 0; i--) {
-            if (candidateRoots[i].hasWorkspaces) {
-                appRoot = candidateRoots[i].path;
-                break;
-            }
-        }
-    }
-    return appRoot;
-}
 /**
  * Print the discovery result in full: what will be built, and every package
  * that was found and will not be. Nothing is discovered silently.
@@ -799,51 +756,82 @@ function runBuildScript(pkg, failureOutput) {
     });
 }
 export function buildAll(options) {
-    console.log('Building all linked packages of this repository in order of dependencies');
-    const plan = planBuildAll('./', findAppRoot() || undefined);
-    printBuildAllPlan(plan);
-    if (plan.build.size === 0) {
-        console.log(chalk.yellow('Nothing to build.'));
-        return;
-    }
-    // The build tool goes first and alone: every other build runs it.
-    const order = orderBuildToolFirst(plan.build, options === null || options === void 0 ? void 0 : options.from);
-    const sync = (options === null || options === void 0 ? void 0 : options.sync) || false;
-    // Successfully built (or deliberately passed over by --from).
-    const done = new Set();
-    if (!order.tool) {
-        return buildInDependencyOrder(order.rest, order.from, sync, done);
-    }
-    const tool = order.tool;
-    if (!order.buildToolFirst) {
-        log(chalk.blue('skipping ' + tool.packageName));
-        done.add(tool);
-        return buildInDependencyOrder(order.rest, order.from, sync, done);
-    }
-    // This process has already loaded every module `build-all` uses (the
-    // command's code is imported statically), so the tool's `rimraf ./lib`
-    // cannot pull anything out from under it.
-    console.log(chalk.blue(`Building ${tool.packageName} first: the other packages build with it.`));
-    return runBuildScript(tool).then((res) => {
-        if (typeof res === 'undefined') {
-            const others = order.rest.size;
-            console.error(chalk.red(`${tool.packageName} failed to build, so build-all stopped before ` +
-                `the other ${others} package${others === 1 ? '' : 's'}: they build with it. ` +
-                `Fix ${tool.packageName} and run build-all again.`));
-            process.exit(1);
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        console.log('Building all linked packages of this repository in order of dependencies');
+        const plan = planBuildAll('./', (_a = findWorkspaceRoot(process.cwd())) !== null && _a !== void 0 ? _a : undefined);
+        printBuildAllPlan(plan);
+        if (plan.build.size === 0) {
+            console.log(chalk.yellow('Nothing to build.'));
+            return;
+        }
+        // The build tool's own dependencies, then the tool alone (every other build
+        // runs it), then the rest. See `orderBuildToolFirst`.
+        const order = orderBuildToolFirst(plan.build, options === null || options === void 0 ? void 0 : options.from);
+        const sync = (options === null || options === void 0 ? void 0 : options.sync) || false;
+        // Successfully built (or deliberately passed over by --from).
+        const done = new Set();
+        const tool = order.tool;
+        if (!tool) {
+            yield buildInDependencyOrder(order.rest, order.from, sync, done);
             return;
         }
-        log(chalk.green('Built ' + tool.packageName) +
-            (res === false ? chalk.redBright(' (with warnings)') : ''));
-        done.add(tool);
+        const passOver = (pkg) => {
+            log(chalk.blue('skipping ' + pkg.packageName));
+            done.add(pkg);
+        };
+        const plural = (n) => `${n} package${n === 1 ? '' : 's'}`;
+        if (order.start === 'pre' && order.pre.size > 0) {
+            const names = [...order.pre.keys()].join(', ');
+            const them = order.pre.size === 1 ? 'it' : 'them';
+            console.log(chalk.blue(`Building ${names} first: ${tool.packageName} depends on ${them}.`));
+            const built = yield buildInDependencyOrder(order.pre, order.from, sync, done, {
+                stopNote: `${tool.packageName} needs ${names}, so build-all stopped before it and ` +
+                    `the other ${plural(order.rest.size)}, which build with it. ` +
+                    `Fix the failure and run build-all again.`,
+            });
+            if (!built)
+                return;
+        }
+        else {
+            order.pre.forEach(passOver);
+        }
+        if (order.start === 'rest') {
+            passOver(tool);
+        }
+        else {
+            // This process has already loaded every module `build-all` uses (the
+            // command's code is imported statically), so the tool's `rimraf ./lib`
+            // cannot pull anything out from under it.
+            console.log(chalk.blue(`Building ${tool.packageName} alone: the other packages build with it.`));
+            const res = yield runBuildScript(tool);
+            if (typeof res === 'undefined') {
+                console.error(chalk.red(`${tool.packageName} failed to build, so build-all stopped before ` +
+                    `the other ${plural(order.rest.size)}: they build with it. ` +
+                    `Fix ${tool.packageName} and run build-all again.`));
+                process.exit(1);
+                return;
+            }
+            log(chalk.green('Built ' + tool.packageName) +
+                (res === false ? chalk.redBright(' (with warnings)') : ''));
+            done.add(tool);
+        }
         if (order.rest.size === 0) {
             printBuildAllSummary(done, new Set(), new Map(), [], new Map());
             return;
         }
-        return buildInDependencyOrder(order.rest, order.from, sync, done);
+        yield buildInDependencyOrder(order.rest, order.start === 'rest' ? order.from : undefined, sync, done);
     });
 }
-function buildInDependencyOrder(lincdPackages, from, sync, done) {
+/**
+ * Build `lincdPackages` in dependency order, in parallel where they allow it.
+ * Resolves to whether every package was built (or passed over by `from`).
+ *
+ * The last group of a run prints the end-of-run summary. A group with more to
+ * follow (`then`) prints it only when something failed, followed by
+ * `then.stopNote`, since nothing after it can be built.
+ */
+function buildInDependencyOrder(lincdPackages, from, sync, done, then) {
     let startFrom;
     //by default start building
     let building = true;
@@ -863,7 +851,8 @@ function buildInDependencyOrder(lincdPackages, from, sync, done) {
     const failureOutput = new Map();
     progressUpdate(lincdPackages.size + ' packages left');
     let packagesLeft = lincdPackages.size;
-    // `done` may already hold the build tool, built before this ran.
+    let allBuilt = false;
+    // `done` may already hold earlier groups (the build tool and what it needs).
     const doneBefore = done.size;
     const finished = runOnPackagesGroupedByDependencies(lincdPackages, (packageGroup, dependencies) => {
         if (done.size > doneBefore) {
@@ -956,12 +945,19 @@ function buildInDependencyOrder(lincdPackages, from, sync, done) {
                 }
             }
         }
-        printBuildAllSummary(done, failed, notBuilt, unscheduled, failureOutput);
-        if (failed.size > 0 || notBuilt.size > 0 || unscheduled.length > 0) {
+        const problems = failed.size > 0 || notBuilt.size > 0 || unscheduled.length > 0;
+        if (problems || !then) {
+            printBuildAllSummary(done, failed, notBuilt, unscheduled, failureOutput);
+        }
+        if (problems) {
+            if (then)
+                console.error(chalk.red(then.stopNote));
             process.exit(1);
+            return;
         }
+        allBuilt = true;
     }, sync);
-    return finished;
+    return finished.then(() => allBuilt);
 }
 /**
  * The end-of-run report of `build-all`: what was built, every package whose
@@ -1104,7 +1100,7 @@ const ensureBackendImportsShapes = function (root = process.cwd()) {
     let contents = fs.readFileSync(backendPath, 'utf-8');
     if (contents.includes('./shapes/index'))
         return;
-    fs.writeFileSync(backendPath, `import './shapes/index.js';\n` + contents);
+    fs.writeFileSync(backendPath, withEolOf(`import './shapes/index.js';\n`, contents) + contents);
 };
 // Register a shape in the shapes barrel (src/shapes/index.ts), creating it if needed, and
 // make sure both the main index and backend.ts import the barrel. Idempotent.
@@ -1120,7 +1116,7 @@ export const addShapeToBarrel = function (shapeHyphenName, root = process.cwd())
         contents = contents.includes('//SHAPES')
             ? contents.replace('//SHAPES', `//SHAPES\n${line}`)
             : contents.replace(/\n*$/, '') + `\n${line}\n`;
-        fs.writeFileSync(barrelPath, contents);
+        fs.writeFileSync(barrelPath, withEolOf(contents, contents));
     }
     // Both boot paths must load the barrel (idempotent).
     addLineToIndex(`import './shapes/index.js';`, 'shapes', root);
@@ -1164,7 +1160,7 @@ export const addLineToIndex = function (line, insertMatchString, root = process.
             }
             // log("Added at end",newContents);
         }
-        fs.writeFileSync(indexPath, newContents);
+        fs.writeFileSync(indexPath, withEolOf(newContents, indexContents));
     }
     return indexPath;
 };
@@ -1177,7 +1173,12 @@ const replaceVariablesInFolder = function (folder) {
     return __awaiter(this, void 0, void 0, function* () {
         //get all files in folder, including files that start with a dot
         try {
-            const files = yield glob(folder + '/**/*', { dot: true, nodir: true });
+            const files = yield glob('**/*', {
+                cwd: folder,
+                absolute: true,
+                dot: true,
+                nodir: true,
+            });
             yield Promise.all(files.map((file) => {
                 return replaceVariablesInFile(file);
             }));
@@ -1497,7 +1498,7 @@ export const runScript = (scriptName, options) => __awaiter(void 0, void 0, void
     }
     log('Running script ' + scriptName);
     const scriptPath = path.join(process.cwd(), 'scripts', scriptName);
-    const script = yield import(scriptPath);
+    const script = yield importFile(scriptPath);
     yield script.default().catch((error) => {
         log('Script ' + scriptName + ' finished with errors');
         logError(error);
@@ -1509,17 +1510,17 @@ export const runScript = (scriptName, options) => __awaiter(void 0, void 0, void
 export const runMethod = (packageName, method, options) => __awaiter(void 0, void 0, void 0, function* () {
     yield ensureEnvironmentLoaded();
     if (options.spawn) {
-        let linkedConfig = (yield import(path.join(process.cwd(), 'linked.config.js'))).default;
+        let linkedConfig = (yield importFile(path.join(process.cwd(), 'linked.config.js'))).default;
         // Set default loadAppComponent if not provided
         if (!linkedConfig.server) {
             linkedConfig.server = {};
         }
         if (!linkedConfig.server.loadAppComponent) {
-            linkedConfig.server.loadAppComponent = () => __awaiter(void 0, void 0, void 0, function* () { return (yield import(path.join(process.cwd(), 'src', 'App'))).default; });
+            linkedConfig.server.loadAppComponent = () => __awaiter(void 0, void 0, void 0, function* () { return (yield importFile(path.join(process.cwd(), 'src', 'App'))).default; });
         }
         // Set default loadRoutes if not provided
         if (!linkedConfig.server.loadRoutes) {
-            linkedConfig.server.loadRoutes = () => __awaiter(void 0, void 0, void 0, function* () { return yield import(path.join(process.cwd(), 'src', 'routes.tsx')); });
+            linkedConfig.server.loadRoutes = () => __awaiter(void 0, void 0, void 0, function* () { return yield importFile(path.join(process.cwd(), 'src', 'routes.tsx')); });
         }
         const ServerClass = yield loadServerClass();
         yield loadBackendStorageConfig();
@@ -1602,7 +1603,7 @@ export const runMethod = (packageName, method, options) => __awaiter(void 0, voi
 });
 export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (initOnly = false, ServerClass = null) {
     yield ensureEnvironmentLoaded();
-    let linkedConfig = (yield import(path.join(process.cwd(), 'linked.config.js')))
+    let linkedConfig = (yield importFile(path.join(process.cwd(), 'linked.config.js')))
         .default;
     // function scssLoadcall(source, filename) {
     //   return 'console.log("SCSS CALL: ' + filename + '");\n' + source;
@@ -1625,11 +1626,11 @@ export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0,
     if (!linkedConfig.server.loadAppComponent) {
         let appPromise;
         if (process.env.NODE_ENV !== 'development') {
-            appPromise = (yield import(path.join(process.cwd(), 'lib', 'App.js')))
+            appPromise = (yield importFile(path.join(process.cwd(), 'lib', 'App.js')))
                 .default;
         }
         else {
-            appPromise = (yield import(path.join(process.cwd(), 'src', 'App.tsx')))
+            appPromise = (yield importFile(path.join(process.cwd(), 'src', 'App.tsx')))
                 .default;
         }
         linkedConfig.server.loadAppComponent = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -1640,10 +1641,10 @@ export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0,
     if (!linkedConfig.server.loadRoutes) {
         linkedConfig.server.loadRoutes = () => __awaiter(void 0, void 0, void 0, function* () {
             if (process.env.NODE_ENV !== 'development') {
-                return yield import(path.join(process.cwd(), 'lib', 'routes.js'));
+                return yield importFile(path.join(process.cwd(), 'lib', 'routes.js'));
             }
             else {
-                return yield import(path.join(process.cwd(), 'src', 'routes.tsx'));
+                return yield importFile(path.join(process.cwd(), 'src', 'routes.tsx'));
             }
         });
     }
@@ -1920,6 +1921,8 @@ export const createPackage = (name_1, uriBase_1, ...args_1) => __awaiter(void 0,
             yield installWorkspacePackage(packageName, targetFolder, appRoot, options.skipInstall);
         }
         else if (options.skipInstall) {
+            // Files, not install: the app is set up for checkouts either way.
+            yield setUpAppForCheckouts(appRoot);
             skipped();
         }
         else {
@@ -1970,8 +1973,8 @@ function packageTargetFolder(name, basePath, appRoot, decision) {
         }
         // localize's own naming, so `linked localize` and this command can never
         // disagree about where a package lives.
-        const { checkoutNameFor, DEFAULT_DIR } = yield import('./localize/index.js');
-        return path.join(appRoot, DEFAULT_DIR, checkoutNameFor(name));
+        const { checkoutNameFor, LOCAL_DIR } = yield import('./localize/index.js');
+        return path.join(appRoot, LOCAL_DIR, checkoutNameFor(name));
     });
 }
 /**
@@ -2144,13 +2147,14 @@ function installStandalonePackage(targetFolder) {
 function installWorkspacePackage(name_1, targetFolder_1, appRoot_1) {
     return __awaiter(this, arguments, void 0, function* (name, targetFolder, appRoot, skipInstall = false) {
         const appPkgPath = path.join(appRoot, 'package.json');
-        const appPkg = fs.readJsonSync(appPkgPath);
+        const appPkgText = fs.readFileSync(appPkgPath, 'utf8');
+        const appPkg = JSON.parse(appPkgText);
         const workspaces = ensureWorkspaceGlob(appPkg);
         if (workspaces.warning)
             console.warn(chalk.yellow(workspaces.warning));
         const version = fs.readJsonSync(path.join(targetFolder, 'package.json')).version;
         appPkg.dependencies = Object.assign(Object.assign({}, appPkg.dependencies), { [name]: `^${version}` });
-        fs.writeJsonSync(appPkgPath, appPkg, { spaces: 2 });
+        fs.writeFileSync(appPkgPath, withEolOf(JSON.stringify(appPkg, null, 2) + '\n', appPkgText));
         log(`Added ${name}@^${version} to ${path.relative(process.cwd(), appPkgPath) || 'package.json'}` +
             (workspaces.changed ? ' and packages/* to its workspaces' : ''));
         if (skipInstall) {
@@ -2164,7 +2168,8 @@ function installWorkspacePackage(name_1, targetFolder_1, appRoot_1) {
 }
 /**
  * packages-local/: a repository of its own. Its git history starts here, and
- * localize's `adopt` installs, builds, links and records it. The app's
+ * localize's `adopt` sets the app up for checkouts, installs at the app root
+ * (npm links it as a workspace member) and builds it. The app's
  * dependencies are NOT touched: until the package is published a version range
  * fails `npm install` (E404 once a lockfile exists), and a `file:` path would
  * install cleanly for a teammate without the checkout and fail at runtime.
@@ -2189,14 +2194,8 @@ function installOwnRepoPackage(name, targetFolder, appRoot, decision) {
             pkg.repository = { type: 'git', url: repositoryUrlFor(remote) };
             fs.writeJsonSync(pkgPath, pkg, { spaces: 2 });
         }
-        // Before adopt, never during it: adopt asserts the app's package.json did not
-        // change while it ran.
-        const appPkgPath = path.join(appRoot, 'package.json');
-        const appPkg = fs.readJsonSync(appPkgPath);
-        if (ensureRelinkPostinstall(appPkg)) {
-            fs.writeJsonSync(appPkgPath, appPkg, { spaces: 2 });
-            log(`Added \`${RELINK_COMMAND}\` to the app's postinstall, so npm install keeps the link`);
-        }
+        // adopt sets the app up for checkouts (workspaces glob, lock-at-rest hook,
+        // .gitignore) and says what it changed, then installs at the app root.
         const { adoptPackage } = yield import('./commands/localize.js');
         const { EXIT_WARNED } = yield import('./localize/index.js');
         // Only the build command matters here: adopt always installs with npm, so
@@ -2204,12 +2203,11 @@ function installOwnRepoPackage(name, targetFolder, appRoot, decision) {
         const { buildCommand } = planPackageSetup('', path.join(getScriptDir(), 'launch.js'), process.execPath);
         const code = yield adoptPackage(name, { appRoot, build: buildCommand });
         if (code === EXIT_WARNED) {
-            fail('The package is linked, but its initial build failed');
+            fail('The package is installed, but its initial build failed');
         }
         else if (code !== 0) {
-            return fail(`Linking ${name} failed (localize exit ${code}). ${rel} is scaffolded with an uncommitted ` +
-                `git init, and the app's postinstall relinks localized packages. Fix the cause and retry ` +
-                `with: linked localize ${name} --adopt`);
+            return fail(`Installing ${name} failed (localize exit ${code}). ${rel} is scaffolded with an uncommitted ` +
+                `git init. Fix the cause and retry with: linked localize ${name} --adopt`);
         }
         const committed = git(['add', '-A'], targetFolder) &&
             git(['commit', '--quiet', '-m', `feat: scaffold ${name}`], targetFolder);
@@ -2225,10 +2223,27 @@ function installOwnRepoPackage(name, targetFolder, appRoot, decision) {
         }
         const version = fs.readJsonSync(pkgPath).version;
         log(`Prepared ${name} in ${chalk.magenta(rel)}, in its own git repository` +
-            (remote ? ` (origin ${remote}${pushed ? ', pushed' : ''})` : ' (no remote yet)'), `It is linked into node_modules and recorded in local-packages.json.`, `It is not in the app's dependencies: until it is published a version range would fail npm install.`, `  After publishing: ${chalk.blueBright(`npm install ${name}@^${version}`)}`);
+            (remote ? ` (origin ${remote}${pushed ? ', pushed' : ''})` : ' (no remote yet)'), `It is a workspace member through the app's packages-local/* glob, so npm links it.`, `It is not in the app's dependencies: until it is published a version range would fail npm install.`, `  After publishing: ${chalk.blueBright(`npm install ${name}@^${version}`)}`);
         if (!remote) {
-            log(`To add a remote later: ${chalk.blueBright('git remote add origin <url>')} in ${rel}, ` +
-                `then ${chalk.blueBright(`linked localize ${name} --adopt`)} to record it.`);
+            log(`To add a remote later: ${chalk.blueBright('git remote add origin <url>')} in ${rel}.`);
+        }
+    });
+}
+/** localize's one-time app setup, reported the way localize reports it. */
+function setUpAppForCheckouts(appRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ensureAppSetup, LocalizeError } = yield import('./localize/index.js');
+        try {
+            const changes = ensureAppSetup(appRoot);
+            if (changes.length) {
+                log(`Set up this app for checkouts in packages-local/ (commit these):`, ...changes.map((c) => `  ${c.file}: ${c.what}`));
+            }
+        }
+        catch (e) {
+            if (!(e instanceof LocalizeError))
+                throw e;
+            console.warn(chalk.yellow(e.message));
+            process.exitCode = 1;
         }
     });
 }
@@ -2514,22 +2529,23 @@ export const planBuildSteps = (pkgJson, packagePath) => {
         {
             name: 'Copying files to lib folder',
             apply: () => __awaiter(void 0, void 0, void 0, function* () {
-                const files = yield glob(packagePath + '/src/**/*.{json,d.ts,css,scss}');
+                // Relative to src/ (glob's cwd), so the destination is a plain join: a pattern or a
+                // prefix built from an absolute Windows path would not match.
+                const files = yield glob('**/*.{json,d.ts,css,scss}', {
+                    cwd: path.join(packagePath, 'src'),
+                });
                 let cjsPublished = false;
                 try {
                     cjsPublished = packagePublishesCjs(JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json'), 'utf8')));
                 }
                 catch (_a) { }
                 return Promise.all(files.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+                    const source = path.join(packagePath, 'src', file);
                     try {
-                        yield fs.copy(file, packagePath +
-                            '/lib/esm/' +
-                            file.replace(packagePath + '/src/', ''));
+                        yield fs.copy(source, path.join(packagePath, 'lib', 'esm', file));
                         // Only mirror into lib/cjs when there is a CJS build to mirror.
                         if (cjsPublished) {
-                            yield fs.copy(file, packagePath +
-                                '/lib/cjs/' +
-                                file.replace(packagePath + '/src/', ''));
+                            yield fs.copy(source, path.join(packagePath, 'lib', 'cjs', file));
                         }
                         return true;
                     }
@@ -2884,7 +2900,8 @@ export var publishPackage = function (pkg, test, info, publishVersion) {
         const versionAndPublish = publishPm === 'yarn'
             ? `yarn version ${publishVersion} && yarn npm publish`
             : `npm version ${publishVersion} --no-git-tag-version && npm publish`;
-        return execPromise(`cd ${pkg.path} && ${envJsonPath ? `env-cmd -f ${envJsonPath} --use-shell "` : ''}${versionAndPublish}${envJsonPath ? `"` : ''}`, true, false, {}, true)
+        // The package as cwd, not `cd <dir> &&`: cmd.exe's `cd` does not change drives.
+        return execPromise(`${envJsonPath ? `env-cmd -f "${envJsonPath}" --use-shell "` : ''}${versionAndPublish}${envJsonPath ? `"` : ''}`, true, false, { cwd: pkg.path }, true)
             .then((res) => {
             if (res.indexOf('Aborted due to warnings') !== -1 ||
                 res.indexOf('Could not publish') !== -1 ||
@@ -3044,7 +3061,7 @@ export var executeCommandForEachPackage = function (packages, command, filterMet
     packages.forEach((pkg) => {
         p = p.then(() => {
             log('# Package ' + chalk.magenta(pkg.packageName));
-            return execp('cd ' + pkg.path + ' && ' + command);
+            return execp(command, false, false, { cwd: pkg.path });
         });
     });
     return p;
@@ -3124,16 +3141,15 @@ export var executeCommandForPackage = function (packageName, command) {
         // npm is the default; only a package inside a yarn project is driven with
         // yarn (`yarn linked <cmd>` resolves the bin from the yarn workspace).
         const pm = detectPackageManager(packageDetails.path);
-        // Windows quirk: the shim is `yarn.cmd` / `npx.cmd`.
-        const isWin = process.platform === 'win32';
-        const runner = pm === 'yarn' ? (isWin ? 'yarn.cmd' : 'yarn') : isWin ? 'npx.cmd' : 'npx';
+        const runner = pm === 'yarn' ? 'yarn' : 'npx';
         const runnerArgs = pm === 'yarn' ? ['linked'] : ['--no-install', 'linked'];
-        log("Executing 'cd " +
-            packageDetails.path +
-            ` && ${runner} linked` +
-            (command ? ' ' + command : '') +
-            "'");
-        spawnChild(runner, [...runnerArgs, command || null], {
+        const commandArgs = command ? String(command).split(/\s+/).filter(Boolean) : [];
+        log("Executing '" +
+            [runner, ...runnerArgs, ...commandArgs].join(' ') +
+            "' in " +
+            packageDetails.path);
+        // spawnCommand starts the `.cmd` shim on Windows.
+        spawnCommand(runner, [...runnerArgs, ...commandArgs], {
             cwd: packageDetails.path,
             stdio: 'inherit',
         });
@@ -3151,7 +3167,7 @@ export const removeOldFiles = (packagePath) => __awaiter(void 0, void 0, void 0,
     const libPath = path.join(packagePath, 'lib');
     try {
         // Read all files in the 'lib' folder asynchronously
-        const files = yield glob(packagePath + '/lib/**/*.*');
+        const files = yield glob('**/*.*', { cwd: libPath, absolute: true });
         // Iterate through each file
         for (const file of files) {
             // const filePath = path.join(libPath, file);