linear-sdk-cli 0.1.3 → 0.2.3

package/src/output/color.ts

@@ -0,0 +1,52 @@
+/**
+ * Resolve terminal colour and debug policy in one place. Both the per-command
+ * Context and the top-level error boundary use these helpers, so a parse-time
+ * failure behaves exactly like an API result.
+ */
+
+export interface ColorPolicy {
+  /** An explicit CLI opt-out (`--no-ansi` / `--no-color`). */
+  disabled?: boolean;
+  /** JSON is a byte-oriented machine format and never carries terminal ANSI. */
+  json?: boolean;
+  /** TTY state of the stream that will receive the text. */
+  isTTY?: boolean;
+  env?: NodeJS.ProcessEnv;
+}
+
+/** Values conventionally used to turn a forcing variable off. */
+function isFalse(value: string): boolean {
+  return value === "0" || value.toLowerCase() === "false";
+}
+
+/**
+ * Whether human output should contain ANSI colour.
+ *
+ * Precedence is deliberately conservative:
+ *
+ *   CLI opt-out / JSON > NO_COLOR > FORCE_COLOR > CLICOLOR_FORCE > TTY
+ *
+ * `FORCE_COLOR=0` is also an explicit opt-out, matching the convention used by
+ * Node tooling. `CLICOLOR_FORCE=0` merely means "do not force". This lets a
+ * caller keep colour while stdout is connected to a pager without ever
+ * putting ANSI into JSON.
+ */
+export function shouldUseColor(policy: ColorPolicy): boolean {
+  if (policy.disabled === true || policy.json === true) return false;
+
+  const env = policy.env ?? process.env;
+  if (env.NO_COLOR !== undefined) return false;
+
+  if (env.FORCE_COLOR !== undefined) {
+    return !isFalse(env.FORCE_COLOR);
+  }
+  if (env.CLICOLOR_FORCE !== undefined && !isFalse(env.CLICOLOR_FORCE)) return true;
+
+  return policy.isTTY === true;
+}
+
+/** `--debug` and LINEAR_DEBUG are equivalent, with the flag always additive. */
+export function isDebugEnabled(explicit: boolean | undefined, env = process.env): boolean {
+  const value = env.LINEAR_DEBUG?.toLowerCase();
+  return explicit === true || value === "1" || value === "true";
+}

package/src/output/format.ts

@@ -6,7 +6,7 @@
  *   - lists → bare array, single resource → bare object, mutations → affected
  *     object (or {success,id} when there is no body)
  *   - status/progress/pagination notes → stderr
- *   - errors → {"error":{"message","code"}} on stderr + non-zero exit
+ *   - errors → {"error":{"message","code", …optional additive fields}} on stderr + non-zero exit
  */
 
 import pc from "picocolors";
@@ -20,6 +20,9 @@ import {
   type Column,
 } from "./table.js";
 import { sanitizeForTerminal } from "./sanitize.js";
