@qwen-code/qwen-code 0.19.8 → 0.19.9-nightly.20260714.9dd8389eb

package/chunks/chunk-MR3PXB6E.js

@@ -0,0 +1,48 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/path-comparison.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isWithinRoot(childPath, parentPath) {
+  const relativePath = path.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+__name(isWithinRoot, "isWithinRoot");
+function getPathComparisonVariants(rawPath) {
+  const variants = /* @__PURE__ */ new Set([path.normalize(path.resolve(rawPath))]);
+  try {
+    variants.add(path.normalize(fs.realpathSync(rawPath)));
+  } catch {
+  }
+  return variants;
+}
+__name(getPathComparisonVariants, "getPathComparisonVariants");
+function arePathsEquivalent(left, right) {
+  const rightVariants = getPathComparisonVariants(right);
+  for (const leftVariant of getPathComparisonVariants(left)) {
+    if (rightVariants.has(leftVariant)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(arePathsEquivalent, "arePathsEquivalent");
+
+export {
+  isWithinRoot,
+  getPathComparisonVariants,
+  arePathsEquivalent
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-ZE6E424U.js → chunk-N7FCSERB.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   t
-} from "./chunk-O33TBKDC.js";
+} from "./chunk-SE74CIZD.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-332PWN27.js → chunk-NHDKSOEY.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 
 // packages/cli/src/patches/is-in-ci.ts
 init_esbuild_shims();

package/chunks/chunk-OATTJGPJ.js

@@ -0,0 +1,448 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolveChannelCwd
+} from "./chunk-ZRKBI3DP.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/config-utils.ts
+init_esbuild_shims();
+
+// packages/cli/src/commands/channel/channel-registry.ts
+init_esbuild_shims();
+var registry = /* @__PURE__ */ new Map();
+var builtinsPromise = null;
+function ensureBuiltins() {
+  if (!builtinsPromise) {
+    builtinsPromise = (async () => {
+      const labelled = [
+        { 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++) {
+        const result = results[i];
+        if (result.status === "fulfilled") {
+          registry.set(result.value.plugin.channelType, result.value.plugin);
+        } else {
+          process.stderr.write(
+            `[channel-registry] Failed to load "${labelled[i].name}" channel: ${result.reason}
+`
+          );
+        }
+      }
+    })();
+  }
+  return builtinsPromise;
+}
+__name(ensureBuiltins, "ensureBuiltins");
+function registerPlugin(plugin) {
+  if (registry.has(plugin.channelType)) {
+    throw new Error(
+      `Channel type "${plugin.channelType}" is already registered.`
+    );
+  }
+  registry.set(plugin.channelType, plugin);
+}
+__name(registerPlugin, "registerPlugin");
+async function getPlugin(channelType) {
+  await ensureBuiltins();
+  return registry.get(channelType);
+}
+__name(getPlugin, "getPlugin");
+async function supportedTypes() {
+  await ensureBuiltins();
+  return [...registry.keys()];
+}
+__name(supportedTypes, "supportedTypes");
+
+// packages/cli/src/commands/channel/config-utils.ts
+var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+var CHANNEL_APPROVAL_MODES = /* @__PURE__ */ new Set([
+  "plan",
+  "default",
+  "auto-edit",
+  "auto",
+  "yolo"
+]);
+function resolveEnvVars(value, env = process.env) {
+  if (value.startsWith("$$")) {
+    return value.substring(1);
+  }
+  if (value.startsWith("$")) {
+    const envName = value.substring(1);
+    const envValue = env[envName];
+    if (envValue === void 0) {
+      throw new Error(
+        `Environment variable ${envName} is not set (referenced as ${value})`
+      );
+    }
+    if (envValue === "") {
+      throw new Error(
+        `Environment variable ${envName} is empty (referenced as ${value})`
+      );
+    }
+    return envValue;
+  }
+  return value;
+}
+__name(resolveEnvVars, "resolveEnvVars");
+function resolveOptionalStringField(channelName, rawConfig, field, envResolution) {
+  const value = rawConfig[field];
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(
+      `Channel "${channelName}" field "${field}" must be a string.`
+    );
+  }
+  return resolveConfigEnvVar(value, envResolution);
+}
+__name(resolveOptionalStringField, "resolveOptionalStringField");
+var KNOWN_CREDENTIAL_FIELDS = /* @__PURE__ */ new Set(["token", "clientId", "clientSecret"]);
+function resolveConfigEnvVar(value, mode) {
+  if (mode === false) return value;
+  if (value.startsWith("$$")) return value.substring(1);
+  if (mode === "available" && value.startsWith("$")) {
+    const envName = value.substring(1);
+    const envValue = process.env[envName];
+    if (envValue === void 0) {
+      throw new Error(
+        `Environment variable ${envName} is not set (referenced as ${value}). Set the variable or remove the $ prefix to use a literal value.`
+      );
+    }
+    if (envValue === "") {
+      throw new Error(
+        `Environment variable ${envName} is empty (referenced as ${value})`
+      );
+    }
+    return envValue;
+  }
+  return resolveEnvVars(value);
+}
+__name(resolveConfigEnvVar, "resolveConfigEnvVar");
+function parseObjectStringFields(channelName, rawConfig, key, fields) {
+  const value = rawConfig[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(
+      `Channel "${channelName}" field "${key}" must be an object.`
+    );
+  }
+  const record = value;
+  const result = {};
+  for (const field of fields) {
+    const fieldValue = record[field];
+    if (fieldValue === void 0 || fieldValue === null || fieldValue === "") {
+      continue;
+    }
+    if (typeof fieldValue !== "string") {
+      throw new Error(
+        `Channel "${channelName}" field "${key}.${field}" must be a string.`
+      );
+    }
+    result[field] = fieldValue;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+__name(parseObjectStringFields, "parseObjectStringFields");
+function parseMemoryScopeConfig(channelName, rawConfig) {
+  const parsed = parseObjectStringFields(
+    channelName,
+    rawConfig,
+    "memoryScope",
+    ["namespace", "mode"]
+  );
+  if (parsed?.["mode"] !== void 0 && parsed["mode"] !== "metadata-only") {
+    throw new Error(
+      `Channel "${channelName}" field "memoryScope.mode" must be "metadata-only".`
+    );
+  }
+  return parsed;
+}
+__name(parseMemoryScopeConfig, "parseMemoryScopeConfig");
+function requireStringField(channelName, path, value) {
+  if (typeof value !== "string" || value === "") {
+    throw new Error(
+      `Channel "${channelName}" field "${path}" must be a string.`
+    );
+  }
+  return value;
+}
+__name(requireStringField, "requireStringField");
+function optionalBooleanField(channelName, path, value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(
+      `Channel "${channelName}" field "${path}" must be a boolean.`
+    );
+  }
+  return value;
+}
+__name(optionalBooleanField, "optionalBooleanField");
+function requireObjectField(channelName, path, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `Channel "${channelName}" field "${path}" must be an object.`
+    );
+  }
+  return value;
+}
+__name(requireObjectField, "requireObjectField");
+function parseWebhookTarget(channelName, path, raw) {
+  const record = requireObjectField(channelName, path, raw);
+  const target = {
+    chatId: requireStringField(channelName, `${path}.chatId`, record["chatId"]),
+    senderId: requireStringField(
+      channelName,
+      `${path}.senderId`,
+      record["senderId"]
+    )
+  };
+  if (record["threadId"] !== void 0) {
+    target.threadId = requireStringField(
+      channelName,
+      `${path}.threadId`,
+      record["threadId"]
+    );
+  }
+  const isGroup = optionalBooleanField(
+    channelName,
+    `${path}.isGroup`,
+    record["isGroup"]
+  );
+  if (isGroup !== void 0) {
+    target.isGroup = isGroup;
+  }
+  return target;
+}
+__name(parseWebhookTarget, "parseWebhookTarget");
+function parseWebhookSource(channelName, path, raw, env) {
+  const record = requireObjectField(channelName, path, raw);
+  const rawTargets = requireObjectField(
+    channelName,
+    `${path}.targets`,
+    record["targets"]
+  );
+  const targets = {};
+  for (const [targetRef, targetConfig] of Object.entries(rawTargets)) {
+    targets[targetRef] = parseWebhookTarget(
+      channelName,
+      `${path}.targets.${targetRef}`,
+      targetConfig
+    );
+  }
+  const hasSecret = record["secret"] !== void 0 && record["secret"] !== null;
+  const hasSecretEnv = record["secretEnv"] !== void 0 && record["secretEnv"] !== null;
+  if (hasSecret === hasSecretEnv) {
+    throw new Error(
+      `Channel "${channelName}" field "${path}" must define exactly one of "secret" or "secretEnv".`
+    );
+  }
+  const secret = hasSecret ? resolveEnvVars(
+    requireStringField(channelName, `${path}.secret`, record["secret"]),
+    env
+  ) : resolveWebhookSecretEnv(
+    channelName,
+    path,
+    requireStringField(
+      channelName,
+      `${path}.secretEnv`,
+      record["secretEnv"]
+    ),
+    env
+  );
+  if (secret.length === 0) {
+    throw new Error(
+      `Channel "${channelName}" field "${path}" webhook secret must be non-empty.`
+    );
+  }
+  return { secret, targets };
+}
+__name(parseWebhookSource, "parseWebhookSource");
+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 = env[envName];
+  if (envValue === void 0) {
+    throw new Error(
+      `Channel "${channelName}" field "${path}.secretEnv" references an unset environment variable.`
+    );
+  }
+  if (envValue === "") {
+    throw new Error(
+      `Channel "${channelName}" field "${path}.secretEnv" references an empty environment variable.`
+    );
+  }
+  return envValue;
+}
+__name(resolveWebhookSecretEnv, "resolveWebhookSecretEnv");
+function parseWebhookConfig(channelName, rawConfig, env = process.env) {
+  const raw = rawConfig["webhooks"];
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  const record = requireObjectField(channelName, "webhooks", raw);
+  const rawSources = requireObjectField(
+    channelName,
+    "webhooks.sources",
+    record["sources"]
+  );
+  const sources = {};
+  for (const [source, sourceConfig] of Object.entries(rawSources)) {
+    sources[source] = parseWebhookSource(
+      channelName,
+      `webhooks.sources.${source}`,
+      sourceConfig,
+      env
+    );
+  }
+  return { sources };
+}
+__name(parseWebhookConfig, "parseWebhookConfig");
+function parseApprovalModeConfig(channelName, rawConfig) {
+  const approvalMode = rawConfig["approvalMode"];
+  if (approvalMode === void 0 || approvalMode === null) {
+    return void 0;
+  }
+  if (typeof approvalMode !== "string" || !CHANNEL_APPROVAL_MODES.has(approvalMode)) {
+    throw new Error(
+      `Channel "${channelName}" field "approvalMode" must be one of: ${[
+        ...CHANNEL_APPROVAL_MODES
+      ].join(", ")}.`
+    );
+  }
+  return approvalMode;
+}
+__name(parseApprovalModeConfig, "parseApprovalModeConfig");
+function parseChannelWebhookConfig(channelName, rawConfig, env = process.env) {
+  return parseWebhookConfig(channelName, rawConfig, env);
+}
+__name(parseChannelWebhookConfig, "parseChannelWebhookConfig");
+function parseChannelWebhookConfigLenient(channelName, rawConfig, onSourceError, env = process.env) {
+  const raw = rawConfig["webhooks"];
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  const record = requireObjectField(channelName, "webhooks", raw);
+  const rawSources = requireObjectField(
+    channelName,
+    "webhooks.sources",
+    record["sources"]
+  );
+  const sources = {};
+  for (const [source, sourceConfig] of Object.entries(rawSources)) {
+    try {
+      sources[source] = parseWebhookSource(
+        channelName,
+        `webhooks.sources.${source}`,
+        sourceConfig,
+        env
+      );
+    } catch (error) {
+      onSourceError?.(source, error);
+    }
+  }
+  return { sources };
+}
+__name(parseChannelWebhookConfigLenient, "parseChannelWebhookConfigLenient");
+async function parseChannelConfig(name, rawConfig, defaultCwd = process.cwd(), options = {}) {
+  if (!rawConfig["type"]) {
+    throw new Error(`Channel "${name}" is missing required field "type".`);
+  }
+  const channelType = rawConfig["type"];
+  const plugin = await getPlugin(channelType);
+  if (!plugin) {
+    const types = await supportedTypes();
+    throw new Error(
+      `Channel type "${channelType}" is not supported. Available: ${types.join(", ")}`
+    );
+  }
+  const resolvedRawConfig = { ...rawConfig };
+  const envResolution = options.resolveEnvVars ?? true;
+  const resolvedPluginFields = /* @__PURE__ */ new Set();
+  for (const field of plugin.requiredConfigFields ?? []) {
+    const value = rawConfig[field];
+    if (value === void 0 || value === null || value === "") {
+      throw new Error(
+        `Channel "${name}" (${channelType}) requires "${field}".`
+      );
+    }
+    if (typeof value === "string" && !KNOWN_CREDENTIAL_FIELDS.has(field)) {
+      resolvedRawConfig[field] = resolveConfigEnvVar(value, envResolution);
+      resolvedPluginFields.add(field);
+    }
+  }
+  for (const field of plugin.envResolvableConfigFields ?? []) {
+    if (resolvedPluginFields.has(field)) continue;
+    const value = rawConfig[field];
+    if (typeof value === "string" && value !== "") {
+      resolvedRawConfig[field] = resolveConfigEnvVar(value, envResolution);
+    }
+  }
+  const token = resolveOptionalStringField(name, rawConfig, "token", envResolution) ?? "";
+  const clientId = resolveOptionalStringField(
+    name,
+    rawConfig,
+    "clientId",
+    envResolution
+  );
+  const clientSecret = resolveOptionalStringField(
+    name,
+    rawConfig,
+    "clientSecret",
+    envResolution
+  );
+  return {
+    ...resolvedRawConfig,
+    type: channelType,
+    token,
+    clientId,
+    clientSecret,
+    senderPolicy: rawConfig["senderPolicy"] || "allowlist",
+    allowedUsers: rawConfig["allowedUsers"] || [],
+    sessionScope: rawConfig["sessionScope"] || "user",
+    cwd: resolveChannelCwd(rawConfig["cwd"], defaultCwd),
+    approvalMode: parseApprovalModeConfig(name, rawConfig),
+    instructions: rawConfig["instructions"],
+    identity: parseObjectStringFields(name, rawConfig, "identity", [
+      "id",
+      "displayName",
+      "description"
+    ]),
+    memoryScope: parseMemoryScopeConfig(name, rawConfig),
+    model: rawConfig["model"],
+    groupPolicy: rawConfig["groupPolicy"] || "disabled",
+    dmPolicy: rawConfig["dmPolicy"] || "open",
+    groups: rawConfig["groups"] || {},
+    webhooks: parseWebhookConfig(name, rawConfig)
+  };
+}
+__name(parseChannelConfig, "parseChannelConfig");
+
+export {
+  registerPlugin,
+  getPlugin,
+  resolveEnvVars,
+  parseChannelWebhookConfig,
+  parseChannelWebhookConfigLenient,
+  parseChannelConfig
+};

