@haystackeditor/cli 0.15.2 → 0.15.4

package/dist/commands/setup.js

@@ -19,7 +19,7 @@ import { resolveAuthContext } from '../utils/auth.js';
 import { hooksInstall } from './hooks.js';
 import { findGitRoot } from '../utils/hooks.js';
 import { trackError, trackSetupEvent } from '../utils/telemetry.js';
-import { createPrompter, loadAnswersFile } from '../utils/prompter.js';
+import { createPrompter, loadAnswersFile, PromptCancelledError } from '../utils/prompter.js';
 /** The active prompter for this `setup` invocation (TTY or JSON). */
 let ui;
 /**
@@ -744,6 +744,13 @@ async function isAppInstalled(token) {
         // keeps waiting instead of crashing the wizard.
         if (err instanceof InstallationsAuthError)
             throw err;
+        // Transient (5xx / network / rate limit): log so it isn't a silent fallback
+        // (PR001), then return false so the install poll keeps waiting. Re-throwing
+        // here — a literal reading of "no silent fallback" — would reintroduce the
+        // poll-crash this function exists to prevent, so we log instead.
+        trackError('haystack_setup_app_check_transient_error', {
+            error_message: err instanceof Error ? err.message : String(err),
+        });
         return false;
     }
 }
@@ -783,9 +790,9 @@ async function stepEnsureAppInstalled(token) {
     // ui.action emits an `action` event (JSON) or prints + spins (TTY), then polls
     // until the App is detected or it times out. A mid-poll auth failure surfaces
     // as a thrown InstallationsAuthError.
-    let installed = false;
+    let result;
     try {
-        installed = await ui.action({
+        result = await ui.action({
             id: 'install_app',
             message: 'Install the Haystack GitHub App, then it is detected automatically.',
             url: HAYSTACK_APP_INSTALL_URL,
@@ -803,10 +810,18 @@ async function stepEnsureAppInstalled(token) {
         }
         throw err;
     }
-    if (installed) {
+    if (result === 'ok') {
         console.log(chalk.green('\n  ✓ App installed\n'));
         return;
     }
+    if (result === 'skip') {
+        // Caller intentionally skipped — proceed (refuse-to-fail), but warn that the
+        // App is needed for Haystack to actually act on the configured repos.
+        console.log(chalk.yellow('\n  Skipping GitHub App verification.'));
+        console.log(chalk.dim('  Haystack needs the App installed to analyze, triage, or merge your PRs.\n'));
+        return;
+    }
+    // result === 'timeout'
     trackError('haystack_setup_app_install_timeout', { timeout_ms: APP_INSTALL_TIMEOUT_MS });
     console.log(chalk.yellow('\n  Timed out waiting for App install.'));
     console.log(chalk.dim(`  Install at ${HAYSTACK_APP_INSTALL_URL}, then re-run \`haystack setup\`.\n`));
@@ -829,11 +844,12 @@ async function stepSelectRepos(token) {
         });
         if (selectedRepos.length > 0)
             break;
-        // Interactive: keep the picker open so the user can correct an empty pick
-        // (restores the old inquirer `validate` behavior). Non-interactive: a
-        // pre-supplied / agent-sent empty selection can't be fixed by re-prompting,
-        // so fail clearly instead of looping forever.
-        if (!ui.interactive) {
+        // Interactive live pick: keep the picker open so the user can correct an
+        // empty selection (restores the old inquirer `validate`). But a PRE-SUPPLIED
+        // empty selection (--answers select_repos:[]) would be returned unchanged
+        // every iteration — re-prompting can't fix it, so fail instead of looping.
+        // Non-interactive likewise can't be corrected.
+        if (!ui.interactive || ui.hasPreset('select_repos')) {
             console.log(chalk.yellow('\n  No repositories selected. Pass --repo <owner/name>.\n'));
             process.exit(1);
         }
@@ -1172,6 +1188,15 @@ export async function setupCommand(options = {}) {
     try {
         await runSetupFlow(options);
     }
+    catch (err) {
+        // An agent cancelling a prompt is a clean exit, not a crash.
+        if (err instanceof PromptCancelledError) {
+            console.log(chalk.yellow('\n  Setup cancelled.\n'));
+            ui.result({ status: 'cancelled' });
+            return;
+        }
+        throw err;
+    }
     finally {
         ui.close();
     }

package/dist/utils/prompter.d.ts

@@ -25,10 +25,22 @@ export type Choice<T> = {
 } | {
     separator: string;
 };
+/** Thrown when an agent explicitly rejects/cancels a prompt (vs. answering it),
+ *  so callers can distinguish a cancellation from a valid empty answer. */
+export declare class PromptCancelledError extends Error {
+    readonly requestID: string;
+    constructor(requestID: string);
+}
+/** Outcome of an `action`: satisfied, intentionally skipped, or timed out —
+ *  distinct so callers don't report a skip as a timeout. */
+export type ActionResult = 'ok' | 'skip' | 'timeout';
 export interface Prompter {
     /** True for the human TTY prompter — gates side effects like opening a browser
      *  that only make sense for a local interactive user. */
     readonly interactive: boolean;
+    /** Whether an answer for `id` was pre-supplied (flag / --answers), so the
+     *  prompt is skipped. Callers use this to avoid re-prompting a fixed answer. */
+    hasPreset(id: string): boolean;
     /** Yes/no decision. */
     confirm(q: {
         id: string;
@@ -43,9 +55,8 @@ export interface Prompter {
     }): Promise<T[]>;
     /**
      * An action the user must take out-of-band (e.g. install the GitHub App).
-     * Polls `check()` until it returns true (satisfied) or `timeoutMs` elapses.
-     * A pre-supplied / stdin answer of "skip" resolves false without polling.
-     * Returns true when satisfied, false when skipped or timed out.
+     * Polls `check()` until it returns true (`'ok'`) or `timeoutMs` elapses
+     * (`'timeout'`). A pre-supplied / stdin "skip"/reject resolves `'skip'`.
      */
     action(q: {
         id: string;
@@ -54,7 +65,7 @@ export interface Prompter {
         check: () => Promise<boolean>;
         pollIntervalMs?: number;
         timeoutMs?: number;
-    }): Promise<boolean>;
+    }): Promise<ActionResult>;
     /** Transient progress line (scan ticker, per-repo write status). */
     progress(message: string, detail?: string): void;
     /** Clear the current progress line. */

package/dist/utils/prompter.js

@@ -23,6 +23,16 @@ import { readFileSync } from 'node:fs';
 function isSeparator(c) {
     return c.separator !== undefined;
 }
+/** Thrown when an agent explicitly rejects/cancels a prompt (vs. answering it),
+ *  so callers can distinguish a cancellation from a valid empty answer. */
+export class PromptCancelledError extends Error {
+    requestID;
+    constructor(requestID) {
+        super(`Prompt "${requestID}" was cancelled.`);
+        this.requestID = requestID;
+        this.name = 'PromptCancelledError';
+    }
+}
 export function loadAnswersFile(path) {
     const raw = readFileSync(path, 'utf8');
     const parsed = JSON.parse(raw);
@@ -40,9 +50,12 @@ class TtyPrompter {
     constructor(answers) {
         this.answers = answers;
     }
+    hasPreset(id) {
+        return id in this.answers;
+    }
     async confirm(q) {
         if (q.id in this.answers)
-            return Boolean(this.answers[q.id]);
+            return toBool(this.answers[q.id]);
         const { value } = await inquirer.prompt([
             { type: 'confirm', name: 'value', message: q.message, default: q.default ?? true },
         ]);
@@ -59,9 +72,9 @@ class TtyPrompter {
     }
     async action(q) {
         if (this.answers[q.id] === 'skip')
-            return false;
+            return 'skip';
         if (await q.check())
-            return true;
+            return 'ok';
         console.log(chalk.yellow(`  ${q.message}`));
         if (q.url)
             console.log(`  ${chalk.cyan(q.url)}`);
@@ -72,9 +85,9 @@ class TtyPrompter {
         while (Date.now() - started < timeout) {
             await sleep(interval);
             if (await q.check())
-                return true;
+                return 'ok';
         }
-        return false;
+        return 'timeout';
     }
     progress(message, detail) {
         // Only emit carriage-return / clear-line ANSI to a real TTY; piped to a file
@@ -122,6 +135,9 @@ class JsonPrompter {
             console.error = origError;
         };
     }
+    hasPreset(id) {
+        return id in this.answers;
+    }
     emit(event) {
         process.stdout.write(JSON.stringify(event) + '\n');
     }
@@ -174,15 +190,16 @@ class JsonPrompter {
     }
     async confirm(q) {
         if (q.id in this.answers)
-            return Boolean(this.answers[q.id]);
+            return toBool(this.answers[q.id]);
         // A confirm is a single-choice question; emit OpenCode's `question` envelope.
         // Reply: {requestID, answers: <bool>}; reject: {requestID, reject: true}.
         this.emit({ type: 'question', requestID: q.id, kind: 'confirm', prompt: q.message, default: q.default ?? true });
         const reply = await this.awaitReply(q.id);
+        // Reject = cancellation (distinct from "No"); parse the answer robustly so a
+        // string "false" isn't coerced truthy.
         if (reply.reject)
-            return false;
-        const a = reply.answers ?? reply.value; // `answers` is canonical; `value` accepted
-        return typeof a === 'boolean' ? a : Boolean(a);
+            throw new PromptCancelledError(q.id);
+        return toBool(reply.answers ?? reply.value);
     }
     async multiselect(q) {
         if (q.id in this.answers)
@@ -193,16 +210,18 @@ class JsonPrompter {
         // Reply: {requestID, answers: <value[]>}; reject: {requestID, reject: true}.
         this.emit({ type: 'question', requestID: q.id, kind: 'multiselect', prompt: q.message, options });
         const reply = await this.awaitReply(q.id);
+        // Surface a rejection as a distinct cancellation rather than masking it as an
+        // empty selection, and surface a non-array reply as a protocol error rather
+        // than silently coercing to [] (PR001: no silent fallback).
         if (reply.reject)
-            return [];
-        const a = reply.answers ?? reply.value;
-        return Array.isArray(a) ? a : [];
+            throw new PromptCancelledError(q.id);
+        return asArray(reply.answers ?? reply.value, q.id);
     }
     async action(q) {
         if (this.answers[q.id] === 'skip')
-            return false;
+            return 'skip';
         if (await q.check())
-            return true;
+            return 'ok';
         // An out-of-band action maps to OpenCode's `permission` request. Reply:
         // {permissionID, response: "once"|"always"|"reject"}. We also keep polling
         // check() so it resolves on its own once the action completes.
@@ -216,22 +235,29 @@ class JsonPrompter {
             const r = (reply.response ?? reply.value);
             override = r === 'reject' || r === 'skip' ? 'skip' : 'done';
         });
-        while (Date.now() - started < timeout) {
-            if (await q.check())
-                return true;
-            if (override === 'skip')
-                return false;
-            // 'done' means the agent reports the action complete — but completion may
-            // be eventually-consistent, so keep polling check() at the interval until
-            // it confirms or we time out (matching TTY behavior), rather than failing
-            // on a single immediate check.
-            if (override === 'done') {
-                await sleep(interval);
-                continue;
+        try {
+            while (Date.now() - started < timeout) {
+                if (await q.check())
+                    return 'ok';
+                if (override === 'skip')
+                    return 'skip';
+                // 'done' means the agent reports the action complete — but completion may
+                // be eventually-consistent, so keep polling check() at the interval until
+                // it confirms or we time out (matching TTY behavior), rather than failing
+                // on a single immediate check.
+                if (override === 'done') {
+                    await sleep(interval);
+                    continue;
+                }
+                await Promise.race([sleep(interval), answerPromise]);
             }
-            await Promise.race([sleep(interval), answerPromise]);
+            return 'timeout';
+        }
+        finally {
+            // If polling or the timeout won before any stdin reply arrived, drop the
+            // dangling resolver so it doesn't accumulate across action() calls.
+            this.pending.delete(q.id);
         }
-        return false;
     }
     progress(message, detail) {
         this.emit({ type: 'progress', message, ...(detail ? { detail } : {}) });
@@ -256,6 +282,20 @@ export function createPrompter(options = {}) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/** Coerce an answer to a boolean without the `Boolean("false") === true` trap:
+ *  recognizes string forms ("true"/"false", "yes"/"no", "1"/"0") explicitly. */
+function toBool(v) {
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'string') {
+        const s = v.trim().toLowerCase();
+        if (['true', 'yes', 'y', '1'].includes(s))
+            return true;
+        if (['false', 'no', 'n', '0', ''].includes(s))
+            return false;
+    }
+    return Boolean(v);
+}
 /** Validate a pre-supplied multiselect answer is actually an array before use,
  *  so a bad --answers value (e.g. a string) fails fast with a clear message
  *  instead of crashing downstream array operations. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "Set up Haystack for your project — automated PR review, triage, and merge queue",
   "type": "module",
   "bin": {