feat(import): carry a chosen import target through the backends

Add AutoImportOptions.forceCreate, which plans a separate session with create reason 'user-choice' regardless of what automatic matching would find. Expose the existing analyzeAutoImportFile preview through the desktop worker (chat:analyzeAutoImport) and a CLI Web /_web/import/analyze-target route so the renderer can preselect the target automatic matching would pick. Transport: chat:importWithOptions accepts a `target` option and maps it to explicitSessionId / forceCreate; /_web/import accepts targetMode and targetSessionId; /_web/import/batch accepts only auto and new, since appending several files to one chosen session has no defined meaning; clb import gains --new-session, mutually exclusive with --session-id. Refs #376 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Zycheng114514 · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026
commit e5d9867cdbdf43fad65f3fc4e60270107aef3513
diff --git a/apps/cli/src/http/routes/web/import.test.ts b/apps/cli/src/http/routes/web/import.test.ts
@@ -6,7 +6,7 @@ import multipart from '@fastify/multipart'
 
 import { registerImportRoutes } from './import'
 
-function multipartPayload(): { payload: Buffer; contentType: string } {
+function multipartPayload(extraFields: Record<string, string> = {}): { payload: Buffer; contentType: string } {
   const boundary = '----chatlab-auto-import-route-test'
   const field = (name: string, value: string) =>
     [`--${boundary}`, `Content-Disposition: form-data; name="${name}"`, '', value].join('\r\n')
@@ -24,6 +24,7 @@ function multipartPayload(): { payload: Buffer; contentType: string } {
         field('formatId', 'telegram-json'),
         field('chatIndex', '2'),
         field('sessionGapThreshold', '7200'),
+        ...Object.entries(extraFields).map(([name, value]) => field(name, value)),
         file,
         `--${boundary}--`,
         '',
@@ -61,9 +62,14 @@ function directoryMultipartPayload(): { payload: Buffer; contentType: string } {
   }
 }
 
-function batchMultipartPayload(): { payload: Buffer; contentType: string } {
+function batchMultipartPayload(targetMode?: string): { payload: Buffer; contentType: string } {
   const boundary = '----chatlab-batch-import-route-test'
-  const field = [`--${boundary}`, 'Content-Disposition: form-data; name="sessionGapThreshold"', '', '7200'].join('\r\n')
+  const fields = [
+    [`--${boundary}`, 'Content-Disposition: form-data; name="sessionGapThreshold"', '', '7200'].join('\r\n'),
+    ...(targetMode === undefined
+      ? []
+      : [[`--${boundary}`, 'Content-Disposition: form-data; name="targetMode"', '', targetMode].join('\r\n')]),
+  ]
   const files = ['first.json', 'second.json'].map((filename, index) =>
     [
       `--${boundary}`,
@@ -74,7 +80,7 @@ function batchMultipartPayload(): { payload: Buffer; contentType: string } {
     ].join('\r\n')
   )
   return {
-    payload: Buffer.from([field, ...files, `--${boundary}--`, ''].join('\r\n')),
+    payload: Buffer.from([...fields, ...files, `--${boundary}--`, ''].join('\r\n')),
     contentType: `multipart/form-data; boundary=${boundary}`,
   }
 }
@@ -371,4 +377,123 @@ describe('CLI Web automatic import route', () => {
       await app.close()
     }
   })
+
+  it('maps the requested import target onto the auto importer options', async () => {
+    const cases: Array<{
+      fields: Record<string, string>
+      expected: { sessionId?: string; forceCreate?: boolean }
+    }> = [
+      { fields: {}, expected: { sessionId: undefined, forceCreate: undefined } },
+      { fields: { targetMode: 'auto' }, expected: { sessionId: undefined, forceCreate: undefined } },
+      { fields: { targetMode: 'new' }, expected: { sessionId: undefined, forceCreate: true } },
+      {
+        fields: { targetMode: 'session', targetSessionId: 'chat_42' },
+        expected: { sessionId: 'chat_42', forceCreate: undefined },
+      },
+    ]
+
+    for (const { fields, expected } of cases) {
+      const app = Fastify()
+      const calls: Array<{ sessionId?: string; forceCreate?: boolean }> = []
+      try {
+        await app.register(multipart)
+        registerImportRoutes(
+          app,
+          {} as any,
+          {
+            runAutoImport: async (_filePath: string, options: Record<string, unknown>) => {
+              calls.push({
+                sessionId: options.sessionId as string | undefined,
+                forceCreate: options.forceCreate as boolean | undefined,
+              })
+              return { success: true, sessionId: 'chat_42', importMode: 'incremental' }
+            },
+          } as any
+        )
+
+        const body = multipartPayload(fields)
+        const response = await app.inject({
+          method: 'POST',
+          url: '/_web/import',
+          headers: { 'content-type': body.contentType },
+          payload: body.payload,
+        })
+
+        assert.equal(response.statusCode, 200)
+        assert.deepEqual(calls, [expected])
+      } finally {
+        await app.close()
+      }
+    }
+  })
+
+  it('rejects an import target that names a session but no session id', async () => {
+    const app = Fastify()
+    try {
+      await app.register(multipart)
+      registerImportRoutes(
+        app,
+        {} as any,
+        {
+          runAutoImport: async () => {
+            throw new Error('import must not start')
+          },
+        } as any
+      )
+
+      const body = multipartPayload({ targetMode: 'session' })
+      const response = await app.inject({
+        method: 'POST',
+        url: '/_web/import',
+        headers: { 'content-type': body.contentType },
+        payload: body.payload,
+      })
+
+      assert.equal(response.statusCode, 400)
+      assert.equal(response.json().error, 'targetSessionId is required when targetMode is "session"')
+    } finally {
+      await app.close()
+    }
+  })
+
+  it('lets a batch ask for separate sessions but refuses one shared session target', async () => {
+    const app = Fastify()
+    const forceCreateFlags: Array<boolean | undefined> = []
+    try {
+      await app.register(multipart)
+      registerImportRoutes(
+        app,
+        {} as any,
+        {
+          runAutoImportBatch: async (items: any[]) => {
+            for (const item of items) forceCreateFlags.push(item.forceCreate)
+            return items.map((item) => ({ id: item.id, status: 'success', result: { success: true } }))
+          },
+        } as any
+      )
+
+      const newBody = batchMultipartPayload('new')
+      const newResponse = await app.inject({
+        method: 'POST',
+        url: '/_web/import/batch',
+        headers: { 'content-type': newBody.contentType },
+        payload: newBody.payload,
+      })
+
+      const sessionBody = batchMultipartPayload('session')
+      const sessionResponse = await app.inject({
+        method: 'POST',
+        url: '/_web/import/batch',
+        headers: { 'content-type': sessionBody.contentType },
+        payload: sessionBody.payload,
+      })
+
+      assert.equal(newResponse.statusCode, 200)
+      assert.deepEqual(forceCreateFlags, [true, true])
+      assert.equal(sessionResponse.statusCode, 400)
+      assert.equal(sessionResponse.json().error, 'targetMode "session" is not supported for batch imports')
+    } finally {
+      await app.close()
+    }
+  })
 })
diff --git a/apps/cli/src/http/routes/web/import.ts b/apps/cli/src/http/routes/web/import.ts
@@ -19,6 +19,7 @@ import {
   streamImport,
   incrementalImport,
   analyzeIncrementalImport,
+  analyzeAutoImport,
   analyzeNewImport,
   detectFormat,
   detectAllFormats,
@@ -27,6 +28,7 @@ import {
   findEntryFileInDirectory,
 } from '../../../import'
 import type {
+  AutoImportAnalysisResult,
   AutoImportBatchOptions,
   AutoImportBatchRequest,
   AutoImportResult,
@@ -39,6 +41,7 @@ const ARCHIVE_UPLOAD_LIMIT = 50 * 1024 * 1024 * 1024
 interface ImportRouteOptions {
   sourceManager?: ArchiveImportSourceManager
   runAutoImport?: (filePath: string, options: StreamImportOptions) => Promise<AutoImportResult>
+  runAnalyzeAutoImport?: (filePath: string, options: StreamImportOptions) => Promise<AutoImportAnalysisResult>
   runAutoImportBatch?: (
     items: AutoImportBatchRequest[],
     options: AutoImportBatchOptions
@@ -57,6 +60,31 @@ function parseOptionalInteger(value: unknown): number | undefined {
   return Number.isInteger(parsed) ? parsed : undefined
 }
 
+interface ImportTargetFields {
+  sessionId?: string
+  forceCreate?: boolean
+}
+
+/**
+ * Map the requested import target onto the auto importer's own options.
+ * `allowSession` is false for batch endpoints, where appending several files to one
+ * chosen session has no well-defined meaning.
+ */
+function resolveImportTarget(
+  mode: unknown,
+  sessionId: unknown,
+  allowSession: boolean
+): { target: ImportTargetFields } | { error: string } {
+  if (mode === undefined || mode === '' || mode === 'auto') return { target: {} }
+  if (mode === 'new') return { target: { forceCreate: true } }
+  if (mode !== 'session') return { error: `Unsupported targetMode: ${String(mode)}` }
+  if (!allowSession) return { error: 'targetMode "session" is not supported for batch imports' }
+  if (typeof sessionId !== 'string' || sessionId === '') {
+    return { error: 'targetSessionId is required when targetMode is "session"' }
+  }
+  return { target: { sessionId } }
+}
+
 function cleanupTemp(...paths: string[]) {
   for (const p of paths) {
     try {
@@ -80,6 +108,7 @@ export function registerImportRoutes(
   const activeBatchControllers = new Map<string, AbortController>()
   const sourceManager = options.sourceManager ?? new ArchiveImportSourceManager()
   const runAutoImport = options.runAutoImport ?? autoImport.bind(null, dbManager)
+  const runAnalyzeAutoImport = options.runAnalyzeAutoImport ?? analyzeAutoImport.bind(null, dbManager)
   const runAutoImportBatch = options.runAutoImportBatch ?? autoImportBatch.bind(null, dbManager)
   const runPreparedImport =
     options.runPreparedImport ??
@@ -232,6 +261,15 @@ export function registerImportRoutes(
     const chatIndexStr = (data.fields?.chatIndex as any)?.value as string | undefined
     const chatIndex = chatIndexStr !== undefined ? parseInt(chatIndexStr, 10) : undefined
     const sessionGapThreshold = parseOptionalInteger((data.fields?.sessionGapThreshold as any)?.value)
+    const target = resolveImportTarget(
+      (data.fields?.targetMode as any)?.value,
+      (data.fields?.targetSessionId as any)?.value,
+      true
+    )
+    if ('error' in target) {
+      cleanupTemp(tmpPath, tmpDir)
+      return reply.code(400).send({ error: target.error })
+    }
 
     reply.raw.writeHead(200, {
       'Content-Type': 'text/event-stream',
@@ -249,6 +287,8 @@ export function registerImportRoutes(
         formatId,
         chatIndex,
         sessionGapThreshold,
+        sessionId: target.target.sessionId,
+        forceCreate: target.target.forceCreate,
         nativeBinding,
         onProgress: (p) => sendEvent('progress', p),
       })
@@ -279,6 +319,7 @@ export function registerImportRoutes(
     const tmpDir = createChatLabTempDir('imports', 'batch-')
     const items: AutoImportBatchRequest[] = []
     let sessionGapThreshold: number | undefined
+    let targetMode: unknown
     let completed = false
     const controller = new AbortController()
     activeBatchControllers.set(batchId, controller)
@@ -289,6 +330,10 @@ export function registerImportRoutes(
           sessionGapThreshold = parseOptionalInteger(part.value)
           continue
         }
+        if (part.type === 'field' && part.fieldname === 'targetMode') {
+          targetMode = part.value
+          continue
+        }
         if (part.type !== 'file') continue
         const index = items.length
         const safeName = path.basename(part.filename || `upload-${index}`)
@@ -299,6 +344,12 @@ export function registerImportRoutes(
 
       if (items.length === 0) return reply.code(400).send({ error: 'No files uploaded' })
 
+      const target = resolveImportTarget(targetMode, undefined, false)
+      if ('error' in target) return reply.code(400).send({ error: target.error })
+      if (target.target.forceCreate) {
+        for (const item of items) item.forceCreate = true
+      }
+
       reply.raw.writeHead(200, {
         'Content-Type': 'text/event-stream',
         'Cache-Control': 'no-cache',
@@ -422,6 +473,37 @@ export function registerImportRoutes(
     }
   })
 
+  // Preview which target automatic matching would pick, so the import dialog can preselect it.
+  server.post('/_web/import/analyze-target', async (request, reply) => {
+    const data = await (request as any).file()
+    if (!data) return reply.code(400).send({ error: 'No file uploaded' })
+
+    const tmpDir = createChatLabTempDir('imports', 'analyze-target-')
+    const tmpPath = path.join(tmpDir, data.filename || 'upload')
+
+    const chunks: Buffer[] = []
+    for await (const chunk of data.file) {
+      chunks.push(chunk)
+    }
+    fs.writeFileSync(tmpPath, Buffer.concat(chunks))
+
+    const formatId = (data.fields?.formatId as any)?.value as string | undefined
+    const chatIndexStr = (data.fields?.chatIndex as any)?.value as string | undefined
+    const chatIndex = chatIndexStr !== undefined ? parseInt(chatIndexStr, 10) : undefined
+
+    try {
+      return await runAnalyzeAutoImport(tmpPath, {
+        formatId,
+        chatIndex,
+        nativeBinding: resolveNativeBinding(),
+      })
+    } catch (err) {
+      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) })
+    } finally {
+      cleanupTemp(tmpPath, tmpDir)
+    }
+  })
+
   // ==================== Incremental Import ====================
 
   server.post<{ Params: { id: string } }>('/_web/sessions/:id/import/incremental', async (request, reply) => {

diff --git a/apps/cli/src/import/command.test.ts b/apps/cli/src/import/command.test.ts
@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
-import { buildImportCommandEnvelope, withJsonDiagnosticsOnStderr } from './command'
+import { Command } from 'commander'
+import { buildImportCommandEnvelope, registerImportCommand, withJsonDiagnosticsOnStderr } from './command'
 
 test('buildImportCommandEnvelope exposes a stable dry-run success contract', () => {
   assert.deepEqual(
@@ -66,3 +67,37 @@ test('withJsonDiagnosticsOnStderr keeps runtime diagnostics out of machine-reada
   assert.deepEqual(stdout, [])
   assert.deepEqual(stderr, ['[Parser V2] Using parser: ChatLab JSON'])
 })
+
+test('import rejects --session-id together with --new-session before touching the data directory', async () => {
+  const program = new Command()
+  program.exitOverride()
+  registerImportCommand(program)
+
+  const stdout: string[] = []
+  const originalWrite = process.stdout.write.bind(process.stdout)
+  const originalExitCode = process.exitCode
+  process.stdout.write = ((chunk: string) => {
+    stdout.push(String(chunk))
+    return true
+  }) as typeof process.stdout.write
+
+  try {
+    await program.parseAsync(['import', 'missing-file.json', '--json', '--session-id', 'target', '--new-session'], {
+      from: 'user',
+    })
+  } finally {
+    process.stdout.write = originalWrite
+    process.exitCode = originalExitCode
+  }
+
+  assert.deepEqual(JSON.parse(stdout.join('')), {
+    ok: false,
+    command: 'import',
+    error: {
+      code: 'CONFLICTING_TARGET_OPTIONS',
+      message: 'Use either --session-id or --new-session, not both',
+      hint: '--session-id appends to an existing session; --new-session always creates a separate one.',
+    },
+    meta: { dryRun: false, apiVersion: 1 },
+  })
+})