tabby-bianbu-mcp 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to `tabby-bianbu-mcp` will be documented in this file.
 
+## [0.5.0] - 2026-03-19
+
+### Added
+- 32-slot MCP request scheduler with 2 interactive lanes and up to 30 transfer lanes
+- single-active-file queue so multiple file transfers run one file at a time
+- explicit worker cadence setting for 100 ms dispatch cycles
+- parallel offset-based chunk transfer support between the Tabby client and remote Bianbu MCP server
+
+### Changed
+- upload chunk default changed to 32 KiB
+- download chunk default changed to 128 KiB
+- downloads now stream into Tabby's native download sink instead of browser Blob URLs
+- remote installer now raises the Express JSON body limit explicitly and reports parallel chunk capability in health
+
 ## [0.4.0] - 2026-03-19
 
 ### Added

package/README.md

@@ -14,6 +14,9 @@ It adds a dedicated Bianbu MCP settings page, a shell-like terminal tab, a file
 - packaged remote installer asset with SHA-256 metadata and integrity verification
 - push latest installer to the remote host and trigger `up` or `repair`
 - chunked upload and download support for larger files
+- 32-slot request scheduling with 2 reserved interactive lanes and up to 30 transfer lanes
+- one active file transfer at a time with queued follow-up uploads/downloads
+- parallel offset-based file chunk transfers against the matching remote installer
 - atomic rename support through MCP `rename_path`
 - remote backup and `restore-latest` recovery support in the installer
 
@@ -37,9 +40,13 @@ The plugin stores these main settings under `bianbuMcp`:
 - `name`
 - `url`
 - `apiKey`
-- `minIntervalMs`
+- `interactiveConcurrency`
+- `transferConcurrency`
+- `workerCadenceMs`
 - `maxRetries`
 - `retryBaseMs`
+- `uploadChunkBytes`
+- `downloadChunkBytes`
 - `notes`
 - `installerRemotePath`
 - `maintenanceAsRoot`

package/assets/bianbu_agent_proxy.meta.json

@@ -3,7 +3,7 @@
   "sourceFile": "bianbu_agent_proxy.sh",
   "scriptVersion": "1.2.0",
   "serverVersion": "1.2.0",
-  "sha256": "d4f21b824acf3f73356977706da8c5917ec7832903ba1d2312322cead4f8c69f",
-  "bytes": 56914,
-  "generatedAt": "2026-03-19T06:19:56.738Z"
+  "sha256": "62c492d026fe0e16e007d9f0bbeeaedfcbd55b457ca357a8d137aff9a24ce594",
+  "bytes": 63063,
+  "generatedAt": "2026-03-19T11:00:34.100Z"
 }

package/assets/bianbu_agent_proxy.sh

@@ -92,6 +92,7 @@ MCP tools:
   ENABLE_PASSWORDLESS_SUDO  bootstrap 时为 RUN_USER 自动配置 sudo 免密码，默认: ${ENABLE_PASSWORDLESS_SUDO}
   MAX_FILE_MB            上传/下载单文件大小限制，默认: ${MAX_FILE_MB} MB
   MAX_COMMAND_OUTPUT_KB  命令输出截断上限，默认: ${MAX_COMMAND_OUTPUT_KB} KB
+  MAX_REQUEST_BODY_MB    HTTP JSON 请求体上限，默认: ${MAX_REQUEST_BODY_MB} MB
   TLS_CERT_FILE          可选，HTTPS 证书路径
   TLS_KEY_FILE           可选，HTTPS 私钥路径
 
@@ -345,6 +346,7 @@ write_package() {
   "type": "module",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.27.1",
+    "express": "^5.2.1",
     "zod": "^4.0.0"
   }
 }
@@ -361,7 +363,7 @@ import path from 'node:path';
 import http from 'node:http';
 import https from 'node:https';
 
