fix: address PR #416 review comments

Addresses 18 review comments from BYK on the generator-commands PR:

#2: Use result.user = user instead of cherry-picking fields (login.ts)
#3: Remove process.stdin param from runInteractiveLogin (interactive-login.ts)
#4: Use return yield pattern for one-liner yields (logout.ts)
#5: Make OutputConfig.json optional (defaults to true) (output.ts)
#6: Convert trace/logs.ts to yield commandOutput (trace/logs.ts)
#7: Move URL/QR display through yield commandOutput (trial/start.ts)
#8: Rename const log → const logger, import logger as log (trial/start.ts)
#9: Convert help.ts to yield commandOutput (help.ts)
#11: Replace Symbol branding with class + instanceof for CommandOutput (output.ts, command.ts)
#12: Remove jsonlLines/JSONL mechanism — each yield becomes one JSON line (output.ts, log/list.ts)
#15-#17: Replace polling dots with spinner in interactive login (interactive-login.ts)
#18: Yield individual log items in follow mode (log/list.ts)

Key changes:
- CommandOutput is now a class using instanceof instead of Symbol branding
- JSONL support removed — streaming commands yield items individually
- trace/logs.ts uses OutputConfig with human/jsonTransform instead of manual stdout
- help.ts yields through output framework
- trial/start.ts handlePlanTrial is now an async generator yielding display data
- interactive-login.ts uses consola spinner for polling, removes stdin param
- OutputConfig.json is now optional (defaults to true when object form is used)

Tests updated for trace/logs and trial/start to use context stdout.

Author: BYK

src/bin.ts

@@ -103,7 +103,7 @@ const autoAuthMiddleware: ErrorMiddleware = async (next, args) => {
           : "Authentication required. Starting login flow...\n\n"
       );
 
-      const loginSuccess = await runInteractiveLogin(process.stdin);
+      const loginSuccess = await runInteractiveLogin();
 
       if (loginSuccess) {
         process.stderr.write("\nRetrying command...\n\n");

src/commands/auth/login.ts

@@ -177,12 +177,7 @@ export const loginCommand = buildCommand({
           username: user.username,
           name: user.name,
         });
-        result.user = {
-          name: user.name,
-          email: user.email,
-          username: user.username,
-          id: user.id,
-        };
+        result.user = user;
       } catch {
         // Non-fatal: user info is supplementary. Token remains stored and valid.
       }
