@carthooks/arcubase-cli 0.1.12 → 0.1.15

package/src/tests/command_registry.test.ts

@@ -11,10 +11,12 @@ test('admin surface is restricted to reset white list', () => {
   const actual = commandPaths(adminCommands)
   const expected = [
     'app create',
+    'app create-from-bundle-url',
     'app delete',
     'app get',
     'app list',
     'app update',
+    'app watch-import-task',
     'table create',
     'table delete',
     'table get',
@@ -45,6 +47,8 @@ test('user surface is restricted to reset white list', () => {
     'row create',
     'row delete',
     'row get',
+    'row import-csv',
+    'row import-excel',
     'row query',
     'row selection-action',
     'row update',

package/src/tests/entity_import_mapping.test.ts

@@ -0,0 +1,87 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { compileCSVImportMapping, compileExcelImportMapping } from '../runtime/entity_import_mapping.js'
+import { CLIError } from '../runtime/errors.js'
+
+test('excel mapping compiles column letters to backend mapper', () => {
+  const result = compileExcelImportMapping({
+    sheet: 'Sheet1',
+    mode: 'addorupdate',
+    headerRow: 1,
+    dataStartRow: 2,
+    recordId: { column: 'A' },
+    fields: [
+      { fieldId: 1001, column: 'B' },
+      { fieldId: 1002, column: 'AA' },
+    ],
+  })
+  assert.deepEqual(result, {
+    fileFormat: 'excel',
+    importMode: 'addorupdate',
+    workingSheet: 'Sheet1',
+    titleRowIndex: 0,
+    mapper: {
+      '$id': 0,
+      '1001': 1,
+      '1002': 26,
+    },
+  })
+})
+
+test('excel mapping rejects string field id', () => {
+  assert.throws(() => {
+    compileExcelImportMapping({
+      sheet: 'Sheet1',
+      mode: 'addonly',
+      dataStartRow: 2,
+      fields: [{ fieldId: '1001', column: 'A' }],
+    } as any)
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'INVALID_IMPORT_MAPPING')
+    assert.match(error.message, /fieldId must be a number/)
+    return true
+  })
+})
+
+test('csv mapping resolves headers to backend mapper', () => {
+  const result = compileCSVImportMapping({
+    mode: 'updateonly',
+    header: true,
+    dataStartRow: 2,
+    delimiter: ',',
+    recordId: { header: 'ID' },
+    fields: [
+      { fieldId: 1001, header: '客户名称' },
+      { fieldId: 1002, header: '手机号' },
+    ],
+  }, ['ID', '客户名称', '手机号'])
+  assert.deepEqual(result, {
+    fileFormat: 'csv',
+    importMode: 'updateonly',
+    titleRowIndex: 0,
+    csvDelimiter: ',',
+    mapper: {
+      '$id': 0,
+      '1001': 1,
+      '1002': 2,
+    },
+  })
+})
+
+test('csv mapping missing header lists available headers', () => {
+  assert.throws(() => {
+    compileCSVImportMapping({
+      mode: 'addonly',
+      header: true,
+      dataStartRow: 2,
+      fields: [{ fieldId: 1001, header: 'missing' }],
+    }, ['客户名称', '手机号'])
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'INVALID_IMPORT_MAPPING')
+    assert.match(error.message, /missing/)
+    assert.ok(error.details?.suggestions?.some((item) => item.includes('客户名称')))
+    return true
+  })
+})

package/src/tests/entity_save_schema.test.ts

@@ -65,6 +65,46 @@ test('EntitySaveReqVO normalizes mechanical FieldVO defaults', () => {
   assert.deepEqual(parsed.data.fields[0].depends, [])
 })
 
+test('EntitySaveReqVO rejects textarea size as string', () => {
+  assert.ok(schema)
+  const parsed = schema!.safeParse({
+    name: '订单',
+    field_id_seq: 1003,
+    layout: [[1001], [1002]],
+    fields: [
+      buildMinimalField(1001),
+      {
+        ...buildMinimalField(1002),
+        label: '描述',
+        type: 'textarea',
+        key: 'description',
+        options: { placeholder: '', html: false, size: 'default', lengthLimit: false, lengthMin: 0, lengthMax: 2000 },
+      },
+    ],
+  })
+  assert.equal(parsed.success, false)
+})
+
+test('EntitySaveReqVO accepts textarea size as number', () => {
+  assert.ok(schema)
+  const parsed = schema!.safeParse({
+    name: '订单',
+    field_id_seq: 1003,
+    layout: [[1001], [1002]],
+    fields: [
+      buildMinimalField(1001),
+      {
+        ...buildMinimalField(1002),
+        label: '描述',
+        type: 'textarea',
+        key: 'description',
+        options: { placeholder: '', html: false, size: 6, lengthLimit: false, lengthMin: 0, lengthMax: 2000 },
+      },
+    ],
+  })
+  assert.equal(parsed.success, true)
+})
+
 test('EntitySaveReqVO rejects fields as object', () => {
   assert.ok(schema)
   const parsed = schema!.safeParse({

package/src/tests/execute_validation.test.ts

@@ -146,15 +146,196 @@ test('table update-schema rejects invalid body file', async () => {
 })
 
 test('app create rejects name longer than 20 chars', async () => {
-  const bodyFile = tempJSONFile({ name: 'CLI Verify Happy Path' })
-  await assert.rejects(async () => {
-    await executeCLI('admin', ['app', 'create', '--body-file', bodyFile], env as any, async () => new Response('{}', { status: 200 }))
+	const bodyFile = tempJSONFile({ name: 'CLI Verify Happy Path' })
+	await assert.rejects(async () => {
+		await executeCLI('admin', ['app', 'create', '--body-file', bodyFile], env as any, async () => new Response('{}', { status: 200 }))
   }, (error: unknown) => {
     assert.ok(error instanceof CLIError)
     assert.equal(error.code, 'BODY_VALIDATION_FAILED')
     assert.ok((error.details?.issues ?? []).some((item) => item.path === 'body.name'))
     return true
+	})
+})
+
+test('app create-from-bundle-url posts url body and returns task id', async () => {
+	const calls: Array<{ url: string; method?: string; body?: string }> = []
+	const out = await executeCLI(
+		'admin',
+		['app', 'create-from-bundle-url', '--url', 'https://cdn.example.com/app-bundles/2026/06/17/a.zip', '--name', 'Demo'],
+		env as any,
+		async (url, init) => {
+			calls.push({ url: String(url), method: init?.method, body: String(init?.body ?? '') })
+			return new Response(JSON.stringify({ data: { task_id: 'task-1' } }), { status: 200 })
+		},
+	)
+	assert.equal(calls[0].method, 'POST')
+	assert.match(calls[0].url, /\/api\/apps\/import-task$/)
+	assert.deepEqual(JSON.parse(calls[0].body ?? '{}'), {
+		url: 'https://cdn.example.com/app-bundles/2026/06/17/a.zip',
+		name: 'Demo',
+	})
+	assert.equal((out as any).data.data.task_id, 'task-1')
+	assert.deepEqual((out as any).nextAction, {
+		command: 'app watch-import-task',
+		args: ['--task-id', 'task-1', '--ttl-seconds', '300'],
+		hint: 'run this command until the task returns status=finished and app_id > 0; task_id alone is not success',
+	})
+})
+
+test('app create --url points to bundle import flow', async () => {
+	await assert.rejects(async () => {
+		await executeCLI(
+			'admin',
+			['app', 'create', '--url', 'https://cdn.example.com/app-bundles/2026/06/17/a.zip', '--name', 'Demo'],
+			env as any,
+			async () => new Response('{}', { status: 200 }),
+		)
+	}, (error: unknown) => {
+		assert.ok(error instanceof CLIError)
+		assert.equal(error.code, 'UNKNOWN_FLAG')
+		assert.equal(error.details?.hint, 'app bundle URLs must use app create-from-bundle-url; do not retry app create')
+		assert.deepEqual(error.details?.commonMistakes, [
+			'do not use app create for app bundle URLs',
+			'do not put url inside app create --body-json',
+		])
+		assert.deepEqual(error.details?.suggestions, [
+			'retry with: app create-from-bundle-url --url <public_http_zip_url> --name <app_name>',
+			'then watch with: app watch-import-task --task-id <task_id> --ttl-seconds 300',
+		])
+		return true
+	})
+})
+
+test('app create-from-bundle-url rejects unsupported url scheme before request', async () => {
+	let called = false
+	await assert.rejects(async () => {
+		await executeCLI(
+			'admin',
+			['app', 'create-from-bundle-url', '--url', 'file:///tmp/app.zip', '--name', 'Demo'],
+			env as any,
+			async () => {
+				called = true
+				return new Response('{}', { status: 200 })
+			},
+		)
+	}, (error: unknown) => {
+		assert.ok(error instanceof CLIError)
+		assert.equal(error.code, 'INVALID_IMPORT_URL')
+		assert.equal(called, false)
+		return true
+	})
+})
+
+test('app watch-import-task polls until finished', async () => {
+  const statuses = [
+    { data: { task_id: 'task-1', status: 'processing' } },
+    { data: { task_id: 'task-1', status: 'finished', app_id: 2188889999 } },
+	]
+	const calls: string[] = []
+	const out = await executeCLI(
+		'admin',
+		['app', 'watch-import-task', '--task-id', 'task-1', '--ttl-seconds', '1'],
+		{ ...env, ARCUBASE_IMPORT_TASK_WATCH_INTERVAL_MS: '1' } as any,
+		async (url) => {
+			calls.push(String(url))
+			return new Response(JSON.stringify(statuses.shift()), { status: 200 })
+		},
+	)
+	assert.equal(calls.length, 2)
+  assert.equal((out as any).data.data.status, 'finished')
+})
+
+test('app watch-import-task rejects finished status without app id', async () => {
+	await assert.rejects(async () => {
+		await executeCLI(
+			'admin',
+			['app', 'watch-import-task', '--task-id', 'task-1', '--ttl-seconds', '1'],
+			{ ...env, ARCUBASE_IMPORT_TASK_WATCH_INTERVAL_MS: '1' } as any,
+			async () => new Response(JSON.stringify({ data: { task_id: 'task-1', status: 'finished' } }), { status: 200 }),
+		)
+	}, (error: unknown) => {
+		assert.ok(error instanceof CLIError)
+		assert.equal(error.code, 'IMPORT_TASK_APP_ID_MISSING')
+		return true
+	})
+})
+
+test('row import-csv validates mapping, uploads local file, starts import, and watches task', async () => {
+  const csvFile = tempJSONFile('ID,客户名称\n12,Alice\n').replace(/payload\.json$/, 'records.csv')
+  fs.writeFileSync(csvFile, 'ID,客户名称\n12,Alice\n')
+  const mappingFile = tempJSONFile({
+    mode: 'addorupdate',
+    header: true,
+    dataStartRow: 2,
+    recordId: { header: 'ID' },
+    fields: [{ fieldId: 1001, header: '客户名称' }],
   })
+  const calls: Array<{ url: string; method?: string; body?: string; isForm?: boolean }> = []
+  const out = await executeCLI(
+    'user',
+    ['row', 'import-csv', '--app-id', 'app_1', '--table-id', 'table_1', '--file', csvFile, '--mapping-file', mappingFile, '--ttl-seconds', '1'],
+    { ...env, ARCUBASE_IMPORT_TASK_WATCH_INTERVAL_MS: '1' } as any,
+    async (url, init) => {
+      calls.push({
+        url: String(url),
+        method: init?.method,
+        body: typeof init?.body === 'string' ? init.body : undefined,
+        isForm: init?.body instanceof FormData,
+      })
+      if (String(url).endsWith('/api/entity/app_1/table_1/import') && init?.method === 'POST') {
+        const body = JSON.parse(String(init.body))
+        if (body._import_action === 'init-token') {
+          return new Response(JSON.stringify({ data: { taskId: 'task-1', token: { id: 123, mode: 's3', token_data: { host: 'https://uploads.example.com', dir: 'upload/123/', policy: 'p', signature: 's', accessid: 'a' } } } }), { status: 200 })
+        }
+        if (body._import_action === 'uploaded') {
+          return new Response(JSON.stringify({ data: 'task-1' }), { status: 200 })
+        }
+        if (body._import_action === 'do-process') {
+          assert.deepEqual(body.config, {
+            fileFormat: 'csv',
+            importMode: 'addorupdate',
+            titleRowIndex: 0,
+            csvDelimiter: ',',
+            mapper: { '$id': 0, '1001': 1 },
+          })
+          return new Response(JSON.stringify({ data: { taskId: 'task-1', status: 'processing', state: {} } }), { status: 200 })
+        }
+        if (body._import_action === 'get-state') {
+          return new Response(JSON.stringify({ data: { taskId: 'task-1', status: 'finished', state: { state: { SuccessNum: 1 } } } }), { status: 200 })
+        }
+      }
+      if (String(url) === 'https://uploads.example.com') {
+        return new Response(null, { status: 204 })
+      }
+      throw new Error(`unexpected fetch ${url}`)
+    },
+  )
+  assert.equal(out.kind, 'result')
+  assert.equal(out.data.data.status, 'finished')
+  assert.ok(calls.some((call) => call.isForm), 'expected local file upload form request')
+})
+
+test('row import-csv missing header fails before fetch', async () => {
+  const csvFile = tempJSONFile('Name\nAlice\n').replace(/payload\.json$/, 'records.csv')
+  fs.writeFileSync(csvFile, 'Name\nAlice\n')
+  const mappingFile = tempJSONFile({
+    mode: 'addonly',
+    header: true,
+    dataStartRow: 2,
+    fields: [{ fieldId: 1001, header: 'Missing' }],
+  })
+  let called = false
+  await assert.rejects(async () => {
+    await executeCLI('user', ['row', 'import-csv', '--app-id', 'app_1', '--table-id', 'table_1', '--file', csvFile, '--mapping-file', mappingFile], env as any, async () => {
+      called = true
+      return new Response('{}')
+    })
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'INVALID_IMPORT_MAPPING')
+    return true
+  })
+  assert.equal(called, false)
 })
 
 test('table create rejects empty schema body before request', async () => {
@@ -281,6 +462,38 @@ test('body json parse errors include command docs and type hints', async () => {
   })
 })
 
+test('access-rule invalid json returns copyable create retry examples', async () => {
+  await assert.rejects(async () => {
+    await executeCLI('admin', ['access-rule', 'create', '--app-id', 'app_1', '--table-id', 'table_1', '--body-json', '{"name":"Admin full access","enabled":true,"type":"form","options":{"user_scope":[{"type":"user","id":2188889977}],"policy":{"key":"custom","actions":["view","add","edit","delete"],"all_fields_read":true,"all_fields_write":true},"list_options":{}}'], env as any, async () => new Response('{}', { status: 200 }))
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'INVALID_BODY_JSON')
+    assert.equal(error.details?.requestType, 'AppIngressCreateReqVO')
+    assert.match(error.message, /retryToolCalls/)
+    const toolCall = (error.details?.retryToolCalls ?? [])[0] as any
+    assert.ok(toolCall)
+    assert.equal(toolCall.command, 'access-rule create')
+    assert.deepEqual(toolCall.args.slice(0, 5), ['--app-id', '<app_id>', '--table-id', '<table_id>', '--body-json'])
+    const body = JSON.parse(toolCall.args[5])
+    assert.deepEqual(body, {
+      name: 'Admin full access',
+      enabled: true,
+      type: 'form',
+      options: {
+        user_scope: [{ type: 'user', id: 2188889977 }],
+        policy: {
+          key: 'custom',
+          actions: ['view', 'add', 'edit', 'delete'],
+          all_fields_read: true,
+          all_fields_write: true,
+        },
+        list_options: {},
+      },
+    })
+    return true
+  })
+})
+
 test('access-rule list executes against external root path', async () => {
   const out = await executeCLI(
     'admin',
@@ -355,7 +568,7 @@ test('table update-schema rejects per-user permission patches', async () => {
     layout: [[1001], [1002]],
     fields: [
       { id: 1001, label: 'Title', type: 'text', required: true, unique: false, editable: true, visible: true, show_label: true, scannable: false, default_value_mode: 0, description: '', value: null, number_decimal: 0, depends: [], key: 'title', code_index: false, options: { type: 'text', placeholder: '', lengthLimit: false, lengthMin: 0, lengthMax: 255 }, transfers: null, children: null },
-      { id: 1002, label: 'Description', type: 'textarea', required: false, unique: false, editable: true, visible: true, show_label: true, scannable: false, default_value_mode: 0, description: '', value: null, number_decimal: 0, depends: [], key: 'description', code_index: false, options: { placeholder: '', html: false, size: 'default', lengthLimit: false, lengthMin: 0, lengthMax: 2000 }, transfers: null, children: null, permission: { user: { read: false } } },
+      { id: 1002, label: 'Description', type: 'textarea', required: false, unique: false, editable: true, visible: true, show_label: true, scannable: false, default_value_mode: 0, description: '', value: null, number_decimal: 0, depends: [], key: 'description', code_index: false, options: { placeholder: '', html: false, size: 6, lengthLimit: false, lengthMin: 0, lengthMax: 2000 }, transfers: null, children: null, permission: { user: { read: false } } },
     ],
     options: { Buttons: [], CustomActions: [], FrontendEvents: [], TitleFormat: { Fields: [], Parts: [], Body: '' }, misc: {} },
     workflow_enabled: false,
@@ -477,6 +690,43 @@ test('row get resolves internal policy_id as query parameter', async () => {
   assert.equal(calls[0], 'https://arcubase.example.com/api/entity/2188900691/2188900694/row/4000000046?policy_id=policy_hash_1')
 })
 
+test('row get returns machine-readable row value evidence', async () => {
+  const out = await executeCLI(
+    'user',
+    ['row', 'get', '--app-id', '2188900691', '--table-id', '2188900694', '--row-id', '4000000046'],
+    env as any,
+    withRowPolicyResolver('2188900694', ['view'], async () => new Response(JSON.stringify({
+      data: {
+        record: {
+          id: 4000000046,
+          fields: { 1001: '复测投票' },
+        },
+        fieldPermits: {
+          all_fields_read: false,
+          fields: [
+            { key: ':1001', read: true, write: true, report: false },
+            { key: ':1002', read: false, write: false, report: false },
+            { key: ':1003', read: true, write: true, report: false },
+          ],
+        },
+      },
+    }), { status: 200 })),
+  )
+  assert.deepEqual(out.rowValueEvidence, {
+    source: 'row get record.fields',
+    returnedFieldIds: ['1001'],
+    notReturnedFieldIds: ['1002', '1003'],
+    deniedReadFieldIds: ['1002'],
+    absentFieldMeaning: 'not returned to current user; no row-value evidence',
+    rules: [
+      'current row values come only from row query fields or row get record.fields',
+      'table schema fields[].value and default_value_mode are schema defaults, not returned row values',
+      'a field id absent from returned row fields has no row-value evidence',
+      'read visibility status is fieldPermits read:false; FIELD_PERMISSION_REQUIRED is only a write preflight error',
+    ],
+  })
+})
+
 test('row command rejects user-provided policy_id', async () => {
   const bodyFile = tempJSONFile({ fields: { 1001: '今天吃什么' }, policy_id: 'manual_policy' })
   await assert.rejects(async () => {
@@ -701,6 +951,45 @@ test('row query rejects camelCase viewMode and points to row crud doc', async ()
   })
 })
 
+test('row query rejects invalid search shape through EntityQueryReqVO zod schema', async () => {
+  for (const search of [
+    { conditions: [{ field_id: 1002, op: 'eq', value: 'member_1' }] },
+    { field_filters: [{ field_id: 1002, operator: 'eq', value: 'member_1' }] },
+    { q: ['SO-1001'] },
+  ]) {
+    const bodyFile = tempJSONFile({ limit: 20, offset: 0, search })
+    let dataQueryFetchCount = 0
+    await assert.rejects(async () => {
+      await executeCLI(
+        'user',
+        ['row', 'query', '--app-id', 'app_1', '--table-id', 'table_1', '--body-file', bodyFile],
+        env as any,
+        withRowPolicyResolver('table_1', ['view'], async () => {
+          dataQueryFetchCount += 1
+          return new Response('{}', { status: 200 })
+        }),
+      )
+    }, (error: unknown) => {
+      assert.ok(error instanceof CLIError)
+      assert.equal(error.code, 'BODY_VALIDATION_FAILED')
+      assert.equal(error.details?.requestType, 'EntityQueryReqVO')
+      assert.ok((error.details?.issues ?? []).some((item) => item.path.startsWith('body.search.')))
+      assert.ok(error.details?.tsHints?.some((item) => item.symbol === 'EntityQueryReqVO' && item.file === '/runtime/arcubase-sdk/types/user-action.ts'))
+      assert.deepEqual(error.details?.shapeHint, {
+        limit: 20,
+        offset: 0,
+        search: { q: 'SO-1001' },
+        sorts: [{ column: ':1001', order: 'asc' }],
+      })
+      assert.ok(error.details?.commonMistakes?.some((item) => item.includes('string route-query keys')))
+      assert.ok(error.details?.suggestions?.some((item) => item.includes('"search":{"q":"SO-1001"}')))
+      assert.ok(error.details?.suggestions?.some((item) => item.includes('"filter_:1002"')))
+      return true
+    })
+    assert.equal(dataQueryFetchCount, 0)
+  }
+})
+
 test('row query unknown limit flag gives body-json retry path', async () => {
   await assert.rejects(async () => {
     await executeCLI('user', ['row', 'query', '--app-id', '2188900691', '--table-id', '2188900694', '--limit', '1', '--offset', '0'], env as any, async () => new Response('{}', { status: 200 }))
@@ -708,7 +997,12 @@ test('row query unknown limit flag gives body-json retry path', async () => {
     assert.ok(error instanceof CLIError)
     assert.equal(error.code, 'UNKNOWN_FLAG')
     assert.equal(error.details?.requestType, 'EntityQueryReqVO')
-    assert.deepEqual(error.details?.shapeHint, { limit: 20, offset: 0, search: { text_search: 'SO-1001' } })
+    assert.deepEqual(error.details?.shapeHint, {
+      limit: 20,
+      offset: 0,
+      search: { q: 'SO-1001' },
+      sorts: [{ column: ':1001', order: 'asc' }],
+    })
     assert.ok(error.details?.suggestions?.some((item) => item.includes('--body-json')))
     return true
   })

package/src/tests/help.test.ts

@@ -66,6 +66,20 @@ test('user row help does not expose internal policy id input', async () => {
   assert.doesNotMatch(out.text, /policy_id/)
 })
 
+test('row import help explains mapping formats and local files', async () => {
+  const excel = await executeCLI('user', ['row', 'import-excel', '--help'], env as any, async () => new Response('{}'))
+  assert.equal(excel.kind, 'help')
+  assert.match(excel.text, /mapping-file/)
+  assert.match(excel.text, /Excel columns use letters/)
+  assert.match(excel.text, /local file/)
+
+  const csv = await executeCLI('user', ['row', 'import-csv', '--help'], env as any, async () => new Response('{}'))
+  assert.equal(csv.kind, 'help')
+  assert.match(csv.text, /CSV mapping uses headers/)
+  assert.match(csv.text, /does not support embedded images/)
+  assert.match(csv.text, /arcubase-admin table get/)
+})
+
 test('admin table update-schema help uses table nouns and body-json', async () => {
   const out = await executeCLI('admin', ['table', 'update-schema', '--help'], env as any, async () => new Response('{}'))
   assert.equal(out.kind, 'help')
@@ -90,6 +104,8 @@ test('admin access-rule help gives update whitelist and assign-users body-json e
   assert.equal(create.kind, 'help')
   assert.match(create.text, /Access rule/)
   assert.match(create.text, /access-rule\.md/)
+  assert.match(create.text, /full access/)
+  assert.match(create.text, /"actions":\["view","add","edit","delete"\]/)
   assert.match(create.text, /"user_scope":\[\{"type":"user","id":2188889901\}\]/)
   assert.doesNotMatch(create.text, /"user_scope":\[\{"type":"member"/)
 

package/src/tests/local_upload.test.ts

@@ -0,0 +1,47 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { uploadLocalFileWithToken } from '../runtime/local_upload.js'
+import { CLIError } from '../runtime/errors.js'
+
+function tempFile(name: string, content = 'hello'): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'arcubase-upload-'))
+  const file = path.join(dir, name)
+  fs.writeFileSync(file, content)
+  return file
+}
+
+test('uploadLocalFileWithToken uploads aliyun-compatible post policy', async () => {
+  const file = tempFile('records.csv')
+  const calls: Array<{ url: string; method?: string; body: any }> = []
+  await uploadLocalFileWithToken(file, {
+    mode: 's3',
+    token_data: {
+      host: 'https://uploads.example.com',
+      dir: 'upload/123/',
+      policy: 'policy',
+      signature: 'signature',
+      accessid: 'access',
+      expire: 123,
+    },
+  }, async (url, init) => {
+    calls.push({ url: String(url), method: init?.method, body: init?.body })
+    return new Response(null, { status: 204 })
+  })
+  assert.equal(calls[0].url, 'https://uploads.example.com')
+  assert.equal(calls[0].method, 'POST')
+  assert.ok(calls[0].body instanceof FormData)
+})
+
+test('uploadLocalFileWithToken rejects unsupported token shape', async () => {
+  const file = tempFile('records.csv')
+  await assert.rejects(async () => {
+    await uploadLocalFileWithToken(file, { mode: 'unknown', token_data: {} }, async () => new Response(''))
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'UPLOAD_TOKEN_UNSUPPORTED')
+    return true
+  })
+})

package/src/tests/zod_registry.test.ts

@@ -14,6 +14,33 @@ test('EntityQueryReqVO schema exists', () => {
   assert.ok(getBodySchema('EntityQueryReqVO'))
 })
 
+test('EntityQueryReqVO search only accepts route-query string keys', () => {
+  const schema = getBodySchema('EntityQueryReqVO')
+  assert.ok(schema)
+
+  assert.equal(schema.safeParse({
+    limit: 100,
+    offset: 0,
+    search: {
+      q: 'SO-1001',
+      tab: 'all',
+      'filter_:1002': 'eq:member_1',
+    },
+  }).success, true)
+
+  for (const search of [
+    { conditions: [{ field_id: 1002, op: 'eq', value: 'member_1' }] },
+    { condition: { field_id: 1002, op: 'eq', value: 'member_1' } },
+    { field_filters: [{ field_id: 1002, operator: 'eq', value: 'member_1' }] },
+    { filter: { field_id: 1002, value: 'member_1' } },
+    { order: [{ column: ':1001', order: 'asc' }] },
+    { q: ['SO-1001'] },
+    { 'filter_:1002': { op: 'eq', value: 'member_1' } },
+  ]) {
+    assert.equal(schema.safeParse({ limit: 100, offset: 0, search }).success, false)
+  }
+})
+
 test('unknown request type has no schema and no unsupported reason', () => {
   assert.equal(getBodySchema('DefinitelyMissingReqVO'), null)
   assert.equal(getUnsupportedBodySchemaReason('DefinitelyMissingReqVO'), null)