+import { renderMarkdown } from "./markdown.js";
+import { pageOutput, shouldUsePager } from "./pager.js";
+import { hasMoreResults } from "../lib/pagination.js";
 
 export interface OutputOptions {
   json: boolean;
@@ -28,10 +31,38 @@ export interface OutputOptions {
   debug: boolean;
   /** `--fields`: table columns / detail lines (human), top-level keys (json). */
   fields?: string[];
+  /** Injectable terminal facts; default to stdout's live state. */
+  isTTY?: boolean;
+  terminalRows?: number;
+  terminalColumns?: number;
+  /** Used only to resolve PAGER when long-form output is eligible. */
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface ListOutputOptions {
+  /** JSON rows may be richer/differently shaped than the human table rows. */
+  jsonRows?: unknown[];
+  /** Context shown instead of the default `(no results)` in human mode. */
+  empty?: string;
+}
+
+export interface MarkdownOutputOptions {
+  /** Leave Markdown syntax intact (terminal controls are still removed). */
+  raw?: boolean;
+  /** Commands with `--no-pager` pass false. Defaults to enabled. */
+  pager?: boolean;
 }
 
 export class Output {
-  constructor(private readonly opts: OutputOptions) {}
+  private readonly opts: OutputOptions;
+  private readonly colors: ReturnType<typeof pc.createColors>;
+
+  constructor(opts: OutputOptions) {
+    this.opts = opts;
+    // Do not rely on picocolors' module-load-time environment detection:
+    // CLICOLOR_FORCE and per-stream TTY policy are resolved by Context.
+    this.colors = pc.createColors(opts.color);
+  }
 
   get json(): boolean {
     return this.opts.json;
@@ -54,13 +85,28 @@ export class Output {
    * Emit a list as a table (human) or bare array (json). `--fields` narrows
    * both: the table's columns (or any row key), and the JSON objects' keys.
    */
-  list<T>(rows: T[], columns: Column<T>[], jsonRows?: unknown[]): void {
+  list<T>(
+    rows: T[],
+    columns: Column<T>[],
+    jsonRowsOrOptions?: unknown[] | ListOutputOptions,
+    legacyOptions?: Pick<ListOutputOptions, "empty">,
+  ): void {
+    const options: ListOutputOptions = Array.isArray(jsonRowsOrOptions)
+      ? { jsonRows: jsonRowsOrOptions, ...legacyOptions }
+      : (jsonRowsOrOptions ?? {});
+    if (hasMoreResults(rows)) {
+      this.info(
+        `Showing ${rows.length} results; more exist. Use --all or increase --limit to see them.`,
+      );
+    }
     if (this.opts.json) {
-      this.writeJson(projectFields(jsonRows ?? rows, this.opts.fields));
+      this.writeJson(projectFields(options.jsonRows ?? rows, this.opts.fields));
       return;
     }
     const cols = selectColumns(columns, this.opts.fields, rows[0]);
-    process.stdout.write(renderTable(rows, cols, { color: this.opts.color }) + "\n");
+    process.stdout.write(
+      renderTable(rows, cols, { color: this.opts.color, empty: options.empty }) + "\n",
+    );
   }
 
   /**
@@ -84,6 +130,41 @@ export class Output {
     if (!this.opts.json) process.stdout.write(sanitizeForTerminal(text) + "\n");
   }
 
+  /**
+   * Render a long Markdown body for a human, optionally through a pager.
+   *
+   * Non-TTY output keeps the original Markdown so pipes/files receive stable,
+   * reusable text. JSON mode writes nothing — callers normally put this inside
+   * `emit(value, () => output.markdown(...))`, but the guard prevents an
+   * accidental second stdout value. Both human paths remain terminal-sanitized.
+   */
+  markdown(text: string, options: MarkdownOutputOptions = {}): void {
+    if (this.opts.json) return;
+
+    const isTTY = this.opts.isTTY ?? process.stdout.isTTY === true;
+    const columns = this.opts.terminalColumns ?? process.stdout.columns ?? 80;
+    const rows = this.opts.terminalRows ?? process.stdout.rows;
+    const content =
+      isTTY && options.raw !== true
+        ? renderMarkdown(text, { color: this.opts.color, width: columns })
+        : sanitizeForTerminal(text);
+    const output = content.endsWith("\n") ? content : `${content}\n`;
+
+    if (
+      shouldUsePager(output, {
+        enabled: options.pager,
+        json: this.opts.json,
+        isTTY,
+        rows,
+        columns,
+      }) &&
+      pageOutput(output, { env: this.opts.env })
+    ) {
+      return;
+    }
+    process.stdout.write(output);
+  }
+
   /** Status/progress to stderr. Suppressed by --quiet. */
   info(text: string): void {
     if (!this.opts.quiet) process.stderr.write(sanitizeForTerminal(text) + "\n");
@@ -91,13 +172,11 @@ export class Output {
 
   success(text: string): void {
     if (!this.opts.quiet)
-      process.stderr.write(
-        (this.opts.color ? pc.green("✓ ") : "✓ ") + sanitizeForTerminal(text) + "\n",
-      );
+      process.stderr.write(this.colors.green("✓ ") + sanitizeForTerminal(text) + "\n");
   }
 
   warn(text: string): void {
-    process.stderr.write((this.opts.color ? pc.yellow("! ") : "! ") + sanitizeForTerminal(text) + "\n");
+    process.stderr.write(this.colors.yellow("! ") + sanitizeForTerminal(text) + "\n");
   }
 
   /**
@@ -117,7 +196,7 @@ export class Output {
     }
     if (!this.opts.quiet) {
       process.stderr.write(
-        (this.opts.color ? pc.yellow("! ") : "! ") + `Cancelled: ${sanitizeForTerminal(action)}\n`,
+        this.colors.yellow("! ") + `Cancelled: ${sanitizeForTerminal(action)}\n`,
       );
     }
   }
@@ -137,20 +216,19 @@ export class Output {
       // `message` and `code` keep their positions; `detail` is additive, and
       // absent entirely without --debug.
       const error: Record<string, unknown> = { message: err.message, code: err.code };
+      if (err.suggestion !== undefined) error.suggestion = err.suggestion;
       if (showDetail) error.detail = err.detail;
       process.stderr.write(JSON.stringify({ error }) + "\n");
       return;
     }
     // An error message can quote API data (a name that matched several, …).
-    process.stderr.write(
-      (this.opts.color ? pc.red("error: ") : "error: ") + sanitizeForTerminal(err.message) + "\n",
-    );
+    process.stderr.write(this.colors.red("error: ") + sanitizeForTerminal(err.message) + "\n");
+    if (err.suggestion !== undefined) {
+      process.stderr.write(this.colors.dim("hint: ") + sanitizeForTerminal(err.suggestion) + "\n");
+    }
     if (showDetail) {
-      process.stderr.write(
-        (this.opts.color ? pc.dim("detail: ") : "detail: ") +
-          JSON.stringify(err.detail, null, 2) +
-          "\n",
-      );
+      const detail = JSON.stringify(err.detail, null, 2) ?? String(err.detail);
+      process.stderr.write(this.colors.dim("detail: ") + sanitizeForTerminal(detail) + "\n");
     }
   }
 

package/src/output/markdown.ts

@@ -0,0 +1,133 @@
+/**
+ * A small, dependency-free Markdown renderer for terminal output.
+ *
+ * This intentionally implements the Markdown constructs that occur in Linear
+ * bodies rather than pretending to be a CommonMark parser. The important
+ * properties for the CLI are deterministic readable text, optional ANSI, and
+ * sanitizing API-controlled bytes *before* adding any of our own escapes.
+ */
+
+import pc from "picocolors";
+import { sanitizeForTerminal } from "./sanitize.js";
+
+export interface MarkdownRenderOptions {
+  color?: boolean;
+  /** Used for horizontal rules. Wrapping itself is left to the terminal. */
+  width?: number;
+}
+
+/** Render the useful subset of Markdown used by issue/document/project bodies. */
+export function renderMarkdown(markdown: string, options: MarkdownRenderOptions = {}): string {
+  const colors = pc.createColors(options.color === true);
+  const width = Math.max(10, options.width ?? 80);
+  // CR and terminal controls disappear here. JSON paths never call this and
+  // therefore retain the exact API bytes (escaped by JSON.stringify).
+  const source = sanitizeForTerminal(markdown);
+  const lines = source.split("\n");
+  const rendered: string[] = [];
+  let fence: "```" | "~~~" | undefined;
+
+  for (const original of lines) {
+    const fenceMatch = original.match(/^\s*(```|~~~)/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1] as "```" | "~~~";
+      if (!fence) fence = marker;
+      else if (fence === marker) fence = undefined;
+      // Fence markers and their language labels are presentation syntax.
+      continue;
+    }
+
+    if (fence) {
+      rendered.push(`    ${colors.cyan(original)}`.trimEnd());
+      continue;
+    }
+
+    const heading = original.match(/^\s{0,3}(#{1,6})\s+(.+?)\s*#*\s*$/);
+    if (heading) {
+      const text = inline(heading[2] ?? "", options.color === true);
+      rendered.push(
+        heading[1]?.length === 1 ? colors.underline(colors.bold(text)) : colors.bold(text),
+      );
+      continue;
+    }
+
+    if (/^\s{0,3}((\*\s*){3,}|(-\s*){3,}|(_\s*){3,})$/.test(original)) {
+      rendered.push(colors.dim("─".repeat(Math.min(width, 72))));
+      continue;
+    }
+
+    const quote = original.match(/^(\s*)>\s?(.*)$/);
+    if (quote) {
+      rendered.push(
+        `${quote[1] ?? ""}${colors.dim("│")} ${colors.dim(inline(quote[2] ?? "", options.color === true))}`,
+      );
+      continue;
+    }
+
+    const task = original.match(/^(\s*)[-+*]\s+\[([ xX])\]\s+(.*)$/);
+    if (task) {
+      rendered.push(
+        `${task[1] ?? ""}${task[2]?.toLowerCase() === "x" ? "☑" : "☐"} ${inline(task[3] ?? "", options.color === true)}`,
+      );
+      continue;
+    }
+
+    const bullet = original.match(/^(\s*)[-+*]\s+(.*)$/);
+    if (bullet) {
+      rendered.push(`${bullet[1] ?? ""}• ${inline(bullet[2] ?? "", options.color === true)}`);
+      continue;
+    }
+
+    const ordered = original.match(/^(\s*)(\d+)[.)]\s+(.*)$/);
+    if (ordered) {
+      rendered.push(
+        `${ordered[1] ?? ""}${ordered[2]}. ${inline(ordered[3] ?? "", options.color === true)}`,
+      );
+      continue;
+    }
+
+    rendered.push(inline(original, options.color === true));
+  }
+
+  // Opening a malformed/unclosed fence must not make content disappear; its
+  // body has already been emitted as code. Trim only trailing blank lines so
+  // Output can own the single final newline consistently.
+  while (rendered.at(-1) === "") rendered.pop();
+  return rendered.join("\n");
+}
+
+/** Inline Markdown, with code spans shielded from emphasis/link processing. */
+function inline(value: string, color: boolean): string {
+  const colors = pc.createColors(color);
+  const pieces = value.split(/(`+[^`]*`+)/g);
+  return pieces
+    .map((piece) => {
+      if (/^`+[^`]*`+$/.test(piece)) {
+        const ticks = piece.match(/^`+/)?.[0].length ?? 1;
+        return colors.cyan(piece.slice(ticks, -ticks));
+      }
+
+      return piece
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_all, alt: string, url: string) => {
+          const label = alt.trim() ? `image: ${alt.trim()}` : "image";
+          return `${colors.dim(`[${label}]`)} (${url})`;
+        })
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_all, label: string, url: string) => {
+          return `${colors.underline(label)} (${url})`;
+        })
+        .replace(/<((?:https?|mailto):[^>]+)>/g, "$1")
+        .replace(/<br\s*\/?>/gi, " ")
+        .replace(/<\/?[A-Za-z][^>]*>/g, "")
+        .replace(/\*\*([^*]+)\*\*/g, (_all, text: string) => colors.bold(text))
+        .replace(/__([^_]+)__/g, (_all, text: string) => colors.bold(text))
+        .replace(/~~([^~]+)~~/g, (_all, text: string) => colors.strikethrough(text))
+        .replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/g, (_all, before: string, text: string) => {
+          return `${before}${colors.italic(text)}`;
+        })
+        .replace(/(^|[^_])_([^_\n]+)_(?!_)/g, (_all, before: string, text: string) => {
+          return `${before}${colors.italic(text)}`;
+        })
+        .replace(/\\([\\`*_[\]{}()#+.!|>~-])/g, "$1");
+    })
+    .join("");
+}

package/src/output/pager.ts

@@ -0,0 +1,131 @@
+/** Conditional, portable pager support for long human output. */
+
+import { spawnSync } from "node:child_process";
+import { displayWidth } from "./sanitize.js";
+
+export interface PagerCommand {
+  command: string;
+  args: string[];
+}
+
+export interface PagerDecision {
+  enabled?: boolean;
+  json?: boolean;
+  isTTY?: boolean;
+  rows?: number;
+  columns?: number;
+}
+
+/** Count terminal rows, including the wrapping a terminal applies to long lines. */
+export function terminalLineCount(content: string, columns = 80): number {
+  const width = Math.max(1, columns);
+  return content.split("\n").reduce((count, line) => {
+    return count + Math.max(1, Math.ceil(displayWidth(line) / width));
+  }, 0);
+}
+
+/** Page only deliberately-enabled, long, interactive human output. */
+export function shouldUsePager(content: string, decision: PagerDecision): boolean {
+  if (decision.enabled === false || decision.json === true || decision.isTTY !== true) return false;
+  const rows = decision.rows && decision.rows > 2 ? decision.rows : 52;
+  return terminalLineCount(content, decision.columns ?? 80) > rows - 2;
+}
+
+/**
+ * Resolve `$PAGER` followed by platform fallbacks. The environment value is a
+ * command line, not a shell program: quotes/backslashes are honoured, while
+ * expansions and redirections are deliberately not executed.
+ */
+export function pagerCommands(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): PagerCommand[] {
+  const commands: PagerCommand[] = [];
+  const configured = env.PAGER?.trim();
+  if (configured) {
+    const argv = splitCommand(configured);
+    if (argv.length) commands.push({ command: argv[0]!, args: argv.slice(1) });
+  }
+
+  if (platform === "win32") {
+    commands.push({ command: "more.com", args: [] });
+  } else {
+    // -R passes through our SGR colour, -X leaves the terminal contents visible.
+    commands.push({ command: "less", args: ["-R", "-X"] });
+    commands.push({ command: "more", args: [] });
+  }
+
+  const seen = new Set<string>();
+  return commands.filter(({ command, args }) => {
+    const key = JSON.stringify([command, args]);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export interface PageOptions {
+  env?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
+  /** Test seam; production uses spawnSync without a shell. */
+  run?: (candidate: PagerCommand, content: string, env: NodeJS.ProcessEnv) => boolean;
+}
+
+/** Try the configured pager and fallbacks. False means the caller should print directly. */
+export function pageOutput(content: string, options: PageOptions = {}): boolean {
+  const env = options.env ?? process.env;
+  const run = options.run ?? runPager;
+  for (const candidate of pagerCommands(env, options.platform)) {
+    if (run(candidate, content, env)) return true;
+  }
+  return false;
+}
+
+function runPager(candidate: PagerCommand, content: string, env: NodeJS.ProcessEnv): boolean {
+  const result = spawnSync(candidate.command, candidate.args, {
+    input: content,
+    stdio: ["pipe", "inherit", "inherit"],
+    env,
+  });
+  return !result.error && result.status === 0;
+}
+
+/** A non-evaluating, shell-like argv splitter for PAGER. */
+function splitCommand(line: string): string[] {
+  const out: string[] = [];
+  let current = "";
+  let inWord = false;
+  let quote: '"' | "'" | undefined;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i]!;
+    if (quote === "'") {
+      if (char === "'") quote = undefined;
+      else current += char;
+    } else if (quote === '"') {
+      if (char === '"') quote = undefined;
+      else if (char === "\\" && i + 1 < line.length && '"\\'.includes(line[i + 1]!)) {
+        current += line[++i];
+      } else current += char;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+      inWord = true;
+    } else if (char === "\\" && i + 1 < line.length) {
+      current += line[++i];
+      inWord = true;
+    } else if (/\s/.test(char)) {
+      if (inWord) out.push(current);
+      current = "";
+      inWord = false;
+    } else {
+      current += char;
+      inWord = true;
+    }
+  }
+
+  // A malformed environment setting should not abort an otherwise successful
+  // CLI command; ignore it and continue to the portable fallbacks.
+  if (quote) return [];
+  if (inWord) out.push(current);
+  return out;
+}

package/src/output/sanitize.ts

@@ -47,7 +47,7 @@ const ESCAPE_SEQUENCES = new RegExp(
  * characters human output needs.
  */
 const CONTROL_CHARS = new RegExp(
-  // eslint-disable-next-line no-control-regex
+  // oxlint-disable-next-line no-control-regex
   "[\\u0000-\\u0008\\u000B-\\u001F\\u007F-\\u009F\\u200E\\u200F\\u202A-\\u202E\\u2066-\\u2069]",
   "g",
 );

package/src/output/table.ts

@@ -148,15 +148,14 @@ export function selectPairs(
 export function renderTable<T>(
   rows: T[],
   columns: Column<T>[],
-  opts: { color?: boolean } = {},
+  opts: { color?: boolean; empty?: string } = {},
 ): string {
   const color = opts.color ?? false;
-  if (rows.length === 0) return color ? pc.dim("(no results)") : "(no results)";
+  const colors = pc.createColors(color);
+  if (rows.length === 0) return colors.dim(sanitizeForTerminal(opts.empty ?? "(no results)"));
 
   const headers = columns.map((c) => c.header ?? c.key);
-  const body = rows.map((row) =>
-    columns.map((c) => truncate(cell(c.value(row)), c.max ?? 60)),
-  );
+  const body = rows.map((row) => columns.map((c) => truncate(cell(c.value(row)), c.max ?? 60)));
 
   const widths = columns.map((_, i) => {
     const header = headers[i] ?? "";
@@ -167,7 +166,7 @@ export function renderTable<T>(
   const pad = (s: string, w: number) => s + " ".repeat(Math.max(0, w - displayWidth(s)));
 
   const headerLine = headers
-    .map((h, i) => pad(color ? pc.bold(h) : h, widths[i] ?? 0))
+    .map((h, i) => pad(colors.bold(h), widths[i] ?? 0))
     .join("  ")
     .trimEnd();
 
@@ -187,12 +186,13 @@ export function renderDetail(
   opts: { color?: boolean } = {},
 ): string {
   const color = opts.color ?? false;
+  const colors = pc.createColors(color);
   const visible = pairs.filter(([, v]) => v !== undefined && v !== null);
   const keyWidth = visible.reduce((m, [k]) => Math.max(m, k.length), 0);
   return visible
     .map(([k, v]) => {
       const label = (k + ":").padEnd(keyWidth + 1);
-      return `${color ? pc.dim(label) : label} ${cell(v)}`;
+      return `${colors.dim(label)} ${cell(v)}`;
     })
     .join("\n");
 }

package/src/services/agent-session.ts

@@ -14,7 +14,7 @@
 import type { LinearClient } from "@linear/sdk";
 import { withRetry } from "../client.js";
 import { shape } from "../lib/shape.js";
-import { collectRawQuery } from "../lib/pagination.js";
+import { collectRawQuery, hasMoreResults, setPaginationMetadata } from "../lib/pagination.js";
 import { notFound } from "../lib/errors.js";
 
 /** The statuses Linear reports for a session (AgentSessionStatus). */
@@ -35,7 +35,11 @@ export interface SessionUser {
   displayName: string;
 }
 
-const SESSION_USER_SHAPE = shape<SessionUser>({ id: "string", name: "string", displayName: "string" });
+const SESSION_USER_SHAPE = shape<SessionUser>({
+  id: "string",
+  name: "string",
+  displayName: "string",
+});
 
 export interface AgentSessionRow {
   id: string;
@@ -154,7 +158,11 @@ function finish(
   const filtered = opts.status ? present.filter((r) => r.status === opts.status) : present;
   // Newest first, whichever query found them (an issue's comments come oldest first).
   filtered.sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0));
-  return limit === Infinity ? filtered : filtered.slice(0, limit);
+  if (limit === Infinity) return setPaginationMetadata(filtered, false);
+  return setPaginationMetadata(
+    filtered.slice(0, limit),
+    filtered.length > limit || (!opts.status && filtered.length >= limit && hasMoreResults(rows)),
+  );
 }
 
 function toRow(s: any): AgentSessionRow {

package/src/services/attachment.ts

@@ -11,7 +11,7 @@
 import type { LinearClient } from "@linear/sdk";
 import { withRetry } from "../client.js";
 import { shape } from "../lib/shape.js";
-import { collect, pageSize } from "../lib/pagination.js";
+import { collect, inheritPaginationMetadata, pageSize } from "../lib/pagination.js";
 import { notFound, usageError } from "../lib/errors.js";
 import { assertMutation, unwrapMutation } from "../lib/mutation.js";
 import { resolveIssue } from "../lib/resolve.js";
@@ -65,7 +65,7 @@ export async function listAttachments(
   const issue = await resolveIssue(client, issueArg);
   const conn = await withRetry(() => issue.attachments({ first: pageSize(limit) }));
   const nodes = await collect(conn as any, limit);
-  return nodes.map(toRow);
+  return inheritPaginationMetadata(nodes.map(toRow), nodes);
 }
 
 export interface CreateOptions {
@@ -128,9 +128,15 @@ export async function attachFiles(
   issueArg: string,
   paths: string[],
   opts: AttachFilesOptions,
-): Promise<{ issue: { id: string; identifier: string }; attachments: AttachedFile[]; comment?: { id: string; url: string } }> {
+): Promise<{
+  issue: { id: string; identifier: string };
+  attachments: AttachedFile[];
+  comment?: { id: string; url: string };
+}> {
   if (opts.title !== undefined && paths.length > 1) {
-    throw usageError("--title names a single attachment; with several files, drop it to use each file's name.");
+    throw usageError(
+      "--title names a single attachment; with several files, drop it to use each file's name.",
+    );
   }
   validateUploads(paths, { public: opts.public });
   const issue = await resolveIssue(client, issueArg);
@@ -178,7 +184,10 @@ export async function attachFiles(
 export async function deleteAttachment(client: LinearClient, id: string) {
   const attachment = await withRetry(() => client.attachment(id));
   if (!attachment) throw notFound(`No attachment ${id}.`);
-  await assertMutation(withRetry(() => client.deleteAttachment(id)), "Attachment deletion");
+  await assertMutation(
+    withRetry(() => client.deleteAttachment(id)),
+    "Attachment deletion",
+  );
   return { id: attachment.id, title: attachment.title };
 }