| import { createReadStream, type ReadStream } from 'node:fs'; |
| import { mkdtemp, rm, stat } from 'node:fs/promises'; |
| import type { ServerResponse } from 'node:http'; |
| import { tmpdir } from 'node:os'; |
| import { join } from 'node:path'; |
|
|
| import { |
| ErrorCodes, |
| ILogService, |
| ISessionExportService, |
| isError2, |
| type Scope, |
| } from '@moonshot-ai/agent-core-v2'; |
| import type { KimiHostIdentity } from '@moonshot-ai/kimi-code-oauth'; |
|
|
| import { requestLog } from '../lib/requestLog'; |
| import { defineRoute } from '../middleware/defineRoute'; |
| import { ErrorCode } from '../protocol/error-codes'; |
| import { errEnvelope } from '../protocol/envelope'; |
| import { |
| exportSessionParamsSchema, |
| exportSessionRequestSchema, |
| } from '../protocol/rest-session'; |
|
|
| interface SessionExportRouteHost { |
| post( |
| path: string, |
| options: { preHandler: unknown[]; schema?: Record<string, unknown> }, |
| handler: (req: unknown, reply: SessionExportReply) => unknown, |
| ): unknown; |
| } |
|
|
| interface SessionExportReply { |
| readonly raw: ServerResponse; |
| type(mime: string): SessionExportReply; |
| header(name: string, value: string | number): SessionExportReply; |
| send(payload: unknown): unknown; |
| } |
|
|
| export function registerSessionExportRoute( |
| app: SessionExportRouteHost, |
| core: Scope, |
| options: { readonly hostIdentity: KimiHostIdentity }, |
| ): void { |
| const log = core.accessor.get(ILogService); |
| const route = defineRoute( |
| { |
| method: 'POST', |
| path: '/sessions/{session_id}/export', |
| params: exportSessionParamsSchema, |
| body: exportSessionRequestSchema, |
| rawResponse: { |
| 200: { type: 'string', format: 'binary' }, |
| }, |
| errors: { |
| [ErrorCode.VALIDATION_FAILED]: {}, |
| [ErrorCode.SESSION_NOT_FOUND]: {}, |
| [ErrorCode.INTERNAL_ERROR]: {}, |
| }, |
| description: 'Export a session and diagnostic logs as a zip archive', |
| tags: ['sessions'], |
| }, |
| async (req, reply) => { |
| const response = reply as unknown as SessionExportReply; |
| let aborted = false; |
| let responseStream: ReadStream | undefined; |
| let streaming = false; |
| let tempDir: string | undefined; |
| let cleanupPromise: Promise<void> | undefined; |
| const exportAbort = new AbortController(); |
|
|
| const onResponseClose = (): void => { |
| if (response.raw.writableFinished) return; |
| aborted = true; |
| exportAbort.abort(); |
| responseStream?.destroy(); |
| }; |
| response.raw.once('close', onResponseClose); |
|
|
| const cleanup = async (): Promise<void> => { |
| if (tempDir === undefined) return; |
| cleanupPromise ??= rm(tempDir, { |
| recursive: true, |
| force: true, |
| maxRetries: 3, |
| retryDelay: 50, |
| }).catch((error: unknown) => { |
| log.warn('session export temporary directory cleanup failed', { |
| error, |
| requestId: req.id, |
| tempDir, |
| }); |
| }); |
| await cleanupPromise; |
| }; |
|
|
| try { |
| if (aborted) return; |
|
|
| const safeSessionId = sanitizeSessionId(req.params.session_id); |
| tempDir = await mkdtemp(join(tmpdir(), `kimi-session-export-${safeSessionId}-`)); |
| if (aborted) { |
| await cleanup(); |
| return; |
| } |
|
|
| const outputPath = join(tempDir, 'session.zip'); |
| await core.accessor.get(ISessionExportService).export( |
| { |
| sessionId: req.params.session_id, |
| outputPath, |
| includeGlobalLog: true, |
| includeDesktopLog: req.body.desktop === true, |
| version: options.hostIdentity.version, |
| desktopVersion: |
| req.body.desktop === true ? options.hostIdentity.version : undefined, |
| }, |
| { |
| webLog: req.body.web_log, |
| signal: exportAbort.signal, |
| }, |
| ); |
| if (aborted) { |
| await cleanup(); |
| return; |
| } |
|
|
| const archive = await stat(outputPath); |
| if (aborted) { |
| await cleanup(); |
| return; |
| } |
|
|
| responseStream = createReadStream(outputPath); |
| responseStream.once('close', () => { |
| response.raw.off('close', onResponseClose); |
| void cleanup(); |
| }); |
|
|
| const sent = response |
| .type('application/zip') |
| .header( |
| 'content-disposition', |
| `attachment; filename="kimi-session-${safeSessionId}.zip"`, |
| ) |
| .header('content-length', archive.size) |
| .header('cache-control', 'no-store') |
| .send(responseStream); |
| streaming = true; |
| return sent as void; |
| } catch (error) { |
| const stream = responseStream; |
| if (stream !== undefined && !stream.closed) { |
| const closed = new Promise<void>((resolve) => { |
| stream.once('close', resolve); |
| }); |
| stream.destroy(); |
| await closed; |
| } else { |
| stream?.destroy(); |
| } |
| await cleanup(); |
| if (!aborted) sendMappedError(response, req, error); |
| } finally { |
| if (!streaming) response.raw.off('close', onResponseClose); |
| } |
| }, |
| ); |
|
|
| app.post( |
| route.path, |
| route.options, |
| route.handler as unknown as Parameters<SessionExportRouteHost['post']>[2], |
| ); |
| } |
|
|
| function sanitizeSessionId(sessionId: string): string { |
| return sessionId.replaceAll(/[^A-Za-z0-9_-]/g, '_').slice(0, 48) || 'session'; |
| } |
|
|
| function sendMappedError(reply: SessionExportReply, req: { id: string }, error: unknown): void { |
| const requestId = req.id; |
| if (isError2(error)) { |
| if (error.code === ErrorCodes.SESSION_NOT_FOUND) { |
| reply.send(errEnvelope(ErrorCode.SESSION_NOT_FOUND, error.message, requestId)); |
| return; |
| } |
| } |
| requestLog(req)?.error({ err: error }, 'session export failed'); |
| reply.send( |
| errEnvelope( |
| ErrorCode.INTERNAL_ERROR, |
| error instanceof Error ? error.message : 'internal error', |
| requestId, |
| ), |
| ); |
| } |
|
|
