@newpeak/barista-cli 0.2.197 → 0.2.199

package/dist/core/api/client.js

@@ -11505,7 +11505,12 @@ export const apiClient = {
             return extractApiError(error);
         }
     },
-    async uploadDocument(environment, tenant, filePath, categoryCode, businessData, remark, timeout) {
+    /// ========== ChunkedFileController — single file upload ==========
+    /**
+     * Upload a file via ChunkedFileController (/enterprise/files/upload).
+     * X-TENANT-ID is injected by nginx — no client header needed.
+     */
+    async uploadFileToStorage(environment, tenant, filePath, timeout) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
@@ -11517,23 +11522,13 @@ export const apiClient = {
             const FormData = (await import('form-data')).default;
             const formData = new FormData();
             formData.append('file', createReadStream(filePath), basename(filePath));
-            if (categoryCode)
-                formData.append('categoryCode', categoryCode);
-            if (businessData)
-                formData.append('businessData', businessData);
-            if (remark)
-                formData.append('remark', remark);
-            const axiosConfig = {
-                headers: formData.getHeaders(),
-            };
-            if (timeout !== undefined) {
+            const axiosConfig = { headers: formData.getHeaders() };
+            if (timeout !== undefined)
                 axiosConfig.timeout = timeout;
-            }
-            const response = await client.getClient().post('/api/enterprise/document/upload', formData, axiosConfig);
+            const response = await client.getClient().post('/api/enterprise/files/upload', formData, axiosConfig);
             const body = response.data;
-            if (body && body.code === '00000') {
+            if (body && body.code === '00000')
                 return { success: true, data: body.data };
-            }
             return {
                 success: false,
                 error: { code: body?.code || 'UNKNOWN', message: JSON.stringify(body?.data) || 'Upload failed' },
@@ -11543,40 +11538,215 @@ export const apiClient = {
             return extractApiError(error);
         }
     },
-    async uploadSysFile(environment, tenant, filePath, secretFlag = 'N', timeout) {
+    /// ========== DocumentController — save document metadata ==========
+    /**
+     * Save a document record associating an uploaded file with a category.
+     * POST /api/enterprise/document/save
+     */
+    async saveDocument(environment, tenant, params, timeout) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
                 return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const { createReadStream } = await import('node:fs');
-            const { basename } = await import('node:path');
-            const FormData = (await import('form-data')).default;
-            const formData = new FormData();
-            formData.append('file', createReadStream(filePath), basename(filePath));
-            formData.append('secretFlag', secretFlag);
-            const axiosConfig = {
-                headers: formData.getHeaders(),
+            const payload = {
+                fileId: params.fileId, fileName: params.fileName, fileSize: params.fileSize,
             };
-            if (timeout !== undefined) {
+            if (params.fileType)
+                payload.fileType = params.fileType;
+            if (params.categoryCode)
+                payload.categoryCode = params.categoryCode;
+            if (params.businessData)
+                payload.businessData = params.businessData;
+            if (params.remark)
+                payload.remark = params.remark;
+            const axiosConfig = { headers: { 'Content-Type': 'application/json' } };
+            if (timeout !== undefined)
                 axiosConfig.timeout = timeout;
-            }
-            const response = await client.getClient().post('/api/sysFileInfo/upload', formData, axiosConfig);
+            const response = await client.getClient().post('/api/enterprise/document/save', payload, axiosConfig);
             const body = response.data;
-            // Roses framework returns { code, data } — normalize to CLI's { success, data }
-            if (body && body.code === '00000') {
+            if (body && body.code === '00000')
                 return { success: true, data: body.data };
-            }
             return {
                 success: false,
-                error: { code: body?.code || 'UNKNOWN', message: JSON.stringify(body?.data) || 'Upload failed' },
+                error: { code: body?.code || 'UNKNOWN', message: JSON.stringify(body?.data) || 'Save document failed' },
             };
         }
         catch (error) {
             return extractApiError(error);
         }
     },
+    /// ========== Two-step document upload (upload file + save document metadata) ==========
+    async uploadDocument(environment, tenant, filePath, categoryCode, businessData, remark, timeout) {
+        const uploadResult = await this.uploadFileToStorage(environment, tenant, filePath, timeout);
+        if (!uploadResult.success)
+            return uploadResult;
+        const { fileId, fileName, fileSize } = uploadResult.data;
+        const fileSuffix = fileName.includes('.') ? fileName.split('.').pop() : undefined;
+        return this.saveDocument(environment, tenant, {
+            fileId, fileName, fileSize, fileType: fileSuffix,
+            categoryCode, businessData, remark,
+        }, timeout);
+    },
+    /// ========== Simple file upload (via ChunkedFileController, backward compat) ==========
+    async uploadSysFile(environment, tenant, filePath, _secretFlag = 'N', timeout) {
+        return this.uploadFileToStorage(environment, tenant, filePath, timeout);
+    },
+    /// ========== Chunked upload ==========
+    async initChunkUpload(environment, tenant, fileName, fileSize, chunkSize) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const params = new URLSearchParams({ fileName, fileSize: String(fileSize) });
+            if (chunkSize)
+                params.append('chunkSize', String(chunkSize));
+            const response = await client.getClient().post(`/api/enterprise/files/chunk/init?${params.toString()}`, null);
+            const body = response.data;
+            if (body && body.code === '00000')
+                return { success: true, data: body.data };
+            return { success: false, error: { code: body?.code || 'UNKNOWN', message: 'Init chunk upload failed' } };
+        }
+        catch (error) {
+            return extractApiError(error);
+        }
+    },
+    async uploadChunk(environment, tenant, uploadId, index, chunkFilePath, timeout) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const { createReadStream } = await import('node:fs');
+            const FormData = (await import('form-data')).default;
+            const formData = new FormData();
+            formData.append('uploadId', uploadId);
+            formData.append('index', String(index));
+            formData.append('file', createReadStream(chunkFilePath), `chunk-${index}`);
+            const axiosConfig = { headers: formData.getHeaders() };
+            if (timeout !== undefined)
+                axiosConfig.timeout = timeout;
+            const response = await client.getClient().post('/api/enterprise/files/chunk/upload', formData, axiosConfig);
+            const body = response.data;
+            if (body && body.code === '00000')
+                return { success: true, data: body.data };
+            return { success: false, error: { code: body?.code || 'UNKNOWN', message: 'Chunk upload failed' } };
+        }
+        catch (error) {
+            return extractApiError(error);
+        }
+    },
+    async completeChunkUpload(environment, tenant, uploadId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/files/chunk/complete?uploadId=${uploadId}`, null);
+            const body = response.data;
+            if (body && body.code === '00000')
+                return { success: true, data: body.data };
+            return { success: false, error: { code: body?.code || 'UNKNOWN', message: 'Complete chunk upload failed' } };
+        }
+        catch (error) {
+            return extractApiError(error);
+        }
+    },
+    async getChunkUploadStatus(environment, tenant, uploadId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/files/chunk/complete/status?uploadId=${uploadId}`);
+            const body = response.data;
+            if (body && body.code === '00000')
+                return { success: true, data: body.data };
+            return { success: false, error: { code: body?.code || 'UNKNOWN', message: 'Get chunk status failed' } };
+        }
+        catch (error) {
+            return extractApiError(error);
+        }
+    },
+    /**
+     * Complete chunked upload flow: init → upload all chunks → complete → poll until COMPLETED.
+     * Max poll time: 10 minutes (600s).
+     */
+    async uploadFileChunked(environment, tenant, filePath, timeout) {
+        const { statSync, openSync, readSync, writeFileSync, closeSync, rmSync, mkdtempSync } = await import('node:fs');
+        const { basename, join } = await import('node:path');
+        const { tmpdir } = await import('node:os');
+        const stats = statSync(filePath);
+        const fileName = basename(filePath);
+        const fileSize = stats.size;
+        const chunkSize = 5 * 1024 * 1024;
+        const initResult = await this.initChunkUpload(environment, tenant, fileName, fileSize, chunkSize);
+        if (!initResult.success)
+            return initResult;
+        const { uploadId, chunkCount } = initResult.data;
+        const chunkDir = mkdtempSync(join(tmpdir(), 'barista-chunk-'));
+        try {
+            const fd = openSync(filePath, 'r');
+            const buffer = Buffer.alloc(chunkSize);
+            // Pre-write all chunks to temp files
+            const chunkFiles = [];
+            for (let i = 0; i < chunkCount; i++) {
+                const bytesRead = readSync(fd, buffer, 0, chunkSize, i * chunkSize);
+                const chunkFile = join(chunkDir, `chunk-${i}`);
+                writeFileSync(chunkFile, buffer.subarray(0, bytesRead));
+                chunkFiles.push(chunkFile);
+            }
+            closeSync(fd);
+            // Upload chunks in batches of 3 (like Android OTG_CHUNK_CONCURRENCY)
+            const CONCURRENCY = 3;
+            let chunkError = null;
+            for (let start = 0; start < chunkCount && !chunkError; start += CONCURRENCY) {
+                const end = Math.min(start + CONCURRENCY, chunkCount);
+                const promises = [];
+                for (let i = start; i < end; i++) {
+                    const idx = i;
+                    promises.push(this.uploadChunk(environment, tenant, uploadId, idx, chunkFiles[idx], timeout)
+                        .then((r) => {
+                        if (!r.success && !chunkError) {
+                            chunkError = `Chunk ${idx + 1}/${chunkCount} upload failed: ${r.error?.message || 'unknown'}`;
+                        }
+                    }));
+                }
+                await Promise.all(promises);
+            }
+            if (chunkError) {
+                return { success: false, error: { code: 'CHUNK_UPLOAD_FAILED', message: chunkError } };
+            }
+            const completeResult = await this.completeChunkUpload(environment, tenant, uploadId);
+            if (!completeResult.success)
+                return completeResult;
+            const maxAttempts = 60;
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                await new Promise(r => setTimeout(r, 10000));
+                const statusResult = await this.getChunkUploadStatus(environment, tenant, uploadId);
+                if (!statusResult.success)
+                    continue;
+                const s = statusResult.data;
+                if (s.status === 'COMPLETED')
+                    return { success: true, data: { fileId: s.fileId, fileName: s.fileName || fileName, fileSize: s.fileSize || fileSize } };
+                if (s.status === 'FAILED')
+                    return { success: false, error: { code: 'CHUNK_UPLOAD_FAILED', message: s.errorMessage || 'Chunk upload failed' } };
+            }
+            return { success: false, error: { code: 'CHUNK_UPLOAD_TIMEOUT', message: 'Chunk upload timed out after 10 minutes' } };
+        }
+        finally {
+            try {
+                rmSync(chunkDir, { recursive: true, force: true });
+            }
+            catch { /* cleanup best-effort */ }
+        }
+    },
     async getHrsSkillDefinitions(environment, tenant) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });