@haystackeditor/cli 0.27.0 → 0.27.1

package/dist/capture/app-config.js

@@ -62,7 +62,8 @@ export function recordedApps(gitRoot, candidates) {
             return readCaptureConfig(join(gitRoot, dir))?.app === dir;
         }
         catch (error) {
-            throw new Error(`${posix.join(dir, CAPTURE_CONFIG_PATH)}: ${error instanceof Error ? error.message : String(error)}`);
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(dir === '.' ? message : message.replace(CAPTURE_CONFIG_PATH, posix.join(dir, CAPTURE_CONFIG_PATH)));
         }
     });
 }

package/dist/commands/init-telemetry.js

@@ -21,9 +21,9 @@
  *     stores or reads one), production's environment, the start command, the deploy and the off switches (13c).
  */
 import { execFileSync, spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { accessSync, constants, existsSync, lstatSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
+import { delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import { classifyHttpError, repoApiPath } from '../utils/haystack-api.js';
@@ -103,7 +103,8 @@ function section(json, name) {
 }
 const LOCKFILES = [['pnpm-lock.yaml', 'pnpm'], ['package-lock.json', 'npm'], ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun']];
 /** The package manager that owns the app's lockfile: the nearest `packageManager` field, else the nearest lockfile, from
- * the app up to the repository root. null: no lockfile, so the dependency is written into package.json itself. */
+ * the app up to the repository root (`from` says which). null: no lockfile, so the dependency is written into package.json
+ * itself. */
 function packageManager(gitRoot, appDir) {
     for (let directory = appDir;; directory = dirname(directory)) {
         const manifest = join(directory, 'package.json');
@@ -111,16 +112,32 @@ function packageManager(gitRoot, appDir) {
             const declared = readPackage(manifest).json.packageManager;
             const name = typeof declared === 'string' ? /^(pnpm|npm|yarn|bun)@/.exec(declared)?.[1] : undefined;
             if (name)
-                return { name: name, root: directory };
+                return { name: name, root: directory, from: `${inside(gitRoot, manifest)}'s packageManager field` };
         }
         for (const [lockfile, name] of LOCKFILES) {
             if (isFile(join(directory, lockfile)))
-                return { name, root: directory };
+                return { name, root: directory, from: inside(gitRoot, join(directory, lockfile)) };
         }
         if (directory === gitRoot || dirname(directory) === directory)
             return null;
     }
 }
+/** Whether `command` is an executable on PATH (a package manager init would run, checked before it plans to). */
+function onPath(command) {
+    const extensions = process.platform === 'win32' ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : [''];
+    for (const directory of (process.env.PATH ?? '').split(delimiter)) {
+        if (directory === '')
+            continue;
+        for (const extension of extensions) {
+            try {
+                accessSync(join(directory, `${command}${extension}`), constants.X_OK);
+                return true;
+            }
+            catch { /* not in this directory */ }
+        }
+    }
+    return false;
+}
 /** The first release whose sites record repository-relative paths (what a registered tenant's src_prefix '' relies on)
  * and that ships the `./next` entry: earlier releases are not compatible with either integration. */
 const CLI_COMPATIBLE_SINCE = [0, 24, 0];
@@ -216,14 +233,29 @@ function planDependency(gitRoot, appDir, pkg, after, need) {
     const spec = `${CLI_PACKAGE}@${version}`;
     const dev = field === 'devDependencies';
     const workspaceRoot = isFile(join(appDir, 'pnpm-workspace.yaml')) ? ['--workspace-root'] : [];
-    // Each package manager's add, as it changes no lockfile entry but the CLI's own (lockfile-pin.ts): npm with its tree
-    // nested under the CLI (hoisting would replace packages the app already locks), pnpm through the merge.
+    // Each package manager's add, as it changes no lockfile entry but the CLI's own (lockfile-pin.ts; pnpm through the merge).
     const argv = manager === null ? null : {
         pnpm: ['pnpm', 'add', '--save-exact', dev ? '--save-dev' : '--save-prod', ...workspaceRoot, spec],
-        npm: ['npm', 'install', '--save-exact', dev ? '--save-dev' : '--save-prod', '--install-strategy=nested', spec],
+        npm: ['npm', 'install', '--save-exact', dev ? '--save-dev' : '--save-prod', spec],
         yarn: ['yarn', 'add', '--exact', ...(dev ? ['--dev'] : []), spec],
         bun: ['bun', 'add', '--exact', ...(dev ? ['--dev'] : []), spec],
     }[manager.name];
+    const appPath = inside(gitRoot, appDir) || '.';
+    // npm re-resolves entries the CLI does not own whatever the flags (39 in fosrl/pangolin, with --install-strategy=nested
+    // too), so init never rewrites an npm lockfile: the person adds the CLI with npm and sees the lockfile's diff.
+    if (manager?.name === 'npm' && argv) {
+        return { kind: 'manual', why: `${appPath} uses npm (${manager.from}), whose install also re-resolves lockfile entries the CLI does not own, so init`
+                + ` does not run it. Run \`${argv.join(' ')}\` in ${appPath}, check package-lock.json's diff, then run \`haystack init\` again` };
+    }
+    // A package manager that is not installed is never run (rule 13: telemetry never fails init).
+    if (manager && argv && !onPath(manager.name)) {
+        const provide = (manager.name === 'pnpm' || manager.name === 'yarn') && onPath('corepack')
+            ? `run \`corepack enable ${manager.name}\` (corepack is installed here)`
+            : `install it (${manager.name === 'bun' ? 'https://bun.sh' : manager.name === 'yarn' ? 'https://yarnpkg.com/getting-started/install' : 'https://pnpm.io/installation'})`;
+        return { kind: 'manual', why: `${appPath} uses ${manager.name} (${manager.from}), which is not installed here, so init did not run it. Either`
+                + ` ${provide} and run \`haystack init\` again, or run \`${argv.join(' ')}\` in ${appPath} wherever ${manager.name} is installed and then`
+                + ' run `haystack init` again' };
+    }
     const action = promoting ? `Moved from devDependencies to dependencies at ${version}` : `Pinned to ${version}`;
     const lockfileNote = manager?.name === 'pnpm'
         ? `, keeping every other entry of pnpm's lockfile as it was (pnpm's own add re-resolves packages the CLI shares with the app; init adds only the CLI's entries, then \`pnpm install --frozen-lockfile\`)`
@@ -247,12 +279,14 @@ function planDependency(gitRoot, appDir, pkg, after, need) {
 }
 /** The lockfile a package manager writes, in a format lockfile-pin.ts reads (bun's binary lockb aside). */
 function textLockfile(manager) {
-    const name = { pnpm: 'pnpm-lock.yaml', npm: 'package-lock.json', yarn: 'yarn.lock', bun: 'bun.lock' }[manager.name];
+    if (manager.name === 'npm')
+        throw new Error('init never runs npm to pin the CLI');
+    const name = { pnpm: 'pnpm-lock.yaml', yarn: 'yarn.lock', bun: 'bun.lock' }[manager.name];
     const path = join(manager.root, name);
     return isFile(path) ? { path, format: manager.name } : null;
 }
 /** Runs the add, so that the lockfile gains the CLI's entries and nothing else moves (rule 13); throws (init then restores
- * every file) when the package manager moved anything else. */
+ * telemetry's files and leaves telemetry manual) when the package manager moved anything else. */
 function pin(manager, appDir, argv) {
     const run = (command) => { execFileSync(command[0], command.slice(1), { cwd: appDir, stdio: ['ignore', 2, 2] }); };
     const lockfile = textLockfile(manager);
@@ -272,8 +306,8 @@ function pin(manager, appDir, argv) {
     const moved = lockfileDrift(lockfile.format, before, readFileSync(lockfile.path, 'utf8'), importer, CLI_PACKAGE);
     if (moved.length > 0) {
         throw new Error(`\`${argv.join(' ')}\` also changed ${moved.length} lockfile ${moved.length === 1 ? 'entry' : 'entries'} the CLI does not own`
-            + ` (${moved.slice(0, 5).join(', ')}${moved.length > 5 ? ', …' : ''}), so init put every file back. Add ${CLI_PACKAGE} at its exact version`
-            + ` to ${inside(manager.root, appDir) || '.'} yourself, keeping the lockfile's other entries, then run \`haystack init\` again`);
+            + ` (${moved.slice(0, 5).join(', ')}${moved.length > 5 ? ', …' : ''}). Add ${CLI_PACKAGE} at its exact version to`
+            + ` ${inside(manager.root, appDir) || '.'} yourself, keeping the lockfile's other entries, then run \`haystack init\` again`);
     }
 }
 function isNode(value) {
@@ -1006,6 +1040,22 @@ export function previewTelemetry(plan, repository, notes) {
     const profile = dbProfile(repository, null, notes);
     return { telemetry: { capture: plan.capture, server: serverPartOf(plan), dbProfileCommand: profile?.command ?? null }, steps };
 }
+/** A telemetry plan with nothing planned, for a run whose telemetry could not be planned at all (failedTelemetry says why). */
+export function emptyTelemetryPlan() {
+    return { app: null, changes: [], notices: [], server: { status: 'manual', kind: null, steps: [] }, settings: null,
+        capture: { status: 'manual', steps: [], received: null }, captureRegistration: null };
+}
+/** Telemetry that could not be set up (a package manager failed, a file init could not read, Haystack not answering): each
+ * part it would have set up is manual with what happened, every file telemetry changed is back, and the rest of init stands
+ * (telemetry never fails init). */
+export function failedTelemetry(plan, failure) {
+    const step = `init could not set up telemetry: ${failure.replace(/\.?\s*$/, '')}. It put back every file telemetry changed; the rest of init is`
+        + ' done. Fix that, then run `haystack init` again.';
+    // A part that was already waiting for answers keeps its questions after what happened.
+    const part = (value) => (value.status === 'unsupported' ? value
+        : { status: 'manual', steps: [step, ...(value.status === 'manual' ? value.steps : [])], received: null });
+    return { telemetry: { capture: part(plan.capture), server: part(serverPartOf(plan)), dbProfileCommand: null }, steps: [step] };
+}
 /** Rule 8(e): the report, and what the person does for telemetry to arrive (the token, production's environment, the start,
  * the deploy) with the off switches (rule 13c). `onboarding` and `notes` feed the data profile. */
 export async function telemetryReport(plan, context) {

package/dist/commands/init.js

@@ -299,6 +299,33 @@ export function planInit(gitRoot) {
     const notices = [];
     return { changes: [...planStopHook(gitRoot, notices), ...planAgentNotes(gitRoot, notices)], notices };
 }
+/** Makes `changes` all or nothing: one that fails (an install that does not end as planned) restores every file they
+ * touched (bytes, not text: a lockfile can be binary), so no edit is left referencing what was never installed. */
+function applyAll(gitRoot, changes, say) {
+    const before = new Map();
+    for (const planned of changes) {
+        for (const path of [planned.target, ...(planned.run?.touches ?? [])]) {
+            if (!before.has(path))
+                before.set(path, existsSync(path) ? readFileSync(path) : null);
+        }
+    }
+    try {
+        for (const planned of changes) {
+            applyChange(gitRoot, planned);
+            say(chalk.green(`✓ ${planned.action === 'create' ? 'Created' : planned.action === 'delete' ? 'Deleted' : 'Updated'} ${planned.path}`));
+        }
+    }
+    catch (error) {
+        for (const [path, content] of before) {
+            if (content !== null)
+                writeFileSync(path, content);
+            else if (existsSync(path))
+                unlinkSync(path);
+        }
+        throw error;
+    }
+}
+const errorText = (error) => (error instanceof Error ? error.message : String(error));
 function applyChange(gitRoot, planned) {
     const inside = relative(gitRoot, planned.target);
     if (!inside.startsWith('..') && !isAbsolute(inside))
@@ -362,19 +389,35 @@ export async function initCommand(options) {
     // Read before anything else, so notes that cannot be used stop init with nothing done.
     const notes = options.notes === undefined ? null : readNotes(options.notes);
     const plan = planInit(gitRoot);
-    // Telemetry is part of onboarding (CAPTURE-V1 rule 8): planned on every run; a missing answer stops only it.
+    // Telemetry is part of onboarding (CAPTURE-V1 rule 8): planned on every run; a missing answer stops only it. It never fails
+    // init: whatever goes wrong with it (a file it cannot read, a package manager that fails, Haystack not answering) puts its
+    // own files back and leaves it manual with what happened, and the rest of init goes on.
     const telemetryModule = await import('./init-telemetry.js');
     const telemetryOptions = { app: options.app, origins: options.origin ?? [], consent: options.consent, urlRewrites: options.urlRewrites };
-    let telemetryPlan = await telemetryModule.planTelemetry(gitRoot, repository, telemetryOptions);
+    let telemetryFailure = null;
+    let telemetryPlan = telemetryModule.emptyTelemetryPlan();
+    try {
+        telemetryPlan = await telemetryModule.planTelemetry(gitRoot, repository, telemetryOptions);
+    }
+    catch (error) {
+        telemetryFailure = errorText(error);
+    }
     const telemetryFrom = plan.changes.length;
     plan.changes.push(...telemetryPlan.changes);
     plan.notices.push(...telemetryPlan.notices);
     let notesWritten = null;
     let telemetry = null;
+    /** Telemetry did not happen: its changes leave the plan (none of them was made), and the report says why. */
+    const telemetryFailed = (error) => {
+        telemetryFailure = errorText(error);
+        plan.changes.splice(telemetryFrom);
+        say(chalk.yellow(`Telemetry was not set up: ${telemetryFailure} The rest of init goes on; the telemetry report says what to do.`));
+    };
     // Before the apply (a preview, or no login), the report is the preview: what telemetry will do, `received` unchecked (null).
-    const report = () => telemetry ?? telemetryModule.previewTelemetry(telemetryPlan, repository, notes);
+    const report = () => (telemetryFailure !== null ? telemetryModule.failedTelemetry(telemetryPlan, telemetryFailure)
+        : telemetry ?? telemetryModule.previewTelemetry(telemetryPlan, repository, notes));
     const showPreview = () => {
-        const preview = telemetryModule.previewTelemetry(telemetryPlan, repository, notes);
+        const preview = report();
         for (const line of telemetryModule.formatTelemetry(preview.telemetry, preview.steps))
             say(line);
         say('');
@@ -424,44 +467,48 @@ export async function initCommand(options) {
             return;
         }
     }
-    // Browser capture's registration (rule 8b), which the preview announced: checked with Haystack now, and when the files
-    // need a new key the telemetry changes are planned again with it (or without capture's, when it is refused).
+    // Init's own changes (the agent instructions, the Stop hook) first, all or nothing: a failure there is init's.
+    try {
+        applyAll(gitRoot, plan.changes.slice(0, telemetryFrom), say);
+    }
+    catch (error) {
+        throw new Error(`${errorText(error)} Every file init changed was restored; nothing was changed.`);
+    }
+    // Then telemetry, all or nothing on its own. Browser capture's registration (rule 8b), which the preview announced, is
+    // checked with Haystack first, and when the files need a new key the telemetry changes are planned again with it (or
+    // without capture's, when it is refused).
     const approved = options.yes === true || plan.changes.length > 0;
-    const capture = telemetryPlan.captureRegistration
-        ? await telemetryModule.prepareCapture(telemetryPlan.captureRegistration, token, say, approved) : null;
-    if (capture?.replan) {
-        telemetryPlan = await telemetryModule.planTelemetry(gitRoot, repository, { ...telemetryOptions, registration: capture.replan });
-        plan.changes.splice(telemetryFrom, plan.changes.length - telemetryFrom, ...telemetryPlan.changes);
-    }
-    // All or nothing: a change that fails (an install that does not end as planned) restores every file the changes
-    // touched, so no edit is left referencing what was never installed.
-    // Bytes, not text: a lockfile can be binary (bun.lockb).
-    const before = new Map();
-    for (const planned of plan.changes) {
-        for (const path of [planned.target, ...(planned.run?.touches ?? [])]) {
-            if (!before.has(path))
-                before.set(path, existsSync(path) ? readFileSync(path) : null);
+    let capture = null;
+    if (telemetryFailure === null) {
+        try {
+            capture = telemetryPlan.captureRegistration
+                ? await telemetryModule.prepareCapture(telemetryPlan.captureRegistration, token, say, approved) : null;
+            if (capture?.replan) {
+                telemetryPlan = await telemetryModule.planTelemetry(gitRoot, repository, { ...telemetryOptions, registration: capture.replan });
+                plan.changes.splice(telemetryFrom, plan.changes.length - telemetryFrom, ...telemetryPlan.changes);
+            }
+            applyAll(gitRoot, plan.changes.slice(telemetryFrom), say);
         }
-    }
-    try {
-        for (const planned of plan.changes) {
-            applyChange(gitRoot, planned);
-            say(chalk.green(`✓ ${planned.action === 'create' ? 'Created' : planned.action === 'delete' ? 'Deleted' : 'Updated'} ${planned.path}`));
+        catch (error) {
+            try {
+                await capture?.rollback(say);
+            }
+            catch (rollbackError) {
+                say(chalk.yellow(`Capture's registration could not be put back: ${errorText(rollbackError)}`));
+            }
+            telemetryFailed(error);
         }
     }
-    catch (error) {
-        for (const [path, content] of before) {
-            if (content !== null)
-                writeFileSync(path, content);
-            else if (existsSync(path))
-                unlinkSync(path);
+    if (telemetryFailure === null && capture) {
+        try {
+            const captureFollowUp = await capture.finish(say);
+            if (captureFollowUp)
+                telemetryPlan.capture = telemetryModule.withCaptureStep(telemetryPlan.capture, captureFollowUp);
+        }
+        catch (error) {
+            telemetryPlan.capture = telemetryModule.withCaptureStep(telemetryPlan.capture, `Run \`haystack init\` again: Haystack did not take the app's origins (${errorText(error)}).`);
         }
-        await capture?.rollback(say);
-        throw new Error(`${error instanceof Error ? error.message : String(error)} Every file init changed was restored; nothing was changed.`);
     }
-    const captureFollowUp = await capture?.finish(say);
-    if (captureFollowUp)
-        telemetryPlan.capture = telemetryModule.withCaptureStep(telemetryPlan.capture, captureFollowUp);
     let onboarding;
     try {
         // The notes first: onboarding plans from the facts it starts with, and new notes are new facts (a new onboarding).
@@ -485,8 +532,18 @@ export async function initCommand(options) {
     reportOnboardingState(onboarding);
     say(formatOnboarding(onboarding));
     say('');
-    telemetry = await telemetryModule.telemetryReport(telemetryPlan, { repository, token, onboarding, notes });
-    for (const line of telemetryModule.formatTelemetry(telemetry.telemetry, telemetry.steps))
+    if (telemetryFailure === null) {
+        try {
+            telemetry = await telemetryModule.telemetryReport(telemetryPlan, { repository, token, onboarding, notes });
+        }
+        catch (error) {
+            // What Haystack holds could not be read: the report as previewed (`received` unchecked), and why.
+            const preview = telemetryModule.previewTelemetry(telemetryPlan, repository, notes);
+            telemetry = { telemetry: preview.telemetry, steps: [...preview.steps, `Run \`haystack init --json\` again to read what telemetry Haystack has received (it could not: ${errorText(error)}).`] };
+        }
+    }
+    const shown = report();
+    for (const line of telemetryModule.formatTelemetry(shown.telemetry, shown.steps))
         say(line);
     say('');
     if (onboarding.state === 'ready')

package/dist/commands/lockfile-pin.js

@@ -4,13 +4,14 @@
  * locks older versions of packages the CLI also uses):
  *   - yarn 1, yarn 4 and bun add only the new descriptors and entries; nothing else moves.
  *   - npm hoists the new tree and replaces hoisted packages the app already locks (ws, yaml, zod moved to the CLI's
- *     versions); with `--install-strategy=nested` it places the new tree under the dependency and moves nothing.
+ *     versions), and re-resolves other entries even with `--install-strategy=nested` (39 in fosrl/pangolin): init never
+ *     runs it (init-telemetry.ts leaves the npm install to the person, who sees the lockfile's diff).
  *   - pnpm re-resolves the dependencies of every package the new tree shares with the old one to the newest version in the
  *     graph (47 entries in Rallly, from @smithy/* to express), and no flag stops it. So init lets pnpm resolve the new
  *     dependency (`--lockfile-only`), keeps every entry the lockfile had, adds the entries only the new dependency
  *     reaches (mergePnpmLockfile), and installs exactly that (`pnpm install --frozen-lockfile`, which also proves it).
- * lockfileDrift checks the result for every format init can read, so a package manager that moves anything else fails the
- * change (and init restores every file).
+ * lockfileDrift checks the result for every format init runs, so a package manager that moves anything else fails the
+ * change (and init restores telemetry's files, leaving telemetry manual).
  */
 function unquote(text) {
     if (text.startsWith('\'') && text.endsWith('\''))
@@ -271,11 +272,6 @@ function entriesOf(format, text, importer) {
             }
         }
     }
-    else if (format === 'npm') {
-        const packages = JSON.parse(text).packages ?? {};
-        for (const [key, value] of Object.entries(packages))
-            out.set(key === (importer === '.' ? '' : importer) ? IMPORTER : key, JSON.stringify(value));
-    }
     else if (format === 'yarn') {
         for (const block of text.split(/\n\s*\n/)) {
             const lines = block.split('\n').filter(line => line.trim() !== '' && !line.startsWith('#'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "haystack verify: run your app with and without a change, and see what the change broke",
   "type": "module",
   "bin": {