@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260730.1643a6c9a

package/chunks/channel-management-service-RAPKQK24.js

@@ -0,0 +1,418 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  resolveChannelCwd
+} from "./chunk-FANRZEAJ.js";
+import {
+  getPlugin
+} from "./chunk-JZQUOT4B.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-2RFKHEXL.js";
+import {
+  normalizeWorkerDiagnostic
+} from "./chunk-6MPDY6ZG.js";
+import {
+  isAllChannelSelectionName
+} from "./chunk-ALMR3E6Q.js";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
+import {
+  PairingStore,
+  sanitizeLogText
+} from "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-H6XPXXMH.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-management-service.ts
+init_esbuild_shims();
+var ChannelManagementError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelManagementError";
+  }
+  static {
+    __name(this, "ChannelManagementError");
+  }
+};
+function diagnostic(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return sanitizeLogText(
+    redactLogCredentials(normalizeWorkerDiagnostic(message)),
+    512
+  );
+}
+__name(diagnostic, "diagnostic");
+function usesEnvironment(value) {
+  return typeof value === "string" && /^\$[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+__name(usesEnvironment, "usesEnvironment");
+function createChannelManagementService(opts) {
+  const diagnostics = /* @__PURE__ */ new Map();
+  let mutationTail = Promise.resolve();
+  const inMutationLane = /* @__PURE__ */ __name((mutation) => {
+    const result = mutationTail.then(mutation, mutation);
+    mutationTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }, "inMutationLane");
+  const assertExpectedRevision = /* @__PURE__ */ __name((snapshot, expectedRevision) => {
+    if (snapshot.revision !== expectedRevision) {
+      throw new ChannelManagementError(
+        "channel_settings_conflict",
+        "Channel settings changed; reload before trying again."
+      );
+    }
+  }, "assertExpectedRevision");
+  const workerFor = /* @__PURE__ */ __name((name) => {
+    const matches = opts.manager.state().workers.filter(
+      (worker) => worker.adapters?.some((adapter) => adapter.name === name) || worker.requestedChannels?.includes(name) || worker.channels.includes(name)
+    );
+    return matches;
+  }, "workerFor");
+  const workspaceCommittedNames = /* @__PURE__ */ __name(() => opts.manager.committedChannelNames().filter(
+    (name) => workerFor(name).some((w) => w.workspaceCwd === opts.workspaceCwd)
+  ), "workspaceCommittedNames");
+  const assertOwnedRuntime = /* @__PURE__ */ __name((name) => {
+    if (!workspaceCommittedNames().includes(name)) return;
+    const workers = workerFor(name).filter(
+      (worker) => worker.workspaceCwd === opts.workspaceCwd
+    );
+    if (workers.length !== 1) {
+      throw new ChannelManagementError(
+        "channel_runtime_owner_mismatch",
+        `Channel "${name}" does not have one confirmed runtime owner in this workspace.`
+      );
+    }
+  }, "assertOwnedRuntime");
+  const runtimeFor = /* @__PURE__ */ __name((name) => {
+    const retainedError = diagnostics.get(name);
+    if (retainedError) return { state: "error", lastError: retainedError };
+    if (!workspaceCommittedNames().includes(name)) {
+      return { state: "stopped" };
+    }
+    const state = opts.manager.state();
+    const workers = workerFor(name).filter(
+      (worker2) => worker2.workspaceCwd === opts.workspaceCwd
+    );
+    if (workers.length !== 1) {
+      return {
+        state: "error",
+        lastError: "Channel runtime owner is unknown or ambiguous."
+      };
+    }
+    const worker = workers[0];
+    const adapter = worker.adapters?.find((item) => item.name === name);
+    if (adapter?.state === "connected") return { state: "connected" };
+    if (adapter?.state === "error") {
+      return {
+        state: "error",
+        ...adapter.error ? { lastError: diagnostic(adapter.error) } : {}
+      };
+    }
+    if (adapter?.state === "starting" || state.transition === "starting" || state.transition === "reconciling") {
+      return { state: "starting" };
+    }
+    if (worker.state === "running") return { state: "partial" };
+    return {
+      state: "error",
+      ...worker.error ? { lastError: diagnostic(worker.error) } : {}
+    };
+  }, "runtimeFor");
+  const instanceFrom = /* @__PURE__ */ __name(async (name, rawConfig, startupNames) => {
+    const type = typeof rawConfig["type"] === "string" ? rawConfig["type"] : "";
+    const plugin = type ? await getPlugin(type) : void 0;
+    if (!plugin?.management) {
+      return {
+        name,
+        config: type ? { type } : {},
+        secrets: {},
+        startsWithServe: startupNames.some(isAllChannelSelectionName) || startupNames.includes(name),
+        runtime: runtimeFor(name)
+      };
+    }
+    const secretKeys = new Set(
+      plugin.management.fields.filter((field) => field.kind === "secret").map((field) => field.key)
+    );
+    const config = {};
+    const secrets = {};
+    for (const [key, value] of Object.entries(rawConfig)) {
+      if (!secretKeys.has(key)) {
+        config[key] = value;
+        continue;
+      }
+      secrets[key] = {
+        present: value !== void 0,
+        ...value !== void 0 ? { source: usesEnvironment(value) ? "environment" : "literal" } : {}
+      };
+    }
+    for (const key of secretKeys) {
+      secrets[key] ??= { present: false };
+    }
+    return {
+      name,
+      config,
+      secrets,
+      startsWithServe: startupNames.some(isAllChannelSelectionName) || startupNames.includes(name),
+      runtime: runtimeFor(name)
+    };
+  }, "instanceFrom");
+  const listFrom = /* @__PURE__ */ __name(async (persisted) => {
+    const entries = await Promise.all(
+      Object.entries(persisted.channels).map(
+        async ([name, config]) => [
+          name,
+          await instanceFrom(name, config, persisted.startupNames)
+        ]
+      )
+    );
+    return {
+      revision: persisted.revision,
+      instances: Object.fromEntries(entries)
+    };
+  }, "listFrom");
+  const resultFor = /* @__PURE__ */ __name(async (name, persisted = opts.store.snapshot()) => {
+    const snapshot = await listFrom(persisted);
+    const instance = Object.hasOwn(snapshot.instances, name) ? snapshot.instances[name] : {
+      name,
+      config: {},
+      secrets: {},
+      startsWithServe: false,
+      runtime: runtimeFor(name)
+    };
+    return { snapshot, instance };
+  }, "resultFor");
+  const stopChannel = /* @__PURE__ */ __name((name) => opts.manager.setChannelEnabled(
+    { name, workspaceCwd: opts.workspaceCwd },
+    false
+  ), "stopChannel");
+  const assertManageableInstanceName = /* @__PURE__ */ __name((name) => {
+    if (isAllChannelSelectionName(name)) {
+      throw new ChannelManagementError(
+        "invalid_channel_instance_name",
+        'Channel instance name "all" is reserved for startup selection.'
+      );
+    }
+  }, "assertManageableInstanceName");
+  const assertWorkspaceConfig = /* @__PURE__ */ __name((config) => {
+    const rawCwd = config["cwd"];
+    if (typeof rawCwd !== "string") return;
+    const workspaceCwd = canonicalizeWorkspace(opts.workspaceCwd);
+    const channelCwd = canonicalizeWorkspace(
+      resolveChannelCwd(rawCwd, workspaceCwd)
+    );
+    if (channelCwd !== workspaceCwd) {
+      throw new ChannelManagementError(
+        "channel_workspace_mismatch",
+        "Channel workspace must match the selected workspace."
+      );
+    }
+  }, "assertWorkspaceConfig");
+  const pairingStoreFor = /* @__PURE__ */ __name((name) => {
+    assertManageableInstanceName(name);
+    const channels = opts.store.snapshot().channels;
+    if (!Object.hasOwn(channels, name)) {
+      throw new ChannelManagementError(
+        "channel_instance_not_found",
+        `Channel "${name}" is not configured in this workspace.`
+      );
+    }
+    const config = channels[name];
+    assertWorkspaceConfig(config);
+    if (config["senderPolicy"] !== "pairing") {
+      throw new ChannelManagementError(
+        "channel_pairing_not_enabled",
+        `Channel "${name}" does not use pairing mode.`
+      );
+    }
+    return new PairingStore(name, opts.workspaceCwd);
+  }, "pairingStoreFor");
+  const service = {
+    async list() {
+      return listFrom(opts.store.snapshot());
+    },
+    async upsert(name, request) {
+      assertManageableInstanceName(name);
+      assertWorkspaceConfig(request.config);
+      const active = workspaceCommittedNames().includes(name);
+      if (active) assertOwnedRuntime(name);
+      const persisted = await opts.store.upsert(name, request);
+      diagnostics.delete(name);
+      if (active) {
+        try {
+          await opts.manager.reloadWorkspace(opts.workspaceCwd, name);
+        } catch (error) {
+          diagnostics.set(name, diagnostic(error));
+          try {
+            await stopChannel(name);
+          } catch {
+          }
+        }
+      }
+      return resultFor(name, persisted);
+    },
+    async remove(name, request) {
+      assertManageableInstanceName(name);
+      const current = opts.store.snapshot();
+      if (!Object.hasOwn(current.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(current.channels[name]);
+      assertExpectedRevision(current, request.expectedRevision);
+      if (workspaceCommittedNames().includes(name)) {
+        assertOwnedRuntime(name);
+        await stopChannel(name);
+      }
+      const persisted = await opts.store.remove(name, request);
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async setStartup(name, request) {
+      assertManageableInstanceName(name);
+      const current = opts.store.snapshot();
+      if (!Object.hasOwn(current.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(current.channels[name]);
+      const startsAll = current.startupNames.some(isAllChannelSelectionName);
+      if (startsAll && request.enabled) {
+        assertExpectedRevision(current, request.expectedRevision);
+        return resultFor(name, current);
+      }
+      const startupNames = startsAll ? Object.keys(current.channels).filter(
+        (item) => !isAllChannelSelectionName(item) && item !== name
+      ) : request.enabled ? current.startupNames.includes(name) ? current.startupNames : [...current.startupNames, name] : current.startupNames.filter((item) => item !== name);
+      const persisted = await opts.store.setStartupNames(startupNames, {
+        expectedRevision: request.expectedRevision
+      });
+      return resultFor(name, persisted);
+    },
+    async start(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      await opts.manager.setChannelEnabled(
+        { name, workspaceCwd: opts.workspaceCwd },
+        true
+      );
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async stop(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      await opts.manager.setChannelEnabled(
+        { name, workspaceCwd: opts.workspaceCwd },
+        false
+      );
+      diagnostics.delete(name);
+      return resultFor(name, persisted);
+    },
+    async restart(name) {
+      assertManageableInstanceName(name);
+      const persisted = opts.store.snapshot();
+      if (!Object.hasOwn(persisted.channels, name)) {
+        throw new ChannelManagementError(
+          "channel_instance_not_found",
+          `Channel "${name}" is not configured in this workspace.`
+        );
+      }
+      assertWorkspaceConfig(persisted.channels[name]);
+      if (!workspaceCommittedNames().includes(name)) {
+        throw new ChannelManagementError(
+          "channel_worker_not_enabled",
+          `Channel "${name}" is not running.`
+        );
+      }
+      assertOwnedRuntime(name);
+      try {
+        await opts.manager.reloadWorkspace(opts.workspaceCwd, name);
+        diagnostics.delete(name);
+      } catch (error) {
+        diagnostics.set(name, diagnostic(error));
+        throw error;
+      }
+      return resultFor(name, persisted);
+    },
+    async pairingRequests(name) {
+      return { requests: pairingStoreFor(name).listPending() };
+    },
+    async approvePairing(name, code) {
+      const store = pairingStoreFor(name);
+      const approved = store.approve(code);
+      if (!approved) {
+        throw new ChannelManagementError(
+          "channel_pairing_request_not_found",
+          "Pairing request was not found or has expired."
+        );
+      }
+      return { approved, requests: store.listPending() };
+    },
+    async pairingApprovals(name) {
+      return { senderIds: pairingStoreFor(name).getAllowlist() };
+    },
+    async revokePairingApproval(name, senderId) {
+      const store = pairingStoreFor(name);
+      if (!store.revoke(senderId)) {
+        throw new ChannelManagementError(
+          "channel_pairing_approval_not_found",
+          "Pairing approval was not found."
+        );
+      }
+      return { revoked: senderId, senderIds: store.getAllowlist() };
+    }
+  };
+  return {
+    list: /* @__PURE__ */ __name(() => service.list(), "list"),
+    upsert: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.upsert(name, request)), "upsert"),
+    remove: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.remove(name, request)), "remove"),
+    setStartup: /* @__PURE__ */ __name((name, request) => inMutationLane(() => service.setStartup(name, request)), "setStartup"),
+    start: /* @__PURE__ */ __name((name) => inMutationLane(() => service.start(name)), "start"),
+    stop: /* @__PURE__ */ __name((name) => inMutationLane(() => service.stop(name)), "stop"),
+    restart: /* @__PURE__ */ __name((name) => inMutationLane(() => service.restart(name)), "restart"),
+    pairingRequests: /* @__PURE__ */ __name((name) => service.pairingRequests(name), "pairingRequests"),
+    approvePairing: /* @__PURE__ */ __name((name, code) => inMutationLane(() => service.approvePairing(name, code)), "approvePairing"),
+    pairingApprovals: /* @__PURE__ */ __name((name) => service.pairingApprovals(name), "pairingApprovals"),
+    revokePairingApproval: /* @__PURE__ */ __name((name, senderId) => inMutationLane(() => service.revokePairingApproval(name, senderId)), "revokePairingApproval")
+  };
+}
+__name(createChannelManagementService, "createChannelManagementService");
+export {
+  ChannelManagementError,
+  createChannelManagementService
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/channel-settings-store-KJQKY6NN.js

@@ -0,0 +1,89 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  ChannelSettingsError,
+  WorkspaceChannelSettingsStore,
+  assertValidChannelSecretUpdates
+} from "./chunk-PGHTM673.js";
+import "./chunk-JZQUOT4B.js";
+import "./chunk-7A4V5CJY.js";
+import "./chunk-RKUWKYED.js";
+import "./chunk-GOXKNSDZ.js";
+import "./chunk-IDS7MSUP.js";
+import "./chunk-RWZPM2BP.js";
+import "./chunk-UJBURGBH.js";
+import "./chunk-6PEXNQTX.js";
+import "./chunk-5IDU2UGL.js";
+import "./chunk-ALGGS7UH.js";
+import "./chunk-MR3PXB6E.js";
+import "./chunk-OWAK7LMW.js";
+import "./chunk-EYGWU66Z.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-CVHIL5IG.js";
+import "./chunk-UPUG4GXM.js";
+import "./chunk-64LQLPL7.js";
+import "./chunk-2LQTH543.js";
+import "./chunk-KRXPRVGL.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-LW67T6GH.js";
+import "./chunk-IRH27ZC2.js";
+import "./chunk-QHWCP53L.js";
+import "./chunk-PONHVBRT.js";
+import "./chunk-PMGFWLAZ.js";
+import "./chunk-T26EAKDL.js";
+import "./chunk-CPBF7KYF.js";
+import "./chunk-6QIGFD5W.js";
+import "./chunk-XWWKIXVD.js";
+import "./chunk-75GFAX4R.js";
+import "./chunk-OKF7JF3R.js";
+import "./chunk-6FMJLI5M.js";
+import "./chunk-FH6SU2OG.js";
+import "./chunk-S6LOFUVP.js";
+import "./chunk-JCW2R7WC.js";
+import "./chunk-2DN4J57Y.js";
+import "./chunk-ZPJWUGCS.js";
+import "./chunk-2LKVPASC.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-LW3RFMG7.js";
+import "./chunk-W4MIWP6M.js";
+import "./chunk-DGEIYUC3.js";
+import "./chunk-MPHPFVKK.js";
+import "./chunk-GLNBDYUX.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-ZWUDSQBD.js";
+import "./chunk-RQLRERVY.js";
+import "./chunk-2J3OJGTL.js";
+import "./chunk-P3QQPMQA.js";
+import "./chunk-RPLGZJV2.js";
+import "./chunk-GLCZKT5V.js";
+import "./chunk-DZLYR4U3.js";
+import "./chunk-2Q4CZ3V6.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-SGFT55XI.js";
+import "./chunk-Y4IHBGBP.js";
+import "./chunk-Y6AXW2OG.js";
+import "./chunk-OINT3ZNV.js";
+import "./chunk-46UV252V.js";
+import "./chunk-ZBVS26BY.js";
+import "./chunk-WZRWHXFE.js";
+import "./chunk-A3NDJ5SB.js";
+import "./chunk-7XATOOE7.js";
+import "./chunk-YX4DHA6S.js";
+import "./chunk-W4RQUHY3.js";
+import "./chunk-G7XXKQYS.js";
+import "./chunk-UHUSJ6X7.js";
+import "./chunk-VOQXFAY5.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-AMDSOFFV.js";
+import "./chunk-QUGAUQGJ.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  ChannelSettingsError,
+  WorkspaceChannelSettingsStore,
+  assertValidChannelSecretUpdates
+};

package/chunks/{channel-worker-group-2ZD7TVAT.js → channel-worker-group-7SZ7MR3K.js}

@@ -3,15 +3,20 @@
 import {
   ChannelWorkerReconcileError,
   createChannelWorkerGroup
-} from "./chunk-UDX5OBWR.js";
-import "./chunk-5NBDS5S6.js";
-import "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+} from "./chunk-77IMMLN2.js";
+import "./chunk-XZC5VLBZ.js";
+import "./chunk-B4AJNNOL.js";
+import "./chunk-2RFKHEXL.js";
+import "./chunk-FCYYAB4S.js";
+import "./chunk-FYJ7W2PI.js";
+import "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
-import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";

package/chunks/{channel-worker-manager-4OA4BCGB.js → channel-worker-manager-RN5KJYPF.js}

@@ -2,21 +2,26 @@
 "use strict";
 import {
   ChannelWorkerReconcileError
-} from "./chunk-UDX5OBWR.js";
+} from "./chunk-77IMMLN2.js";
+import "./chunk-XZC5VLBZ.js";
+import "./chunk-B4AJNNOL.js";
+import "./chunk-2RFKHEXL.js";
 import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError
-} from "./chunk-5NBDS5S6.js";
+} from "./chunk-FCYYAB4S.js";
+import "./chunk-FYJ7W2PI.js";
 import {
   ChannelDeliveryError,
   ChannelWebhookEnqueueError
-} from "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+} from "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
-import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import {

package/chunks/{channel-worker-supervisor-V7KCFJTS.js → channel-worker-supervisor-CABBXYHK.js}

@@ -4,14 +4,16 @@ import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
   createChannelWorkerSupervisor
-} from "./chunk-5NBDS5S6.js";
-import "./chunk-LK7CHLVP.js";
-import "./chunk-JLU636DO.js";
+} from "./chunk-FCYYAB4S.js";
+import "./chunk-FYJ7W2PI.js";
+import "./chunk-U4VTUMMK.js";
+import "./chunk-6MPDY6ZG.js";
+import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RWTEFFPU.js";
-import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
+import "./chunk-JCJ7LKNA.js";
+import "./chunk-UDXSXLER.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";

package/chunks/{chunk-M5JM7OSF.js → chunk-2DN4J57Y.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -818,7 +818,7 @@ var QwenIgnoreParser = class {
         }
         continue;
       }
-      const patterns = (content ?? "").split("\n").map((p) => p.trim()).filter((p) => p !== "" && !p.startsWith("#"));
+      const patterns = (content ?? "").split("\n").map((p) => p.endsWith("\r") ? p.slice(0, -1) : p).filter((p) => p.trim() !== "" && !p.startsWith("#"));
       if (patterns.length > 0) {
         const sourceIgnorer = (0, import_ignore.default)();
         sourceIgnorer.add(patterns);
@@ -902,7 +902,6 @@ export {
   getQwenIgnoreFileNames,
   formatQwenIgnoreFileNames,
   QwenIgnoreParser,
-  DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
   DEFAULT_FILE_FILTERING_OPTIONS
 };
 /**