package/chunks/{chunk-UX6OTBVD.js → chunk-OCC3UTWA.js}

@@ -6,10 +6,10 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-M7S4GK5Z.js";
+} from "./chunk-T2L6SGQY.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-P7M4GA57.js → chunk-OCPBI7J5.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 
 // packages/acp-bridge/src/mcpTimeouts.ts
 init_esbuild_shims();

package/chunks/chunk-OJAMDVF5.js

@@ -0,0 +1,66 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-webhook-ipc.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var CHANNEL_WEBHOOK_ENQUEUE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "channel_worker_unavailable",
+  "channel_webhook_enqueue_timeout",
+  "channel_webhook_queue_full",
+  "channel_webhook_target_unavailable",
+  "channel_webhook_invalid_task",
+  "channel_webhook_enqueue_failed"
+]);
+var ChannelWebhookEnqueueError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelWebhookEnqueueError";
+  }
+  static {
+    __name(this, "ChannelWebhookEnqueueError");
+  }
+};
+function isChannelWebhookEnqueueErrorCode(value) {
+  return typeof value === "string" && CHANNEL_WEBHOOK_ENQUEUE_ERROR_CODES.has(value);
+}
+__name(isChannelWebhookEnqueueErrorCode, "isChannelWebhookEnqueueErrorCode");
+function isChannelWebhookEnqueueError(value) {
+  return value instanceof ChannelWebhookEnqueueError || typeof value === "object" && value !== null && isChannelWebhookEnqueueErrorCode(value.code) && typeof value.message === "string";
+}
+__name(isChannelWebhookEnqueueError, "isChannelWebhookEnqueueError");
+var CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS = 3e4;
+function createChannelWebhookTaskMessage(task) {
+  return {
+    type: "webhook_task",
+    id: randomUUID(),
+    expiresAt: Date.now() + CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
+    task
+  };
+}
+__name(createChannelWebhookTaskMessage, "createChannelWebhookTaskMessage");
+function isChannelWebhookTaskMessage(value) {
+  return typeof value === "object" && value !== null && value.type === "webhook_task" && typeof value.id === "string" && typeof value.expiresAt === "number" && typeof value.task === "object" && value.task !== null;
+}
+__name(isChannelWebhookTaskMessage, "isChannelWebhookTaskMessage");
+function isChannelWebhookTaskResultMessage(value) {
+  return typeof value === "object" && value !== null && value.type === "webhook_task_result" && typeof value.id === "string" && typeof value.ok === "boolean";
+}
+__name(isChannelWebhookTaskResultMessage, "isChannelWebhookTaskResultMessage");
+
+export {
+  ChannelWebhookEnqueueError,
+  isChannelWebhookEnqueueErrorCode,
+  isChannelWebhookEnqueueError,
+  CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
+  createChannelWebhookTaskMessage,
+  isChannelWebhookTaskMessage,
+  isChannelWebhookTaskResultMessage
+};

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

