fix(cli): loop-compute table widths; surface real errors in collections list

Address PR review feedback:

- printTable computed column widths with Math.max(c.length, ...rows.map(...)),
  spreading a per-column array into one call — a large table risks a
  max-arguments RangeError. Compute widths in a plain loop.
- `collections list` caught every error from getCollection()/count() while the
  comment claimed it only skipped a delete race, so real provider failures
  vanished from the listing. Narrow the catch to CollectionNotFoundError and
  rethrow anything else; add tests for both paths.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015DvW7ANd1KemvLhUBoKCcF

Author: claude

packages/cli/src/commands/collections.ts

@@ -73,8 +73,13 @@ export function registerCollectionCommands(program: Command): void {
               workflow:
                 (await workflowName(metadata["workflow"])) ?? ""
             });
-          } catch {
-            // Skip a collection that races a delete between list and get.
+          } catch (err) {
+            // A collection can race a delete between listCollections() and
+            // getCollection(); skip only that. Surface anything else (corrupt
+            // collection, provider failure) instead of hiding it.
+            if (!(err instanceof CollectionNotFoundError)) {
+              throw err;
+            }
           }
         }
         if (opts.json) {

packages/cli/src/commands/output.ts

@@ -19,9 +19,19 @@ export function printTable(
     return;
   }
   const cols = columns ?? Object.keys(rows[0]!);
-  const widths = cols.map((c) =>
-    Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length))
-  );
+  // Compute widths in a loop rather than Math.max(...spread): a large table
+  // would spread thousands of args into one call, risking a max-arguments
+  // RangeError and extra allocations.
+  const widths = cols.map((c) => {
+    let width = c.length;
+    for (const r of rows) {
+      const len = String(r[c] ?? "").length;
+      if (len > width) {
+        width = len;
+      }
+    }
+    return width;
+  });
   const sep = widths.map((w) => "─".repeat(w + 2)).join("┼");
   const header = cols.map((c, i) => ` ${c.padEnd(widths[i]!)} `).join("│");
   console.log(header);

packages/cli/tests/collections-action.test.ts

@@ -103,6 +103,39 @@ beforeEach(() => {
   readFile.mockReset();
 });
 
+describe("collections list", () => {
+  it("skips a collection that raced a delete but keeps healthy ones", async () => {
+    listCollections.mockResolvedValueOnce([
+      { name: "good", metadata: { embedding_model: "m" } },
+      { name: "gone", metadata: {} }
+    ]);
+    getCollection.mockReset().mockImplementation(async ({ name }) => {
+      if (name === "gone") {
+        throw new CollectionNotFoundError("gone");
+      }
+      return { name, metadata: {}, count: async () => 3, query, upsert };
+    });
+    const program = await buildProgram();
+    const { stdout } = await captureOutput(() =>
+      program.parseAsync(["node", "cli", "collections", "list", "--json"])
+    );
+    const rows = JSON.parse(stdout.trim()) as Array<{ name: string }>;
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.name).toBe("good");
+  });
+
+  it("surfaces a non-not-found error instead of hiding it (exit 1)", async () => {
+    listCollections.mockResolvedValueOnce([{ name: "bad", metadata: {} }]);
+    getCollection.mockReset().mockRejectedValueOnce(new Error("provider boom"));
+    const program = await buildProgram();
+    const { exitCode, stderr } = await captureOutput(() =>
+      program.parseAsync(["node", "cli", "collections", "list"])
+    );
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("provider boom");
+  });
+});
+
 describe("collections create", () => {
   it("creates with embedding metadata", async () => {
     createCollection.mockResolvedValueOnce({ name: "docs", metadata: {} });