@qwen-code/qwen-code 0.19.3 → 0.19.4-nightly.20260702.46814e4f1

package/chunks/{run-qwen-serve-SGEEVMXD.js → run-qwen-serve-FN2SW5ZI.js}

@@ -1,7 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  findCliEntryPath
+} from "./chunk-AHNXYU4O.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
+  ClientMcpSenderRegistry,
   SERVE_CAPABILITY_REGISTRY,
   allowOriginCors,
   allowOriginMode,
@@ -13,90 +17,58 @@ import {
   getRateLimiter,
   getServeProtocolVersions,
   hostAllowlist,
-  isLoopbackBind,
   listenerMaxConnections,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-N4EJFBN5.js";
+} from "./chunk-JVLP5US5.js";
+import {
+  isLoopbackBind
+} from "./chunk-RNBYOUGV.js";
 import "./chunk-3HX5LZ6R.js";
 import "./chunk-7RYW5LQV.js";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-GHOTR7HL.js";
 import {
   getCliVersion
-} from "./chunk-GT2FGICD.js";
-import "./chunk-VBZ452JT.js";
-import "./chunk-QBZ22PQX.js";
-import "./chunk-ALX6BUYW.js";
-import "./chunk-P7M4GA57.js";
+} from "./chunk-DE7YXUR7.js";
+import "./chunk-EWALXUAD.js";
 import {
   canonicalizeWorkspace
-} from "./chunk-JE5FVRPC.js";
-import "./chunk-FXKVLFFY.js";
-import "./chunk-UFC57OYT.js";
-import "./chunk-L7OKCI7T.js";
+} from "./chunk-SEZC2725.js";
+import {
+  QWEN_SERVER_TOKEN_ENV
+} from "./chunk-S6RLAIUR.js";
+import {
+  channelSelectionNames
+} from "./chunk-MX2YXRER.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-QI7GOGJR.js";
+} from "./chunk-KKQWC6WS.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
-} from "./chunk-CF6BB3LT.js";
+} from "./chunk-PPFWEV7G.js";
 import {
   writeStderrLine,
   writeStdoutLine
 } from "./chunk-Y6Z2O3WR.js";
 import "./chunk-QYUE6W3T.js";
-import "./chunk-YAINVQ3Q.js";
-import "./chunk-K5PGHDBN.js";
+import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-XJYUPHRC.js";
-import "./chunk-QLDPRILK.js";
-import "./chunk-BVSVIN45.js";
-import "./chunk-SBBN4BWR.js";
-import "./chunk-S7AKE7HL.js";
-import "./chunk-2MPVVENX.js";
-import "./chunk-ZTQ26VBE.js";
-import "./chunk-O2VBQ3Y2.js";
-import "./chunk-MLZQVCF3.js";
-import "./chunk-LQ7TMOCE.js";
-import "./chunk-LD2XBG6Z.js";
-import "./chunk-HYCC3XM3.js";
-import "./chunk-NL4C3H6C.js";
-import "./chunk-JOLIREYR.js";
-import "./chunk-DDMOU62Q.js";
-import "./chunk-QNKBEJO2.js";
-import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
-import "./chunk-OFEVLU4C.js";
-import "./chunk-OMX7CUOE.js";
-import "./chunk-RD6YJJJ6.js";
-import "./chunk-SKQZZVAV.js";
-import "./chunk-BUUQ5HPX.js";
-import "./chunk-BX5YO7UW.js";
-import "./chunk-UO5GVXQE.js";
-import "./chunk-KMGMKW5Q.js";
-import "./chunk-22IFUCVR.js";
-import "./chunk-3227DZO4.js";
-import "./chunk-U3KSMM7G.js";
-import "./chunk-BKXBARJZ.js";
-import "./chunk-EJYJYJZ2.js";
-import "./chunk-55ZMG67I.js";
-import "./chunk-H6BD2ELD.js";
-import "./chunk-5IFG2VC4.js";
-import "./chunk-64WXLC72.js";
-import "./chunk-UX4SGCGN.js";
+import "./chunk-SYCJMSIJ.js";
 import {
   finalizeStartupProfile,
   profileCheckpoint
 } from "./chunk-ITOGNELQ.js";
 import "./chunk-FXGLL2HL.js";
-import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
-import "./chunk-Z2Z3GUXZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -108,7 +80,9 @@ import {
 // packages/cli/src/serve/run-qwen-serve.ts
 init_esbuild_shims();
 var import_express = __toESM(require_express(), 1);
+import { X509Certificate } from "node:crypto";
 import * as fs from "node:fs";
+import * as https from "node:https";
 import * as path from "node:path";
 import { performance } from "node:perf_hooks";
 