@@ -2,23 +2,23 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-AHNJGLFV.js";
+} from "./chunk-ZPAHLFZU.js";
 import {
   openBrowserSecurely
-} from "./chunk-22IFUCVR.js";
+} from "./chunk-JESCGQM3.js";
 import {
   atomicWriteFile
-} from "./chunk-7LTB54MK.js";
+} from "./chunk-WIEO4CWB.js";
 import {
   combineAbortSignals
-} from "./chunk-64WXLC72.js";
+} from "./chunk-DJ2GSRLV.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-WQTHLB5T.js → chunk-P3S67A5R.js}

@@ -2,27 +2,27 @@
 "use strict";
 import {
   t
-} from "./chunk-O33TBKDC.js";
+} from "./chunk-SE74CIZD.js";
 import {
   computeThresholds,
   getCoreSystemPrompt
-} from "./chunk-3GNOQZDC.js";
+} from "./chunk-SSFDPGFN.js";
 import {
   buildSkillLlmContent
-} from "./chunk-NQKLOAVJ.js";
+} from "./chunk-2Z5UX4KI.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-BUZ6HGL4.js";
+} from "./chunk-T7FSRWQ5.js";
 import {
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-2UUAIFQO.js";
 import {
   DEFAULT_TOKEN_LIMIT
-} from "./chunk-HW4N45EE.js";
+} from "./chunk-B7NUUEXC.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";