feat(cli): sim tables import

Imports a CSV into a new or existing table, driving the same presigned
handshake `files upload` uses — the two are the same protocol against
different paths, so they now share one implementation.

What made this more than a wrapper is that the import carries decisions the
handshake does not: the source is a local file or one already in the workspace,
the target is a new table or an existing one to append to or replace, and
mapping/createColumns are rejected unless the target is existing. Both choices
are required rather than inferred — defaulting to a new table would turn a
forgotten --to-table into a silent second copy of the data — and the
conditional flags are checked here so the error names the flag instead of
arriving as a complaint about the request body.

The transfer only queues the work; rows are parsed afterwards, so returning at
`complete` would report success for an import that goes on to fail on a bad
row. It polls to a settled status and reports the rows written, with progress
on a terminal only. --no-wait opts out.

The handshake steps are hidden now that a command drives them; `imports get`
and `imports cancel` stay, being useful against an import already running.

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/commands/hand-written.test.ts

@@ -1,8 +1,16 @@
 import { createWriteStream, existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { streamToFile } from './hand-written.js'
+import { Command } from 'commander'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { attachHandWritten, streamToFile } from './hand-written.js'
+
+vi.mock('../context.js', () => ({
+  clientFrom: () => ({
+    client: { request: vi.fn(), requireWorkspace: () => 'ws_local' },
+    profile: { workspaceId: 'ws_local', output: 'json', name: 'default', apiKey: 'k' },
+  }),
+}))
 
 let dir: string
 
@@ -59,3 +67,48 @@ describe('streamToFile', () => {
     }
   )
 })
+
+describe('tables import argument guards', () => {
+  function importCommand(): Command {
+    const root = new Command('sim').exitOverride()
+    attachHandWritten(root)
+    const walk = (command: Command) => {
+      command.exitOverride()
+      command.commands.forEach(walk)
+    }
+    walk(root)
+    return root
+  }
+
+  async function run(argv: string[]) {
+    await importCommand().parseAsync(['node', 'sim', 'tables', 'import', ...argv])
+  }
+
+  it('refuses to guess the target', async () => {
+    // Defaulting to a new table would turn a forgotten `--to-table` into a
+    // silent second copy of the data.
+    await expect(run(['f.csv'])).rejects.toThrow(/exactly one of --new-table/)
+    await expect(run(['f.csv', '--new-table', 'a', '--to-table', 't'])).rejects.toThrow(
+      /exactly one of --new-table/
+    )
+  })
+
+  it('refuses to guess the source', async () => {
+    await expect(run(['--new-table', 'a'])).rejects.toThrow(/exactly one of <path>/)
+    await expect(run(['f.csv', '--new-table', 'a', '--file-id', 'w_1'])).rejects.toThrow(
+      /exactly one of <path>/
+    )
+  })
+
+  it('names the flag when mapping is paired with a new table', async () => {
+    // The server rejects this too, but as a message about the request body.
+    await expect(run(['f.csv', '--new-table', 'a', '--mapping', '{}'])).rejects.toThrow(
+      /--to-table only/
+    )
+  })
+
+  it('checks all of that before touching the filesystem', async () => {
+    // `f.csv` does not exist; a "cannot read" error would mean a guard ran late.
+    await expect(run(['f.csv'])).rejects.toThrow(/exactly one of/)
+  })
+})