-import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+import express from 'express';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
@@ -400,6 +402,9 @@ const FILE_ROOT = path.resolve(process.env.FILE_ROOT || '/');
 const ENABLE_PASSWORDLESS_SUDO=(process.env.ENABLE_PASSWORDLESS_SUDO || 'true').toLowerCase() === 'true';
 const MAX_FILE_BYTES = Number(process.env.MAX_FILE_MB || '64') * 1024 * 1024;
 const MAX_COMMAND_OUTPUT_BYTES = Number(process.env.MAX_COMMAND_OUTPUT_KB || '256') * 1024;
+const MAX_REQUEST_BODY_MB = Number(process.env.MAX_REQUEST_BODY_MB || '8');
+const MAX_REQUEST_BODY_BYTES = MAX_REQUEST_BODY_MB * 1024 * 1024;
+const EXPRESS_JSON_LIMIT = `${MAX_REQUEST_BODY_MB}mb`;
 const TLS_CERT_FILE = process.env.TLS_CERT_FILE || '';
 const TLS_KEY_FILE = process.env.TLS_KEY_FILE || '';
 const MCP_TRANSPORT_MODE = (process.env.MCP_TRANSPORT_MODE || 'stateless').toLowerCase();
@@ -413,6 +418,9 @@ const SESSION_IDLE_MS = 60 * 60 * 1000;
 if (!['stateless', 'stateful'].includes(MCP_TRANSPORT_MODE)) {
   throw new Error(`Unsupported MCP_TRANSPORT_MODE: ${MCP_TRANSPORT_MODE}`);
 }
+if (!(MAX_REQUEST_BODY_MB > 0)) {
+  throw new Error(`MAX_REQUEST_BODY_MB must be > 0, got ${MAX_REQUEST_BODY_MB}`);
+}
 
 function textResult(text, structuredContent = undefined) {
   const result = { content: [{ type: 'text', text }] };
@@ -451,6 +459,14 @@ def stat_dict(p):
         'is_file': stat.S_ISREG(st.st_mode),
     }
 
+def ensure_parent(p):
+    parent = os.path.dirname(p) or '.'
+    os.makedirs(parent, exist_ok=True)
+
+def part_offset_from_name(name):
+    stem = name.rsplit('.', 1)[0]
+    return int(stem)
+
 if op == 'list_directory':
     if not os.path.isdir(target):
         raise RuntimeError(f'not a directory: {target}')
@@ -465,7 +481,7 @@ elif op == 'read_text_file':
     with open(target, 'r', encoding=payload.get('encoding', 'utf-8')) as fh:
         print(json.dumps({'path': target, 'content': fh.read()}, ensure_ascii=False))
 elif op == 'write_text_file':
-    os.makedirs(os.path.dirname(target), exist_ok=True)
+    ensure_parent(target)
     if (not payload.get('overwrite', True)) and os.path.exists(target):
         raise RuntimeError(f'target exists and overwrite=false: {target}')
     fd, tmp_path = tempfile.mkstemp(prefix='.mcp-write-', dir=os.path.dirname(target) or '.')
@@ -482,7 +498,7 @@ elif op == 'upload_binary_file':
     data = base64.b64decode(payload['content_base64'])
     if len(data) > int(payload['max_file_bytes']):
         raise RuntimeError(f"payload exceeds max size {payload['max_file_bytes']} bytes")
-    os.makedirs(os.path.dirname(target), exist_ok=True)
+    ensure_parent(target)
     if (not payload.get('overwrite', True)) and os.path.exists(target):
         raise RuntimeError(f'target exists and overwrite=false: {target}')
     fd, tmp_path = tempfile.mkstemp(prefix='.mcp-bin-', dir=os.path.dirname(target) or '.')
@@ -495,15 +511,15 @@ elif op == 'upload_binary_file':
         if os.path.exists(tmp_path):
             os.unlink(tmp_path)
     print(json.dumps(stat_dict(target), ensure_ascii=False))
-elif op == 'append_binary_file':
+elif op == 'write_binary_part':
     data = base64.b64decode(payload['content_base64'])
     if len(data) > int(payload['max_file_bytes']):
         raise RuntimeError(f"payload exceeds max size {payload['max_file_bytes']} bytes")