@@ -192,7 +187,7 @@ export const loginCommand = buildCommand({
     }
 
     // OAuth device flow
-    const result = await runInteractiveLogin(process.stdin, {
+    const result = await runInteractiveLogin({
       timeout: flags.timeout * 1000,
     });
 

src/commands/auth/logout.ts

@@ -39,11 +39,10 @@ export const logoutCommand = buildCommand({
   },
   async *func(this: SentryContext) {
     if (!(await isAuthenticated())) {
-      yield commandOutput({
+      return yield commandOutput({
         loggedOut: false,
         message: "Not currently authenticated.",
       });
-      return;
     }
 
     if (isEnvTokenActive()) {
@@ -58,10 +57,9 @@ export const logoutCommand = buildCommand({
     const configPath = getDbPath();
     await clearAuth();
 
-    yield commandOutput({
+    return yield commandOutput({
       loggedOut: true,
       configPath,
     });
-    return;
   },
 });

src/commands/help.ts

@@ -9,6 +9,7 @@
 import { run } from "@stricli/core";
 import type { SentryContext } from "../context.js";
 import { buildCommand } from "../lib/command.js";
+import { commandOutput, stateless } from "../lib/formatters/output.js";
 import { printCustomHelp } from "../lib/help.js";
 
 export const helpCommand = buildCommand({
@@ -18,6 +19,7 @@ export const helpCommand = buildCommand({
       "Display help information. Run 'sentry help' for an overview, " +
       "or 'sentry help <command>' for detailed help on a specific command.",
   },
+  output: { json: true, human: stateless((s: string) => s) },
   parameters: {
     flags: {},
     positional: {
@@ -30,12 +32,10 @@ export const helpCommand = buildCommand({
     },
   },
   // biome-ignore lint/complexity/noBannedTypes: Stricli requires empty object for commands with no flags
-  // biome-ignore lint/correctness/useYield: void generator — delegates to Stricli help system
   async *func(this: SentryContext, _flags: {}, ...commandPath: string[]) {
     // No args: show branded help
     if (commandPath.length === 0) {
-      process.stdout.write(await printCustomHelp());
-      return;
+      return yield commandOutput(await printCustomHelp());
     }
 
     // With args: re-invoke with --helpAll to show full help including hidden items

src/commands/log/list.ts

@@ -22,11 +22,9 @@ import {
 import { filterFields } from "../../lib/formatters/json.js";
 import { renderInlineMarkdown } from "../../lib/formatters/markdown.js";
 import {
-  type CommandOutput,
   commandOutput,
   formatFooter,
   type HumanRenderer,
-  jsonlLines,
 } from "../../lib/formatters/output.js";
 import type { StreamingTable } from "../../lib/formatters/text-table.js";
 import {
@@ -64,12 +62,6 @@ type LogListResult = {
   logs: LogLike[];
   /** Trace ID, present for trace-filtered queries */
   traceId?: string;
-  /**
-   * When true, JSON output uses JSONL (one object per line) instead
-   * of a JSON array. Set for follow-mode batches where output is
-   * consumed incrementally. Does not affect human rendering.
-   */
-  jsonl?: boolean;
 };
 
 /** Maximum allowed value for --limit flag */
@@ -336,16 +328,22 @@ async function* generateFollowLogs<T extends LogLike>(
 }
 
 /**
- * Consume a follow-mode generator, yielding `LogListResult` batches.
+ * Consume a follow-mode generator, yielding each log individually.
+ *
+ * In JSON mode each yield becomes one JSONL line. In human mode the
+ * stateful renderer accumulates rows into the streaming table.
+ *
  * The generator returns when SIGINT fires — the wrapper's `finalize()`
  * callback handles closing the streaming table.
  */
 async function* yieldFollowBatches<T extends LogLike>(
   generator: AsyncGenerator<T[], void, undefined>,
   extra?: Partial<LogListResult>
-): AsyncGenerator<CommandOutput<LogListResult>, void, undefined> {
+): AsyncGenerator<unknown, void, undefined> {
   for await (const batch of generator) {
-    yield commandOutput({ logs: batch, jsonl: true, ...extra });
+    for (const item of batch) {
+      yield commandOutput({ logs: [item], ...extra });
+    }
   }
 }
 
@@ -478,25 +476,22 @@ function createLogRenderer(): HumanRenderer<LogListResult> {
 /**
  * Transform log output into the JSON shape.
  *
- * - **Single-fetch** (`jsonl` absent/false): returns a JSON array.
- * - **Follow mode** (`jsonl: true`): returns JSONL-wrapped objects
- *   so the framework writes one JSON line per log entry.
+ * Each yielded batch is written as a JSON array. In follow mode,
+ * each batch is a short array (one poll result); in single-fetch mode
+ * it's the full result set. Empty batches are suppressed.
  */
 function jsonTransformLogOutput(
   result: LogListResult,
   fields?: string[]
 ): unknown {
-  const applyFields = (log: LogLike) =>
-    fields && fields.length > 0 ? filterFields(log, fields) : log;
-
   if (result.logs.length === 0) {
-    // Follow mode: suppress empty batches (no JSONL output)
-    // Single-fetch: return empty array for valid JSON
-    return result.jsonl ? undefined : [];
+    return;
   }
 
-  const mapped = result.logs.map(applyFields);
-  return result.jsonl ? jsonlLines(mapped) : mapped;
+  const applyFields = (log: LogLike) =>
+    fields && fields.length > 0 ? filterFields(log, fields) : log;
+
+  return result.logs.map(applyFields);
 }
 
 export const listCommand = buildListCommand("log", {

src/commands/trace/logs.ts

@@ -10,7 +10,13 @@ import { validateLimit } from "../../lib/arg-parsing.js";
 import { openInBrowser } from "../../lib/browser.js";
 import { buildCommand } from "../../lib/command.js";
 import { ContextError } from "../../lib/errors.js";
-import { formatTraceLogs } from "../../lib/formatters/index.js";
+import { filterFields } from "../../lib/formatters/json.js";
+import { formatLogTable } from "../../lib/formatters/log.js";
+import {
+  commandOutput,
+  formatFooter,
+  stateless,
+} from "../../lib/formatters/output.js";
 import {
   applyFreshFlag,
   FRESH_ALIASES,
@@ -30,6 +36,34 @@ type LogsFlags = {
   readonly fields?: string[];
 };
 
+/** Minimal log shape shared with the formatters. */
+type LogLike = {
+  timestamp: string;
+  severity?: string | null;
+  message?: string | null;
+  trace?: string | null;
+};
+
+/** Data yielded by the trace logs command. */
+type TraceLogsData = {
+  logs: LogLike[];
+  traceId: string;
+  limit: number;
+};
+
+/** Format trace log results as human-readable table output. */
+function formatTraceLogsHuman(data: TraceLogsData): string {
+  if (data.logs.length === 0) {
+    return "";
+  }
+  const parts = [formatLogTable(data.logs, false)];
+  const hasMore = data.logs.length >= data.limit;
+  const countText = `Showing ${data.logs.length} log${data.logs.length === 1 ? "" : "s"} for trace ${data.traceId}.`;
+  const tip = hasMore ? " Use --limit to show more." : "";
+  parts.push(formatFooter(`${countText}${tip}`));
+  return parts.join("");
+}
+
 /** Maximum allowed value for --limit flag */
 const MAX_LIMIT = 1000;
 
@@ -132,7 +166,16 @@ export const logsCommand = buildCommand({
       "  sentry trace logs --period 7d abc123def456abc123def456abc123de\n" +
       "  sentry trace logs --json abc123def456abc123def456abc123de",
   },
-  output: "json",
+  output: {
+    json: true,
+    human: stateless(formatTraceLogsHuman),
+    jsonTransform: (data: TraceLogsData, fields?: string[]) => {
+      if (fields && fields.length > 0) {
+        return data.logs.map((entry) => filterFields(entry, fields));
+      }
+      return data.logs;
+    },
+  },
   parameters: {
     positional: {
       kind: "array",
@@ -176,7 +219,6 @@ export const logsCommand = buildCommand({
       q: "query",
     },
   },
-  // biome-ignore lint/correctness/useYield: void generator — early returns for web mode
   async *func(this: SentryContext, flags: LogsFlags, ...args: string[]) {
     applyFreshFlag(flags);
     const { cwd, setContext } = this;
@@ -206,17 +248,21 @@ export const logsCommand = buildCommand({
       query: flags.query,
     });
 
-    process.stdout.write(
-      formatTraceLogs({
-        logs,
-        traceId,
-        limit: flags.limit,
-        asJson: flags.json,
-        fields: flags.fields,
-        emptyMessage:
+    // Reverse to chronological order (API returns newest-first)
+    const chronological = [...logs].reverse();
+
+    yield commandOutput({
+      logs: chronological,
+      traceId,
+      limit: flags.limit,
+    });
+
+    if (logs.length === 0) {
+      return {
+        hint:
           `No logs found for trace ${traceId} in the last ${flags.period}.\n\n` +
-          `Try a longer period: sentry trace logs --period 30d ${traceId}\n`,
-      })
-    );
+          `Try a longer period: sentry trace logs --period 30d ${traceId}`,
+      };
+    }
   },
 });