@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{chunk-ZJHVAS7M.js → chunk-2YCYFWYZ.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   getRateLimitErrorDetails
-} from "./chunk-6FGBXPWM.js";
+} from "./chunk-XQK4XXTN.js";
 import {
   isInternalPromptId
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-NVFSGPIF.js";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -279,8 +279,7 @@ var openaiLogger = new OpenAILogger();
 
 export {
   resolveOpenAILogDir,
-  OpenAILogger,
-  openaiLogger
+  OpenAILogger
 };
 /**
  * @license

package/chunks/{chunk-3QMGYBFN.js → chunk-3APUUXRF.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -13,14 +13,6 @@ import {
 // packages/core/src/hooks/types.ts
 init_esbuild_shims();
 var debugLogger = createDebugLogger("TRUSTED_HOOKS");
-var HooksConfigSource = /* @__PURE__ */ ((HooksConfigSource2) => {
-  HooksConfigSource2["Project"] = "project";
-  HooksConfigSource2["User"] = "user";
-  HooksConfigSource2["System"] = "system";
-  HooksConfigSource2["Extensions"] = "extensions";
-  HooksConfigSource2["Session"] = "session";
-  return HooksConfigSource2;
-})(HooksConfigSource || {});
 var HookEventName = /* @__PURE__ */ ((HookEventName2) => {
   HookEventName2["PreToolUse"] = "PreToolUse";
   HookEventName2["PostToolUse"] = "PostToolUse";
@@ -45,19 +37,7 @@ var HookEventName = /* @__PURE__ */ ((HookEventName2) => {
   HookEventName2["InstructionsLoaded"] = "InstructionsLoaded";
   return HookEventName2;
 })(HookEventName || {});
-var HookPhase = /* @__PURE__ */ ((HookPhase2) => {
-  HookPhase2["Validation"] = "validation";
-  HookPhase2["PostWrite"] = "postWrite";
-  return HookPhase2;
-})(HookPhase || {});
 var HOOKS_CONFIG_FIELDS = ["enabled", "disabled", "notifications"];
-var HookType = /* @__PURE__ */ ((HookType2) => {
-  HookType2["Command"] = "command";
-  HookType2["Http"] = "http";
-  HookType2["Function"] = "function";
-  HookType2["Prompt"] = "prompt";
-  return HookType2;
-})(HookType || {});
 function getHookKey(hook) {
   const name = hook.name ?? "";
   switch (hook.type) {
@@ -390,54 +370,6 @@ var PermissionRequestHookOutput = class extends DefaultHookOutput {
     return decision?.updatedPermissions;
   }
 };
-var NotificationType = /* @__PURE__ */ ((NotificationType2) => {
-  NotificationType2["PermissionPrompt"] = "permission_prompt";
-  NotificationType2["IdlePrompt"] = "idle_prompt";
-  NotificationType2["AuthSuccess"] = "auth_success";
-  NotificationType2["ElicitationDialog"] = "elicitation_dialog";
-  return NotificationType2;
-})(NotificationType || {});
-var SessionStartSource = /* @__PURE__ */ ((SessionStartSource2) => {
-  SessionStartSource2["Startup"] = "startup";
-  SessionStartSource2["Resume"] = "resume";
-  SessionStartSource2["Clear"] = "clear";
-  SessionStartSource2["Compact"] = "compact";
-  SessionStartSource2["Branch"] = "branch";
-  return SessionStartSource2;
-})(SessionStartSource || {});
-var PermissionMode = /* @__PURE__ */ ((PermissionMode2) => {
-  PermissionMode2["Default"] = "default";
-  PermissionMode2["Plan"] = "plan";
-  PermissionMode2["AutoEdit"] = "auto_edit";
-  PermissionMode2["Auto"] = "auto";
-  PermissionMode2["Yolo"] = "yolo";
-  return PermissionMode2;
-})(PermissionMode || {});
-var SessionEndReason = /* @__PURE__ */ ((SessionEndReason2) => {
-  SessionEndReason2["Clear"] = "clear";
-  SessionEndReason2["Logout"] = "logout";
-  SessionEndReason2["PromptInputExit"] = "prompt_input_exit";
-  SessionEndReason2["Bypass_permissions_disabled"] = "bypass_permissions_disabled";
-  SessionEndReason2["Other"] = "other";
-  return SessionEndReason2;
-})(SessionEndReason || {});
-var PreCompactTrigger = /* @__PURE__ */ ((PreCompactTrigger2) => {
-  PreCompactTrigger2["Manual"] = "manual";
-  PreCompactTrigger2["Auto"] = "auto";
-  return PreCompactTrigger2;
-})(PreCompactTrigger || {});
-var PostCompactTrigger = /* @__PURE__ */ ((PostCompactTrigger2) => {
-  PostCompactTrigger2["Manual"] = "manual";
-  PostCompactTrigger2["Auto"] = "auto";
-  return PostCompactTrigger2;
-})(PostCompactTrigger || {});
-var AgentType = /* @__PURE__ */ ((AgentType2) => {
-  AgentType2["Bash"] = "Bash";
-  AgentType2["Explorer"] = "Explorer";
-  AgentType2["Plan"] = "Plan";
-  AgentType2["Custom"] = "Custom";
-  return AgentType2;
-})(AgentType || {});
 function detectTodoChanges(oldTodos, newTodos) {
   const oldTodosMap = new Map(oldTodos.map((t) => [t.id, t]));
   const changes = {
@@ -457,14 +389,10 @@ function detectTodoChanges(oldTodos, newTodos) {
 __name(detectTodoChanges, "detectTodoChanges");
 
 export {
-  HooksConfigSource,
   HookEventName,
-  HookPhase,
   HOOKS_CONFIG_FIELDS,
-  HookType,
   getHookKey,
   isToolArtifactLike,
-  MAX_USER_PROMPT_EXPANSION_ADDITIONAL_CONTEXT_LENGTH,
   sanitizeUserPromptExpansionAdditionalContext,
   createHookOutput,
   DefaultHookOutput,
@@ -475,13 +403,6 @@ export {
   PostToolBatchHookOutput,
   StopHookOutput,
   PermissionRequestHookOutput,
-  NotificationType,
-  SessionStartSource,
-  PermissionMode,
-  SessionEndReason,
-  PreCompactTrigger,
-  PostCompactTrigger,
-  AgentType,
   detectTodoChanges
 };
 /**

package/chunks/{chunk-MUP3T3AD.js → chunk-3I6DUGQD.js}

@@ -5,7 +5,7 @@ import {
   Storage,
   resolvePath,
   sanitizeCwd
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -70,11 +70,6 @@ function getAutoMemoryRoot(projectRoot) {
   return result;
 }
 __name(getAutoMemoryRoot, "getAutoMemoryRoot");
-function clearAutoMemoryRootCache() {
-  _autoMemoryRootCache.clear();
-  _teamAutoMemoryRootCache.clear();
-}
-__name(clearAutoMemoryRootCache, "clearAutoMemoryRootCache");
 function getAutoMemoryTrustedAnchor(projectRoot) {
   return process.env["QWEN_CODE_MEMORY_LOCAL"] === "1" ? projectRoot : getMemoryBaseDir();
 }
@@ -115,21 +110,6 @@ function getAutoMemoryConsolidationLockPath(projectRoot) {
   );
 }
 __name(getAutoMemoryConsolidationLockPath, "getAutoMemoryConsolidationLockPath");
-function getAutoMemoryTopicFilename(type) {
-  return `${type}.md`;
-}
-__name(getAutoMemoryTopicFilename, "getAutoMemoryTopicFilename");
-function getAutoMemoryTopicPath(projectRoot, type) {
-  return path.join(
-    getAutoMemoryRoot(projectRoot),
-    getAutoMemoryTopicFilename(type)
-  );
-}
-__name(getAutoMemoryTopicPath, "getAutoMemoryTopicPath");
-function getAutoMemoryFilePath(projectRoot, relativePath) {
-  return path.join(getAutoMemoryRoot(projectRoot), relativePath);
-}
-__name(getAutoMemoryFilePath, "getAutoMemoryFilePath");
 function getUserAutoMemoryRoot() {
   return path.join(getMemoryBaseDir(), USER_AUTO_MEMORY_DIRNAME);
 }
@@ -138,10 +118,6 @@ function getUserAutoMemoryIndexPath() {
   return path.join(getUserAutoMemoryRoot(), AUTO_MEMORY_INDEX_FILENAME);
 }
 __name(getUserAutoMemoryIndexPath, "getUserAutoMemoryIndexPath");
-function getUserAutoMemoryTopicPath(type) {
-  return path.join(getUserAutoMemoryRoot(), getAutoMemoryTopicFilename(type));
-}
-__name(getUserAutoMemoryTopicPath, "getUserAutoMemoryTopicPath");
 function isUserAutoMemPath(absolutePath) {
   const normalizedPath = path.normalize(absolutePath);
   const memRoot = path.normalize(getUserAutoMemoryRoot());
@@ -243,16 +219,10 @@ function isAnyAutoMemPath(absolutePath, projectRoot) {
 __name(isAnyAutoMemPath, "isAnyAutoMemPath");
 
 export {
-  AUTO_MEMORY_DIRNAME,
   AUTO_MEMORY_INDEX_FILENAME,
-  AUTO_MEMORY_METADATA_FILENAME,
-  AUTO_MEMORY_EXTRACT_CURSOR_FILENAME,
-  AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME,
-  USER_AUTO_MEMORY_DIRNAME,
   TEAM_AUTO_MEMORY_DIRNAME,
   getMemoryBaseDir,
   getAutoMemoryRoot,
-  clearAutoMemoryRootCache,
   getAutoMemoryTrustedAnchor,
   getAutoMemoryProjectStateDir,
   isAutoMemPath,
@@ -260,12 +230,8 @@ export {
   getAutoMemoryMetadataPath,
   getAutoMemoryExtractCursorPath,
   getAutoMemoryConsolidationLockPath,
-  getAutoMemoryTopicFilename,
-  getAutoMemoryTopicPath,
-  getAutoMemoryFilePath,
   getUserAutoMemoryRoot,
   getUserAutoMemoryIndexPath,
-  getUserAutoMemoryTopicPath,
   isUserAutoMemPath,
   getTeamAutoMemoryRoot,
   getTeamAutoMemoryIndexPath,

package/chunks/{chunk-JVPM2ULZ.js → chunk-3XZ5SSNR.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-A5T5W7PR.js";
 import {
   getCurrentLanguage
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-B3TA3IF5.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-Z2BC6UJ5.js";
+} from "./chunk-UU2B5YG6.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
@@ -26,14 +26,14 @@ import {
   hashMcpServerConfig,
   isGatedMcpScope,
   normalizeClaudeMcpServer
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   atomicWriteFile
-} from "./chunk-A5L3JMUA.js";
+} from "./chunk-HC45LTEN.js";
 import {
   Storage,
   getErrorMessage
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-42VPM33K.js

@@ -0,0 +1,319 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getUserSettingsPath,
+  v1ToV2Migration
+} from "./chunk-A5T5W7PR.js";
+import {
+  getSystemDefaultsPath,
+  getSystemSettingsPath
+} from "./chunk-IDS7MSUP.js";
+import {
+  LoadedTrustedFolders,
+  TrustLevel,
+  getTrustedFoldersPath
+} from "./chunk-UU2B5YG6.js";
+import {
+  require_strip_json_comments
+} from "./chunk-ALGGS7UH.js";
+import {
+  arePathsEquivalent
+} from "./chunk-MR3PXB6E.js";
+import {
+  ideContextStore
+} from "./chunk-FRXG4ARO.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/daemon-trust-policy.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
+var MAX_TRUSTED_FOLDERS_BYTES = 1024 * 1024;
+var MAX_SETTINGS_BYTES = 4 * 1024 * 1024;
+function policyError(code, filePath, error) {
+  return {
+    code,
+    path: filePath,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+__name(policyError, "policyError");
+async function readJsonObject(filePath, maxBytes, requireRegularFile, retryMissing = false) {
+  const delays = [0, 50, 200];
+  let result = {};
+  for (const delay of delays) {
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    result = await readJsonObjectOnce(filePath, maxBytes, requireRegularFile);
+    if (!result.error && (!result.missing || !retryMissing)) return result;
+  }
+  return result;
+}
+__name(readJsonObject, "readJsonObject");
+async function readJsonObjectOnce(filePath, maxBytes, requireRegularFile) {
+  let stat2;
+  try {
+    stat2 = await fs.lstat(filePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return {
+      error: policyError("trust_policy_unreadable", filePath, error)
+    };
+  }
+  if (!requireRegularFile && stat2.isSymbolicLink()) {
+    try {
+      stat2 = await fs.stat(filePath);
+    } catch (error) {
+      return {
+        error: policyError("trust_policy_unreadable", filePath, error)
+      };
+    }
+  }
+  if (requireRegularFile && stat2.isSymbolicLink() || !stat2.isFile()) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("Trust policy input must be a regular file.")
+      )
+    };
+  }
+  if (stat2.size > maxBytes) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error(`Trust policy input exceeds ${maxBytes} bytes.`)
+      )
+    };
+  }
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse((0, import_strip_json_comments.default)(raw));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Trust policy input must contain a JSON object.");
+    }
+    return { value: parsed };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { value: {}, missing: true };
+    }
+    return { error: policyError("trust_policy_invalid", filePath, error) };
+  }
+}
+__name(readJsonObjectOnce, "readJsonObjectOnce");
+function migrateFolderTrustSettings(value, scope) {
+  if (!value || !v1ToV2Migration.shouldMigrate(value)) return value;
+  return v1ToV2Migration.migrate(value, scope).settings;
+}
+__name(migrateFolderTrustSettings, "migrateFolderTrustSettings");
+function folderTrustSetting(value, filePath) {
+  if (!value || !("security" in value)) return {};
+  const security = value?.["security"];
+  if (typeof security !== "object" || security === null || Array.isArray(security)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security` must be an object.")
+      )
+    };
+  }
+  if (!("folderTrust" in security)) return {};
+  const folderTrust = security["folderTrust"];
+  if (typeof folderTrust !== "object" || folderTrust === null || Array.isArray(folderTrust)) {
+    return {
+      error: policyError(
+        "trust_policy_invalid",
+        filePath,
+        new Error("`security.folderTrust` must be an object.")
+      )
+    };
+  }
+  if (!("enabled" in folderTrust)) return {};
+  const enabled = folderTrust["enabled"];
+  if (typeof enabled === "boolean") return { value: enabled };
+  return {
+    error: policyError(
+      "trust_policy_invalid",
+      filePath,
+      new Error("`security.folderTrust.enabled` must be a boolean.")
+    )
+  };
+}
+__name(folderTrustSetting, "folderTrustSetting");
+function parseTrustedFolders(value, filePath) {
+  const config = {};
+  for (const [rulePath, rawLevel] of Object.entries(value ?? {})) {
+    if (!Object.values(TrustLevel).includes(rawLevel)) {
+      return {
+        config: {},
+        error: policyError(
+          "trust_policy_invalid",
+          filePath,
+          new Error(`Invalid trust level for ${JSON.stringify(rulePath)}.`)
+        )
+      };
+    }
+    config[rulePath] = rawLevel;
+  }
+  return { config };
+}
+__name(parseTrustedFolders, "parseTrustedFolders");
+function semanticRevision(input) {
+  const sortedRules = Object.entries(input.trustedFolders).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return createHash("sha256").update(
+    JSON.stringify({
+      folderTrustEnabled: input.folderTrustEnabled,
+      ideTrust: input.ideTrust ?? null,
+      trustedFolders: sortedRules,
+      settingsError: input.settingsError?.code ?? null,
+      trustedFoldersError: input.trustedFoldersError?.code ?? null
+    })
+  ).digest("hex");
+}
+__name(semanticRevision, "semanticRevision");
+async function readDaemonTrustPolicySnapshot() {
+  const [user, system, systemDefaults] = await Promise.all([
+    readJsonObject(getUserSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemSettingsPath(), MAX_SETTINGS_BYTES, false),
+    readJsonObject(getSystemDefaultsPath(), MAX_SETTINGS_BYTES, false)
+  ]);
+  const systemFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(system.value, "System"),
+    getSystemSettingsPath()
+  );
+  const userFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(user.value, "User"),
+    getUserSettingsPath()
+  );
+  const defaultsFolderTrust = folderTrustSetting(
+    migrateFolderTrustSettings(systemDefaults.value, "SystemDefaults"),
+    getSystemDefaultsPath()
+  );
+  const settingsError = system.error ?? systemFolderTrust.error ?? user.error ?? userFolderTrust.error ?? systemDefaults.error ?? defaultsFolderTrust.error;
+  const folderTrustEnabled = systemFolderTrust.value ?? userFolderTrust.value ?? defaultsFolderTrust.value ?? false;
+  const trustedFoldersFile = await readJsonObject(
+    getTrustedFoldersPath(),
+    MAX_TRUSTED_FOLDERS_BYTES,
+    true,
+    folderTrustEnabled
+  );
+  const parsedTrustedFolders = parseTrustedFolders(
+    trustedFoldersFile.value,
+    getTrustedFoldersPath()
+  );
+  const trustedFoldersError = trustedFoldersFile.error ?? parsedTrustedFolders.error;
+  const ideTrust = ideContextStore.get()?.workspaceState?.isTrusted;
+  const revision = semanticRevision({
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: parsedTrustedFolders.config,
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  });
+  return {
+    revision,
+    folderTrustEnabled,
+    ideTrust,
+    trustedFolders: Object.freeze({ ...parsedTrustedFolders.config }),
+    ...settingsError ? { settingsError } : {},
+    ...trustedFoldersError ? { trustedFoldersError } : {}
+  };
+}
+__name(readDaemonTrustPolicySnapshot, "readDaemonTrustPolicySnapshot");
+function explicitTrustLevel(snapshot, workspaceCwd) {
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const effective = folders.isPathTrusted(workspaceCwd);
+  if (effective === void 0) return null;
+  for (const [rulePath, trustLevel] of Object.entries(
+    snapshot.trustedFolders
+  )) {
+    const preview = new LoadedTrustedFolders(
+      { path: getTrustedFoldersPath(), config: { [rulePath]: trustLevel } },
+      []
+    ).isPathTrusted(workspaceCwd);
+    if (preview === effective) return trustLevel;
+  }
+  return null;
+}
+__name(explicitTrustLevel, "explicitTrustLevel");
+function evaluateDaemonWorkspaceTrust(snapshot, workspaceCwd, processCwd = process.cwd()) {
+  if (snapshot.settingsError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.settingsError
+    };
+  }
+  if (!snapshot.folderTrustEnabled) {
+    return {
+      state: "trusted",
+      targetTrusted: true,
+      source: "disabled",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.ideTrust !== void 0 && arePathsEquivalent(workspaceCwd, processCwd)) {
+    return {
+      state: snapshot.ideTrust ? "trusted" : "untrusted",
+      targetTrusted: snapshot.ideTrust,
+      source: "ide",
+      explicitTrustLevel: null
+    };
+  }
+  if (snapshot.trustedFoldersError) {
+    return {
+      state: "error",
+      targetTrusted: false,
+      source: "none",
+      explicitTrustLevel: null,
+      error: snapshot.trustedFoldersError
+    };
+  }
+  const folders = new LoadedTrustedFolders(
+    {
+      path: getTrustedFoldersPath(),
+      config: { ...snapshot.trustedFolders }
+    },
+    []
+  );
+  const trusted = folders.isPathTrusted(workspaceCwd);
+  return {
+    state: trusted === true ? "trusted" : trusted === false ? "untrusted" : "unknown",
+    targetTrusted: trusted === true,
+    source: trusted === void 0 ? "none" : "file",
+    explicitTrustLevel: explicitTrustLevel(snapshot, workspaceCwd)
+  };
+}
+__name(evaluateDaemonWorkspaceTrust, "evaluateDaemonWorkspaceTrust");
+
+export {
+  readDaemonTrustPolicySnapshot,
+  evaluateDaemonWorkspaceTrust
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-VAK25FTU.js → chunk-45IOTAUS.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-L5UHQJTJ.js";
+} from "./chunk-IGTHU3T4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";