-    os.makedirs(os.path.dirname(target), exist_ok=True)
-    with open(target, 'ab') as fh:
+    ensure_parent(target)
+    with open(target, 'wb') as fh:
         fh.write(data)
     out = stat_dict(target)
-    out['appended'] = len(data)
+    out['written'] = len(data)
     print(json.dumps(out, ensure_ascii=False))
 elif op == 'download_binary_file':
     if not os.path.isfile(target):
@@ -538,13 +554,48 @@ elif op == 'delete_path':
     print(json.dumps(info, ensure_ascii=False))
 elif op == 'rename_path':
     dest = payload['dest']
-    os.makedirs(os.path.dirname(dest), exist_ok=True)
+    ensure_parent(dest)
     os.replace(target, dest)
     print(json.dumps(stat_dict(dest), ensure_ascii=False))
 elif op == 'path_info':
     if not os.path.exists(target):
         raise RuntimeError(f'path not found: {target}')
     print(json.dumps(stat_dict(target), ensure_ascii=False))
+elif op == 'merge_binary_parts':
+    if not os.path.isdir(target):
+        raise RuntimeError(f'parts directory not found: {target}')
+    dest = payload['dest']
+    expected_size = payload.get('expected_size')
+    ensure_parent(dest)
+    part_entries = []
+    for name in os.listdir(target):
+        full = os.path.join(target, name)
+        if not os.path.isfile(full):
+            continue
+        part_entries.append((part_offset_from_name(name), os.path.getsize(full), full))
+    part_entries.sort(key=lambda entry: entry[0])
+    cursor = 0
+    for offset, size, _full in part_entries:
+        if offset != cursor:
+            raise RuntimeError(f'missing or overlapping part at offset={offset}, expected={cursor}')
+        cursor += size
+    if expected_size is not None and cursor != int(expected_size):
+        raise RuntimeError(f'merged size {cursor} does not match expected_size={expected_size}')
+    fd, tmp_path = tempfile.mkstemp(prefix='.mcp-merge-', dir=os.path.dirname(dest) or '.')
+    os.close(fd)
+    try:
+        with open(tmp_path, 'wb') as out:
+            for _offset, _size, full in part_entries:
+                with open(full, 'rb') as src:
+                    shutil.copyfileobj(src, out, 1024 * 1024)
+        os.replace(tmp_path, dest)
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+    out = stat_dict(dest)
+    out['merged_parts'] = len(part_entries)
+    out['merged_bytes'] = cursor
+    print(json.dumps(out, ensure_ascii=False))
 elif op == 'read_binary_chunk':
     if not os.path.isfile(target):
         raise RuntimeError(f'file not found: {target}')
@@ -642,6 +693,13 @@ function newSessionId(prefix) {
   return `${prefix}-${randomUUID()}`;
 }
 
