@qwen-code/qwen-code 0.19.9 → 0.19.10

package/chunks/{chunk-WL4L7EZH.js → chunk-OA4JVLSA.js}

@@ -33,10 +33,36 @@ var WorkspacePermissionRulesSessionRequiredError = class extends Error {
     this.name = "WorkspacePermissionRulesSessionRequiredError";
   }
 };
+var WorkspaceSkillNotFoundError = class extends Error {
+  constructor(skillName) {
+    super(`Skill not found: ${skillName}`);
+    this.skillName = skillName;
+    this.name = "WorkspaceSkillNotFoundError";
+  }
+  static {
+    __name(this, "WorkspaceSkillNotFoundError");
+  }
+};
+var WorkspaceSkillNotToggleableError = class extends Error {
+  constructor(skillName, reason, lockedScope) {
+    super(
+      lockedScope ? `Skill ${skillName} is locked by ${lockedScope} settings` : `Skill ${skillName} is not toggleable: ${reason}`
+    );
+    this.skillName = skillName;
+    this.reason = reason;
+    this.lockedScope = lockedScope;
+    this.name = "WorkspaceSkillNotToggleableError";
+  }
+  static {
+    __name(this, "WorkspaceSkillNotToggleableError");
+  }
+};
 
 export {
   WorkspaceSettingsPartialPersistError,
-  WorkspacePermissionRulesSessionRequiredError
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
 };
 /**
  * @license

package/chunks/{chunk-TO6QE22P.js → chunk-OATTJGPJ.js}

@@ -1,8 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  resolvePath
-} from "./chunk-34Z3U5RQ.js";
+  resolveChannelCwd
+} from "./chunk-ZRKBI3DP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,12 +21,12 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-WKPOYU7O.js") },
-        { name: "weixin", promise: import("./dist-R7LN5AZE.js") },
-        { name: "dingtalk", promise: import("./dist-PNVLTKTL.js") },
-        { name: "wecom", promise: import("./dist-XKU3ABM5.js") },
-        { name: "feishu", promise: import("./dist-QYCAEZIT.js") },
-        { name: "qqbot", promise: import("./dist-VHV4EVHG.js") }
+        { name: "telegram", promise: import("./dist-JZE7F6YR.js") },
+        { name: "weixin", promise: import("./dist-PHEPJLXD.js") },
+        { name: "dingtalk", promise: import("./dist-HNN7DR2L.js") },
+        { name: "wecom", promise: import("./dist-ERCPDVA6.js") },
+        { name: "feishu", promise: import("./dist-MOEC47TR.js") },
+        { name: "qqbot", promise: import("./dist-3V3ZV6ML.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {
@@ -74,13 +74,13 @@ var CHANNEL_APPROVAL_MODES = /* @__PURE__ */ new Set([
   "auto",
   "yolo"
 ]);
