@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/chunk-3MX7D6QN.js

@@ -0,0 +1,516 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  ChannelWebhookEnqueueError
+} from "./chunk-OJAMDVF5.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-worker-group.ts
+init_esbuild_shims();
+var ChannelWorkerReconcileError = class extends Error {
+  static {
+    __name(this, "ChannelWorkerReconcileError");
+  }
+  rolledBack;
+  rollbackError;
+  stopFailed;
+  constructor(message, options) {
+    super(message);
+    this.name = "ChannelWorkerReconcileError";
+    this.rolledBack = options.rolledBack;
+    this.rollbackError = options.rollbackError;
+    this.stopFailed = options.stopFailed === true;
+  }
+};
+var DISABLED_SNAPSHOT = {
+  enabled: false,
+  state: "disabled",
+  channels: []
+};
+function selectionsEqual(left, right) {
+  if (left.mode !== right.mode) return false;
+  if (left.mode === "all") return true;
+  if (right.mode === "all" || left.names.length !== right.names.length) {
+    return false;
+  }
+  return left.names.every((name, index) => name === right.names[index]);
+}
+__name(selectionsEqual, "selectionsEqual");
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(errorMessage, "errorMessage");
+function createChannelWorkerGroup(opts) {
+  let generation = 0;
+  let entries = /* @__PURE__ */ new Map();
+  const groupsByWorkspace = new Map(
+    opts.groups.map((group2) => [group2.workspaceCwd, group2])
+  );
+  const pendingEntries = /* @__PURE__ */ new Set();
+  const pendingGenerations = /* @__PURE__ */ new Map();
+  const drainingWorkspaces = /* @__PURE__ */ new Set();
+  const removalPromises = /* @__PURE__ */ new Map();
+  let reconciling;
+  let stopping = false;
+  let groupStarted = false;
+  const withMeta = /* @__PURE__ */ __name((entry, snapshot) => ({
+    ...snapshot,
+    workspaceId: entry.workspaceId,
+    workspaceCwd: entry.workspaceCwd,
+    primary: entry.primary
+  }), "withMeta");
+  const createEntry = /* @__PURE__ */ __name((group2) => {
+    const runtime = opts.registry.getByWorkspaceCwd(group2.workspaceCwd);
+    if (!runtime) {
+      throw new Error(
+        `Channel worker group references unregistered workspace "${group2.workspaceCwd}".`
+      );
+    }
+    if (!runtime.trusted) {
+      throw Object.assign(
+        new Error(
+          `Channel worker group workspace "${runtime.workspaceCwd}" is not trusted.`
+        ),
+        { code: "untrusted_workspace" }
+      );
+    }
+    const entryGeneration = ++generation;
+    const withRuntimeMeta = /* @__PURE__ */ __name((snapshot) => ({
+      ...snapshot,
+      workspaceId: runtime.workspaceId,
+      workspaceCwd: runtime.workspaceCwd,
+      primary: runtime.primary
+    }), "withRuntimeMeta");
+    const supervisor = opts.createSupervisor({
+      cliEntryPath: opts.shared.cliEntryPath,
+      daemonUrl: opts.shared.daemonUrl,
+      ...opts.shared.daemonToken ? { daemonToken: opts.shared.daemonToken } : {},
+      workspace: runtime.workspaceCwd,
+      selection: group2.selection,
+      // Multi-workspace runtimes expose a per-workspace env overlay; a
+      // parent-process runtime leaves it undefined so the supervisor inherits
+      // process.env exactly as before.
+      ...runtime.env.effectiveEnv ? { workerBaseEnv: runtime.env.effectiveEnv } : {},
+      ...opts.shared.restartPolicy ? { restartPolicy: opts.shared.restartPolicy } : {},
+      ...opts.shared.startupTimeoutMs !== void 0 ? { startupTimeoutMs: opts.shared.startupTimeoutMs } : {},
+      ...opts.shared.heartbeatTimeoutMs !== void 0 ? { heartbeatTimeoutMs: opts.shared.heartbeatTimeoutMs } : {},
+      ...opts.onReady ? {
+        onReady: /* @__PURE__ */ __name((snapshot) => {
+          if (entries.get(runtime.workspaceCwd)?.generation === entryGeneration) {
+            opts.onReady(withRuntimeMeta(snapshot));
+          } else if (pendingGenerations.get(runtime.workspaceCwd) !== entryGeneration) {
+            opts.onLog?.({
+              stream: "stderr",
+              line: `Ignored stale channel worker ready (generation=${entryGeneration}).`,
+              workspaceCwd: runtime.workspaceCwd
+            });
+          }
+        }, "onReady")
+      } : {},
+      ...opts.onExit ? {
+        onExit: /* @__PURE__ */ __name((snapshot) => {
+          if (entries.get(runtime.workspaceCwd)?.generation === entryGeneration) {
+            opts.onExit(withRuntimeMeta(snapshot));
+          } else if (pendingGenerations.get(runtime.workspaceCwd) !== entryGeneration) {
+            opts.onLog?.({
+              stream: "stderr",
+              line: `Ignored stale channel worker exit (generation=${entryGeneration}).`,
+              workspaceCwd: runtime.workspaceCwd
+            });
+          }
+        }, "onExit")
+      } : {},
+      ...opts.onLog ? {
+        onLog: /* @__PURE__ */ __name((logEntry) => opts.onLog({
+          ...logEntry,
+          workspaceCwd: runtime.workspaceCwd
+        }), "onLog")
+      } : {}
+    });
+    return {
+      workspaceId: runtime.workspaceId,
+      workspaceCwd: runtime.workspaceCwd,
+      primary: runtime.primary,
+      selection: group2.selection,
+      generation: entryGeneration,
+      supervisor
+    };
+  }, "createEntry");
+  for (const group2 of opts.groups) {
+    const entry = createEntry(group2);
+    entries.set(entry.workspaceCwd, entry);
+  }
+  const entrySnapshots = /* @__PURE__ */ __name(() => [...entries.values()].map(
+    (entry) => withMeta(entry, entry.supervisor.snapshot())
+  ), "entrySnapshots");
+  const stopEntry = /* @__PURE__ */ __name((entry) => {
+    if (!entry.stopPromise) {
+      const stopPromise = entry.supervisor.stop().finally(() => opts.onStateChange?.());
+      entry.stopPromise = stopPromise;
+      void stopPromise.then(
+        () => {
+          if (entry.stopPromise === stopPromise) entry.stopPromise = void 0;
+        },
+        () => {
+          if (entry.stopPromise === stopPromise) entry.stopPromise = void 0;
+        }
+      );
+    }
+    return entry.stopPromise;
+  }, "stopEntry");
+  const stopEntriesBestEffort = /* @__PURE__ */ __name(async (entriesToStop) => {
+    await Promise.allSettled(entriesToStop.map((entry) => stopEntry(entry)));
+  }, "stopEntriesBestEffort");
+  const stopAllEntries = /* @__PURE__ */ __name(async (entriesToStop) => {
+    const results = await Promise.allSettled(
+      entriesToStop.map((entry) => stopEntry(entry))
+    );
+    const failure = results.find(
+      (result) => result.status === "rejected"
+    );
+    if (failure) throw failure.reason;
+  }, "stopAllEntries");
+  const stopEntriesForRollback = /* @__PURE__ */ __name(async (entriesToStop) => {
+    let firstError;
+    const failedEntries = [];
+    for (const entry of entriesToStop) {
+      try {
+        await stopEntry(entry);
+      } catch (error) {
+        firstError ??= errorMessage(error);
+        failedEntries.push(entry);
+      }
+    }
+    return {
+      ...firstError ? { error: firstError } : {},
+      failedEntries
+    };
+  }, "stopEntriesForRollback");
+  const restoreEntries = /* @__PURE__ */ __name(async (entriesToRestore) => {
+    let firstError;
+    for (const entry of entriesToRestore) {
+      try {
+        await entry.supervisor.start();
+      } catch (error) {
+        firstError ??= errorMessage(error);
+      }
+    }
+    return firstError ? { rolledBack: false, rollbackError: firstError } : { rolledBack: true };
+  }, "restoreEntries");
+  const routeEntry = /* @__PURE__ */ __name((channelName) => {
+    for (const entry of entries.values()) {
+      if (entry.selection.mode === "all" || entry.selection.names.includes(channelName)) {
+        return entry;
+      }
+    }
+    return void 0;
+  }, "routeEntry");
+  const detachEntry = /* @__PURE__ */ __name((entry) => {
+    if (entries.get(entry.workspaceCwd)?.generation === entry.generation) {
+      entries.delete(entry.workspaceCwd);
+    }
+    pendingEntries.delete(entry);
+    if (pendingGenerations.get(entry.workspaceCwd) === entry.generation) {
+      pendingGenerations.delete(entry.workspaceCwd);
+    }
+  }, "detachEntry");
+  const group = {
+    async start() {
+      stopping = false;
+      const started = [];
+      try {
+        for (const entry of entries.values()) {
+          if (drainingWorkspaces.has(entry.workspaceCwd)) {
+            throw new Error("Workspace drained during channel worker startup.");
+          }
+          if (stopping) {
+            throw new Error("Channel worker group stopped during startup.");
+          }
+          started.push(entry);
+          await entry.supervisor.start();
+          if (stopping) {
+            throw new Error("Channel worker group stopped during startup.");
+          }
+          if (entries.get(entry.workspaceCwd)?.generation !== entry.generation || drainingWorkspaces.has(entry.workspaceCwd)) {
+            throw new Error("Workspace drained during channel worker startup.");
+          }
+        }
+        groupStarted = true;
+      } catch (error) {
+        groupStarted = false;
+        await stopEntriesBestEffort(started);
+        throw error;
+      }
+    },
+    async stop() {
+      stopping = true;
+      groupStarted = false;
+      await reconciling?.catch(() => {
+      });
+      await stopAllEntries([...entries.values()]);
+    },
+    reconcile(targetGroups, reconcileOptions) {
+      if (stopping) {
+        return Promise.reject(
+          new ChannelWorkerReconcileError(
+            "Channel worker group has not completed stopping.",
+            { rolledBack: true, stopFailed: true }
+          )
+        );
+      }
+      if (drainingWorkspaces.size > 0) {
+        return Promise.reject(
+          new ChannelWorkerReconcileError(
+            "Channel worker configuration cannot change while a workspace is draining.",
+            { rolledBack: true }
+          )
+        );
+      }
+      if (reconciling) return reconciling;
+      reconciling = (async () => {
+        const targets = new Map(
+          targetGroups.map((target) => [target.workspaceCwd, target])
+        );
+        const unchanged = /* @__PURE__ */ new Map();
+        const oldAffected = [];
+        const newEntries = [];
+        for (const [workspaceCwd, entry] of entries) {
+          const target = targets.get(workspaceCwd);
+          const healthy = entry.supervisor.snapshot().state === "running";
+          if (target && !reconcileOptions?.force && healthy && selectionsEqual(entry.selection, target.selection)) {
+            unchanged.set(workspaceCwd, entry);
+            targets.delete(workspaceCwd);
+          } else {
+            oldAffected.push(entry);
+          }
+        }
+        for (const target of targets.values()) {
+          const entry = createEntry(target);
+          newEntries.push(entry);
+          pendingEntries.add(entry);
+          pendingGenerations.set(entry.workspaceCwd, entry.generation);
+        }
+        if (oldAffected.length === 0 && newEntries.length === 0) {
+          return { changed: false, workers: entrySnapshots() };
+        }
+        const stoppedOld = [];
+        try {
+          for (const entry of oldAffected) {
+            await stopEntry(entry);
+            stoppedOld.push(entry);
+          }
+        } catch (error) {
+          reconcileOptions?.onRollingBack?.();
+          const rollback = await restoreEntries(stoppedOld);
+          throw new ChannelWorkerReconcileError(errorMessage(error), {
+            ...rollback,
+            stopFailed: true
+          });
+        }
+        const startedNew = [];
+        try {
+          for (const entry of newEntries) {
+            if (drainingWorkspaces.has(entry.workspaceCwd)) {
+              throw new Error(
+                "Workspace drained during channel worker reconcile."
+              );
+            }
+            if (stopping) {
+              throw new Error("Channel worker group stopped during reconcile.");
+            }
+            startedNew.push(entry);
+            await entry.supervisor.start();
+            if (stopping) {
+              throw new Error("Channel worker group stopped during reconcile.");
+            }
+            if (drainingWorkspaces.has(entry.workspaceCwd)) {
+              throw new Error(
+                "Workspace drained during channel worker reconcile."
+              );
+            }
+          }
+          if (drainingWorkspaces.size > 0) {
+            throw new Error(
+              "Workspace drained during channel worker reconcile."
+            );
+          }
+        } catch (error) {
+          reconcileOptions?.onRollingBack?.();
+          const cleanup = await stopEntriesForRollback(startedNew);
+          if (cleanup.error) {
+            for (const entry of cleanup.failedEntries) {
+              entries.set(entry.workspaceCwd, entry);
+            }
+            throw new ChannelWorkerReconcileError(errorMessage(error), {
+              rolledBack: false,
+              rollbackError: cleanup.error
+            });
+          }
+          if (stopping) {
+            throw new ChannelWorkerReconcileError(errorMessage(error), {
+              rolledBack: false
+            });
+          }
+          const rollback = await restoreEntries(stoppedOld);
+          throw new ChannelWorkerReconcileError(errorMessage(error), rollback);
+        }
+        const committed = new Map(unchanged);
+        for (const entry of newEntries) {
+          committed.set(entry.workspaceCwd, entry);
+        }
+        entries = committed;
+        const targetWorkspaceCwds = new Set(
+          targetGroups.map((target) => target.workspaceCwd)
+        );
+        for (const workspaceCwd of groupsByWorkspace.keys()) {
+          if (!targetWorkspaceCwds.has(workspaceCwd)) {
+            groupsByWorkspace.delete(workspaceCwd);
+          }
+        }
+        for (const target of targetGroups) {
+          groupsByWorkspace.set(target.workspaceCwd, target);
+        }
+        return { changed: true, workers: entrySnapshots() };
+      })().finally(() => {
+        pendingEntries.clear();
+        pendingGenerations.clear();
+        reconciling = void 0;
+      });
+      return reconciling;
+    },
+    isHealthy() {
+      return entries.size > 0 && [...entries.values()].every(
+        (entry) => entry.supervisor.snapshot().state === "running"
+      );
+    },
+    killAllSync() {
+      stopping = true;
+      groupStarted = false;
+      for (const entry of entries.values()) {
+        entry.supervisor.killAllSync();
+      }
+      for (const entry of pendingEntries) {
+        entry.supervisor.killAllSync();
+      }
+    },
+    snapshots: entrySnapshots,
+    primarySnapshot() {
+      const primary = [...entries.values()].find((entry) => entry.primary);
+      return primary?.supervisor.snapshot() ?? { ...DISABLED_SNAPSHOT };
+    },
+    beginWorkspaceDrain(workspaceCwd) {
+      drainingWorkspaces.add(workspaceCwd);
+    },
+    cancelWorkspaceDrain(workspaceCwd) {
+      drainingWorkspaces.delete(workspaceCwd);
+    },
+    workspaceActivity(workspaceCwd) {
+      if (pendingGenerations.has(workspaceCwd)) return 1;
+      const entry = entries.get(workspaceCwd);
+      if (!entry) return 0;
+      const snapshot = entry.supervisor.snapshot();
+      return snapshot.state === "starting" || snapshot.state === "running" || snapshot.nextRestartAt !== void 0 ? 1 : 0;
+    },
+    removeWorkspace(workspaceCwd) {
+      const existing = removalPromises.get(workspaceCwd);
+      if (existing) return existing;
+      drainingWorkspaces.add(workspaceCwd);
+      const removal = (async () => {
+        try {
+          await reconciling?.catch(() => {
+          });
+          const entry = entries.get(workspaceCwd);
+          if (!entry) return;
+          let killError;
+          try {
+            await stopEntry(entry);
+          } catch {
+            try {
+              entry.supervisor.killAllSync();
+            } catch (err) {
+              killError = err;
+            }
+          } finally {
+            detachEntry(entry);
+          }
+          if (killError) throw killError;
+        } finally {
+          drainingWorkspaces.delete(workspaceCwd);
+        }
+      })();
+      removalPromises.set(workspaceCwd, removal);
+      void removal.then(
+        () => {
+          if (removalPromises.get(workspaceCwd) === removal) {
+            removalPromises.delete(workspaceCwd);
+          }
+        },
+        () => {
+          if (removalPromises.get(workspaceCwd) === removal) {
+            removalPromises.delete(workspaceCwd);
+          }
+        }
+      );
+      return removal;
+    },
+    async restoreWorkspace(workspaceCwd) {
+      if (entries.has(workspaceCwd)) return;
+      const target = groupsByWorkspace.get(workspaceCwd);
+      if (!target) return;
+      const entry = createEntry(target);
+      entries.set(workspaceCwd, entry);
+      if (!groupStarted || stopping) {
+        detachEntry(entry);
+        return;
+      }
+      try {
+        await entry.supervisor.start();
+        if (stopping || !groupStarted) {
+          await stopEntry(entry).catch(() => {
+            try {
+              entry.supervisor.killAllSync();
+            } catch {
+            }
+          });
+          detachEntry(entry);
+        }
+      } catch (err) {
+        await stopEntry(entry).catch(() => {
+          try {
+            entry.supervisor.killAllSync();
+          } catch {
+          }
+        });
+        detachEntry(entry);
+        throw err;
+      }
+    },
+    async enqueueWebhookTask(task) {
+      const entry = routeEntry(task.channelName);
+      if (!entry || drainingWorkspaces.has(entry.workspaceCwd)) {
+        throw new ChannelWebhookEnqueueError(
+          "channel_worker_unavailable",
+          `No channel worker owns channel "${task.channelName}".`
+        );
+      }
+      return entry.supervisor.enqueueWebhookTask(task);
+    }
+  };
+  return group;
+}
+__name(createChannelWorkerGroup, "createChannelWorkerGroup");
+
+export {
+  ChannelWorkerReconcileError,
+  createChannelWorkerGroup
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-SJHDYNHF.js → chunk-4BJVSIS3.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isSupportedImageMimeType
-} from "./chunk-524RQP4Q.js";
+} from "./chunk-FEOZBUMT.js";
 import {
   TextTokenizer
-} from "./chunk-JSG7ZSBC.js";
+} from "./chunk-VRR65QYW.js";
 import {
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-TO6QE22P.js → chunk-5CNYZ7TN.js}

@@ -1,8 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  resolvePath
-} from "./chunk-34Z3U5RQ.js";
+  resolveChannelCwd
+} from "./chunk-FNX3LGAK.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-GXJVCOS7.js") },
+        { name: "weixin", promise: import("./dist-PX2ERZ6I.js") },
+        { name: "dingtalk", promise: import("./dist-V2YVLYOW.js") },
+        { name: "wecom", promise: import("./dist-4WCQEZIN.js") },
+        { name: "feishu", promise: import("./dist-DOPL5LSQ.js") },
+        { name: "qqbot", promise: import("./dist-VYWUKURL.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", [