+async function cleanupUploadSession(session) {
+  if (!session?.temp_dir) {
+    return;
+  }
+  await deleteAnyPath(session.temp_dir, true, session.as_root).catch(() => {});
+}
+
 function sweepSessions() {
   const now = Date.now();
   for (const [id, entry] of shellSessions.entries()) {
@@ -651,6 +709,7 @@ function sweepSessions() {
   }
   for (const [id, entry] of uploadSessions.entries()) {
     if (now - entry.updatedAt > SESSION_IDLE_MS) {
+      cleanupUploadSession(entry).catch(() => {});
       uploadSessions.delete(id);
     }
   }
@@ -704,17 +763,51 @@ async function runCommandWithContext(command, { cwd='.', timeoutSeconds=120, asR
   }
 }
 
-async function appendBinaryChunk(target, contentBase64, asRoot) {
+async function writeBinaryPart(target, contentBase64, asRoot) {
   if (asRoot) {
-    return runRootFileOp({ op: 'append_binary_file', path: target, content_base64: contentBase64, max_file_bytes: MAX_FILE_BYTES });
+    return runRootFileOp({ op: 'write_binary_part', path: target, content_base64: contentBase64, max_file_bytes: MAX_FILE_BYTES });
   }
   const data = Buffer.from(contentBase64, 'base64');
   if (data.length > MAX_FILE_BYTES) {
     throw new Error(`payload exceeds max size ${MAX_FILE_BYTES} bytes`);
   }
   await fs.promises.mkdir(path.dirname(target), { recursive: true });
-  await fs.promises.appendFile(target, data);
-  return fileStat(target);
+  await fs.promises.writeFile(target, data);
+  const info = await fileStat(target);
+  return { ...info, written: data.length };
+}
+
+async function mergeBinaryParts(partsDir, dest, expectedSize, asRoot) {
+  if (asRoot) {
+    return runRootFileOp({ op: 'merge_binary_parts', path: partsDir, dest, expected_size: expectedSize });
+  }
+  const names = (await fs.promises.readdir(partsDir))
+    .filter((name) => /^\d+\.part$/.test(name))
+    .sort((a, b) => Number(a.split('.', 1)[0]) - Number(b.split('.', 1)[0]));
+  let cursor = 0;
+  await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+  const tempPath = `${dest}.tmp-${randomBytes(6).toString('hex')}`;
+  const out = await fs.promises.open(tempPath, 'w');
+  try {
+    for (const name of names) {
+      const offset = Number(name.split('.', 1)[0]);
+      const full = path.join(partsDir, name);
+      const data = await fs.promises.readFile(full);
+      if (offset !== cursor) {
+        throw new Error(`missing or overlapping part at offset=${offset}, expected=${cursor}`);
+      }
+      await out.write(data, 0, data.length, offset);
+      cursor += data.length;
+    }
+  } finally {
+    await out.close();
+  }
+  if (expectedSize !== null && expectedSize !== undefined && cursor !== expectedSize) {
+    await fs.promises.rm(tempPath, { force: true });
+    throw new Error(`merged size ${cursor} does not match expected_size=${expectedSize}`);
+  }
+  const info = await renameAnyPath(tempPath, dest, false);
+  return { ...info, merged_parts: names.length, merged_bytes: cursor };
 }
 
 async function statAnyPath(target, asRoot) {
@@ -785,16 +878,24 @@ function makeServer() {
         file_root: FILE_ROOT,
         max_file_bytes: MAX_FILE_BYTES,
         max_command_output_bytes: MAX_COMMAND_OUTPUT_BYTES,
+        max_request_body_bytes: MAX_REQUEST_BODY_BYTES,
         transport_mode: MCP_TRANSPORT_MODE,
         running_uid: process.getuid(),
         has_sudo: HAS_SUDO,
         passwordless_sudo_expected: ENABLE_PASSWORDLESS_SUDO,
+        session_idle_ms: SESSION_IDLE_MS,
+        logical_session_limits: {
+          shell: null,
+          upload: null,
+          download: null,
+        },
         script_version: INSTALLER_SCRIPT_VERSION,
         server_version: SERVER_VERSION,
         service_name: 'bianbu-mcp-server',
         tools: SUPPORTED_TOOLS,
         supports: {
           chunked_transfers: true,
+          parallel_chunk_offsets: true,
           rename_path: true,
           shell_session: true,
         },
@@ -1133,21 +1234,42 @@ function makeServer() {
       inputSchema: {
         path: z.string(),
         overwrite: z.boolean().default(true),
+        total_size: z.number().int().nonnegative().optional(),
+        chunk_bytes: z.number().int().positive().max(MAX_FILE_BYTES).optional(),
         as_root: z.boolean().default(false),
       },
     },
-    async ({ path: inputPath, overwrite, as_root }) => {
+    async ({ path: inputPath, overwrite, total_size, chunk_bytes, as_root }) => {
       const target = await resolveRequestedPath(inputPath, as_root);
+      const targetExists = await statAnyPath(target, as_root).then(() => true).catch(() => false);
+      if (!overwrite && targetExists) {
+        throw new Error(`target exists and overwrite=false: ${target}`);
+      }
       const upload_id = newSessionId('upload');
-      const temp_path = `${target}.upload-${randomBytes(6).toString('hex')}`;
+      const temp_dir = `${target}.upload-${randomBytes(6).toString('hex')}`;
+      const parts_dir = path.join(temp_dir, 'parts');
+      const merge_path = path.join(temp_dir, 'merged.bin');
       if (as_root) {
-        await runRootFileOp({ op: 'upload_binary_file', path: temp_path, content_base64: '', overwrite: true, max_file_bytes: MAX_FILE_BYTES });
+        await runRootFileOp({ op: 'make_directory', path: parts_dir, parents: true });
       } else {
-        await fs.promises.mkdir(path.dirname(temp_path), { recursive: true });
-        await fs.promises.writeFile(temp_path, Buffer.alloc(0));
+        await fs.promises.mkdir(parts_dir, { recursive: true });
       }
-      uploadSessions.set(upload_id, { upload_id, target, temp_path, overwrite, as_root, bytes_received: 0, updatedAt: Date.now() });
-      const payload = { upload_id, path: target, temp_path, overwrite, as_root, bytes_received: 0 };
+      uploadSessions.set(upload_id, {
+        upload_id,
+        target,
+        temp_dir,
+        parts_dir,
+        merge_path,
+        overwrite,
+        as_root,
+        total_size: total_size ?? null,
+        chunk_bytes: chunk_bytes ?? null,
+        bytes_received: 0,
+        next_offset: 0,
+        parts: new Map(),
+        updatedAt: Date.now(),
+      });
+      const payload = { upload_id, path: target, temp_dir, parts_dir, overwrite, as_root, total_size: total_size ?? null, chunk_bytes: chunk_bytes ?? null, bytes_received: 0 };
       return textResult(JSON.stringify(payload, null, 2), payload);
     },
   );
@@ -1155,22 +1277,28 @@ function makeServer() {
   server.registerTool(
     'upload_chunked_part',
     {
-      description: 'Append a base64 chunk to an upload session.',
+      description: 'Write a base64 chunk to an upload session, optionally at an explicit offset for parallel uploads.',
       inputSchema: {
         upload_id: z.string(),
         content_base64: z.string(),
+        offset: z.number().int().nonnegative().optional(),
       },
     },
-    async ({ upload_id, content_base64 }) => {
+    async ({ upload_id, content_base64, offset }) => {
       const session = uploadSessions.get(upload_id);
       if (!session) {
         throw new Error(`unknown upload session: ${upload_id}`);
       }
-      const stat = await appendBinaryChunk(session.temp_path, content_base64, session.as_root);
-      const appended = Buffer.from(content_base64, 'base64').length;
-      session.bytes_received += appended;
+      const chunkSize = Buffer.from(content_base64, 'base64').length;
+      const effectiveOffset = offset ?? session.next_offset;
+      const partPath = path.join(session.parts_dir, `${effectiveOffset}.part`);
+      const stat = await writeBinaryPart(partPath, content_base64, session.as_root);
+      const previousSize = session.parts.get(effectiveOffset) ?? 0;
+      session.parts.set(effectiveOffset, chunkSize);
+      session.bytes_received += chunkSize - previousSize;
+      session.next_offset = Math.max(session.next_offset, effectiveOffset + chunkSize);
       session.updatedAt = Date.now();
-      const payload = { upload_id, bytes_received: session.bytes_received, temp_path: session.temp_path, stat };
+      const payload = { upload_id, offset: effectiveOffset, part_size: chunkSize, bytes_received: session.bytes_received, parts_dir: session.parts_dir, stat };
       return textResult(JSON.stringify(payload, null, 2), payload);
     },
   );
@@ -1188,9 +1316,11 @@ function makeServer() {
       if (!session) {
         throw new Error(`unknown upload session: ${upload_id}`);
       }
-      const info = await renameAnyPath(session.temp_path, session.target, session.as_root);
+      const merged = await mergeBinaryParts(session.parts_dir, session.merge_path, session.total_size, session.as_root);
+      const info = await renameAnyPath(session.merge_path, session.target, session.as_root);
+      await cleanupUploadSession(session);
       uploadSessions.delete(upload_id);
-      const payload = { upload_id, ok: true, ...info };
+      const payload = { upload_id, ok: true, merged_parts: merged.merged_parts ?? session.parts.size, merged_bytes: merged.merged_bytes ?? session.bytes_received, ...info };
       return textResult(JSON.stringify(payload, null, 2), payload);
     },
   );
@@ -1208,7 +1338,7 @@ function makeServer() {
       if (!session) {
         throw new Error(`unknown upload session: ${upload_id}`);
       }
-      await deleteAnyPath(session.temp_path, false, session.as_root).catch(() => {});
+      await cleanupUploadSession(session);
       uploadSessions.delete(upload_id);
       const payload = { upload_id, ok: true };
       return textResult(JSON.stringify(payload, null, 2), payload);
@@ -1241,21 +1371,27 @@ function makeServer() {
   server.registerTool(
     'download_chunked_part',
     {
-      description: 'Read the next chunk from a download session.',
+      description: 'Read a chunk from a download session. If offset is provided, supports parallel range-style reads.',
       inputSchema: {
         download_id: z.string(),
+        offset: z.number().int().nonnegative().optional(),
+        chunk_bytes: z.number().int().positive().max(MAX_FILE_BYTES).optional(),
       },
     },
-    async ({ download_id }) => {
+    async ({ download_id, offset, chunk_bytes }) => {
       const session = downloadSessions.get(download_id);
       if (!session) {
         throw new Error(`unknown download session: ${download_id}`);
       }
-      const payload = await readBinaryChunk(session.target, session.offset, session.chunk_bytes, session.as_root);
-      session.offset += payload.bytes_read;
+      const effectiveOffset = offset ?? session.offset;
+      const effectiveChunkBytes = chunk_bytes ?? session.chunk_bytes;
+      const payload = await readBinaryChunk(session.target, effectiveOffset, effectiveChunkBytes, session.as_root);
+      if (offset === undefined) {
+        session.offset = effectiveOffset + payload.bytes_read;
+      }
       session.updatedAt = Date.now();
       payload.download_id = download_id;
-      payload.next_offset = session.offset;
+      payload.next_offset = effectiveOffset + payload.bytes_read;
       return textResult(JSON.stringify({ ...payload, content_base64: `[base64:${payload.bytes_read} bytes]` }, null, 2), payload);
     },
   );
@@ -1278,7 +1414,8 @@ function makeServer() {
   return server;
 }
 
-const app = createMcpExpressApp({ host: HOST });
+const app = express();
+app.use(express.json({ limit: EXPRESS_JSON_LIMIT }));
 const transports = new Map();
 const servers = new Map();
 
@@ -1288,11 +1425,19 @@ app.get('/health', (_req, res) => {
     listen: `${HOST}:${PORT}${MCP_PATH}`,
     file_root: FILE_ROOT,
     transport_mode: MCP_TRANSPORT_MODE,
+    max_request_body_bytes: MAX_REQUEST_BODY_BYTES,
+    session_idle_ms: SESSION_IDLE_MS,
+    logical_session_limits: {
+      shell: null,
+      upload: null,
+      download: null,
+    },
     script_version: INSTALLER_SCRIPT_VERSION,
     server_version: SERVER_VERSION,
     tools: SUPPORTED_TOOLS,
     supports: {
       chunked_transfers: true,
+      parallel_chunk_offsets: true,
       rename_path: true,
       shell_session: true,
     },
@@ -1484,6 +1629,7 @@ install_node_modules() {
   run_as_root rm -rf "$INSTALL_ROOT/node_modules" "$INSTALL_ROOT/package-lock.json"
   run_as_root sh -c "cd '$INSTALL_ROOT' && npm install --omit=dev --no-fund --no-audit"
   run_as_root test -f "$INSTALL_ROOT/node_modules/@modelcontextprotocol/sdk/package.json" || die "npm 安装后缺少 @modelcontextprotocol/sdk"
+  run_as_root test -f "$INSTALL_ROOT/node_modules/express/package.json" || die "npm 安装后缺少 express"
   run_as_root test -f "$INSTALL_ROOT/node_modules/zod/package.json" || die "npm 安装后缺少 zod"
   run_as_root chmod -R a+rX "$INSTALL_ROOT/node_modules"
   run_as_root sh -c "cd '$INSTALL_ROOT' && node -e \"import('./server.mjs').then(() => process.exit(0)).catch((err) => { console.error(err); process.exit(1); })\"" || die "Node 运行时无法解析 MCP server"
@@ -1501,6 +1647,7 @@ FILE_ROOT=${FILE_ROOT}
 ENABLE_PASSWORDLESS_SUDO=${ENABLE_PASSWORDLESS_SUDO}
 MAX_FILE_MB=${MAX_FILE_MB}
 MAX_COMMAND_OUTPUT_KB=${MAX_COMMAND_OUTPUT_KB}
+MAX_REQUEST_BODY_MB=${MAX_REQUEST_BODY_MB}
 TLS_CERT_FILE=${TLS_CERT_FILE}
 TLS_KEY_FILE=${TLS_KEY_FILE}
 EOF

package/dist/configProvider.d.ts

@@ -10,6 +10,11 @@ export declare class BianbuMcpConfigProvider extends ConfigProvider {
             minIntervalMs: number;
             maxRetries: number;
             retryBaseMs: number;
+            interactiveConcurrency: number;
+            transferConcurrency: number;
+            workerCadenceMs: number;
+            uploadChunkBytes: number;
+            downloadChunkBytes: number;
             notes: string;
             installerRemotePath: string;
             maintenanceAsRoot: boolean;

package/dist/filesTab.component.d.ts

@@ -1,11 +1,11 @@
 import { Injector } from '@angular/core';
-import { BaseTabComponent, NotificationsService } from 'tabby-core';
+import { BaseTabComponent, NotificationsService, PlatformService } from 'tabby-core';
 import { BianbuMcpService } from './mcp.service';
 interface TransferItem {
     id: number;
     name: string;
     direction: 'upload' | 'download';
-    status: 'running' | 'done' | 'error' | 'cancelled';
+    status: 'queued' | 'running' | 'done' | 'error' | 'cancelled';
     bytesDone: number;
     bytesTotal: number | null;
     startedAt: number;
@@ -17,6 +17,7 @@ interface TransferItem {
 export declare class BianbuCloudFilesTabComponent extends BaseTabComponent {
     private mcp;
     private notifications;
+    private platform;
     currentPath: string;
     pathInput: string;
     asRoot: boolean;
@@ -45,7 +46,9 @@ export declare class BianbuCloudFilesTabComponent extends BaseTabComponent {
     transfersVisible: boolean;
     transfers: TransferItem[];
     private transferSeq;
-    constructor(injector: Injector, mcp: BianbuMcpService, notifications: NotificationsService);
+    private transferQueue;
+    private transferQueueRunning;
+    constructor(injector: Injector, mcp: BianbuMcpService, notifications: NotificationsService, platform: PlatformService);
     ngOnInit(): void;
     get breadcrumbs(): string[];
     get selectedItem(): any | null;
@@ -84,6 +87,12 @@ export declare class BianbuCloudFilesTabComponent extends BaseTabComponent {
     onDragLeave(): void;
     onDrop(event: DragEvent): Promise<void>;
     downloadSelected(): Promise<void>;
+    private enqueueUpload;
+    private enqueueDownload;
+    private queueTransferJob;
+    private pumpTransferQueue;
+    private runUploadTransfer;
+    private runDownloadTransfer;
     private clearPreview;
     private baseName;
     private isTextLike;