@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260711.0ef3a76bd

package/chunks/chunk-43XJTCHT.js

@@ -0,0 +1,444 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolvePath
+} from "./chunk-43JB7OF4.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-ZWZB4CCN.js") },
+        { name: "weixin", promise: import("./dist-QY3THJM5.js") },
+        { name: "dingtalk", promise: import("./dist-KCRX7TGL.js") },
+        { name: "wecom", promise: import("./dist-EFXT7A3G.js") },
+        { name: "feishu", promise: import("./dist-UJOR6KEQ.js") },
+        { name: "qqbot", promise: import("./dist-MFEAEUV4.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) {
+  if (value.startsWith("$$")) {
+    return value.substring(1);
+  }
+  if (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})`
+      );
+    }
+    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) {
+  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"])
+  ) : resolveWebhookSecretEnv(
+    channelName,
+    path,
+    requireStringField(
+      channelName,
+      `${path}.secretEnv`,
+      record["secretEnv"]
+    )
+  );
+  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) {
+  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];
+  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) {
+  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
+    );
+  }
+  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) {
+  return parseWebhookConfig(channelName, rawConfig);
+}
+__name(parseChannelWebhookConfig, "parseChannelWebhookConfig");
+function parseChannelWebhookConfigLenient(channelName, rawConfig, onSourceError) {
+  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
+      );
+    } 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: resolvePath(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-CNSF3WO5.js → chunk-47HXCVGG.js}

@@ -3,27 +3,27 @@
 import {
   AUTO_THEME_NAME,
   themeManager
-} from "./chunk-PC4ZXHU2.js";
+} from "./chunk-MXL5UP4X.js";
 import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-QAKFYMJI.js";
+} from "./chunk-LD5OWZ5E.js";
 import {
   IdeClient
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-UUVCHN62.js";
 import {
   AuthEvent,
   IdeConnectionEvent,
   logAuth,
   logIdeConnection
-} from "./chunk-GMOWQOQQ.js";
+} from "./chunk-MUCWGT7O.js";
 import {
   getErrorMessage
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-J4TSQ5EQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-VEB3NYSO.js → chunk-4GORAUCN.js}

@@ -3,13 +3,13 @@
 import {
   getTeammateContext,
   isTeammate
-} from "./chunk-GO6LNQXT.js";
+} from "./chunk-6AM5D4ME.js";
 import {
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-B5ORX3FG.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -108,6 +108,10 @@ function buildWorktreeNotice(parentCwd, worktreeCwd) {
   return `You are operating in an isolated git worktree at ${worktreeCwd}. The parent agent is in ${parentCwd}. Same repository, same relative file layout, separate working copy. All your file edits, writes, and shell commands MUST target paths under ${worktreeCwd}. When the inherited context references a path under ${parentCwd}, translate it to the corresponding path under ${worktreeCwd} before acting on it. Re-read any file you intend to edit (the parent may have modified it after the snapshot in your context). Your changes stay in this worktree and do not affect the parent's working tree.`;
 }
 __name(buildWorktreeNotice, "buildWorktreeNotice");
+function buildPinnedWorktreeNotice(worktreeCwd) {
+  return `Your working directory is ${worktreeCwd}, a git worktree checked out to the code you have been asked to work on. Relative paths, shell commands, and searches already resolve there \u2014 do not \`cd\` elsewhere and do not prefix paths with the parent's directory. Do not operate on the parent's checkout.`;
+}
+__name(buildPinnedWorktreeNotice, "buildPinnedWorktreeNotice");
 function buildChildMessage(directive) {
   return `<${FORK_BOILERPLATE_TAG}>
 STOP. READ THIS FIRST.
@@ -316,6 +320,7 @@ export {
   buildFunctionResponseParts,
   buildForkedMessages,
   buildWorktreeNotice,
+  buildPinnedWorktreeNotice,
   buildChildMessage,
   runWithAgentContext,
   runWithRuntimeContentGenerator,

package/chunks/{chunk-55ZMG67I.js → chunk-4LD5APFL.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   import_websocket
-} from "./chunk-H6BD2ELD.js";
+} from "./chunk-TYAMGABM.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,
@@ -1358,12 +1358,12 @@ Content-Type: ${partContentType}\r
        * @returns A proxy agent
        */
       static async #getProxyAgent() {
-        this.#proxyAgent ||= (await import("./dist-63IS3ZMI.js")).HttpsProxyAgent;
+        this.#proxyAgent ||= (await import("./dist-PZV5RKM6.js")).HttpsProxyAgent;
         return this.#proxyAgent;
       }
       static async #getFetch() {
         const hasWindow = typeof window !== "undefined" && !!window;
-        this.#fetch ||= hasWindow ? window.fetch : (await import("./src-7XL4G4DC.js")).default;
+        this.#fetch ||= hasWindow ? window.fetch : (await import("./src-VLI3TKEY.js")).default;
         return this.#fetch;
       }
       /**

package/chunks/{chunk-TLWA7TPR.js → chunk-4QLQE5WJ.js}

@@ -3,10 +3,10 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-J4TSQ5EQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,

package/chunks/{chunk-UIDXQNMV.js → chunk-4WGODMVR.js}

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

package/chunks/{chunk-E6US47KI.js → chunk-4WKAA4KS.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name