@trawlme/cli 3.7.4 → 3.7.5

package/dist/commands/scraps.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { spin } from '../lib/spinner.js';
+import { spin, confirmNonTTY } from '../lib/spinner.js';
 import { api, LONG_RUN_TIMEOUT_MS } from '../lib/api.js';
 import { table, json, formatDate } from '../lib/format.js';
 import { parseServerJson } from '../lib/json.js';
@@ -786,6 +786,24 @@ export function attachRunCommand(parent, attachOpts = {}) {
             : await spin(call, { text: 'Launching scrap…', successText: 'Scrap launched' });
         if (opts.json)
             json(data);
+        else if (!opts.watch) {
+            /* #166 — see confirmNonTTY. Two deliberate choices here:
+             *
+             * "run complete", not "launched": `run` is the SYNCHRONOUS verb —
+             * GET /api/scraps/load/:id executes the scrap server-side (30-250s)
+             * and returns the finished result, so by the time this prints the run
+             * is over. The spinner's successText says "Scrap launched", but that
+             * is stderr chrome for a human watching it happen; THIS line is the
+             * machine surface, where a script reading "launched" would poll for a
+             * completion that already happened. `trigger` already draws the same
+             * distinction ("Worker triggered" async vs "Worker run complete" under
+             * --wait) — this matches that vocabulary.
+             *
+             * `--watch` is excluded because pollRunProgress below does its own
+             * reporting; without that guard a watched run would print this line
+             * and then narrate the same run. */
+            confirmNonTTY(`Scrap ${id} run complete`);
+        }
         if (opts.watch) {
             // #107 — under --json, pollRunProgress suppresses its own intermediate
             // console.log calls and instead emits exactly ONE final NDJSON outcome
@@ -1118,6 +1136,7 @@ scraps
         return;
     }
     await spin(call, { text: 'Deleting…', successText: 'Scrap deleted' });
+    confirmNonTTY(`Scrap ${id} deleted`); // #166
 });
 // banner
 scraps
@@ -1163,6 +1182,8 @@ scraps
         text: 'Uploading banner…',
         successText: `Banner uploaded for scrap ${chalk.bold(id)}`,
     });
+    // #166 — plain, unstyled: chalk.bold would emit escape codes into a pipe.
+    confirmNonTTY(`Banner uploaded for scrap ${id}`);
 });
 // watch (stream activities)
 scraps
@@ -1209,24 +1230,13 @@ export function attachTriggerCommand(parent, attachOpts = {}) {
         if (opts.json) {
             json(data);
         }
-        else if (!process.stdout.isTTY) {
-            // #160 — spin() (lib/spinner.ts, #119) intentionally emits NOTHING
-            // when stderr isn't a TTY, so a piped/redirected `trigger` wrote zero
-            // bytes to both stdout AND stderr while exiting 0: a caller driving
-            // this from a script has no way to tell success from a no-op. Gated
-            // on STDOUT specifically — that's the stream a script actually reads
-            // (`$(trawl trigger …)`, `> out.txt`, `| jq`), independent of
-            // whatever spin() decides about stderr — so an interactive TTY
-            // session, where the ora spinner already confirmed this on stderr,
-            // never sees a duplicate line here. Keeps the exact "Worker
-            // triggered"/"Worker run complete" substrings the trawl-internal QA
-            // runbook asserts on, plus the scrap id so a script has something to
-            // parse. Known residual: stdout attached to a real terminal while
-            // stderr is separately redirected (rare) still prints nothing on
-            // either stream, same as pre-#160 — not the reported/common shape
-            // (full redirection or stdout-only capture), left alone to keep this
-            // fix narrowly scoped to the stream it actually touches.
-            console.log(opts.wait ? `Worker run complete for scrap ${id}` : `Worker triggered for scrap ${id}`);
+        else {
+            /* #160, folded onto the shared helper by #166 — the rationale and the
+             * known residual now live once, on `confirmNonTTY` itself, instead of
+             * in the one call site that happened to be fixed first. Wording is
+             * unchanged on purpose: the trawl-internal QA runbook asserts on the
+             * exact "Worker triggered" / "Worker run complete" substrings. */
+            confirmNonTTY(opts.wait ? `Worker run complete for scrap ${id}` : `Worker triggered for scrap ${id}`);
         }
         // #107 — see the matching comment on `run`'s --watch call above (review
         // F1): honest final NDJSON line + exit code under --json, human mode
@@ -1335,6 +1345,7 @@ account
         text: 'Deleting credentials…',
         successText: 'Account credentials deleted',
     });
