@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/chunk-P6UIF2OW.js

@@ -0,0 +1,400 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  STATUS_SCHEMA_VERSION
+} from "./chunk-64QH2UC6.js";
+import {
+  WorkspaceDrainingError
+} from "./chunk-F47DITLZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-runtime-coordinator.ts
+init_esbuild_shims();
+var DEFAULT_ENSURE_TIMEOUT_MS = 6e4;
+var ENSURE_KEEP_ALIVE_MS = 10 * 6e4;
+var MCP_PREPARE_TIMEOUT_MS = 2 * 6e4;
+var MCP_POLL_INTERVAL_MS = 250;
+var WorkspaceRuntimeStillStartingError = class extends Error {
+  static {
+    __name(this, "WorkspaceRuntimeStillStartingError");
+  }
+  constructor() {
+    super("Workspace runtime is still starting");
+    this.name = "WorkspaceRuntimeStillStartingError";
+  }
+};
+var WorkspaceRuntimeInitializationError = class extends Error {
+  static {
+    __name(this, "WorkspaceRuntimeInitializationError");
+  }
+  constructor(cause) {
+    super("Workspace runtime failed to initialize", { cause });
+    this.name = "WorkspaceRuntimeInitializationError";
+  }
+};
+function withTimeout(operation, timeoutMs) {
+  let timer;
+  return Promise.race([
+    operation,
+    new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new WorkspaceRuntimeStillStartingError()),
+        timeoutMs
+      );
+      timer.unref?.();
+    })
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+__name(withTimeout, "withTimeout");
+function supportsWorkspaceRuntimeLifecycle(bridge) {
+  return typeof bridge.getWorkspaceRuntimeLifecycleSnapshot === "function";
+}
+__name(supportsWorkspaceRuntimeLifecycle, "supportsWorkspaceRuntimeLifecycle");
+var WorkspaceRuntimeCoordinator = class {
+  constructor(runtime, bridge) {
+    this.runtime = runtime;
+    this.bridge = bridge;
+  }
+  static {
+    __name(this, "WorkspaceRuntimeCoordinator");
+  }
+  disposed = false;
+  draining = false;
+  activeManagementOperations = 0;
+  mcpRevision = 0;
+  mcpConfigRevision = 0;
+  mcpStatus = {
+    state: "not_started",
+    revision: 0
+  };
+  mcpReconcileDeferred = false;
+  mcpPhysicalTail = Promise.resolve();
+  mcpQueuedWork = 0;
+  beginDrain() {
+    this.draining = true;
+  }
+  cancelDrain() {
+    if (this.disposed) return;
+    this.draining = false;
+    if (this.mcpReconcileDeferred) {
+      this.mcpReconcileDeferred = false;
+      this.scheduleMcpReconciliation();
+    }
+  }
+  hasActiveWork() {
+    return this.activeManagementOperations > 0 || this.mcpQueuedWork > 0 || this.bridge.getWorkspaceRuntimeLifecycleSnapshot().activeWork;
+  }
+  dispose() {
+    this.disposed = true;
+    this.draining = true;
+  }
+  status() {
+    const snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    const mcpStatus = this.mcpStatus.runtimeEpoch !== void 0 && (!snapshot.runtimeLive || this.mcpStatus.runtimeEpoch !== snapshot.runtimeEpoch) ? {
+      state: "stale",
+      revision: this.mcpStatus.revision,
+      runtimeEpoch: this.mcpStatus.runtimeEpoch
+    } : this.mcpStatus;
+    return {
+      v: STATUS_SCHEMA_VERSION,
+      workspaceCwd: this.runtime.workspaceCwd,
+      state: snapshot.state,
+      runtimeLive: snapshot.runtimeLive,
+      runtimeEpoch: snapshot.runtimeEpoch,
+      capabilities: { mcp: mcpStatus }
+    };
+  }
+  async ensure(timeoutMs = DEFAULT_ENSURE_TIMEOUT_MS) {
+    this.assertAcceptingWork();
+    const deadline = Date.now() + timeoutMs;
+    try {
+      await withTimeout(
+        this.bridge.preheat({ keepAliveMs: ENSURE_KEEP_ALIVE_MS }),
+        timeoutMs
+      );
+    } catch (error) {
+      this.assertAcceptingWork(error);
+      if (error instanceof WorkspaceRuntimeStillStartingError) throw error;
+      throw new WorkspaceRuntimeInitializationError(error);
+    }
+    this.assertAcceptingWork();
+    const status = this.status();
+    if (!status.runtimeLive) {
+      throw new WorkspaceRuntimeInitializationError(
+        new Error("ACP preheat completed without a live runtime")
+      );
+    }
+    const revision = this.mcpRevision;
+    const preparation = this.prepareMcp();
+    void preparation.catch((error) => {
+      this.recordMcpError(revision, status.runtimeEpoch, error);
+    });
+    const remainingMs = deadline - Date.now();
+    if (remainingMs > 0) {
+      try {
+        await withTimeout(preparation, remainingMs);
+      } catch (error) {
+        if (!(error instanceof WorkspaceRuntimeStillStartingError)) throw error;
+      }
+    }
+    return this.status();
+  }
+  async runManagementOperation(run) {
+    this.assertAcceptingWork();
+    this.activeManagementOperations += 1;
+    try {
+      return await run();
+    } finally {
+      this.activeManagementOperations -= 1;
+    }
+  }
+  reconcileMcpConfiguration() {
+    this.mcpRevision += 1;
+    this.mcpConfigRevision += 1;
+    return this.scheduleMcpReconciliation();
+  }
+  scheduleMcpReconciliation() {
+    const snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    if (!snapshot.runtimeLive || this.draining || this.disposed) {
+      this.mcpReconcileDeferred ||= snapshot.runtimeLive && this.draining;
+      this.mcpStatus = {
+        state: this.mcpStatus.runtimeEpoch === void 0 ? "not_started" : "stale",
+        revision: this.mcpRevision,
+        ...this.mcpStatus.runtimeEpoch === void 0 ? {} : { runtimeEpoch: this.mcpStatus.runtimeEpoch }
+      };
+      return "deferred";
+    }
+    this.mcpStatus = {
+      state: "starting",
+      revision: this.mcpRevision,
+      runtimeEpoch: snapshot.runtimeEpoch
+    };
+    const revision = this.mcpRevision;
+    const configRevision = this.mcpConfigRevision;
+    void this.queueMcpWork(async () => {
+      if (configRevision !== this.mcpConfigRevision) return;
+      await this.bridge.reloadWorkspaceMcp();
+      await this.prepareMcpRevision(revision);
+    }).catch((error) => {
+      if (this.draining && !this.disposed) this.mcpReconcileDeferred = true;
+      this.recordMcpError(revision, snapshot.runtimeEpoch, error);
+    });
+    return "reconciling";
+  }
+  async runMcpRuntimeMutation(run) {
+    this.assertAcceptingWork();
+    const revision = ++this.mcpRevision;
+    const initial = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    this.mcpStatus = {
+      state: initial.runtimeLive ? "starting" : "not_started",
+      revision,
+      ...initial.runtimeLive ? { runtimeEpoch: initial.runtimeEpoch } : {}
+    };
+    let started = false;
+    const operation = this.queueMcpWork(async () => {
+      started = true;
+      let snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+      let mutationRejected = false;
+      try {
+        if (!snapshot.runtimeLive) {
+          try {
+            await this.bridge.preheat({ keepAliveMs: ENSURE_KEEP_ALIVE_MS });
+          } catch (error) {
+            if (error instanceof WorkspaceRuntimeStillStartingError)
+              throw error;
+            throw new WorkspaceRuntimeInitializationError(error);
+          }
+          snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+          if (!snapshot.runtimeLive) {
+            throw new WorkspaceRuntimeInitializationError(
+              new Error("ACP preheat completed without a live runtime")
+            );
+          }
+        }
+        if (revision === this.mcpRevision) {
+          this.mcpStatus = {
+            state: "starting",
+            revision,
+            runtimeEpoch: snapshot.runtimeEpoch
+          };
+        }
+        let result;
+        try {
+          result = await run();
+        } catch (error) {
+          mutationRejected = true;
+          void this.queueMcpWork(() => this.prepareMcpRevision(revision)).catch(
+            (prepareError) => {
+              this.recordMcpError(
+                revision,
+                snapshot.runtimeEpoch,
+                prepareError
+              );
+            }
+          );
+          throw error;
+        }
+        await this.prepareMcpRevision(revision);
+        return result;
+      } catch (error) {
+        if (!mutationRejected) {
+          this.recordMcpError(revision, snapshot.runtimeEpoch, error);
+        }
+        throw error;
+      }
+    });
+    try {
+      return await operation;
+    } catch (error) {
+      if (!started) {
+        if (this.draining && !this.disposed) this.mcpReconcileDeferred = true;
+        this.recordMcpError(revision, initial.runtimeEpoch, error);
+      }
+      throw error;
+    }
+  }
+  prepareMcp() {
+    const revision = this.mcpRevision;
+    return this.queueMcpWork(() => this.prepareMcpRevision(revision));
+  }
+  queueMcpWork(run) {
+    this.mcpQueuedWork += 1;
+    const operation = this.mcpPhysicalTail.catch(() => void 0).then(async () => {
+      this.assertAcceptingWork();
+      return await run();
+    }).finally(() => {
+      this.mcpQueuedWork -= 1;
+    });
+    this.mcpPhysicalTail = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  }
+  async prepareMcpRevision(revision) {
+    const deadline = Date.now() + MCP_PREPARE_TIMEOUT_MS;
+    let snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    if (!snapshot.runtimeLive) {
+      try {
+        await this.bridge.preheat({ keepAliveMs: ENSURE_KEEP_ALIVE_MS });
+      } catch (error) {
+        if (error instanceof WorkspaceRuntimeStillStartingError) throw error;
+        throw new WorkspaceRuntimeInitializationError(error);
+      }
+      snapshot = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    }
+    const epoch = snapshot.runtimeEpoch;
+    if (revision !== this.mcpRevision) return;
+    this.mcpStatus = { state: "starting", revision, runtimeEpoch: epoch };
+    try {
+      let status = await this.runtime.workspaceService.getWorkspaceMcpStatus({
+        route: "workspace runtime MCP preparation",
+        workspaceCwd: this.runtime.workspaceCwd
+      });
+      let initializationRequested = false;
+      while (true) {
+        if (revision !== this.mcpRevision) return;
+        const current2 = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+        if (this.draining || this.disposed || !current2.runtimeLive || current2.runtimeEpoch !== epoch) {
+          if (this.draining && !this.disposed && current2.runtimeLive && current2.runtimeEpoch === epoch) {
+            this.mcpReconcileDeferred = true;
+          }
+          this.mcpStatus = { state: "stale", revision, runtimeEpoch: epoch };
+          return;
+        }
+        const currentEpochStatus = status.runtimeEpoch === epoch && status.source === "live";
+        if (currentEpochStatus && status.discoveryState === "not_started" && !initializationRequested) {
+          initializationRequested = true;
+          await this.bridge.initializeWorkspaceMcp();
+        }
+        if (currentEpochStatus && status.errors?.length) {
+          throw new Error(
+            status.errors[0]?.error ?? "MCP discovery failed to initialize"
+          );
+        }
+        if (currentEpochStatus && status.discoveryState === "completed") break;
+        if (Date.now() >= deadline) {
+          throw new WorkspaceRuntimeStillStartingError();
+        }
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, MCP_POLL_INTERVAL_MS);
+          timer.unref?.();
+        });
+        status = await this.runtime.workspaceService.getWorkspaceMcpStatus({
+          route: "workspace runtime MCP preparation",
+          workspaceCwd: this.runtime.workspaceCwd
+        });
+      }
+      const current = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+      if (revision !== this.mcpRevision) return;
+      if (!current.runtimeLive || current.runtimeEpoch !== epoch) {
+        this.mcpStatus = { state: "stale", revision, runtimeEpoch: epoch };
+        return;
+      }
+      this.mcpStatus = { state: "ready", revision, runtimeEpoch: epoch };
+    } catch (error) {
+      this.recordMcpError(revision, epoch, error);
+    }
+  }
+  recordMcpError(revision, runtimeEpoch, error) {
+    const current = this.bridge.getWorkspaceRuntimeLifecycleSnapshot();
+    if (revision !== this.mcpRevision) return;
+    if (this.draining || !current.runtimeLive || current.runtimeEpoch !== runtimeEpoch) {
+      this.mcpStatus = { state: "stale", revision, runtimeEpoch };
+      return;
+    }
+    this.mcpStatus = {
+      state: "error",
+      revision,
+      runtimeEpoch,
+      error: {
+        code: error instanceof WorkspaceRuntimeStillStartingError ? "mcp_prepare_timed_out" : "mcp_prepare_failed",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  assertAcceptingWork(cause) {
+    this.runtime.generationGuard?.assertOpen();
+    if (this.disposed || this.draining) {
+      throw new WorkspaceDrainingError(this.runtime.workspaceCwd, cause);
+    }
+  }
+};
+function getWorkspaceRuntimeCoordinatorIfSupported(runtime) {
+  if (!supportsWorkspaceRuntimeLifecycle(runtime.bridge)) return void 0;
+  runtime.runtimeCoordinator ??= new WorkspaceRuntimeCoordinator(
+    runtime,
+    runtime.bridge
+  );
+  return runtime.runtimeCoordinator;
+}
+__name(getWorkspaceRuntimeCoordinatorIfSupported, "getWorkspaceRuntimeCoordinatorIfSupported");
+function getWorkspaceRuntimeCoordinator(runtime) {
+  const coordinator = getWorkspaceRuntimeCoordinatorIfSupported(runtime);
+  if (!coordinator) {
+    throw new Error("Workspace runtime lifecycle is not supported");
+  }
+  return coordinator;
+}
+__name(getWorkspaceRuntimeCoordinator, "getWorkspaceRuntimeCoordinator");
+
+export {
+  WorkspaceRuntimeStillStartingError,
+  WorkspaceRuntimeInitializationError,
+  supportsWorkspaceRuntimeLifecycle,
+  WorkspaceRuntimeCoordinator,
+  getWorkspaceRuntimeCoordinatorIfSupported,
+  getWorkspaceRuntimeCoordinator
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-U54AYGEC.js → chunk-PB7JBAHF.js}

@@ -13,9 +13,13 @@ import { createHash } from "node:crypto";
 import { lstat, mkdir, realpath } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 function hasVerifiableInode(ino) {
-  return Number(ino) !== 0;
+  return Number.isSafeInteger(ino) && ino > 0;
 }
 __name(hasVerifiableInode, "hasVerifiableInode");
+function normalizedInode(ino) {
+  return hasVerifiableInode(ino) ? ino : 0;
+}
+__name(normalizedInode, "normalizedInode");
 var ConversationDirectoryIdentityError = class extends Error {
   constructor(scope, reason, cause) {
     super(
@@ -59,15 +63,14 @@ function validateDirectoryStats(stats, scope) {
 }
 __name(validateDirectoryStats, "validateDirectoryStats");
 function hasRootIdentity(stats, root) {
-  if (!root.inodeVerifiable) return stats.dev === root.device;
-  return hasVerifiableInode(stats.ino) && stats.dev === root.device && stats.ino === root.inode;
+  const inodeVerifiable = hasVerifiableInode(stats.ino);
+  return stats.dev === root.device && inodeVerifiable === root.inodeVerifiable && (!inodeVerifiable || stats.ino === root.inode);
 }
 __name(hasRootIdentity, "hasRootIdentity");
 function isSameDirectoryIdentity(before, after) {
-  if (!hasVerifiableInode(before.ino) || !hasVerifiableInode(after.ino)) {
-    return before.dev === after.dev;
-  }
-  return before.dev === after.dev && before.ino === after.ino;
+  const beforeVerifiable = hasVerifiableInode(before.ino);
+  const afterVerifiable = hasVerifiableInode(after.ino);
+  return before.dev === after.dev && beforeVerifiable === afterVerifiable && (!beforeVerifiable || before.ino === after.ino);
 }
 __name(isSameDirectoryIdentity, "isSameDirectoryIdentity");
 function hasExpectedDirectoryIdentity(identity, expected) {
@@ -118,7 +121,7 @@ async function createConversationRootIdentity(configuredRoot) {
     configuredRoot,
     canonicalRoot,
     device: after.dev,
-    inode: after.ino,
+    inode: normalizedInode(after.ino),
     inodeVerifiable: hasVerifiableInode(after.ino)
   };
 }
@@ -216,7 +219,7 @@ async function inspectConversationNamedDirectoryIdentity(root, storageSessionId,
     name,
     canonicalPath: canonical,
     device: after.dev,
-    inode: after.ino
+    inode: normalizedInode(after.ino)
   };
   if (expected && !hasExpectedDirectoryIdentity(identity, expected)) {
     throw new ConversationDirectoryIdentityError(
@@ -277,46 +280,14 @@ async function materializeConversationDirectoryIdentity(root, storageSessionId)
 }
 __name(materializeConversationDirectoryIdentity, "materializeConversationDirectoryIdentity");
 
-// packages/core/dist/src/services/tool-write-origin.js
-init_esbuild_shims();
-var TOOL_WRITE_ORIGIN_META_KEY = "qwen-code/tool-write-origin";
-var TOOL_WRITE_ORIGINS = [
-  "write_file",
-  "edit",
-  "notebook_edit",
-  "shell_sed_edit"
-];
-var TOOL_WRITE_ORIGIN_SET = new Set(TOOL_WRITE_ORIGINS);
-function buildToolWriteOriginMeta(meta, source) {
-  const sanitized = { ...meta };
-  delete sanitized[TOOL_WRITE_ORIGIN_META_KEY];
-  if (source !== void 0) {
-    sanitized[TOOL_WRITE_ORIGIN_META_KEY] = { version: 1, source };
-  }
-  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
-}
-__name(buildToolWriteOriginMeta, "buildToolWriteOriginMeta");
-function parseToolWriteOriginMeta(meta) {
-  const marker = meta?.[TOOL_WRITE_ORIGIN_META_KEY];
-  if (typeof marker !== "object" || marker === null || Array.isArray(marker)) {
-    return void 0;
-  }
-  const keys = Object.keys(marker);
-  if (keys.length !== 2 || !Object.hasOwn(marker, "version") || !Object.hasOwn(marker, "source")) {
-    return void 0;
-  }
-  const record = marker;
-  return record["version"] === 1 && typeof record["source"] === "string" && TOOL_WRITE_ORIGIN_SET.has(record["source"]) ? record["source"] : void 0;
-}
-__name(parseToolWriteOriginMeta, "parseToolWriteOriginMeta");
-
 export {
-  buildToolWriteOriginMeta,
-  parseToolWriteOriginMeta,
+  hasVerifiableInode,
+  normalizedInode,
   ConversationDirectoryIdentityError,
   isSameConversationPath,
   getConversationDirectoryName,
   getConversationStagedDirectoryName,
+  isSameDirectoryIdentity,
   createConversationRootIdentity,
   revalidateConversationRootIdentity,
   assertExactConversationRootIdentity,
@@ -330,8 +301,3 @@ export {
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */

package/chunks/{chunk-Y5S7LBOZ.js → chunk-PCRBLMIN.js}

@@ -3,13 +3,16 @@
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-3XKLXHGK.js";
+} from "./chunk-NXKOVOM5.js";
 import {
   resolveChannelCwd
-} from "./chunk-HVC3PNVC.js";
+} from "./chunk-TSZSGQ3N.js";
+import {
+  isInternalSecretEnvVar
+} from "./chunk-4F7GQGXB.js";
 import {
   APPROVAL_MODES
-} from "./chunk-V5J4J5TP.js";
+} from "./chunk-JX6XHPTX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,12 +24,21 @@ import {
 init_esbuild_shims();
 var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 var CHANNEL_APPROVAL_MODES = new Set(APPROVAL_MODES);
+function assertNotInternalSecret(envName, reference) {
+  if (isInternalSecretEnvVar(envName)) {
+    throw new Error(
+      `Environment variable ${envName} is a Qwen-internal secret and is never resolved into channel configuration (referenced as ${reference})`
+    );
+  }
+}
+__name(assertNotInternalSecret, "assertNotInternalSecret");
 function resolveEnvVars(value, env = process.env) {
   if (value.startsWith("$$")) {
     return value.substring(1);
   }
   if (value.startsWith("$")) {
     const envName = value.substring(1);
+    assertNotInternalSecret(envName, value);
     const envValue = env[envName];
     if (envValue === void 0) {
       throw new Error(
@@ -82,6 +94,7 @@ function resolveConfigEnvVar(value, mode) {
   if (value.startsWith("$$")) return value.substring(1);
   if (mode === "available" && value.startsWith("$")) {
     const envName = value.substring(1);
+    assertNotInternalSecret(envName, value);
     const envValue = process.env[envName];
     if (envValue === void 0) {
       throw new Error(
@@ -248,6 +261,7 @@ function resolveWebhookSecretEnv(channelName, path, secretEnv, env) {
       `Channel "${channelName}" field "${path}.secretEnv" must be an environment variable name or $-prefixed reference.`
     );
   }
+  assertNotInternalSecret(envName, `${path}.secretEnv`);
   const envValue = env[envName];
   if (envValue === void 0) {
     throw new Error(

package/chunks/{chunk-WAOIHTJS.js → chunk-PDAKFU7M.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-QFCDF5PL.js";
+} from "./chunk-JHN7UIDW.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-YTDVNSUQ.js → chunk-QAK5475D.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";