fix(cli): render single-key resource envelopes, and column the new domains

`sim mcp-servers create` created the server, exited 0, and printed nothing.
The v2 route answers `{ data: { mcpServer: {...} } }`, and the record renderer
keeps only scalar fields — one key holding an object left it with none. Unwrap
a lone object-valued key before rendering; a payload with siblings (`{ row,
operation }` from upsert) is a real result and is left alone.

The five domains that arrived with the last generation had no contract columns,
so `mcp-servers list` inferred 20 including `hasOauthClientSecret`. Give each a
column set.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0148a65fkPhP4N8tgGPYtRTU

Author: TheodoreSpeaks

packages/sim-cli/src/contract/commands.ts

@@ -145,6 +145,52 @@ export const CLI_CONTRACT: CliContract = {
       { header: 'chunks', path: 'chunkCount' },
     ],
   },
+  // Without these the inferred fallback dumps every scalar field — 20 columns
+  // for an MCP server, including `hasOauthClientSecret`.
+  listMcpServers: {
+    columns: [
+      { header: 'id' },
+      { header: 'name' },
+      { header: 'transport' },
+      { header: 'url' },
+      { header: 'status', path: 'connectionStatus' },
+      { header: 'tools', path: 'toolCount' },
+      { header: 'enabled', format: 'bool' },
+    ],
+  },
+  listSkills: {
+    columns: [
+      { header: 'id' },
+      { header: 'name' },
+      { header: 'description' },
+      { header: 'updated', path: 'updatedAt', format: 'timestamp' },
+    ],
+  },
+  listCustomTools: {
+    columns: [
+      { header: 'id' },
+      { header: 'name' },
+      { header: 'description' },
+      { header: 'updated', path: 'updatedAt', format: 'timestamp' },
+    ],
+  },
+  listFolders: {
+    columns: [
+      { header: 'id' },
+      { header: 'name' },
+      { header: 'parent', path: 'parentId' },
+      { header: 'updated', path: 'updatedAt', format: 'timestamp' },
+    ],
+  },
+  listCredentials: {
+    columns: [
+      { header: 'id' },
+      { header: 'name' },
+      { header: 'provider' },
+      { header: 'updated', path: 'updatedAt', format: 'timestamp' },
+    ],
+  },
+
   listAuditLogs: {
     columns: [
       { header: 'at', path: 'createdAt', format: 'timestamp' },

packages/sim-cli/src/runtime/build.test.ts

@@ -13,12 +13,15 @@ import { buildGeneratedCommands } from './build.js'
  * catch that class of bug.
  */
 
-const { mockRequest } = vi.hoisted(() => ({ mockRequest: vi.fn() }))
+const { mockRequest, output } = vi.hoisted(() => ({
+  mockRequest: vi.fn(),
+  output: { format: 'json' },
+}))
 
 vi.mock('../context.js', () => ({
   clientFrom: () => ({
     client: { request: mockRequest, requireWorkspace: () => 'ws_local' },
-    profile: { workspaceId: 'ws_local', output: 'json', name: 'default', apiKey: 'k' },
+    profile: { workspaceId: 'ws_local', output: output.format, name: 'default', apiKey: 'k' },
   }),
 }))
 
@@ -109,6 +112,59 @@ describe('commands parsed through commander', () => {
   })
 })
 
+describe('single-resource rendering', () => {
+  async function lines(argv: string[], data: unknown, format = 'json'): Promise<string[]> {
+    mockRequest.mockReset()
+    mockRequest.mockResolvedValue({ data })
+    const captured: string[] = []
+    vi.spyOn(console, 'log').mockImplementation((line: string) => {
+      captured.push(line)
+    })
+    output.format = format
+    try {
+      await program().parseAsync(['node', 'sim', ...argv])
+    } finally {
+      output.format = 'json'
+    }
+    return captured
+  }
+
+  it('unwraps the single-key envelope a resource is returned in', async () => {
+    // `createMcpServer` answers `{ data: { mcpServer: {...} } }`. Rendering that
+    // as-is found one key holding an object, filtered it out as non-scalar, and
+    // printed nothing at all — the server was created and the CLI said so
+    // nowhere. Same silent-empty class as the body-cursor bug below.
+    const printed = await lines(
+      [
+        'mcp-servers',
+        'create',
+        '--name',
+        'Deepwiki',
+        '--transport',
+        'streamable-http',
+        '--url',
+        'https://mcp.deepwiki.com/mcp',
+      ],
+      { mcpServer: { id: 'mcp-1', name: 'Deepwiki', enabled: true } },
+      'text'
+    )
+
+    expect(printed.join('\n')).toMatch(/mcp-1/)
+    expect(printed.join('\n')).toMatch(/Deepwiki/)
+  })
+
+  it('leaves a payload with sibling keys intact', async () => {
+    // `upsertTableRow` returns `{ row, operation }` — two real fields, not an
+    // envelope. Unwrapping there would drop whether it inserted or updated.
+    const printed = await lines(['tables', 'upsert', 'tbl_1', '--data', '{}'], {
+      row: { id: 'r1' },
+      operation: 'inserted',
+    })
+
+    expect(JSON.parse(printed[0])).toEqual({ row: { id: 'r1' }, operation: 'inserted' })
+  })
+})
+
 describe('pagination slot', () => {
   it('pages a body-cursor operation and renders its rows', async () => {
     // `queryRows` is a POST whose cursor is in the body, not the query. Reading

packages/sim-cli/src/runtime/build.ts

@@ -94,6 +94,25 @@ function inferColumns(rows: unknown[]): Column<unknown>[] {
   }))
 }
 
+/**
+ * Unwraps the single-key envelope several v2 responses put their resource in —
+ * `{ mcpServer }`, `{ knowledgeBase }`, `{ row }`, `{ document }`, `{ table }`.
+ *
+ * Without this the record renderer sees one key whose value is an object,
+ * filters it out as non-scalar, and prints nothing at all: `sim mcp-servers
+ * create` exited 0 having created the server and said nothing about it.
+ *
+ * Only a lone key is unwrapped. A payload with siblings (`{ row, operation }`
+ * from upsert) is a real multi-field result and is rendered as it stands.
+ */
+function unwrapResource(data: unknown): unknown {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return data
+  const entries = Object.entries(data)
+  if (entries.length !== 1) return data
+  const [, value] = entries[0]
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : data
+}
+
 /** The operation's one-line help, taken from the OpenAPI summary at generation time. */
 function summaryFor(operation: V2OperationName): string | undefined {
   return (V2_OPERATIONS[operation] as { summary?: string }).summary
@@ -263,7 +282,7 @@ function buildLeaf(operation: V2OperationName, spec: CommandSpec, leafName: stri
       query: request.query,
       body: request.body,
     })
-    const data = result?.data ?? result
+    const data = unwrapResource(result?.data ?? result)
 
     if (Array.isArray(data)) {
       // Reached when a non-paginated operation answers with a collection.