@qwen-code/qwen-code 0.19.8 → 0.19.9

package/chunks/chunk-TO6QE22P.js

@@ -0,0 +1,444 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolvePath
+} from "./chunk-34Z3U5RQ.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-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") }
+      ];
+      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-H6BD2ELD.js → chunk-TYAMGABM.js}

@@ -9,10 +9,10 @@ import {
   require_subprotocol,
   require_websocket,
   require_websocket_server
-} from "./chunk-5IFG2VC4.js";
+} from "./chunk-FCMNKVXT.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";

package/chunks/chunk-U2NNEY4R.js

@@ -0,0 +1,38 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  t
+} from "./chunk-YAUFFXDS.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/history-gap-notice.ts
+init_esbuild_shims();
+function formatHistoryGapNotice(_gap) {
+  return t(
+    "\u26A0\uFE0F History gap: earlier conversation was lost before this point (storage interruption) and could not be recovered."
+  );
+}
+__name(formatHistoryGapNotice, "formatHistoryGapNotice");
+function indexGapsByChild(gaps) {
+  const byChild = /* @__PURE__ */ new Map();
+  for (const gap of gaps ?? []) {
+    byChild.set(gap.childUuid, gap);
+  }
+  return byChild;
+}
+__name(indexGapsByChild, "indexGapsByChild");
+
+export {
+  formatHistoryGapNotice,
+  indexGapsByChild
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-VRDMOSQS.js → chunk-UDXSXLER.js}

@@ -3,10 +3,10 @@
 import {
   external_exports,
   external_exports2
-} from "./chunk-K5PGHDBN.js";
+} from "./chunk-H6XPXXMH.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-AHNJGLFV.js → chunk-UOZWKTQG.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   isTlsVerificationDisabled
-} from "./chunk-H6EMK6QK.js";
+} from "./chunk-4ZVWQHEQ.js";
 import {
   getErrorMessage,
   isNodeError
-} 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-CJCKDMWO.js → chunk-URK542T4.js}

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

package/chunks/{chunk-AHNXYU4O.js → chunk-V6WHFGST.js}

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

package/chunks/{chunk-DCZWC4PF.js → chunk-VA4KQY6V.js}

@@ -2,23 +2,23 @@
 "use strict";
 import {
   writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-YUZI3WAC.js";
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-3GNOQZDC.js";
+} from "./chunk-NVYTCB5Z.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
   FatalTurnLimitedError,
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-J4TSQ5EQ.js";
 import {
   runExitCleanup
-} from "./chunk-JCH35JB3.js";
+} from "./chunk-ECNYL4AA.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-ZTQ26VBE.js → chunk-VDDGDZMA.js}

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

package/chunks/{chunk-OMX7CUOE.js → chunk-VGC4I5JJ.js}

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

package/chunks/{chunk-43W4YSO6.js → chunk-VJNBRRZG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -18,7 +18,7 @@ async function getPackageJson() {
   if (packageJson) {
     return packageJson;
   }
-  const { readPackageUp } = await import("./read-package-up-ER5OJUGP.js");
+  const { readPackageUp } = await import("./read-package-up-TCM6I7S2.js");
   const result = await readPackageUp({ cwd: __dirname });
   if (!result) {
     return;

package/chunks/{chunk-J7RCB6N5.js → chunk-VTU57BWZ.js}

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

package/chunks/{chunk-LAXNEOBG.js → chunk-VWPVHAMO.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-3GNOQZDC.js";
+} from "./chunk-NVYTCB5Z.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -64,6 +64,7 @@ var SERVE_STATUS_EXT_METHODS = {
   sessionTasks: "qwen/status/session/tasks",
   sessionStats: "qwen/status/session/stats",
   sessionLspStatus: "qwen/status/session/lsp",
+  sessionTranscript: "qwen/status/session/transcript",
   sessionRewindSnapshots: "qwen/status/session/rewind_snapshots",
   workspaceHooks: "qwen/status/workspace/hooks",
   sessionHooks: "qwen/status/session/hooks",
@@ -84,6 +85,8 @@ var SERVE_CONTROL_EXT_METHODS = {
   sessionRewind: "qwen/control/session/rewind",
   sessionContinue: "qwen/control/session/continue",
   sessionTitle: "qwen/control/session/title",
+  sessionParent: "qwen/control/session/parent",
+  sessionArtifactsPersist: "qwen/control/session/artifacts/persist",
   workspaceMcpRestart: "qwen/control/workspace/mcp/restart",
   workspaceMcpManage: "qwen/control/workspace/mcp/manage",
   workspaceAgentGenerate: "qwen/control/workspace/agents/generate",
@@ -109,7 +112,16 @@ var SERVE_CONTROL_EXT_METHODS = {
    * result: `{ payload }`.
    */
   clientMcpMessage: "qwen/control/client_mcp/message",
-  sessionCd: "qwen/control/session/cd"
+  sessionCd: "qwen/control/session/cd",
+  /**
+   * Also called by the CHILD UP into the parent (like `clientMcpMessage`): the
+   * `create_sub_session` tool, running inside a child's agent turn, asks the
+   * daemon to spawn a fresh top-level sub-session and run a prompt in it. Params:
+   * `{ prompt, completion:'sent'|'first-turn', model?, name?, callerSessionId? }`;
+   * result: `{ sessionId, result?, stopReason? }` (result present only for the
+   * `first-turn` mode, which waits for the sub-session's first turn to finish).
+   */
+  createSubSession: "qwen/control/create-sub-session"
 };
 var IDLE_HOOK_EVENTS = {
   PreToolUse: { description: "Before tool execution", matcherKind: "toolName" },