+    confirmNonTTY(`Account credentials deleted for scrap ${id}`); // #166
 });
 // account clear-session
 account
@@ -1353,6 +1364,7 @@ account
         text: 'Clearing session…',
         successText: 'Session cleared',
     });
+    confirmNonTTY(`Session cleared for scrap ${id}`); // #166
 });
 // account session subcommand group
 const accountSession = account

package/dist/lib/spinner.d.ts

@@ -15,4 +15,35 @@ type SpinOptions<T> = string | {
  * to stderr, stdout stays clean either way).
  */
 export declare function spin<T>(action: Action<T>, options?: SpinOptions<T>): Promise<T>;
+/**
+ * The counterpart to `spin()`'s silence — print a plain-text confirmation on
+ * stdout when, and only when, stdout is not a TTY.
+ *
+ * #160 then #166. `spin()` above deliberately emits nothing when stderr is not
+ * a TTY, so for every command whose only non-`--json` feedback was its
+ * `successText`, a piped or redirected invocation wrote **zero bytes to both
+ * streams while exiting 0**. Our ICP is agent builders, and agents pipe stdout:
+ * a verb that writes nothing on success is unusable from a script, because the
+ * caller cannot tell success from a no-op. Two of the affected commands were
+ * deletes, where that ambiguity is at its worst.
+ *
+ * Lives here, next to the silence it compensates for, because #160 fixed
+ * `trigger` by inlining this rule and #166 then found five siblings carrying
+ * the identical defect — five more inlined copies is how the next one gets
+ * missed. Callers pass the message; the gate lives in one place.
+ *
+ * Gated on **stdout**, not stderr: stdout is the stream a script actually reads
+ * (`$(trawl …)`, `> out.txt`, `| jq`), independent of whatever `spin()` decides
+ * about stderr. So an interactive session, where the ora spinner already
+ * confirmed on stderr, never gets a duplicate line here.
+ *
+ * Never call this on a `--json` path: under `--json`, stdout must stay exactly
+ * one parseable document.
+ *
+ * Known residual, unchanged from #160: stdout attached to a real terminal while
+ * stderr is separately redirected still prints nothing on either stream. That is
+ * not the reported or common shape (full redirection, or stdout-only capture),
+ * and widening the gate would put a duplicate line in front of interactive users.
+ */
+export declare function confirmNonTTY(message: string): void;
 export {};

package/dist/lib/spinner.js

@@ -15,3 +15,37 @@ export function spin(action, options) {
     // oraPromise's own overloads accept (action, string) and (action, options).
     return oraPromise(action, options);
 }
+/**
+ * The counterpart to `spin()`'s silence — print a plain-text confirmation on
+ * stdout when, and only when, stdout is not a TTY.
+ *
+ * #160 then #166. `spin()` above deliberately emits nothing when stderr is not
+ * a TTY, so for every command whose only non-`--json` feedback was its
+ * `successText`, a piped or redirected invocation wrote **zero bytes to both
+ * streams while exiting 0**. Our ICP is agent builders, and agents pipe stdout:
+ * a verb that writes nothing on success is unusable from a script, because the
+ * caller cannot tell success from a no-op. Two of the affected commands were
+ * deletes, where that ambiguity is at its worst.
+ *
+ * Lives here, next to the silence it compensates for, because #160 fixed
+ * `trigger` by inlining this rule and #166 then found five siblings carrying
+ * the identical defect — five more inlined copies is how the next one gets
+ * missed. Callers pass the message; the gate lives in one place.
+ *
+ * Gated on **stdout**, not stderr: stdout is the stream a script actually reads
+ * (`$(trawl …)`, `> out.txt`, `| jq`), independent of whatever `spin()` decides
+ * about stderr. So an interactive session, where the ora spinner already
+ * confirmed on stderr, never gets a duplicate line here.
+ *
+ * Never call this on a `--json` path: under `--json`, stdout must stay exactly
+ * one parseable document.
+ *
+ * Known residual, unchanged from #160: stdout attached to a real terminal while
+ * stderr is separately redirected still prints nothing on either stream. That is
+ * not the reported or common shape (full redirection, or stdout-only capture),
+ * and widening the gate would put a duplicate line in front of interactive users.
+ */
+export function confirmNonTTY(message) {
+    if (!process.stdout.isTTY)
+        console.log(message);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trawlme/cli",
-  "version": "3.7.4",
+  "version": "3.7.5",
   "description": "Trawl CLI — manage scraps from the terminal",
   "type": "module",
   "bin": {