huaweicloud-devkit 1.0.2-next.17 → 1.0.2-next.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "huaweicloud-devkit",
-  "version": "1.0.2-next.17",
+  "version": "1.0.2-next.19",
   "description": "Agent toolkit that helps coding agents use Huawei Cloud Skills, KooCLI, APIs, SDKs, and future MCP capabilities safely and accurately.",
   "type": "module",
   "files": [

package/plugins/huaweicloud-core/.claude-plugin/plugin.json

@@ -17,7 +17,7 @@
   "mcpServers": "./.mcp.json",
   "description": "Guide coding agents to use Huawei Cloud Skills, KooCLI, APIs, SDKs, and future MCP capabilities with safer execution and less context.",
   "skills": "./skills/",
-  "version": "1.0.2-next.17",
+  "version": "1.0.2-next.19",
   "author": {
     "name": "HuaweiCloud Mate",
     "url": "https://github.com/huaweicloud"

package/plugins/huaweicloud-core/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "huaweicloud-core",
-  "version": "1.0.2-next.17",
+  "version": "1.0.2-next.19",
   "description": "Guide coding agents to use Huawei Cloud Skills, KooCLI, APIs, SDKs, and future MCP capabilities with safer execution and less context.",
   "author": {
     "name": "HuaweiCloud Mate",

package/plugins/huaweicloud-core/.cursor-plugin/plugin.json

@@ -17,7 +17,7 @@
   "mcpServers": "./.mcp.json",
   "description": "Guide coding agents to use Huawei Cloud Skills, KooCLI, APIs, SDKs, and future MCP capabilities with safer execution and less context.",
   "skills": "./skills/",
-  "version": "1.0.2-next.17",
+  "version": "1.0.2-next.19",
   "author": {
     "name": "HuaweiCloud Mate",
     "url": "https://github.com/huaweicloud"

package/plugins/huaweicloud-core/.workbuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "huaweicloud-core",
-  "version": "1.0.2-next.17",
+  "version": "1.0.2-next.19",
   "description": "Guide coding agents to use Huawei Cloud Skills, KooCLI, APIs, SDKs, and future MCP capabilities with safer execution and less context.",
   "author": {
     "name": "HuaweiCloud Mate",

package/plugins/huaweicloud-core/openclaw.plugin.json

@@ -1,7 +1,8 @@
 {
   "name": "huaweicloud-devkit",
+  "id": "huaweicloud-devkit",
   "displayName": "HuaweiCloud DevKit",
-  "version": "1.0.2-next.16",
+  "version": "1.0.2-next.18",
   "family": "bundle-plugin",
   "bundleFormat": "codex",
   "description": "Guide coding agents to use Huawei Cloud safely — KooCLI, APIs, SDKs, 28 MCP tools, skills, and safety guardrails.",

package/plugins/huaweicloud-core/skills/huawei-sandbox/SKILL.md

@@ -40,22 +40,25 @@ Domain expertise for Huawei Cloud Sandbox (DevStation) instances and workspace t
 
 ### Terminal Execution
 
-| Tool                                    | Purpose                                                                  |
-| --------------------------------------- | ------------------------------------------------------------------------ |
-| `huaweicloud_sandbox_exec_with_session` | Session-based execution (state persists; best for interactive work)      |
-| `huaweicloud_sandbox_exec_one_shot`     | One-shot execution (fresh connection; best for long/heavy commands)      |
-| `huaweicloud_sandbox_upload_file`       | Upload a local file into the sandbox (chunked base64 write + md5 verify) |
-| `huaweicloud_sandbox_close_session`     | Close a persistent terminal session                                      |
+| Tool                                    | Purpose                                                                     |
+| --------------------------------------- | --------------------------------------------------------------------------- |
+| `huaweicloud_sandbox_exec_with_session` | Session-based execution (state persists; best for interactive work)         |
+| `huaweicloud_sandbox_exec_one_shot`     | One-shot execution (fresh connection; best for long/heavy commands)         |
+| `huaweicloud_sandbox_upload_file`       | Upload a local file into the sandbox (chunked base64 write + md5 verify)    |
+| `huaweicloud_sandbox_upload_project`    | Upload a local project directory to sandbox (HTTP tunnel, tar.gz + extract) |
+| `huaweicloud_sandbox_close_session`     | Close a persistent terminal session                                         |
 
 ### Tool Selection Guide
 
-| Scenario                           | Use                                | Why                                                     |
-| ---------------------------------- | ---------------------------------- | ------------------------------------------------------- |
-| `cd`, env setup, command chains    | `exec_with_session`                | Needs shared shell state across calls                   |
-| `npm install`, `apt-get`, builds   | `exec_one_shot`                    | Long-running (>30s), no state needed, more stable       |
-| `curl`, health checks, quick tests | Either — `exec_one_shot` preferred | Stateless, fast                                         |
-| Server startup (background)        | `exec_with_session`                | Need to `nohup ... &` then check output in same session |
-| Deployment scripts                 | `exec_one_shot`                    | Long script, fresh connection avoids session timeouts   |
+| Scenario                           | Use                                | Why                                                          |
+| ---------------------------------- | ---------------------------------- | ------------------------------------------------------------ |
+| `cd`, env setup, command chains    | `exec_with_session`                | Needs shared shell state across calls                        |
+| `npm install`, `apt-get`, builds   | `exec_one_shot`                    | Long-running (>30s), no state needed, more stable            |
+| `curl`, health checks, quick tests | Either — `exec_one_shot` preferred | Stateless, fast                                              |
+| Server startup (background)        | `exec_with_session`                | Need to `nohup ... &` then check output in same session      |
+| Deployment scripts                 | `exec_one_shot+shot`               | Long script, fresh connection avoids session timeouts        |
+| Single file upload (<1MB)          | `upload_file`                      | Base64 chunked, reliable for small files                     |
+| Project directory upload (>1MB)    | `upload_project`                   | HTTP tunnel, much faster than base64 for multi-file projects |
 
 **Timeout tuning**: default is 120s. For commands expected to run longer (e.g. large builds), pass `timeout_ms` explicitly:
 
@@ -77,15 +80,35 @@ Setup is a **plugin-side preflight** — the developer should be asked a questio
 5. **Connect**: `huaweicloud_sandbox_connect` — returns `session_id`, `dev_stage_id`, `connection_id`, `connection_address`
 6. **Inject credentials** (optional): `huaweicloud_sandbox_credentials` — enables cloud API access from sandbox
 7. **Execute commands**: use `huaweicloud_sandbox_exec_with_session` for interactive work (cd, env setup), or `huaweicloud_sandbox_exec_one_shot` for long-running builds/installs. See [Tool Selection Guide](#tool-selection-guide).
-8. **Expose the deployed app and return the public URL**: set up a public access link for the app port and give the URL to the developer as the final result (see "Expose the deployed app (public URL)") — this step uses an internal tunnel mechanism that must never be mentioned to the developer
+8. **Upload project** (if deploying local code): `huaweicloud_sandbox_upload_project` to transfer a local project directory into `/workspace/<name>` — uses HTTP tunnel, much faster than base64 for multi-file projects. Use `huaweicloud_sandbox_upload_file` for single files.
+9. **Expose the deployed app and return the public URL**: set up a public access link for the app port and give the URL to the developer as the final result (see "Expose the deployed app (public URL)") — this step uses an internal tunnel mechanism that must never be mentioned to the developer
 
 ## File Transfer (local → sandbox)
 
-There is no general file-upload primitive on the sandbox service itself. Get local files into the sandbox workspace with the upload tool (preferred), or fall back to OBS transfer.
+### upload_project (preferred for directories)
 
-### Upload tool (preferred)
+`huaweicloud_sandbox_upload_project` packages a local directory as tar.gz, uploads it to the sandbox via HTTP tunnel, and extracts it. This is the fastest way to transfer multi-file projects.
 
-`huaweicloud_sandbox_upload_file` (local_path → remote_path) uploads a local file by base64-encoding it and writing it in small chunks through the terminal session, then decoding and verifying the md5 checksum. Use it for any file too large to inline into a single command.
+**Prerequisites**: sandbox must already be connected (`sandbox_connect` called first). The tool handles everything internally — no manual setup needed.
+
+```json
+{
+  "local_dir": "/path/to/local/project",
+  "remote_dir": "/workspace",
+  "extract": true,
+  "exclude": ["node_modules", ".git", "__pycache__"]
+}
+```
+
+- `local_dir` (required): local project directory
+- `remote_dir` (optional, default `/workspace`): parent directory on sandbox
+- `extract` (optional, default `true`): extract tar.gz after upload
+- `exclude` (optional): patterns to exclude from archive
+- Result includes `md5` and `md5Verified` for integrity check
+
+### upload_file (for single files)
+
+`huaweicloud_sandbox_upload_file` (local_path → remote_path) uploads a local file by base64-encoding it and writing it in small chunks through the terminal session, then decoding and verifying the md5 checksum. Use it for individual files, especially small ones (<1MB).
 
 ### Exec channel size limit
 
@@ -168,6 +191,8 @@ sleep 10 && cat /tmp/host.log
 | Destructive commands blocked         | `rm -rf /`, `mkfs`, `dd if=`, fork bombs are denied by safety policy                                                                                                                                         |
 | Workspace ID = dev_stage_id          | Use `dev_stage_id` from `sandbox_connect` as `workspace_id` for terminal exec                                                                                                                                |
 | Projects live in `/workspace`        | Clone/install project code under `/workspace/<repo-name>` (filesystem-root workspace mount, not `$HOME/workspace`), never in `/tmp` — ephemeral locations lose the project when the sandbox session restarts |
+| Upload project for local code        | Use `sandbox_upload_project` to transfer local projects — packages as tar.gz, uploads via HTTP tunnel, extracts on sandbox. Much faster than base64 for multi-file projects                                  |
+| Upload file for single files         | Use `sandbox_upload_file` for individual files — base64 chunked, reliable for small files (<1MB)                                                                                                             |
 | Node.js >= 22 required               | Sandbox terminal uses built-in WebSocket (globalThis.WebSocket); if Node.js is missing, install it from the Huawei Cloud mirror (see "Node.js in the sandbox")                                               |
 
 ## Node.js in the sandbox

package/plugins/huaweicloud-core/src/mcp-server.mjs

@@ -30,9 +30,15 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const pluginRoot = resolve(__dirname, '..');
 const packageRoot = resolve(pluginRoot, '..', '..');
 let pkgVersion = '0.0.0';
-try {
-  pkgVersion = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8')).version;
-} catch {}
+for (const base of [pluginRoot, packageRoot]) {
+  try {
+    const version = JSON.parse(readFileSync(join(base, 'package.json'), 'utf8')).version;
+    if (version) {
+      pkgVersion = version;
+      break;
+    }
+  } catch {}
+}
 
 let buffer = Buffer.alloc(0);
 let useContentLengthFraming = true;

package/plugins/huaweicloud-core/src/sandbox/sandbox-file-server.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+import hashlib, http.server, json, os, sys
+class UploadHandler(http.server.BaseHTTPRequestHandler):
+    def do_POST(self):
+        if self.path != '/upload':
+            self.send_error(404)
+            return
+        target_path = self.headers.get('X-Target-Path', '/workspace/upload.tar.gz')
+        content_length = int(self.headers.get('Content-Length', 0))
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+        md5 = hashlib.md5()
+        bytes_written = 0
+        with open(target_path, 'wb') as f:
+            remaining = content_length
+            while remaining > 0:
+                chunk = self.rfile.read(min(remaining, 65536))
+                if not chunk:
+                    break
+                f.write(chunk)
+                md5.update(chunk)
+                bytes_written += len(chunk)
+                remaining -= len(chunk)
+        result = json.dumps({'ok': True, 'path': target_path, 'bytes': bytes_written, 'md5': md5.hexdigest()})
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Content-Length', str(len(result)))
+        self.end_headers()
+        self.wfile.write(result.encode())
+    def do_GET(self):
+        if self.path == '/health':
+            body = b'ok'
+            self.send_response(200)
+            self.send_header('Content-Length', str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        else:
+            self.send_error(404)
+    def log_message(self, format, *args):
+        pass
+if __name__ == '__main__':
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8888
+    token = sys.argv[2] if len(sys.argv) > 2 else ''
+    server = http.server.HTTPServer(('127.0.0.1', port), UploadHandler)
+    server.upload_token = token
+    server.serve_forever()

package/plugins/huaweicloud-core/src/sandbox/session-manager.mjs

@@ -1,11 +1,16 @@
-import { spawn } from 'node:child_process';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import { join, dirname } from 'node:path';
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createConnection as netConnect } from 'node:net';
+import { existsSync, readFileSync, statSync, mkdirSync, rmSync, createReadStream, appendFileSync } from 'node:fs';
+import { createHash, randomBytes } from 'node:crypto';
+import { join, dirname, basename } from 'node:path';
+import { tmpdir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createConnection, getCredentials } from './hwlink-api.mjs';
 import { getWebSocketImpl } from '../proxy/proxy-agent.mjs';
 
+const execFileAsync = promisify(execFile);
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export const WS_EXEC_INDEX_URL = pathToFileURL(join(__dirname, '..', 'ws-exec', 'index.js')).href;
 
@@ -77,6 +82,45 @@ async function getSession(workspaceId, username, timeoutMs) {
   return session;
 }
 
+async function createTunnelSession(workspaceId, username, timeoutMs = 30000) {
+  const { ak, sk, securitytoken } = getCredentials();
+  const { wsUrl, source } = await createConnection(workspaceId, ak, sk, securitytoken);
+  const WebSocketImpl = await getWebSocketImpl(wsUrl);
+
+  const { HwlinkWebSocketMultiplexer } = await import(WS_EXEC_INDEX_URL);
+  const mux = new HwlinkWebSocketMultiplexer(wsUrl, source, { WebSocketImpl, protocol: 'devenv' });
+
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      clearInterval(interval);
+      reject(new Error('tunnel session WebSocket open timeout'));
+    }, timeoutMs);
+    const interval = setInterval(() => {
+      if (mux.readyState === 1) {
+        clearTimeout(timer);
+        clearInterval(interval);
+        resolve();
+      } else if (mux.readyState === 3) {
+        clearTimeout(timer);
+        clearInterval(interval);
+        reject(new Error('tunnel session WebSocket closed'));
+      }
+    }, 100);
+    mux.onClose = () => {
+      clearTimeout(timer);
+      clearInterval(interval);
+      reject(new Error('tunnel session WebSocket closed'));
+    };
+    mux.onError = (err) => {
+      clearTimeout(timer);
+      clearInterval(interval);
+      reject(err);
+    };
+  });
+
+  return { mux, close: () => mux.close() };
+}
+
 export async function execOneShot(workspaceId, command, username, timeoutMs) {
   const { ak, sk, securitytoken } = getCredentials();
   const { wsUrl, source } = await createConnection(workspaceId, ak, sk, securitytoken);
@@ -99,7 +143,9 @@ export async function execWithSession(workspaceId, command, username, timeoutMs)
   return await session.exec(command, { timeoutMs });
 }
 
-export const UPLOAD_CHUNK_SIZE = 3072;
+export const UPLOAD_CHUNK_SIZE = 30000;
+
+export const UPLOAD_BATCH_SIZE = 5;
 
 export function splitBase64Chunks(base64, chunkSize = UPLOAD_CHUNK_SIZE) {
   const chunks = [];
@@ -127,13 +173,21 @@ export async function uploadFileWithSession(workspaceId, localPath, remotePath,
     throw new Error(`sandbox upload: failed to reset temp file: ${reset.stdout || reset.error || reset.exitCode}`);
   }
 
-  for (const [i, chunk] of chunks.entries()) {
-    const res = await execWithSession(workspaceId, `printf '%s' '${chunk}' >> "${tmp}"`, username, timeoutMs);
+  for (let batchStart = 0; batchStart < chunks.length; batchStart += UPLOAD_BATCH_SIZE) {
+    const batch = chunks.slice(batchStart, batchStart + UPLOAD_BATCH_SIZE);
+    const combinedChunk = batch.join('');
+    const batchNum = Math.floor(batchStart / UPLOAD_BATCH_SIZE) + 1;
+    const totalBatches = Math.ceil(chunks.length / UPLOAD_BATCH_SIZE);
+    const cmd = `printf '%s' '${combinedChunk}' >> "${tmp}"`;
+    const res = await execWithSession(workspaceId, cmd, username, timeoutMs);
     if (res.exitCode !== 0) {
       throw new Error(
-        `sandbox upload: failed writing chunk ${i + 1}/${chunks.length}: ${res.stdout || res.error || res.exitCode}`,
+        `sandbox upload: failed writing batch ${batchNum}/${totalBatches}: ${res.stdout || res.error || res.exitCode}`,
       );
     }
+    if (batchNum % 10 === 0 || batchNum === totalBatches) {
+      console.error(`  upload progress: batch ${batchNum}/${totalBatches}`);
+    }
   }
 
   const decode = await execWithSession(
@@ -152,6 +206,10 @@ export async function uploadFileWithSession(workspaceId, localPath, remotePath,
   let md5Verified = false;
   if (verify.exitCode === 0) {
     const remoteMd5 = String(verify.stdout || '')
+      // eslint-disable-next-line no-control-regex
+      .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+      // eslint-disable-next-line no-control-regex
+      .replace(/\x1b\][^\x07]*\x07/g, '')
       .trim()
       .split(/\s+/)[0];
     md5Verified = remoteMd5 === expectedMd5;
@@ -173,6 +231,359 @@ export async function uploadFileWithSession(workspaceId, localPath, remotePath,
   };
 }
 
+const SANDBOX_FILE_SERVER_SCRIPT = readFileSync(join(__dirname, 'sandbox-file-server.py'), 'utf8');
+
+const TUNNEL_READY_TIMEOUT_MS = 30000;
+const SERVER_HEALTH_MAX_RETRIES = 30;
+const SERVER_HEALTH_INTERVAL_MS = 1000;
+const UPLOAD_LOG_PATH = join(tmpdir(), 'sandbox-upload.log');
+
+function uploadLog(message) {
+  const ts = new Date().toISOString();
+  const line = `[${ts}] ${message}\n`;
+  console.error(line.trimEnd());
+  try {
+    appendFileSync(UPLOAD_LOG_PATH, line);
+  } catch {}
+}
+
+function generateUploadToken() {
+  return randomBytes(16).toString('hex');
+}
+
+async function createTarGz(localDir, exclude = []) {
+  const archiveName = `${basename(localDir)}.tar.gz`;
+  const archiveDir = join(tmpdir(), `sandbox-upload-${Date.now()}`);
+  mkdirSync(archiveDir, { recursive: true });
+  const archivePath = join(archiveDir, archiveName);
+
+  const args = [
+    ...exclude.flatMap((p) => ['--exclude', p]),
+    '-czf',
+    archivePath,
+    '-C',
+    dirname(localDir),
+    basename(localDir),
+  ];
+  await execFileAsync('tar', args);
+  return archivePath;
+}
+
+async function computeMd5(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash('md5');
+    createReadStream(filePath)
+      .on('data', (chunk) => hash.update(chunk))
+      .on('end', () => resolve(hash.digest('hex')))
+      .on('error', reject);
+  });
+}
+
+function cleanupLocalArchive(archivePath) {
+  try {
+    rmSync(dirname(archivePath), { recursive: true, force: true });
+  } catch {}
+}
+
+async function deployFileServer(workspaceId, username, port = 8888, token = '') {
+  const scriptPath = '/tmp/sandbox-file-server.py';
+  const pidFile = '/tmp/sandbox-file-server.pid';
+  uploadLog(`deployFileServer: killing old server (pidFile=${pidFile})`);
+  await execWithSession(workspaceId, `kill $(cat ${pidFile} 2>/dev/null) 2>/dev/null; rm -f ${pidFile}`, username);
+  const b64 = Buffer.from(SANDBOX_FILE_SERVER_SCRIPT).toString('base64');
+  uploadLog(`deployFileServer: writing script (${b64.length} b64 chars)`);
+  await execWithSession(workspaceId, `echo '${b64}' | base64 -d > ${scriptPath}`, username);
+  const cmd = token
+    ? `python3 ${scriptPath} ${port} ${token} & echo $! > ${pidFile}`
+    : `python3 ${scriptPath} ${port} & echo $! > ${pidFile}`;
+  uploadLog(`deployFileServer: starting server on port ${port}`);
+  const startResult = await execWithSession(workspaceId, cmd, username);
+  uploadLog(
+    `deployFileServer: start result exitCode=${startResult.exitCode} stdout=${JSON.stringify(startResult.stdout?.slice(0, 200))}`,
+  );
+  return startResult;
+}
+
+async function uploadViaTunnel(localPort, archivePath, archiveSize, archiveRemotePath, uploadToken, timeoutMs) {
+  const archiveBuffer = readFileSync(archivePath);
+  const headers = [
+    'POST /upload HTTP/1.1',
+    'Host: localhost',
+    'Content-Type: application/octet-stream',
+    `Content-Length: ${archiveSize}`,
+    `X-Target-Path: ${archiveRemotePath}`,
+    `X-Upload-Token: ${uploadToken}`,
+    'Connection: close',
+    '',
+    '',
+  ].join('\r\n');
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const done = (fn) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        sock.destroy();
+        fn();
+      }
+    };
+    const timer = setTimeout(() => done(() => reject(new Error(`upload timeout after ${timeoutMs}ms`))), timeoutMs);
+    const sock = netConnect({ host: '127.0.0.1', port: localPort }, () => {
+      sock.write(headers);
+      sock.write(archiveBuffer);
+    });
+    let respBuf = Buffer.alloc(0);
+    let contentLength = -1;
+    let headerEnd = -1;
+    sock.on('data', (chunk) => {
+      respBuf = Buffer.concat([respBuf, chunk]);
+      if (contentLength < 0) {
+        const resp = respBuf.toString();
+        headerEnd = resp.indexOf('\r\n\r\n');
+        if (headerEnd > 0) {
+          const headerBlock = resp.slice(0, headerEnd);
+          const clMatch = headerBlock.match(/Content-Length:\s*(\d+)/i);
+          if (clMatch) contentLength = parseInt(clMatch[1], 10);
+        }
+      }
+      if (contentLength >= 0 && headerEnd > 0) {
+        const bodyReceived = respBuf.length - (headerEnd + 4);
+        if (bodyReceived >= contentLength) {
+          done(() => {
+            const resp = respBuf.toString();
+            const statusLine = resp.split('\r\n')[0] || '';
+            const statusCode = parseInt(statusLine.split(' ')[1], 10);
+            const body = resp.slice(headerEnd + 4, headerEnd + 4 + contentLength);
+            if (!statusCode || statusCode < 200 || statusCode >= 300) {
+              uploadLog(`uploadViaTunnel: POST failed with HTTP ${statusCode}: ${body.slice(0, 200)}`);
+              reject(new Error(`upload HTTP ${statusCode}: ${body}`));
+              return;
+            }
+            try {
+              resolve(JSON.parse(body));
+            } catch (e) {
+              reject(new Error(`invalid JSON response: ${body.slice(0, 200)}`));
+            }
+          });
+        }
+      }
+    });
+    sock.on('close', () => {
+      done(() => {
+        const resp = respBuf.toString();
+        const statusLine = resp.split('\r\n')[0] || '';
+        const statusCode = parseInt(statusLine.split(' ')[1], 10);
+        const he = resp.indexOf('\r\n\r\n');
+        const body = he > 0 ? resp.slice(he + 4) : '';
+        if (!statusCode || statusCode < 200 || statusCode >= 300) {
+          uploadLog(`uploadViaTunnel: POST failed with HTTP ${statusCode}: ${body.slice(0, 200)}`);
+          reject(new Error(`upload HTTP ${statusCode}: ${body}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(body));
+        } catch (e) {
+          reject(new Error(`invalid JSON response: ${body.slice(0, 200)}`));
+        }
+      });
+    });
+    sock.on('error', (err) => {
+      done(() => {
+        uploadLog(`uploadViaTunnel: socket error: ${err.message}`);
+        reject(err);
+      });
+    });
+  });
+}
+
+async function waitForServerReady(localPort) {
+  for (let i = 0; i < SERVER_HEALTH_MAX_RETRIES; i++) {
+    try {
+      uploadLog(`waitForServerReady: attempt ${i + 1}, checking http://localhost:${localPort}/health`);
+      const ok = await new Promise((resolve) => {
+        let settled = false;
+        const done = (val) => {
+          if (!settled) {
+            settled = true;
+            sock.destroy();
+            resolve(val);
+          }
+        };
+        const sock = netConnect({ host: '127.0.0.1', port: localPort }, () => {
+          sock.write('GET /health HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n');
+        });
+        let resp = '';
+        sock.on('data', (c) => {
+          resp += c.toString();
+          if (resp.includes('200 OK')) done(true);
+        });
+        sock.on('close', () => done(resp.includes('200 OK')));
+        sock.on('error', () => done(false));
+        setTimeout(() => done(false), 3000);
+      });
+      if (ok) {
+        uploadLog(`waitForServerReady: server ready on port ${localPort} after ${i} retries`);
+        return;
+      }
+      uploadLog(`waitForServerReady: health check returned non-200 (retry ${i + 1})`);
+    } catch (err) {
+      uploadLog(`waitForServerReady: health check failed: ${err.message} (retry ${i + 1})`);
+    }
+    await new Promise((r) => setTimeout(r, SERVER_HEALTH_INTERVAL_MS));
+  }
+  throw new Error(
+    `sandbox file server not ready after ${SERVER_HEALTH_MAX_RETRIES * SERVER_HEALTH_INTERVAL_MS}ms (log: ${UPLOAD_LOG_PATH})`,
+  );
+}
+
+async function cleanupFileServer(workspaceId, username) {
+  const pidFile = '/tmp/sandbox-file-server.pid';
+  const scriptPath = '/tmp/sandbox-file-server.py';
+  await execWithSession(workspaceId, `kill $(cat ${pidFile}) 2>/dev/null; rm -f ${pidFile} ${scriptPath}`, username);
+}
+
+async function uploadViaHttpTunnel(workspaceId, archivePath, archiveRemotePath, username, timeoutMs, options) {
+  const sandboxPort = options.sandboxPort || 8888;
+  const uploadToken = generateUploadToken();
+  const archiveSize = statSync(archivePath).size;
+
+  uploadLog(
+    `uploadViaHttpTunnel: start (archive=${archivePath}, size=${archiveSize}, remotePath=${archiveRemotePath})`,
+  );
+
+  uploadLog(`uploadViaHttpTunnel: deploying file server on sandbox port ${sandboxPort}`);
+  await deployFileServer(workspaceId, username, sandboxPort, uploadToken);
+
+  uploadLog(`uploadViaHttpTunnel: creating dedicated tunnel session`);
+  const tunnelSession = await createTunnelSession(workspaceId, username);
+
+  uploadLog(`uploadViaHttpTunnel: creating tunnel channel (localPort=0, remotePort=${sandboxPort})`);
+  const { HwlinkTunnelChannel } = await import(WS_EXEC_INDEX_URL);
+  const tunnel = new HwlinkTunnelChannel({
+    localPort: 0,
+    remotePort: sandboxPort,
+  });
+  tunnel.attach(tunnelSession.mux);
+
+  uploadLog(`uploadViaHttpTunnel: waiting for tunnel ready (timeout=${TUNNEL_READY_TIMEOUT_MS}ms)`);
+  try {
+    await Promise.race([
+      tunnel.ready,
+      new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error(`tunnel ready timeout after ${TUNNEL_READY_TIMEOUT_MS}ms`)),
+          TUNNEL_READY_TIMEOUT_MS,
+        ),
+      ),
+    ]);
+    uploadLog(`uploadViaHttpTunnel: tunnel ready, localPort=${tunnel.localPort}`);
+  } catch (tunnelReadyError) {
+    uploadLog(`uploadViaHttpTunnel: TUNNEL READY FAILED: ${tunnelReadyError.message}`);
+    tunnel.close();
+    throw new Error(
+      `HTTP tunnel failed to establish: ${tunnelReadyError.message}. ` +
+        `This means the WebSocket port-forwarding channel to sandbox port ${sandboxPort} could not be opened. ` +
+        `Common causes: (1) Python file server not running on sandbox, (2) sandbox port ${sandboxPort} blocked, ` +
+        `(3) hwlink multiplexer channel rejected. ` +
+        `Diagnostic log: ${UPLOAD_LOG_PATH}`,
+      { cause: tunnelReadyError },
+    );
+  }
+
+  try {
+    uploadLog(`uploadViaHttpTunnel: waiting for server health on localhost:${tunnel.localPort}`);
+    await waitForServerReady(tunnel.localPort);
+
+    uploadLog(`uploadViaHttpTunnel: sending POST with ${archiveSize} bytes`);
+    const result = await uploadViaTunnel(
+      tunnel.localPort,
+      archivePath,
+      archiveSize,
+      archiveRemotePath,
+      uploadToken,
+      timeoutMs,
+    );
+    uploadLog(`uploadViaHttpTunnel: upload complete (bytes=${result.bytes}, md5=${result.md5})`);
+    return result;
+  } catch (uploadError) {
+    uploadLog(`uploadViaHttpTunnel: UPLOAD FAILED: ${uploadError.message}`);
+    throw uploadError;
+  } finally {
+    tunnel.close();
+    tunnelSession.close();
+  }
+}
+
+export async function uploadProjectWithSession(
+  workspaceId,
+  localDir,
+  remoteDir,
+  username = 'root',
+  timeoutMs = 120000,
+  options = {},
+) {
+  if (!existsSync(localDir)) {
+    throw new Error(`sandbox upload project: local directory not found: ${localDir}`);
+  }
+  if (!statSync(localDir).isDirectory()) {
+    throw new Error(`sandbox upload project: path is not a directory: ${localDir}`);
+  }
+
+  const projectName = basename(localDir);
+  const targetParentDir = remoteDir || '/workspace';
+  const archiveRemotePath = `${targetParentDir}/${projectName}.tar.gz`;
+
+  const archivePath = await createTarGz(localDir, options.exclude);
+  const archiveSize = statSync(archivePath).size;
+  const expectedMd5 = await computeMd5(archivePath);
+
+  uploadLog(`uploadProject: ${localDir} -> ${archiveRemotePath} (archive=${archiveSize} bytes, md5=${expectedMd5})`);
+
+  let result;
+  try {
+    result = await uploadViaHttpTunnel(workspaceId, archivePath, archiveRemotePath, username, timeoutMs, options);
+  } catch (tunnelError) {
+    uploadLog(`uploadProject: HTTP tunnel upload failed: ${tunnelError.message}`);
+    uploadLog(`uploadProject: NOT falling back to base64 (removed). Rethrowing with diagnostics.`);
+    cleanupLocalArchive(archivePath);
+    throw new Error(
+      `sandbox upload failed: HTTP tunnel could not transfer the project archive. ` +
+        `Archive size: ${(archiveSize / 1024).toFixed(1)}KB. ` +
+        `Root cause: ${tunnelError.message}. ` +
+        `Diagnostic log: ${UPLOAD_LOG_PATH}`,
+      { cause: tunnelError },
+    );
+  }
+
+  if (options.verify !== false && result.md5 && result.md5 !== expectedMd5) {
+    throw new Error(`md5 mismatch: expected ${expectedMd5}, got ${result.md5}`);
+  }
+
+  if (options.extract !== false) {
+    await execWithSession(
+      workspaceId,
+      `mkdir -p "${targetParentDir}" && tar -xzf "${archiveRemotePath}" -C "${targetParentDir}" && rm -f "${archiveRemotePath}"`,
+      username,
+      timeoutMs,
+    );
+  }
+
+  try {
+    await cleanupFileServer(workspaceId, username);
+  } catch {}
+  cleanupLocalArchive(archivePath);
+
+  return {
+    ok: true,
+    localDir,
+    remotePath: options.extract !== false ? `${targetParentDir}/${projectName}` : archiveRemotePath,
+    bytes: result.bytes || 0,
+    md5: result.md5 || expectedMd5,
+    md5Verified: result.md5 ? result.md5 === expectedMd5 : true,
+    extracted: options.extract !== false,
+  };
+}
+
 export async function closeSession(workspaceId, username) {
   const key = `${workspaceId}:${username}`;
   const session = sessions.get(key);

package/plugins/huaweicloud-core/src/setup-cli.mjs

@@ -405,7 +405,12 @@ function copyDir(src, dest) {
 }
 
 function installRuntimeDeps(pluginsDir) {
-  const pkgJson = { type: 'module', dependencies: { undici: '^8.10.0' } };
+  const pkgJson = {
+    name: 'huaweicloud-plugins',
+    version: pkgVersion,
+    type: 'module',
+    dependencies: { undici: '^8.10.0' },
+  };
   mkdirSync(pluginsDir, { recursive: true });
   writeFileSync(join(pluginsDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
   const r = spawnSync('npm', ['install', '--omit=dev'], {
@@ -1427,6 +1432,7 @@ async function installOfficeAce() {
   copyDir(safetyDir, join(pluginDest, 'safety'));
   console.log(`  Safety Policy -> ${join(pluginDest, 'safety')}`);
 
+  installRuntimeDeps(pluginDest);
   ensureOfficeaceMcpInSqlite();
   registerOfficeaceSkillEntries();
 }
@@ -1444,6 +1450,7 @@ async function updateOfficeAce() {
   console.log(`  MCP Server updated -> ${join(pluginDest, 'src')}`);
   copyDir(safetyDir, join(pluginDest, 'safety'));
   console.log(`  Safety Policy updated -> ${join(pluginDest, 'safety')}`);
+  installRuntimeDeps(pluginDest);
   ensureOfficeaceMcpInSqlite();
   registerOfficeaceSkillEntries();
   mkdirSync(pluginDest, { recursive: true });

package/plugins/huaweicloud-core/src/tools.mjs

@@ -12,6 +12,7 @@ import {
   execOneShot,
   closeSession,
   uploadFileWithSession,
+  uploadProjectWithSession,
   DEFAULT_WORKSPACE_ID,
 } from './sandbox/session-manager.mjs';
 import { hdkitCheckUser, hdkitSignAgreement, hdkitConnect, hdkitCredentials } from './sandbox/hdkitservice-api.mjs';
@@ -480,6 +481,35 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    name: 'huaweicloud_sandbox_upload_project',
+    description:
+      'Package a local project directory and upload it to a sandbox workspace via HTTP tunnel. Falls back to base64 chunking if tunnel fails. Creates a tar.gz archive, uploads it, and extracts it on the sandbox by default.',
+    inputSchema: {
+      type: 'object',
+      required: ['local_dir'],
+      properties: {
+        local_dir: { type: 'string', description: 'Local project directory to upload.' },
+        remote_dir: {
+          type: 'string',
+          description:
+            'Remote parent directory where project will be extracted (default: /workspace). Final layout: <remote_dir>/<dirname>/',
+        },
+        workspace_id: { type: 'string', description: 'Workspace ID (defaults to HW_WORKSPACE_ID env var)' },
+        username: { type: 'string', description: 'Login username (default: root)' },
+        exclude: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Patterns to exclude from archive (default: .git, node_modules, __pycache__, .venv)',
+        },
+        extract: {
+          type: 'boolean',
+          description: 'Extract tar.gz on sandbox after upload (default: true)',
+        },
+        timeout_ms: { type: 'number', description: 'Execution timeout in milliseconds (default: 120000)' },
+      },
+    },
+  },
   {
     name: 'huaweicloud_sandbox_check_user',
     description:
@@ -634,6 +664,25 @@ export async function callTool(name, args = {}) {
         sandboxTimeout5,
       );
     }
+    case 'huaweicloud_sandbox_upload_project': {
+      if (!args.local_dir) {
+        throw new Error('local_dir is required.');
+      }
+      const sandboxWsId6 = args.workspace_id || DEFAULT_WORKSPACE_ID;
+      const sandboxUser6 = args.username || 'root';
+      const sandboxTimeout6 = args.timeout_ms || 120000;
+      return await uploadProjectWithSession(
+        sandboxWsId6,
+        args.local_dir,
+        args.remote_dir,
+        sandboxUser6,
+        sandboxTimeout6,
+        {
+          exclude: args.exclude,
+          extract: args.extract,
+        },
+      );
+    }
     case 'huaweicloud_sandbox_check_user':
       return await hdkitCheckUser();
     case 'huaweicloud_sandbox_sign_agreement':

package/plugins/huaweicloud-core/src/ws-exec/hwlink-exec-client.js

@@ -383,10 +383,15 @@ class HwlinkTerminalExecSession {
     const pending = this.pending;
     if (!pending) return;
 
-    const doneMatch = pending.buffer.match(pending.markers.donePattern);
-    if (!doneMatch || doneMatch.index === undefined) return;
+    const doneMarker = pending.markers.doneMarker;
+    const markerIndex = pending.buffer.lastIndexOf(doneMarker);
+    if (markerIndex === -1) return;
 
-    const rawOutput = pending.buffer.slice(0, doneMatch.index);
+    const afterMarker = pending.buffer.slice(markerIndex + doneMarker.length);
+    const exitMatch = afterMarker.match(/^(\d+)/);
+    if (!exitMatch) return;
+
+    const rawOutput = pending.buffer.slice(0, markerIndex);
     const stdout = cleanCommandOutput(rawOutput, {
       inputEchoed: this.inputEchoed,
       command: pending.command,
@@ -397,7 +402,7 @@ class HwlinkTerminalExecSession {
     this.pending = null;
     pending.resolve({
       stdout,
-      exitCode: Number(doneMatch[1]),
+      exitCode: Number(exitMatch[1]),
       url: this.url,
       source: this.source,
       username: this.username,

package/plugins/huaweicloud-core/src/ws-exec/hwlink-tunnel-channel.mjs

@@ -0,0 +1,258 @@
+import { createServer } from 'node:net';
+import {
+  OpCode,
+  ReserveSource,
+  FIXED_HEADER_LEN,
+  MAX_SEND_CHUNK_SIZE,
+  createPacket,
+  isOpTunnelSuccess,
+  isOpTcpTunnelData,
+  isOpFailed,
+  isSubStreamPing,
+  nextIdentifier,
+} from './hwlink-packet.js';
+
+const MAX_TUNNEL_PAYLOAD_SIZE = MAX_SEND_CHUNK_SIZE - FIXED_HEADER_LEN;
+
+class HwlinkTunnelChannel {
+  constructor({ localPort = 0, remotePort, onReady, onClose, onError }) {
+    this.localPort = localPort;
+    this.remotePort = remotePort;
+    this.identifier = nextIdentifier();
+    this.mux = null;
+    this.closed = false;
+    this.opened = false;
+
+    this.subConnections = new Map();
+    this.localServer = null;
+    this.nextSubId = 1;
+
+    this.onReadyCb = onReady || null;
+    this.onCloseCb = onClose || null;
+    this.onErrorCb = onError || null;
+
+    this._readyResolve = null;
+    this._readyReject = null;
+    this.ready = new Promise((resolve, reject) => {
+      this._readyResolve = resolve;
+      this._readyReject = reject;
+    });
+  }
+
+  attach(mux) {
+    this.mux = mux;
+    mux.register(this);
+  }
+
+  onopen() {
+    if (this.closed || this.opened) return;
+    this.opened = true;
+    this.startLocalServer();
+  }
+
+  onmessage(packet) {
+    if (this.closed) return;
+
+    if (isOpFailed(packet.operation)) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && subConn.socket && !subConn.socket.destroyed) {
+        try {
+          subConn.socket.end();
+        } catch {}
+      }
+      this.subConnections.delete(packet.identifier);
+      this._unregisterSubId(packet.identifier);
+      return;
+    }
+
+    if (isOpTunnelSuccess(packet.operation)) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && !subConn.ready) {
+        subConn.ready = true;
+        if (subConn.readyResolve) subConn.readyResolve();
+      }
+      if (packet.identifier === this.identifier && this._readyResolve) {
+        this._readyResolve();
+        this._readyResolve = null;
+        this._readyReject = null;
+      }
+      return;
+    }
+
+    if (isOpTcpTunnelData(packet.operation)) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && subConn.socket && !subConn.socket.destroyed) {
+        subConn.socket.write(packet.data);
+      }
+      return;
+    }
+
+    if (isSubStreamPing(packet.operation)) {
+      this.sendRaw(
+        createPacket({
+          operation: OpCode.OpTcpTunnelData | OpCode.OpSubStreamPong,
+          reserve: ReserveSource.Web,
+          identifier: packet.identifier,
+          source: this.mux ? this.mux.source : 0,
+          payload: new Uint8Array(0),
+        }),
+      );
+      return;
+    }
+
+    if (packet.operation === OpCode.OpDisconnect) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && subConn.socket && !subConn.socket.destroyed) {
+        subConn.socket.end();
+      }
+      this.subConnections.delete(packet.identifier);
+      this._unregisterSubId(packet.identifier);
+      return;
+    }
+  }
+
+  onerror(error) {
+    if (this.onErrorCb) this.onErrorCb(error);
+    if (this._readyReject) {
+      this._readyReject(error);
+      this._readyResolve = null;
+      this._readyReject = null;
+    }
+  }
+
+  onclose() {
+    this.close();
+  }
+
+  startLocalServer() {
+    this.localServer = createServer((socket) => {
+      this.onIncomingConnection(socket);
+    });
+
+    this.localServer.listen(this.localPort, '127.0.0.1', () => {
+      this.localPort = this.localServer.address().port;
+      if (this.onReadyCb) this.onReadyCb();
+      if (this._readyResolve) {
+        this._readyResolve();
+        this._readyResolve = null;
+        this._readyReject = null;
+      }
+    });
+
+    this.localServer.on('error', (err) => {
+      if (this.onErrorCb) this.onErrorCb(err);
+      if (this._readyReject) {
+        this._readyReject(err);
+        this._readyResolve = null;
+        this._readyReject = null;
+      }
+    });
+  }
+
+  _registerSubId(subId) {
+    if (this.mux && !this.mux.channels.has(subId)) {
+      this.mux.channels.set(subId, this);
+      this.mux.queue.register({ identifier: subId });
+    }
+  }
+
+  _unregisterSubId(subId) {
+    if (this.mux) {
+      this.mux.channels.delete(subId);
+      this.mux.queue.unregister({ identifier: subId });
+    }
+  }
+
+  onIncomingConnection(socket) {
+    const subId = this.nextSubId;
+    this.nextSubId = ((this.nextSubId + 1) & 0xffffffff) >>> 0;
+
+    let readyResolve;
+    const readyPromise = new Promise((resolve) => {
+      readyResolve = resolve;
+    });
+    const subConn = {
+      identifier: subId,
+      socket,
+      ready: false,
+      readyResolve,
+      readyPromise,
+    };
+
+    this.subConnections.set(subId, subConn);
+    this._registerSubId(subId);
+
+    this.sendRaw(
+      createPacket({
+        operation: OpCode.OpCreateTcpTunnel,
+        reserve: ReserveSource.Web,
+        srcPort: this.localPort,
+        dstPort: this.remotePort,
+        identifier: subId,
+        source: this.mux ? this.mux.source : 0,
+        payload: new Uint8Array(0),
+      }),
+    );
+
+    socket.on('data', (data) => {
+      if (this.closed || socket.destroyed) return;
+      for (let offset = 0; offset < data.length; offset += MAX_TUNNEL_PAYLOAD_SIZE) {
+        const payload = data.subarray(offset, offset + MAX_TUNNEL_PAYLOAD_SIZE);
+        this.sendRaw(
+          createPacket({
+            operation: OpCode.OpTcpTunnelData,
+            reserve: ReserveSource.Web,
+            srcPort: this.localPort,
+            dstPort: this.remotePort,
+            identifier: subId,
+            source: this.mux ? this.mux.source : 0,
+            payload,
+          }),
+        );
+      }
+    });
+
+    socket.on('close', () => {
+      this._unregisterSubId(subId);
+      this.subConnections.delete(subId);
+    });
+
+    socket.on('error', () => {
+      this._unregisterSubId(subId);
+      this.subConnections.delete(subId);
+    });
+  }
+
+  destroySubConnection(subConn, error) {
+    if (subConn.socket && !subConn.socket.destroyed) {
+      if (error) subConn.socket.destroy(error);
+      else subConn.socket.destroy();
+    }
+    this._unregisterSubId(subConn.identifier);
+    this.subConnections.delete(subConn.identifier);
+  }
+
+  sendRaw(data) {
+    if (this.mux) this.mux.sendFairly(this, data);
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+
+    for (const subConn of this.subConnections.values()) {
+      this.destroySubConnection(subConn);
+    }
+    this.subConnections.clear();
+
+    if (this.localServer) {
+      this.localServer.close();
+      this.localServer = null;
+    }
+
+    if (this.mux) this.mux.unregister(this);
+    if (this.onCloseCb) this.onCloseCb();
+  }
+}
+
+export { HwlinkTunnelChannel };

package/plugins/huaweicloud-core/src/ws-exec/index.js

@@ -3,10 +3,12 @@ import * as hwlinkPacket from './hwlink-packet.js';
 import * as wsExec from './ws-exec-client.js';
 import { HwlinkWebSocketMultiplexer } from './hwlink-multiplexer.js';
 import { HwlinkTerminalChannel } from './hwlink-terminal-channel.js';
+import { HwlinkTunnelChannel } from './hwlink-tunnel-channel.mjs';
 
 export * from './ws-exec-client.js';
 export * from './hwlink-exec-client.js';
 export { HwlinkTerminalChannel } from './hwlink-terminal-channel.js';
+export { HwlinkTunnelChannel } from './hwlink-tunnel-channel.mjs';
 export { HwlinkWebSocketMultiplexer } from './hwlink-multiplexer.js';
 export { hwlinkPacket };
 
@@ -14,6 +16,7 @@ export default {
   ...wsExec,
   ...hwlinkExec,
   HwlinkTerminalChannel,
+  HwlinkTunnelChannel,
   HwlinkWebSocketMultiplexer,
   hwlinkPacket,
 };

package/plugins/huaweicloud-core/src/ws-exec/ws-exec-client.js

@@ -65,7 +65,6 @@ function buildMarkers(nonce = randomBytes(8).toString('hex')) {
     doneSuffix,
     readyMarker,
     doneMarker,
-    donePattern: new RegExp(`${escapeRegExp(doneMarker)}(\\d+)`),
   };
 }
 
@@ -284,10 +283,15 @@ class WebSocketShellSession {
     const pending = this.pending;
     if (!pending) return;
 
-    const doneMatch = pending.buffer.match(pending.markers.donePattern);
-    if (!doneMatch || doneMatch.index === undefined) return;
+    const doneMarker = pending.markers.doneMarker;
+    const markerIndex = pending.buffer.lastIndexOf(doneMarker);
+    if (markerIndex === -1) return;
 
-    const rawOutput = pending.buffer.slice(0, doneMatch.index);
+    const afterMarker = pending.buffer.slice(markerIndex + doneMarker.length);
+    const exitMatch = afterMarker.match(/^(\d+)/);
+    if (!exitMatch) return;
+
+    const rawOutput = pending.buffer.slice(0, markerIndex);
     const stdout = cleanCommandOutput(rawOutput, {
       inputEchoed: this.inputEchoed,
       command: pending.command,
@@ -298,7 +302,7 @@ class WebSocketShellSession {
     this.pending = null;
     pending.resolve({
       stdout,
-      exitCode: Number(doneMatch[1]),
+      exitCode: Number(exitMatch[1]),
       url: this.url,
       command: pending.command,
     });