@@ -391,11 +365,14 @@ function initDaemonLogger(opts) {
 __name(initDaemonLogger, "initDaemonLogger");
 
 // packages/cli/src/serve/run-qwen-serve.ts
-var QWEN_SERVER_TOKEN_ENV = "QWEN_SERVER_TOKEN";
+var QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV = "QWEN_SERVE_CLIENT_MCP_OVER_WS";
+var QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV = "QWEN_SERVE_CDP_TUNNEL_OVER_WS";
 var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
 var QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV = "QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS";
 var SHUTDOWN_FORCE_CLOSE_MS = 5e3;
 var DEFAULT_RUNTIME_STARTUP_TIMEOUT_MS = 12e4;
+var FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS = 50;
+var FAST_PATH_RUNTIME_START_FALLBACK_MS = 1e3;
 var RUNTIME_STARTUP_TIMEOUT_ENV = "QWEN_SERVE_RUNTIME_STARTUP_TIMEOUT_MS";
 var MAX_EVENT_RING_SIZE = 1e6;
 var DEFAULT_MAX_SESSIONS = 20;
@@ -436,6 +413,18 @@ function parseDeadlineEnv(envName, raw) {
   return parsed;
 }
 __name(parseDeadlineEnv, "parseDeadlineEnv");
+function envFlagDisabled(raw) {
+  if (raw === void 0) return false;
+  const normalized = raw.trim().toLowerCase();
+  return normalized === "0" || normalized === "false";
+}
+__name(envFlagDisabled, "envFlagDisabled");
+function hasChromeExtensionOrigin(origins) {
+  return origins?.some(
+    (origin) => origin.trim().toLowerCase().startsWith("chrome-extension://")
+  ) === true;
+}
+__name(hasChromeExtensionOrigin, "hasChromeExtensionOrigin");
 function createDaemonTelemetryRuntimeConfig(telemetry, cliVersion, daemonSessionId, defaults) {
   return {
     getTelemetryEnabled: /* @__PURE__ */ __name(() => telemetry.enabled ?? false, "getTelemetryEnabled"),
@@ -506,6 +495,14 @@ function formatHostForUrl(host) {
   return host;
 }
 __name(formatHostForUrl, "formatHostForUrl");
+function formatChannelWorkerDaemonUrl(host, port) {
+  const normalized = host.trim().toLowerCase();
+  if (normalized === "" || normalized === "0.0.0.0" || normalized === "::" || normalized === "[::]") {
+    return `http://127.0.0.1:${port}`;
+  }
+  return `http://${formatHostForUrl(host)}:${port}`;
+}
+__name(formatChannelWorkerDaemonUrl, "formatChannelWorkerDaemonUrl");
 function extractContextFilename(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -531,6 +528,52 @@ function withSettingsLock(workspace, fn) {
   return next;
 }
 __name(withSettingsLock, "withSettingsLock");
+var channelWorkerRuntimePromise;
+async function loadChannelWorkerRuntime() {
+  channelWorkerRuntimePromise ??= Promise.all([
+    import("./channel-worker-supervisor-C3IB63V7.js"),
+    import("./pidfile-KW2QQJZI.js")
+  ]).then(([supervisor, pidfile]) => ({
+    createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
+    channelServicePidfile: pidfile
+  })).catch((err) => {
+    channelWorkerRuntimePromise = void 0;
+    throw err;
+  });
+  return channelWorkerRuntimePromise;
+}
+__name(loadChannelWorkerRuntime, "loadChannelWorkerRuntime");
+function createDisabledChannelWorkerSupervisor() {
+  const snapshot = {
+    enabled: false,
+    state: "disabled",
+    channels: []
+  };
+  return {
+    async start() {
+    },
+    async stop() {
+    },
+    killAllSync() {
+    },
+    snapshot: /* @__PURE__ */ __name(() => ({ ...snapshot, channels: [] }), "snapshot")
+  };
+}
+__name(createDisabledChannelWorkerSupervisor, "createDisabledChannelWorkerSupervisor");
+function writeServeChannelReservation(channelServicePidfile, channels) {
+  channelServicePidfile.reserveServeServiceInfo({
+    channels,
+    servePid: process.pid
+  });
+}
+__name(writeServeChannelReservation, "writeServeChannelReservation");
+function channelServicePidfileConflictError(info) {
+  const owner = info.owner === "serve" ? "qwen serve" : "qwen channel start";
+  return new Error(
+    `Channel service is already running under ${owner} (PID ${info.pid}). Stop it before starting qwen serve --channel.`
+  );
+}
+__name(channelServicePidfileConflictError, "channelServicePidfileConflictError");
 function normalizeInstallModelIds(req, provider, getDefaultModelIds) {
   const fromRequest = req.modelIds?.map((id) => id.trim()).filter((id) => id.length > 0);
   const modelIds = fromRequest && fromRequest.length > 0 ? fromRequest : getDefaultModelIds(provider);
@@ -560,7 +603,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-KUV5J5Q2.js");
+  coreRuntimePromise ??= import("./src-IZSP7L6Y.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -590,9 +633,9 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-SGWRDQSC.js"),
-    import("./loadedSettingsAdapter-6KJXD6M3.js"),
-    import("./trustedFolders-5B24TMEA.js")
+    import("./settings-JCPVUZMB.js"),
+    import("./loadedSettingsAdapter-RUTZVVIA.js"),
+    import("./trustedFolders-RJ5WXJ6L.js")
   ]).then(([settings, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     loadedSettingsAdapter,
@@ -611,13 +654,13 @@ async function loadServeRuntimeModules() {
     daemonStatusProviderModule,
     workspaceProvidersStatusModule
   ] = await Promise.all([
-    import("./server-4QMUWXPW.js"),
-    import("./bridge-JL2PMCIW.js"),
-    import("./spawnChannel-3VHW5EPY.js"),
-    import("./workspace-service-YAIOD4HG.js"),
+    import("./server-BRKALJ4F.js"),
+    import("./bridge-AMOL4W4P.js"),
+    import("./spawnChannel-V3QT62TE.js"),
+    import("./workspace-service-CYMCOEIO.js"),
     import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-HH2EC5FI.js"),
-    import("./workspace-providers-status-PIAFVYHA.js")
+    import("./daemon-status-provider-H5SNMK42.js"),
+    import("./workspace-providers-status-4QIZN2W4.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -662,7 +705,11 @@ function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled) {
     persistSettingAvailable: true,
     sessionShellCommandEnabled,
     rateLimit: opts.rateLimit === true,
-    reloadAvailable: true
+    reloadAvailable: true,
+    // Advertise the same WS feature flags as the runtime path (serve-features.ts)
+    // so the bootstrap `/capabilities` window doesn't briefly under-report them.
+    clientMcpOverWsEnabled: opts.clientMcpOverWs === true,
+    cdpTunnelOverWsEnabled: opts.cdpTunnelOverWs === true
   });
 }
 __name(currentServeFeaturesForRunQwenServe, "currentServeFeaturesForRunQwenServe");
@@ -721,8 +768,23 @@ function installSameOriginOriginStrip(app, getPort) {
           `http://127.0.0.1:${port}`,
           `http://localhost:${port}`,
           `http://[::1]:${port}`,
-          `http://host.docker.internal:${port}`
+          `http://host.docker.internal:${port}`,
+          `https://127.0.0.1:${port}`,
+          `https://localhost:${port}`,
+          `https://[::1]:${port}`,
+          `https://host.docker.internal:${port}`
         ]);
+        if (port === 80 || port === 443) {
+          for (const host of [
+            "127.0.0.1",
+            "localhost",
+            "[::1]",
+            "host.docker.internal"
+          ]) {
+            cachedSelfOrigins.add(`http://${host}`);
+            cachedSelfOrigins.add(`https://${host}`);
+          }
+        }
       }
       if (cachedSelfOrigins.has(origin)) {
         delete req.headers.origin;
@@ -787,6 +849,14 @@ async function waitForRuntimeStartingForShutdown(runtimeStarting, daemonLog, tim
   });
 }
 __name(waitForRuntimeStartingForShutdown, "waitForRuntimeStartingForShutdown");
+var BOOTSTRAP_HEALTH_PATH = "/health";
+var BOOTSTRAP_CAPABILITIES_PATH = "/capabilities";
+var BOOTSTRAP_DAEMON_STATUS_PATH = "/daemon/status";
+var BOOTSTRAP_SERVE_PATHS = /* @__PURE__ */ new Set([
+  BOOTSTRAP_HEALTH_PATH,
+  BOOTSTRAP_CAPABILITIES_PATH,
+  BOOTSTRAP_DAEMON_STATUS_PATH
+]);
 function createBootstrapServeApp(input) {
   const {
     opts,
@@ -797,7 +867,9 @@ function createBootstrapServeApp(input) {
     qwenCodeVersion,
     sessionShellCommandEnabled,
     permissionPolicy,
-    getRuntimeError
+    getRuntimeError,
+    getChannelWorkerSnapshot,
+    onHealthServed
   } = input;
   const app = (0, import_express.default)();
   installSameOriginOriginStrip(app, getPort);
@@ -816,18 +888,21 @@ function createBootstrapServeApp(input) {
       });
       return;
     }
+    if (onHealthServed) {
+      res.once("finish", onHealthServed);
+    }
     res.status(200).json({ status: "ok" });
   }, "healthHandler");
   const loopback = isLoopbackBind(opts.hostname);
   const exposeHealthPreAuth = loopback && !opts.requireAuth;
   if (exposeHealthPreAuth) {
-    app.get("/health", healthHandler);
+    app.get(BOOTSTRAP_HEALTH_PATH, healthHandler);
   }
   app.use(bearerAuth(opts.token));
   if (!exposeHealthPreAuth) {
-    app.get("/health", healthHandler);
+    app.get(BOOTSTRAP_HEALTH_PATH, healthHandler);
   }
-  app.get("/capabilities", (_req, res) => {
+  app.get(BOOTSTRAP_CAPABILITIES_PATH, (_req, res) => {
     res.status(200).json(
       createBootstrapCapabilities({
         opts,
@@ -838,7 +913,7 @@ function createBootstrapServeApp(input) {
       })
     );
   });
-  app.get("/daemon/status", (req, res) => {
+  app.get(BOOTSTRAP_DAEMON_STATUS_PATH, (req, res) => {
     const detail = parseDaemonStatusDetail(req.query["detail"]);
     if (!detail.ok || !detail.detail) {
       res.status(400).json({
@@ -848,6 +923,7 @@ function createBootstrapServeApp(input) {
       return;
     }
     const runtimeError = getRuntimeError();
+    const channelWorker = getChannelWorkerSnapshot();
     const runtimeFailed = runtimeError !== void 0;
     const issue = runtimeError ? {
       code: "daemon_runtime_failed",
@@ -914,6 +990,7 @@ function createBootstrapServeApp(input) {
           policy: permissionPolicy ?? "first-responder"
         },
         channel: { live: false },
+        channelWorker,
         transport: {
           restSseActive: 0,
           acp: {
@@ -960,16 +1037,58 @@ function createBootstrapServeApp(input) {
   return app;
 }
 __name(createBootstrapServeApp, "createBootstrapServeApp");
-function createDelegatingServeApp(bootstrapApp, getRuntimeApp) {
+function createDelegatingServeApp(bootstrapApp, getRuntimeApp, options = {}) {
   const app = (0, import_express.default)();
   app.use((req, res, next) => {
-    const target = getRuntimeApp() ?? bootstrapApp;
-    const handler = target;
-    handler(req, res, next);
+    const dispatch = /* @__PURE__ */ __name(async () => {
+      let target = getRuntimeApp();
+      if (!target && options.waitForDeferredRuntimeRoutes === true && !isBootstrapServeRoute(req) && !isCorsPreflightRequest(req) && options.startRuntime && options.runtimeReady) {
+        if (options.authenticateDeferredRuntimeRequest && !runSynchronousRequestGate(
+          options.authenticateDeferredRuntimeRequest,
+          req,
+          res,
+          next
+        )) {
+          return;
+        }
+        options.startRuntime();
+        try {
+          await options.runtimeReady;
+        } catch {
+        }
+        target = getRuntimeApp();
+      }
+      const handler = target ?? bootstrapApp;
+      handler(req, res, next);
+    }, "dispatch");
+    void dispatch().catch(next);
   });
   return app;
 }
 __name(createDelegatingServeApp, "createDelegatingServeApp");
+function isBootstrapServeRoute(req) {
+  const path2 = req.path.length > 1 && req.path.endsWith("/") ? req.path.slice(0, -1) : req.path;
+  return BOOTSTRAP_SERVE_PATHS.has(path2);
+}
+__name(isBootstrapServeRoute, "isBootstrapServeRoute");
+function isCorsPreflightRequest(req) {
+  return req.method === "OPTIONS" && Boolean(req.headers.origin) && Boolean(
+    req.headers["access-control-request-method"] || req.headers["access-control-request-headers"]
+  );
+}
+__name(isCorsPreflightRequest, "isCorsPreflightRequest");
+function runSynchronousRequestGate(handler, req, res, next) {
+  let passed = false;
+  handler(req, res, (err) => {
+    if (err) {
+      next(err);
+      return;
+    }
+    passed = true;
+  });
+  return passed;
+}
+__name(runSynchronousRequestGate, "runSynchronousRequestGate");
 async function runQwenServe(optsIn, deps = {}) {
   const runStartedAt = performance.now();
   const shouldPreheat = !deps.bridge && shouldPreheatBridge(deps);
@@ -998,12 +1117,78 @@ async function runQwenServe(optsIn, deps = {}) {
     QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV,
     process.env[QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV]
   );
+  const clientMcpOverWsEnv = process.env[QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV];
+  const cdpTunnelOverWsEnv = process.env[QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV];
+  const chromeExtensionOriginAllowed = hasChromeExtensionOrigin(
+    optsIn.allowOrigins
+  );
   const opts = {
     ...optsIn,
     token,
     promptDeadlineMs,
-    writerIdleTimeoutMs
+    writerIdleTimeoutMs,
+    clientMcpOverWs: optsIn.clientMcpOverWs ?? (!envFlagDisabled(clientMcpOverWsEnv) && clientMcpOverWsEnv !== void 0),
+    cdpTunnelOverWs: optsIn.cdpTunnelOverWs ?? (!envFlagDisabled(cdpTunnelOverWsEnv) && (cdpTunnelOverWsEnv !== void 0 || chromeExtensionOriginAllowed))
   };
+  const channelRuntime = opts.channelSelection ? await loadChannelWorkerRuntime() : void 0;
+  const channelServicePidfile = deps.channelServicePidfile ?? channelRuntime?.channelServicePidfile;
+  let channelPidfileReserved = false;
+  const removeCurrentServePidfile = /* @__PURE__ */ __name(() => {
+    if (!opts.channelSelection || !channelServicePidfile) return;
+    if (!channelPidfileReserved) return;
+    if (channelServicePidfile.removeServeServiceInfo) {
+      if (channelServicePidfile.removeServeServiceInfo(process.pid)) {
+        channelPidfileReserved = false;
+      }
+      return;
+    }
+    const info = channelServicePidfile.readServiceInfo();
+    if (info?.owner === "serve" && info.pid === process.pid && info.servePid === process.pid) {
+      channelServicePidfile.removeServiceInfo();
+      channelPidfileReserved = false;
+    }
+  }, "removeCurrentServePidfile");
+  const reserveChannelServicePidfile = /* @__PURE__ */ __name(() => {
+    if (!opts.channelSelection) return;
+    if (!channelServicePidfile) {
+      throw new Error("Channel service pidfile runtime is not available.");
+    }
+    const channelPidfileNames = channelSelectionNames(opts.channelSelection);
+    const existingChannelService = channelServicePidfile.readServiceInfo();
+    if (existingChannelService) {
+      throw channelServicePidfileConflictError(existingChannelService);
+    }
+    try {
+      writeServeChannelReservation(channelServicePidfile, channelPidfileNames);
+      channelPidfileReserved = true;
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err) {
+        const code = err.code;
+        if (code === "EEXIST") {
+          const info = channelServicePidfile.readServiceInfo();
+          if (info) {
+            throw channelServicePidfileConflictError(info);
+          }
+          try {
+            writeServeChannelReservation(
+              channelServicePidfile,
+              channelPidfileNames
+            );
+            channelPidfileReserved = true;
+            return;
+          } catch (retryErr) {
+            if (retryErr && typeof retryErr === "object" && "code" in retryErr && retryErr.code === "EEXIST") {
+              throw new Error(
+                "Channel service is already starting. Retry after the current startup finishes."
+              );
+            }
+            throw retryErr;
+          }
+        }
+      }
+      throw err;
+    }
+  }, "reserveChannelServicePidfile");
   validateRateLimitOptions(opts);
   if (!opts.hostname.startsWith("[") && opts.hostname.split(":").length === 2) {
     const [host, port] = opts.hostname.split(":");
@@ -1011,6 +1196,50 @@ async function runQwenServe(optsIn, deps = {}) {
       `Invalid --hostname "${opts.hostname}": looks like a "host:port" combination. Use --port for the port, e.g. "--hostname ${host} --port ${port}".`
     );
   }
+  let tlsOptions;
+  if (opts.tlsCert && !opts.tlsKey || !opts.tlsCert && opts.tlsKey) {
+    throw new Error(
+      `--tls-cert and --tls-key must be provided together (got only --tls-${opts.tlsCert ? "cert" : "key"}).`
+    );
+  }
+  if (opts.tlsCert && opts.tlsKey) {
+    let cert;
+    let key;
+    try {
+      cert = fs.readFileSync(opts.tlsCert);
+    } catch (err) {
+      throw new Error(
+        `Failed to read --tls-cert "${opts.tlsCert}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    try {
+      key = fs.readFileSync(opts.tlsKey);
+    } catch (err) {
+      throw new Error(
+        `Failed to read --tls-key "${opts.tlsKey}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let x509;
+    try {
+      x509 = new X509Certificate(cert);
+    } catch (err) {
+      throw new Error(
+        `--tls-cert "${opts.tlsCert}" is not a valid certificate: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const now = Date.now();
+    if (new Date(x509.validTo).getTime() < now) {
+      throw new Error(
+        `--tls-cert "${opts.tlsCert}" expired on ${x509.validTo}. Renew the certificate and restart.`
+      );
+    }
+    if (new Date(x509.validFrom).getTime() > now) {
+      throw new Error(
+        `--tls-cert "${opts.tlsCert}" is not yet valid (validFrom: ${x509.validFrom}). Check the certificate's notBefore date or the system clock.`
+      );
+    }
+    tlsOptions = { cert, key };
+  }
   if (!isLoopbackBind(opts.hostname) && !token) {
     throw new Error(
       `Refusing to bind ${opts.hostname}:${opts.port} without a bearer token. Set ${QWEN_SERVER_TOKEN_ENV} or pass --token, or rebind to loopback (127.0.0.1, localhost, ::1, or [::1]).`
@@ -1182,7 +1411,8 @@ async function runQwenServe(optsIn, deps = {}) {
   }
   const childEnvOverrides = {
     QWEN_SERVE_MCP_CLIENT_BUDGET: opts.mcpClientBudget !== void 0 ? String(opts.mcpClientBudget) : void 0,
-    QWEN_SERVE_MCP_BUDGET_MODE: opts.mcpBudgetMode
+    QWEN_SERVE_MCP_BUDGET_MODE: opts.mcpBudgetMode,
+    QWEN_SERVE_CDP_TUNNEL_OVER_WS: opts.cdpTunnelOverWs ? "1" : void 0
   };
   const cliVersionPromise = getCliVersion();
   let cliVersion;
@@ -1217,12 +1447,31 @@ async function runQwenServe(optsIn, deps = {}) {
   let markRuntimeReady;
   let markRuntimeFailed;
   let runtimeStartupSettled = false;
+  let startRuntimeAfterHealth;
+  let startRuntimeForRequest;
+  const deferRuntimeUntilFirstHealth = deps.resolveOnListen === true && deps.deferRuntimeUntilFirstHealth === true;
   const runtimeReady = new Promise((resolve, reject) => {
     markRuntimeReady = resolve;
     markRuntimeFailed = reject;
   });
   void runtimeReady.catch(() => {
   });
+  let channelWorker = createDisabledChannelWorkerSupervisor();
+  const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorker.snapshot(), "getChannelWorkerSnapshot");
+  const writeChannelWorkerPidfile = /* @__PURE__ */ __name((snapshot = channelWorker.snapshot(), options = {}) => {
+    if (!opts.channelSelection || !channelServicePidfile) return;
+    try {
+      channelServicePidfile.writeServeServiceInfo({
+        channels: snapshot.channels,
+        servePid: process.pid,
+        ...!options.clearWorkerPid && snapshot.pid !== void 0 ? { workerPid: snapshot.pid } : {}
+      });
+    } catch (err) {
+      daemonLog.warn(
+        `failed to write channel worker pidfile metadata: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }, "writeChannelWorkerPidfile");
   const handleBridge = deps.bridge ?? createLazyBridgeProxy(
     () => bridgeRef,
     () => runtimeStartupError
@@ -1329,6 +1578,7 @@ async function runQwenServe(optsIn, deps = {}) {
     });
     const statusProvider = runtime.createDaemonStatusProvider();
     const workspaceProvidersStatusProvider = runtime.createWorkspaceProvidersStatusProvider();
+    const clientMcpSenderRegistry = new ClientMcpSenderRegistry();
     const persistDisabledToolsFn = /* @__PURE__ */ __name((workspace, toolName, enabled) => withSettingsLock(workspace, async () => {
       const fresh = settingsRuntime.settings.loadSettings(workspace);
       const wsScope = fresh.forScope(WORKSPACE_SETTING_SCOPE).settings;
@@ -1376,6 +1626,9 @@ async function runQwenServe(optsIn, deps = {}) {
       }
     }), "persistSettingsFn");
     const bridge = deps.bridge ?? runtime.createAcpSessionBridge({
+      // Reverse tool channel: let `BridgeClient.extMethod` reach the WS
+      // connection that hosts a named client MCP server (#5626).
+      clientMcpSender: clientMcpSenderRegistry.lookup,
       maxSessions: opts.maxSessions,
       ...opts.maxPendingPromptsPerSession !== void 0 ? { maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession } : {},
       ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
@@ -1438,7 +1691,11 @@ async function runQwenServe(optsIn, deps = {}) {
       startup,
       fsFactory,
       daemonLog,
+      getChannelWorkerSnapshot,
       workspace: workspaceService,
+      // Reverse tool channel (#5626): the SAME registry wired into `bridge` above,
+      // so the WS provider and the child-answering bridge share one sender map.
+      clientMcpSenderRegistry,
       persistDisabledTools: persistDisabledToolsFn,
       persistSetting: persistSettingFn,
       persistSettings: persistSettingsFn,
@@ -1487,8 +1744,10 @@ async function runQwenServe(optsIn, deps = {}) {
     runtimeAppForCleanup = runtime.app;
     runtimeApp = runtime.app;
     bridgeRef = runtime.bridge;
-    runtimeStartupSettled = true;
-    markRuntimeReady();
+    if (!opts.channelSelection) {
+      runtimeStartupSettled = true;
+      markRuntimeReady();
+    }
   }
   cliVersion ??= await cliVersionPromise;
   const bootstrapApp = createBootstrapServeApp({
@@ -1500,9 +1759,16 @@ async function runQwenServe(optsIn, deps = {}) {
     qwenCodeVersion: cliVersion,
     sessionShellCommandEnabled,
     permissionPolicy,
-    getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError")
+    getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
+    getChannelWorkerSnapshot,
+    onHealthServed: deferRuntimeUntilFirstHealth ? () => startRuntimeAfterHealth?.() : void 0
+  });
+  const app = runtimeApp ?? createDelegatingServeApp(bootstrapApp, () => runtimeApp, {
+    waitForDeferredRuntimeRoutes: deferRuntimeUntilFirstHealth,
+    startRuntime: /* @__PURE__ */ __name(() => startRuntimeForRequest?.(), "startRuntime"),
+    runtimeReady,
+    authenticateDeferredRuntimeRequest: bearerAuth(opts.token)
   });
-  const app = runtimeApp ?? createDelegatingServeApp(bootstrapApp, () => runtimeApp);
   let listenHostname = opts.hostname;
   if (opts.hostname.startsWith("[")) {
     const inner = opts.hostname.slice(1, -1);
@@ -1518,8 +1784,9 @@ async function runQwenServe(optsIn, deps = {}) {
       `Invalid maxConnections: ${opts.maxConnections}. Must be >= 0 (0 / Infinity = unlimited).`
     );
   }
+  reserveChannelServicePidfile();
   return await new Promise((resolve, reject) => {
-    const server = app.listen(opts.port, listenHostname, () => {
+    const onListening = /* @__PURE__ */ __name(() => {
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
       startup.processToListenMs = Math.round(process.uptime() * 1e3);
       startup.runQwenServeToListenMs = Math.round(
@@ -1533,7 +1800,55 @@ async function runQwenServe(optsIn, deps = {}) {
       }
       const addr = server.address();
       actualPort = typeof addr === "object" && addr ? addr.port : opts.port;
-      const url = `http://${formatHostForUrl(opts.hostname)}:${actualPort}`;
+      const scheme = tlsOptions ? "https" : "http";
+      const url = `${scheme}://${formatHostForUrl(opts.hostname)}:${actualPort}`;
+      try {
+        if (opts.channelSelection) {
+          const createSupervisor = deps.channelWorkerSupervisorFactory ?? channelRuntime?.createChannelWorkerSupervisor;
+          if (!createSupervisor) {
+            throw new Error(
+              "Channel worker supervisor runtime is not available."
+            );
+          }
+          channelWorker = createSupervisor({
+            cliEntryPath: findCliEntryPath(),
+            daemonUrl: formatChannelWorkerDaemonUrl(opts.hostname, actualPort),
+            ...token ? { daemonToken: token } : {},
+            workspace: boundWorkspace,
+            selection: opts.channelSelection,
+            onReady: /* @__PURE__ */ __name((snapshot) => {
+              writeChannelWorkerPidfile(snapshot);
+            }, "onReady"),
+            onLog: /* @__PURE__ */ __name(({ stream, line }) => {
+              const message = `channel worker ${stream}: ${line}`;
+              if (stream === "stderr") {
+                daemonLog.warn(message);
+              } else {
+                daemonLog.info(message);
+              }
+            }, "onLog"),
+            onExit: /* @__PURE__ */ __name((snapshot) => {
+              daemonLog.warn(
+                `channel worker exited (state=${snapshot.state}, pid=${snapshot.pid ?? "unknown"}, code=${snapshot.exitCode ?? "null"}, signal=${snapshot.signal ?? "null"}, error=${snapshot.error ?? "none"}, restartCount=${snapshot.restartCount ?? 0}, nextRestartAt=${snapshot.nextRestartAt ?? "none"}, staleHeartbeatAt=${snapshot.staleHeartbeatAt ?? "none"})`
+              );
+              writeChannelWorkerPidfile(snapshot, { clearWorkerPid: true });
+            }, "onExit")
+          });
+        }
+      } catch (err) {
+        removeCurrentServePidfile();
+        const error = err instanceof Error ? err : new Error(String(err));
+        server.close((closeErr) => {
+          if (closeErr) {
+            daemonLog.error(
+              "server close after channel worker setup error failed",
+              closeErr
+            );
+          }
+          reject(error);
+        });
+        return;
+      }
       writeStdoutLine(
         `qwen serve listening on ${url} (mode=${opts.mode}, workspace=${boundWorkspace})`
       );
@@ -1547,6 +1862,11 @@ async function runQwenServe(optsIn, deps = {}) {
         writeStderrLine(
           `qwen serve: bearer auth disabled (loopback default). Set ${QWEN_SERVER_TOKEN_ENV} to enable.`
         );
+        if (opts.clientMcpOverWs === true) {
+          writeStderrLine(
+            `qwen serve: client-hosted MCP tools are accepted over the WebSocket without auth. Set ${QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV}=0 to disable.`
+          );
+        }
       } else if (opts.requireAuth) {
         writeStderrLine(
           "qwen serve: --require-auth enabled (bearer token mandatory on every route, including loopback /health)."
@@ -1555,6 +1875,8 @@ async function runQwenServe(optsIn, deps = {}) {
       let shuttingDown = false;
       let closePromise;
       let runtimeStartupTimer;
+      let runtimeStartAfterHealthTimer;
+      let runtimeStartFallbackTimer;
       const runtimeStartupTimeoutMs = resolveRuntimeStartupTimeoutMs(
         deps.runtimeStartupTimeoutMs
       );
@@ -1563,6 +1885,27 @@ async function runQwenServe(optsIn, deps = {}) {
         clearTimeout(runtimeStartupTimer);
         runtimeStartupTimer = void 0;
       }, "clearRuntimeStartupTimer");
+      const clearRuntimeStartFallbackTimer = /* @__PURE__ */ __name(() => {
+        if (!runtimeStartFallbackTimer) return;
+        clearTimeout(runtimeStartFallbackTimer);
+        runtimeStartFallbackTimer = void 0;
+      }, "clearRuntimeStartFallbackTimer");
+      const clearRuntimeStartAfterHealthTimer = /* @__PURE__ */ __name(() => {
+        if (!runtimeStartAfterHealthTimer) return;
+        clearTimeout(runtimeStartAfterHealthTimer);
+        runtimeStartAfterHealthTimer = void 0;
+      }, "clearRuntimeStartAfterHealthTimer");
+      const cancelDeferredRuntimeStartup = /* @__PURE__ */ __name(() => {
+        if (!deferRuntimeUntilFirstHealth || runtimeStarting || runtimeStartupSettled)
+          return;
+        daemonLog.info(
+          "deferred runtime: cancelled, server closed before startup"
+        );
+        runtimeStartupSettled = true;
+        const error = new Error(RUNTIME_STARTUP_CANCELLED_MESSAGE);
+        runtimeStartupError = error.message;
+        markRuntimeFailed(error);
+      }, "cancelDeferredRuntimeStartup");
       const shutdownBridgeAfterFailedStartup = /* @__PURE__ */ __name(async (bridge) => {
         if (!bridge || deps.bridge) return;
         try {
@@ -1578,6 +1921,14 @@ async function runQwenServe(optsIn, deps = {}) {
           }
         }
       }, "shutdownBridgeAfterFailedStartup");
+      const stopChannelWorkerAfterFailedStartup = /* @__PURE__ */ __name(async () => {
+        await channelWorker.stop().catch((stopErr) => {
+          daemonLog.error(
+            "channel worker stop after runtime startup error failed",
+            stopErr instanceof Error ? stopErr : null
+          );
+        });
+      }, "stopChannelWorkerAfterFailedStartup");
       const failRuntimeStartup = /* @__PURE__ */ __name(async (err, bridgeForCleanup) => {
         const error = err instanceof Error ? err : new Error(String(err));
         if (runtimeStartupSettled) {
@@ -1594,9 +1945,33 @@ async function runQwenServe(optsIn, deps = {}) {
         }
         writeStderrLine(`qwen serve: runtime startup failed: ${message}`);
         daemonLog.error("runtime startup failed", error);
-        markRuntimeFailed(error);
+        await stopChannelWorkerAfterFailedStartup();
+        removeCurrentServePidfile();
         await shutdownBridgeAfterFailedStartup(bridgeForCleanup ?? bridgeRef);
+        markRuntimeFailed(error);
       }, "failRuntimeStartup");
+      const armRuntimeStartupTimer = /* @__PURE__ */ __name(() => {
+        if (runtimeStartupTimeoutMs <= 0 || runtimeStartupTimer) return;
+        runtimeStartupTimer = setTimeout(() => {
+          void failRuntimeStartup(
+            new Error(
+              `Daemon runtime startup timed out after ${runtimeStartupTimeoutMs}ms.`
+            )
+          );
+        }, runtimeStartupTimeoutMs);
+        runtimeStartupTimer.unref();
+      }, "armRuntimeStartupTimer");
+      const completeRuntimeStartup = /* @__PURE__ */ __name(async () => {
+        if (runtimeStartupSettled) return;
+        if (opts.channelSelection) {
+          await channelWorker.start();
+          if (runtimeStartupSettled) return;
+        }
+        if (runtimeStartupSettled) return;
+        runtimeStartupSettled = true;
+        clearRuntimeStartupTimer();
+        markRuntimeReady();
+      }, "completeRuntimeStartup");
       const startBridgePreheat = /* @__PURE__ */ __name((bridge) => {
         startup.preheat.status = "running";
         const preheatStartedAt = performance.now();
@@ -1619,6 +1994,9 @@ async function runQwenServe(optsIn, deps = {}) {
       }, "startBridgePreheat");
       const startRuntime = /* @__PURE__ */ __name(() => {
         if (runtimeStarting) return;
+        armRuntimeStartupTimer();
+        clearRuntimeStartAfterHealthTimer();
+        clearRuntimeStartFallbackTimer();
         runtimeStarting = buildRuntime().then(async (runtime) => {
           if (runtimeStartupSettled) {
             await shutdownBridgeAfterFailedStartup(runtime.bridge);
@@ -1639,26 +2017,47 @@ async function runQwenServe(optsIn, deps = {}) {
           if (shouldPreheat) {
             startBridgePreheat(runtime.bridge);
           }
-          runtimeStartupSettled = true;
-          clearRuntimeStartupTimer();
-          markRuntimeReady();
+          await completeRuntimeStartup();
         }).catch((err) => failRuntimeStartup(err));
-        if (runtimeStartupTimeoutMs > 0) {
-          runtimeStartupTimer = setTimeout(() => {
-            void failRuntimeStartup(
-              new Error(
-                `Daemon runtime startup timed out after ${runtimeStartupTimeoutMs}ms.`
-              )
-            );
-          }, runtimeStartupTimeoutMs);
-          runtimeStartupTimer.unref();
-        }
       }, "startRuntime");
+      startRuntimeForRequest = startRuntime;
+      const scheduleRuntimeStartFallback = /* @__PURE__ */ __name(() => {
+        if (shuttingDown || runtimeStarting || runtimeStartFallbackTimer)
+          return;
+        daemonLog.info(
+          `deferred runtime: scheduling fallback start in ${FAST_PATH_RUNTIME_START_FALLBACK_MS}ms`
+        );
+        runtimeStartFallbackTimer = setTimeout(() => {
+          runtimeStartFallbackTimer = void 0;
+          if (shuttingDown) return;
+          daemonLog.info("deferred runtime: fallback timer fired, starting");
+          startRuntime();
+        }, FAST_PATH_RUNTIME_START_FALLBACK_MS);
+        runtimeStartFallbackTimer.unref();
+      }, "scheduleRuntimeStartFallback");
+      startRuntimeAfterHealth = /* @__PURE__ */ __name(() => {
+        if (shuttingDown || runtimeStarting || runtimeStartAfterHealthTimer) {
+          return;
+        }
+        clearRuntimeStartFallbackTimer();
+        daemonLog.info(
+          `deferred runtime: health served, scheduling start in ${FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS}ms`
+        );
+        runtimeStartAfterHealthTimer = setTimeout(() => {
+          runtimeStartAfterHealthTimer = void 0;
+          if (shuttingDown) return;
+          daemonLog.info("deferred runtime: health timer fired, starting");
+          startRuntime();
+        }, FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS);
+        runtimeStartAfterHealthTimer.unref();
+      }, "startRuntimeAfterHealth");
       const onSignal = /* @__PURE__ */ __name(async (signal) => {
         if (shuttingDown) {
           daemonLog.warn(`received ${signal} during drain \u2014 forcing exit`);
           try {
+            channelWorker.killAllSync();
             bridgeRef?.killAllSync();
+            removeCurrentServePidfile();
           } catch (err) {
             daemonLog.error(
               "force-kill error",
@@ -1682,6 +2081,11 @@ async function runQwenServe(optsIn, deps = {}) {
           process.exit(1);
         }
       }, "onSignal");
+      const onUncaughtExceptionMonitor = /* @__PURE__ */ __name(() => {
+        if (process.listenerCount("uncaughtException") === 0) {
+          removeCurrentServePidfile();
+        }
+      }, "onUncaughtExceptionMonitor");
       const handle = {
         server,
         url,
@@ -1693,6 +2097,9 @@ async function runQwenServe(optsIn, deps = {}) {
           if (closePromise) return closePromise;
           closePromise = new Promise((res, rej) => {
             shuttingDown = true;
+            clearRuntimeStartAfterHealthTimer();
+            clearRuntimeStartFallbackTimer();
+            cancelDeferredRuntimeStartup();
             let settled = false;
             let bridgeShutdownError;
             const finish = /* @__PURE__ */ __name((err) => {
@@ -1700,6 +2107,10 @@ async function runQwenServe(optsIn, deps = {}) {
               settled = true;
               process.removeListener("SIGINT", onSignal);
               process.removeListener("SIGTERM", onSignal);
+              process.removeListener(
+                "uncaughtExceptionMonitor",
+                onUncaughtExceptionMonitor
+              );
               void (coreRuntimePromise ? coreRuntimePromise.then((core) => core.shutdownTelemetry()) : Promise.resolve()).catch((telemetryErr) => {
                 writeStderrLine(
                   `qwen serve: telemetry shutdown error: ${telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr)}`
@@ -1747,6 +2158,13 @@ async function runQwenServe(optsIn, deps = {}) {
                 rl.setDraining(true);
                 rl.dispose();
               }
+              await channelWorker.stop().catch((err) => {
+                daemonLog.error(
+                  "channel worker stop error",
+                  err instanceof Error ? err : null
+                );
+              });
+              removeCurrentServePidfile();
               const bridgeForShutdown = bridgeRef;
               if (bridgeForShutdown) {
                 await bridgeForShutdown.shutdown().catch((err) => {
@@ -1786,6 +2204,7 @@ async function runQwenServe(optsIn, deps = {}) {
       };
       process.on("SIGINT", onSignal);
       process.on("SIGTERM", onSignal);
+      process.on("uncaughtExceptionMonitor", onUncaughtExceptionMonitor);
       server.removeAllListeners("error");
       server.on("error", (err) => {
         daemonLog.error("server error", err instanceof Error ? err : null);
@@ -1796,6 +2215,14 @@ async function runQwenServe(optsIn, deps = {}) {
         if (shouldPreheat) {
           startBridgePreheat(bridgeRef);
         }
+        if (opts.channelSelection && !runtimeStartupSettled) {
+          armRuntimeStartupTimer();
+          runtimeStarting = completeRuntimeStartup().catch(
+            (err) => failRuntimeStartup(err, bridgeRef)
+          );
+        }
+      } else if (deferRuntimeUntilFirstHealth) {
+        scheduleRuntimeStartFallback();
       } else {
         startRuntime();
       }
@@ -1816,8 +2243,28 @@ async function runQwenServe(optsIn, deps = {}) {
           }
         );
       }
+    }, "onListening");
+    let server;
+    if (tlsOptions) {
+      let httpsServer;
+      try {
+        httpsServer = https.createServer(tlsOptions, app);
+      } catch (err) {
+        reject(
+          new Error(
+            `--tls-cert "${opts.tlsCert}" and --tls-key "${opts.tlsKey}" could not be loaded (do they match?): ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        return;
+      }
+      server = httpsServer.listen(opts.port, listenHostname, onListening);
+    } else {
+      server = app.listen(opts.port, listenHostname, onListening);
+    }
+    server.once("error", (err) => {
+      removeCurrentServePidfile();
+      reject(err);
     });
-    server.once("error", reject);
   });
 }
 __name(runQwenServe, "runQwenServe");
@@ -1825,6 +2272,7 @@ export {
   InvalidPolicyConfigError,
   createLazyBridgeProxy,
   extractContextFilename,
+  formatChannelWorkerDaemonUrl,
   resolveRuntimeStartupTimeoutMs,
   runQwenServe,
   validatePolicyConfig,