-function resolveEnvVars(value) {
+function resolveEnvVars(value, env = process.env) {
   if (value.startsWith("$$")) {
     return value.substring(1);
   }
   if (value.startsWith("$")) {
     const envName = value.substring(1);
-    const envValue = process.env[envName];
+    const envValue = env[envName];
     if (envValue === void 0) {
       throw new Error(
         `Environment variable ${envName} is not set (referenced as ${value})`
@@ -231,7 +231,7 @@ function parseWebhookTarget(channelName, path, raw) {
   return target;
 }
 __name(parseWebhookTarget, "parseWebhookTarget");
-function parseWebhookSource(channelName, path, raw) {
+function parseWebhookSource(channelName, path, raw, env) {
   const record = requireObjectField(channelName, path, raw);
   const rawTargets = requireObjectField(
     channelName,
@@ -254,7 +254,8 @@ function parseWebhookSource(channelName, path, raw) {
     );
   }
   const secret = hasSecret ? resolveEnvVars(
-    requireStringField(channelName, `${path}.secret`, record["secret"])
+    requireStringField(channelName, `${path}.secret`, record["secret"]),
+    env
   ) : resolveWebhookSecretEnv(
     channelName,
     path,
@@ -262,7 +263,8 @@ function parseWebhookSource(channelName, path, raw) {
       channelName,
       `${path}.secretEnv`,
       record["secretEnv"]
-    )
+    ),
+    env
   );
   if (secret.length === 0) {
     throw new Error(
@@ -272,14 +274,14 @@ function parseWebhookSource(channelName, path, raw) {
   return { secret, targets };
 }
 __name(parseWebhookSource, "parseWebhookSource");
-function resolveWebhookSecretEnv(channelName, path, secretEnv) {
+function resolveWebhookSecretEnv(channelName, path, secretEnv, env) {
   const envName = secretEnv.startsWith("$") ? secretEnv.substring(1) : secretEnv;
   if (!ENV_VAR_NAME_PATTERN.test(envName)) {
     throw new Error(
       `Channel "${channelName}" field "${path}.secretEnv" must be an environment variable name or $-prefixed reference.`
     );
   }
-  const envValue = process.env[envName];
+  const envValue = env[envName];
   if (envValue === void 0) {
     throw new Error(
       `Channel "${channelName}" field "${path}.secretEnv" references an unset environment variable.`
@@ -293,7 +295,7 @@ function resolveWebhookSecretEnv(channelName, path, secretEnv) {
   return envValue;
 }
 __name(resolveWebhookSecretEnv, "resolveWebhookSecretEnv");
-function parseWebhookConfig(channelName, rawConfig) {
+function parseWebhookConfig(channelName, rawConfig, env = process.env) {
   const raw = rawConfig["webhooks"];
   if (raw === void 0 || raw === null) {
     return void 0;
@@ -309,7 +311,8 @@ function parseWebhookConfig(channelName, rawConfig) {
     sources[source] = parseWebhookSource(
       channelName,
       `webhooks.sources.${source}`,
-      sourceConfig
+      sourceConfig,
+      env
     );
   }
   return { sources };
@@ -330,11 +333,11 @@ function parseApprovalModeConfig(channelName, rawConfig) {
   return approvalMode;
 }
 __name(parseApprovalModeConfig, "parseApprovalModeConfig");
-function parseChannelWebhookConfig(channelName, rawConfig) {
-  return parseWebhookConfig(channelName, rawConfig);
+function parseChannelWebhookConfig(channelName, rawConfig, env = process.env) {
+  return parseWebhookConfig(channelName, rawConfig, env);
 }
 __name(parseChannelWebhookConfig, "parseChannelWebhookConfig");
-function parseChannelWebhookConfigLenient(channelName, rawConfig, onSourceError) {
+function parseChannelWebhookConfigLenient(channelName, rawConfig, onSourceError, env = process.env) {
   const raw = rawConfig["webhooks"];
   if (raw === void 0 || raw === null) {
     return void 0;
@@ -351,7 +354,8 @@ function parseChannelWebhookConfigLenient(channelName, rawConfig, onSourceError)
       sources[source] = parseWebhookSource(
         channelName,
         `webhooks.sources.${source}`,
-        sourceConfig
+        sourceConfig,
+        env
       );
     } catch (error) {
       onSourceError?.(source, error);
@@ -416,7 +420,7 @@ async function parseChannelConfig(name, rawConfig, defaultCwd = process.cwd(), o
     senderPolicy: rawConfig["senderPolicy"] || "allowlist",
     allowedUsers: rawConfig["allowedUsers"] || [],
     sessionScope: rawConfig["sessionScope"] || "user",
-    cwd: resolvePath(rawConfig["cwd"] || defaultCwd),
+    cwd: resolveChannelCwd(rawConfig["cwd"], defaultCwd),
     approvalMode: parseApprovalModeConfig(name, rawConfig),
     instructions: rawConfig["instructions"],
     identity: parseObjectStringFields(name, rawConfig, "identity", [

package/chunks/{chunk-X6TJ3YZV.js → chunk-OFEVHGVU.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-5VXNZWGF.js";
+} from "./chunk-N6FXRR6P.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-PDZ7MBDG.js";
+} from "./chunk-FXMC7SL2.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,11 +16,13 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-HPDUL5MF.js";
+} from "./chunk-DPFBNG72.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError
-} from "./chunk-WL4L7EZH.js";
+  WorkspaceSettingsPartialPersistError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
+} from "./chunk-OA4JVLSA.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-OCPBI7J5.js";
@@ -32,8 +34,9 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-IAVB3HM3.js";
+} from "./chunk-KSO42X3Z.js";
 import {
+  BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
@@ -45,23 +48,23 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-VWPVHAMO.js";
+} from "./chunk-CUUXANEQ.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-4C5BQ2D2.js";
+} from "./chunk-6GETGQWP.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-HKMAENAO.js";
+} from "./chunk-4YWLED2A.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
 import {
   ModelsConfig
-} from "./chunk-NVYTCB5Z.js";
+} from "./chunk-K7CRWKOE.js";
 import {
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -96,14 +99,11 @@ function voiceSettingsScopeToWire(scope) {
 }
 __name(voiceSettingsScopeToWire, "voiceSettingsScopeToWire");
 function buildWorkspaceVoiceSettingsWrites(settings, update, opts = {}) {
-  const voiceSettingsScope = getVoiceSettingsScope(
-    settings,
-    opts.workspaceTrusted
-  );
+  const voiceSettingsScope = opts.scopeOverride ?? getVoiceSettingsScope(settings, opts.workspaceTrusted);
   const writes = [];
   if (update.voiceModel !== void 0) {
     writes.push({
-      scope: getPersistScopeForModelSelection(settings),
+      scope: opts.scopeOverride ?? getPersistScopeForModelSelection(settings),
       key: "voiceModel",
       value: update.voiceModel
     });
@@ -158,13 +158,13 @@ function listAvailableVoiceModels(settings) {
   );
 }
 __name(listAvailableVoiceModels, "listAvailableVoiceModels");
-function hasConfiguredBatchVoiceTranscriptionModel(settings) {
+function hasConfiguredBatchVoiceTranscriptionModel(settings, opts = {}) {
   for (const model of listAvailableVoiceModels(settings)) {
     if (model.transport !== "qwen-asr-chat") {
       continue;
     }
     try {
-      validateWorkspaceVoiceConfig(settings, model.id);
+      validateWorkspaceVoiceConfig(settings, model.id, opts);
       return true;
     } catch (err) {
       debugLogger.debug(
@@ -223,14 +223,24 @@ function validateWorkspaceVoiceModel(settings, voiceModel) {
   return { id: model.id, transport };
 }
 __name(validateWorkspaceVoiceModel, "validateWorkspaceVoiceModel");
-function validateWorkspaceVoiceConfig(settings, voiceModel) {
+function validateWorkspaceVoiceConfig(settings, voiceModel, opts = {}) {
   const descriptor = validateWorkspaceVoiceModel(settings, voiceModel);
   try {
     const config = createVoiceModelSource(settings);
     if (descriptor.transport === "qwen-asr-chat") {
-      resolveVoiceTranscriptionConfig({ config, settings, voiceModel });
+      resolveVoiceTranscriptionConfig({
+        config,
+        settings,
+        voiceModel,
+        env: opts.env
+      });
     } else {
-      resolveVoiceStreamConfig({ config, settings, voiceModel });
+      resolveVoiceStreamConfig({
+        config,
+        settings,
+        voiceModel,
+        env: opts.env
+      });
     }
   } catch (err) {
     throw new WorkspaceVoiceError(
@@ -242,7 +252,7 @@ function validateWorkspaceVoiceConfig(settings, voiceModel) {
   return descriptor;
 }
 __name(validateWorkspaceVoiceConfig, "validateWorkspaceVoiceConfig");
-function validateWorkspaceVoiceState(settings, update) {
+function validateWorkspaceVoiceState(settings, update, opts = {}) {
   if (update.enabled === void 0 && update.mode === void 0 && update.language === void 0 && update.voiceModel === void 0) {
     throw new WorkspaceVoiceError(
       400,
@@ -265,7 +275,7 @@ function validateWorkspaceVoiceState(settings, update) {
       "A valid voiceModel is required before enabling voice."
     );
   }
-  validateWorkspaceVoiceConfig(settings, nextVoiceModel);
+  validateWorkspaceVoiceConfig(settings, nextVoiceModel, opts);
 }
 __name(validateWorkspaceVoiceState, "validateWorkspaceVoiceState");
 async function transcribeWorkspaceVoiceAudio(input) {
@@ -286,6 +296,7 @@ async function transcribeWorkspaceVoiceAudio(input) {
       config: createVoiceModelSource(input.settings),
       settings: input.settings,
       voiceModel: input.voiceModel,
+      env: input.env,
       abortSignal: input.abortSignal
     }
   );
@@ -360,8 +371,11 @@ function createDaemonWorkspaceService(deps) {
     workspaceSkillsStatusProvider,
     isChannelLive,
     persistDisabledTools,
+    persistDisabledSkills,
     persistSetting,
     persistSettings,
+    voiceEnv,
+    voiceSettingsScope,
     preheatAcpChild: preheatAcpChildOnBridge,
     queryWorkspaceStatus,
     invokeWorkspaceCommand,
@@ -370,6 +384,35 @@ function createDaemonWorkspaceService(deps) {
   } = deps;
   let lastWorkspaceSkillsStatus;
   let inFlightAcpPreheat;
+  const getWorkspaceSkillsStatus = /* @__PURE__ */ __name(async () => {
+    let status;
+    try {
+      status = await queryWorkspaceStatus(
+        SERVE_STATUS_EXT_METHODS.workspaceSkills,
+        () => createIdleWorkspaceSkillsStatus(boundWorkspace)
+      );
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: getWorkspaceSkillsStatus query failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      status = createIdleWorkspaceSkillsStatus(boundWorkspace);
+    }
+    if (status.initialized) {
+      lastWorkspaceSkillsStatus = status;
+      return status;
+    }
+    if (lastWorkspaceSkillsStatus) return lastWorkspaceSkillsStatus;
+    if (workspaceSkillsStatusProvider) {
+      try {
+        return await workspaceSkillsStatusProvider(boundWorkspace);
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return status;
+  }, "getWorkspaceSkillsStatus");
   return {
     // -- Status queries (delegate to ACP child via queryWorkspaceStatus) --
     async getWorkspaceMcpStatus(_ctx) {
@@ -379,35 +422,7 @@ function createDaemonWorkspaceService(deps) {
       );
     },
     async getWorkspaceSkillsStatus(_ctx) {
-      let status;
-      try {
-        status = await queryWorkspaceStatus(
-          SERVE_STATUS_EXT_METHODS.workspaceSkills,
-          () => createIdleWorkspaceSkillsStatus(boundWorkspace)
-        );
-      } catch (err) {
-        writeStderrLine(
-          `qwen serve: getWorkspaceSkillsStatus query failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-        status = createIdleWorkspaceSkillsStatus(boundWorkspace);
-      }
-      if (status.initialized) {
-        lastWorkspaceSkillsStatus = status;
-        return status;
-      }
-      if (lastWorkspaceSkillsStatus) {
-        return lastWorkspaceSkillsStatus;
-      }
-      if (workspaceSkillsStatusProvider) {
-        try {
-          return await workspaceSkillsStatusProvider(boundWorkspace);
-        } catch (err) {
-          writeStderrLine(
-            `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-      return status;
+      return getWorkspaceSkillsStatus();
     },
     async getWorkspaceProvidersStatus(_ctx) {
       if (workspaceProvidersStatusProvider) {
@@ -566,7 +581,10 @@ function createDaemonWorkspaceService(deps) {
     async getWorkspaceVoiceStatus(_ctx) {
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(boundWorkspace)
+        loadSettings(
+          boundWorkspace,
+          voiceEnv ? { skipLoadEnvironment: true } : true
+        )
       );
     },
     // -- Mutations --
@@ -619,11 +637,15 @@ function createDaemonWorkspaceService(deps) {
           "Workspace voice settings persistence is not available"
         );
       }
-      const settings = loadSettings(boundWorkspace);
-      validateWorkspaceVoiceState(settings, request);
+      const settings = loadSettings(
+        boundWorkspace,
+        voiceEnv ? { skipLoadEnvironment: true } : true
+      );
+      validateWorkspaceVoiceState(settings, request, { env: voiceEnv });
       const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, boundWorkspace).effective.state === "trusted";
       const writes = buildWorkspaceVoiceSettingsWrites(settings, request, {
-        workspaceTrusted
+        workspaceTrusted,
+        ...voiceSettingsScope ? { scopeOverride: voiceSettingsScope } : {}
       });
       const publishWrite = /* @__PURE__ */ __name((write) => {
         publishWorkspaceEvent({
@@ -664,6 +686,9 @@ function createDaemonWorkspaceService(deps) {
             writeStderrLine(
               `qwen serve: workspace voice partial persist error (workspace=${boundWorkspace}, committed=${committed.length}/${writes.length}, failedKey=${write.key}, failedScope=${voiceSettingsScopeToWire(write.scope)}): ${err instanceof Error ? err.message : String(err)}`
             );
+            for (const committedWrite of committed) {
+              publishWrite(committedWrite);
+            }
             throw new WorkspaceSettingsPartialPersistError(
               `Voice settings partial persist failed: committed=${committed.length}/${writes.length}`,
               committed,
@@ -678,7 +703,10 @@ function createDaemonWorkspaceService(deps) {
       }
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(boundWorkspace)
+        loadSettings(
+          boundWorkspace,
+          voiceEnv ? { skipLoadEnvironment: true } : true
+        )
       );
     },
     async setWorkspaceToolEnabled(ctx, toolName, enabled) {
@@ -690,6 +718,80 @@ function createDaemonWorkspaceService(deps) {
       });
       return { toolName, enabled };
     },
+    async setWorkspaceSkillEnabled(ctx, requestedSkillName, enabled) {
+      const normalizedName = requestedSkillName.trim().toLowerCase();
+      const status = await getWorkspaceSkillsStatus();
+      const skill = status.skills.find(
+        (candidate) => candidate.name.trim().toLowerCase() === normalizedName
+      );
+      if (!skill) throw new WorkspaceSkillNotFoundError(requestedSkillName);
+      if (skill.userInvocable === false) {
+        throw new WorkspaceSkillNotToggleableError(
+          skill.name,
+          "not_user_invocable"
+        );
+      }
+      const disabled = loadSettings(boundWorkspace).merged.skills?.disabled;
+      const disabledNames = new Set(
+        (Array.isArray(disabled) ? disabled : []).filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
+      );
+      if (skill.level === "extension" && skill.status === "disabled" && !disabledNames.has(normalizedName)) {
+        throw new WorkspaceSkillNotToggleableError(
+          skill.name,
+          "inactive_extension"
+        );
+      }
+      const persisted = await persistDisabledSkills(
+        boundWorkspace,
+        skill.name,
+        enabled
+      );
+      const channelLive = isChannelLive?.() ?? false;
+      let activation = channelLive ? "applied" : "deferred";
+      let sessionsRefreshed = 0;
+      let sessionsFailed = 0;
+      if (persisted.changed) {
+        lastWorkspaceSkillsStatus = void 0;
+        if (channelLive) {
+          try {
+            const refreshed = await invokeWorkspaceCommand(
+              SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh,
+              { cwd: boundWorkspace }
+            );
+            sessionsRefreshed = refreshed.sessionsRefreshed;
+            sessionsFailed = refreshed.sessionsFailed;
+            if (sessionsFailed > 0) activation = "partial";
+          } catch (err) {
+            if (err instanceof SessionNotFoundError || err instanceof BridgeChannelClosedError) {
+              activation = "deferred";
+            } else {
+              activation = "partial";
+              sessionsFailed = 1;
+              writeStderrLine(
+                `qwen serve: workspace skill refresh failed: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        }
+        publishWorkspaceEvent({
+          type: "settings_changed",
+          data: {
+            key: "skills.disabled",
+            value: persisted.disabled.length > 0 ? persisted.disabled : void 0,
+            scope: "workspace"
+          },
+          originatorClientId: ctx.originatorClientId
+        });
+      }
+      return {
+        skillName: skill.name,
+        enabled,
+        changed: persisted.changed,
+        activation,
+        sessionsRefreshed,
+        sessionsFailed
+      };
+    },
     async initWorkspace(ctx, opts) {
       const filename = contextFilename;
       const target = path.resolve(boundWorkspace, filename);

package/chunks/{chunk-X4NKFGFJ.js → chunk-OJAMDVF5.js}

@@ -7,15 +7,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/serve/channel-worker-env.ts
-init_esbuild_shims();
-var CHANNEL_DAEMON_WORKER_SENTINEL = "QWEN_CHANNEL_DAEMON_WORKER";
-var CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS = 15e3;
-var QWEN_DAEMON_TOKEN_ENV = "QWEN_DAEMON_TOKEN";
-var QWEN_DAEMON_URL_ENV = "QWEN_DAEMON_URL";
-var QWEN_DAEMON_WORKSPACE_ENV = "QWEN_DAEMON_WORKSPACE";
-var QWEN_SERVER_TOKEN_ENV = "QWEN_SERVER_TOKEN";
-
 // packages/cli/src/serve/channel-webhook-ipc.ts
 init_esbuild_shims();
 import { randomUUID } from "node:crypto";
@@ -65,12 +56,6 @@ function isChannelWebhookTaskResultMessage(value) {
 __name(isChannelWebhookTaskResultMessage, "isChannelWebhookTaskResultMessage");
 
 export {
-  CHANNEL_DAEMON_WORKER_SENTINEL,
-  CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
-  QWEN_DAEMON_TOKEN_ENV,
-  QWEN_DAEMON_URL_ENV,
-  QWEN_DAEMON_WORKSPACE_ENV,
-  QWEN_SERVER_TOKEN_ENV,
   ChannelWebhookEnqueueError,
   isChannelWebhookEnqueueErrorCode,
   isChannelWebhookEnqueueError,

package/chunks/{chunk-BZIFY5TF.js → chunk-OKAIGAYW.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-UOZWKTQG.js";
+} from "./chunk-ZPAHLFZU.js";
 import {
   openBrowserSecurely
 } from "./chunk-JESCGQM3.js";
 import {
   atomicWriteFile
-} from "./chunk-ZLXQN2QS.js";
+} from "./chunk-WIEO4CWB.js";
 import {
   combineAbortSignals
 } from "./chunk-DJ2GSRLV.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";