@qwen-code/qwen-code 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/chunks/{chunk-NOYV2NXI.js → chunk-ZXCVPMIK.js}

@@ -1,12 +1,15 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  contextCommand
-} from "./chunk-GZKQ36JS.js";
 import {
   isValidSessionId,
   validateAuthMethod
-} from "./chunk-ZGSV5ORL.js";
+} from "./chunk-MVZXZWGT.js";
+import {
+  isKittyProtocolEnabled
+} from "./chunk-JZSY4WP3.js";
+import {
+  contextCommand
+} from "./chunk-SFN4TEHY.js";
 import {
   VSCODE_SHIFT_ENTER_SEQUENCE,
   calculateCost,
@@ -17,41 +20,38 @@ import {
   getSystemInfoFields,
   useKeypress,
   writeOsc52
-} from "./chunk-IBEM64M4.js";
+} from "./chunk-75X2VLSH.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-KSPVDFE4.js";
 import {
   Text
-} from "./chunk-N4V4VBP6.js";
+} from "./chunk-2X2JUE47.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
-import {
-  isKittyProtocolEnabled
-} from "./chunk-JZSY4WP3.js";
 import {
   themeManager
 } from "./chunk-HTWHAN44.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-AIBPG5MB.js";
+} from "./chunk-OAFUMTWW.js";
 import {
   GITHUB_WORKFLOW_PATHS,
   setupGithub
-} from "./chunk-Q3JOGB4U.js";
+} from "./chunk-L7QPM2YD.js";
 import {
   require_undici
-} from "./chunk-M2U5NM24.js";
+} from "./chunk-54YZOP7P.js";
 import {
   stripUnsafeCharacters,
   toCodePoints
-} from "./chunk-GDIG7TMG.js";
+} from "./chunk-HRZB5CSC.js";
 import {
   getExtendedSystemInfo,
   getGitVersion,
   getNpmVersion
-} from "./chunk-G525INVW.js";
+} from "./chunk-W2ZOAX7F.js";
 import {
   formatDuration,
   formatMemoryUsage,
@@ -60,7 +60,7 @@ import {
 import {
   isInlineModelOverrideAllowed,
   parseAcpModelOption
-} from "./chunk-OEY3YAL2.js";
+} from "./chunk-BQNJBEUA.js";
 import {
   formatUnsupportedVoiceModelMessage,
   getVoiceSettingsScope,
@@ -68,14 +68,19 @@ import {
   isVoiceEnabled,
   readVoiceMode,
   readVoiceModel
-} from "./chunk-LXEW6BHF.js";
+} from "./chunk-Q7VHIRDD.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
+  getAllSettingKeys,
+  getFlattenedSchema,
+  getNestedProperty,
   getPersistScopeForModelSelection,
+  getSettingDefinition,
   isAutoLanguage,
   resolveOutputLanguage,
+  validateSettingValue,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-6FIWYVN4.js";
+} from "./chunk-MKHC4BYZ.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
@@ -83,11 +88,11 @@ import {
   resolveSupportedLanguage,
   setLanguageAsync,
   t
-} from "./chunk-3O2BJMFW.js";
+} from "./chunk-UQYOMM6J.js";
 import {
   isFolderTrustEnabled,
   loadTrustedFolders
-} from "./chunk-Z34RYLRO.js";
+} from "./chunk-ZJP5T7IA.js";
 import {
   require_strip_json_comments
 } from "./chunk-QYUE6W3T.js";
@@ -105,10 +110,13 @@ import {
   SESSION_TITLE_MAX_LENGTH,
   SessionService,
   ShellExecutionService,
+  So,
   appendToLastTextPart,
   buildBackgroundEntryLabel,
+  buildBareRememberPrompt,
   buildBtwCacheSafeParams,
   buildBtwPrompt,
+  buildManagedRememberPrompt,
   canUseRipgrep,
   checkArgumentSafety,
   checkCommandPermissions,
@@ -117,7 +125,6 @@ import {
   encodeInsightProgressMessage,
   encodeInsightReadyMessage,
   escapeShellArg,
-  extract,
   findProviderByCredentials,
   flatMapTextParts,
   generateSessionRecap,
@@ -147,6 +154,7 @@ import {
   normalizeSkillPriority,
   parse,
   parseInstallSource,
+  parseVisionModelSetting,
   partToString,
   persistSessionUsage,
   readPathFromWorkspace,
@@ -160,13 +168,13 @@ import {
   stripStartupContext,
   tryGenerateSessionTitle,
   unregisterGoalHook
-} from "./chunk-35FH347N.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
 import {
   runSideQuery
-} from "./chunk-YCRTJYSQ.js";
+} from "./chunk-MEQWZGK5.js";
 import {
   applySkillAllowedTools,
   buildSkillLlmContent
@@ -187,14 +195,13 @@ import {
   recordSkillInvocation,
   resolveOpenAILogDir,
   uiTelemetryService
-} from "./chunk-B5MPZI4K.js";
+} from "./chunk-HJDF3ZVU.js";
 import {
-  getAutoMemoryRoot,
-  getUserAutoMemoryRoot
+  getAutoMemoryRoot
 } from "./chunk-MOUXUCXQ.js";
 import {
   ToolNames
-} from "./chunk-JV7A66DR.js";
+} from "./chunk-4VZH35PN.js";
 import {
   openBrowserSecurely
 } from "./chunk-22IFUCVR.js";
@@ -211,7 +218,7 @@ import {
   isCpuProfileRecording,
   startCpuProfile,
   stopCpuProfile
-} from "./chunk-OE5J6UA7.js";
+} from "./chunk-XCUFHOAD.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -3664,6 +3671,332 @@ var clearCommand = {
   }, "action")
 };
 
+// packages/cli/src/ui/commands/config-command.ts
+init_esbuild_shims();
+var SETTABLE_TYPES = /* @__PURE__ */ new Set(["boolean", "string", "number", "enum"]);
+var SENSITIVE_KEY_PATTERNS = [
+  /apikey/i,
+  /api[_-]?key/i,
+  /secret/i,
+  /(?:^|\.)token(?:$|\.)/i,
+  /password/i,
+  /credential/i,
+  /private[_-]?key/i
+];
+var SENSITIVE_URL_PATTERNS = [/baseurl/i, /base_url/i, /proxy/i];
+function isSensitiveKey(key) {
+  return SENSITIVE_KEY_PATTERNS.some((p) => p.test(key)) || SENSITIVE_URL_PATTERNS.some((p) => p.test(key));
+}
+__name(isSensitiveKey, "isSensitiveKey");
+function maskValue(value) {
+  if (value === void 0) return t("(not set)");
+  if (typeof value === "string") {
+    if (!value) return t("(empty)");
+    if (value.length <= 4) return "****";
+    return `${value.slice(0, 4)}****`;
+  }
+  return "****";
+}
+__name(maskValue, "maskValue");
+function findClosestKey(input) {
+  const allKeys = getAllSettingKeys();
+  let bestMatch;
+  let bestDistance = Infinity;
+  for (const key of allKeys) {
+    const def = getSettingDefinition(key);
+    if (!def || !SETTABLE_TYPES.has(def.type)) continue;
+    const distance = levenshteinDistance(
+      input.toLowerCase(),
+      key.toLowerCase()
+    );
+    if (distance < bestDistance && distance <= 3) {
+      bestDistance = distance;
+      bestMatch = key;
+    }
+  }
+  return bestMatch;
+}
+__name(findClosestKey, "findClosestKey");
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= a.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= b.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+__name(levenshteinDistance, "levenshteinDistance");
+function coerceValue(def, rawValue) {
+  switch (def.type) {
+    case "boolean": {
+      const normalised = rawValue?.toLowerCase().trim();
+      if (normalised === "true" || normalised === "1") return { value: true };
+      if (normalised === "false" || normalised === "0") return { value: false };
+      return {
+        value: void 0,
+        error: t('Invalid boolean value: "{{value}}". Use "true" or "false".', {
+          value: String(rawValue)
+        })
+      };
+    }
+    case "number": {
+      if (!rawValue || rawValue.trim() === "") {
+        return {
+          value: void 0,
+          error: t('Invalid number value: "{{value}}".', {
+            value: String(rawValue)
+          })
+        };
+      }
+      const parsed = Number(rawValue);
+      if (Number.isNaN(parsed) || !Number.isFinite(parsed)) {
+        return {
+          value: void 0,
+          error: t('Invalid number value: "{{value}}".', {
+            value: String(rawValue)
+          })
+        };
+      }
+      const validationError = validateSettingValue(def, parsed);
+      if (validationError) {
+        return { value: void 0, error: validationError };
+      }
+      return { value: parsed };
+    }
+    case "string": {
+      const strValue = rawValue ?? "";
+      const validationError = validateSettingValue(def, strValue);
+      if (validationError) {
+        return { value: void 0, error: validationError };
+      }
+      return { value: strValue };
+    }
+    case "enum": {
+      const validValues = def.options?.map((o) => o.value) ?? [];
+      if (!validValues.includes(rawValue)) {
+        return {
+          value: void 0,
+          error: t(
+            'Invalid enum value: "{{value}}". Valid values: {{options}}.',
+            { value: String(rawValue), options: validValues.join(", ") }
+          )
+        };
+      }
+      return { value: rawValue };
+    }
+    case "array":
+    case "object":
+      return {
+        value: void 0,
+        error: t(
+          'Setting "{{type}}" type cannot be set via /config. Edit settings.json directly.',
+          { type: def.type }
+        )
+      };
+    default:
+      return {
+        value: void 0,
+        error: t('Unsupported setting type: "{{type}}".', {
+          type: String(def.type)
+        })
+      };
+  }
+}
+__name(coerceValue, "coerceValue");
+function formatValue(value) {
+  if (value === void 0) return t("(not set)");
+  if (typeof value === "string") return value || t("(empty)");
+  return JSON.stringify(value);
+}
+__name(formatValue, "formatValue");
+function padRight(str, len) {
+  if (str.length > len) return str.slice(0, len - 3) + "... ";
+  if (str.length === len) return str + " ";
+  return str + " ".repeat(len - str.length);
+}
+__name(padRight, "padRight");
+function listAllSettings(context) {
+  const flattened = getFlattenedSchema();
+  const merged = context.services.settings.merged;
+  const lines = [];
+  lines.push(t("Available settings:"));
+  lines.push("");
+  lines.push(
+    padRight("Key", 40) + padRight("Type", 10) + padRight("Current", 15) + "Description"
+  );
+  lines.push("-".repeat(90));
+  const keys = Object.keys(flattened).sort();
+  for (const key of keys) {
+    const def = flattened[key];
+    if (!SETTABLE_TYPES.has(def.type)) continue;
+    const current = getNestedProperty(merged, key);
+    let displayCurrent;
+    if (isSensitiveKey(key)) {
+      displayCurrent = maskValue(current ?? def.default);
+    } else {
+      displayCurrent = current !== void 0 ? formatValue(current) : formatValue(def.default);
+    }
+    lines.push(
+      padRight(key, 40) + padRight(def.type, 10) + padRight(displayCurrent, 15) + (def.description ?? def.label)
+    );
+  }
+  return {
+    type: "message",
+    messageType: "info",
+    content: lines.join("\n")
+  };
+}
+__name(listAllSettings, "listAllSettings");
+var configCommand = {
+  name: "config",
+  get description() {
+    return t("Get or set any setting by dot-path key");
+  },
+  argumentHint: "<key>[=<value>] or --help",
+  kind: "built-in" /* BUILT_IN */,
+  supportedModes: ["interactive", "non_interactive", "acp"],
+  action: /* @__PURE__ */ __name(async (context, args) => {
+    const trimmed = args.trim();
+    if (!trimmed || trimmed === "--help" || trimmed === "-h") {
+      return listAllSettings(context);
+    }
+    const eqIndex = trimmed.indexOf("=");
+    const isToggle = eqIndex === -1;
+    const key = isToggle ? trimmed : trimmed.slice(0, eqIndex).trim();
+    const rawValue = isToggle ? void 0 : trimmed.slice(eqIndex + 1).trim();
+    const def = getSettingDefinition(key);
+    if (!def) {
+      const suggestion = findClosestKey(key);
+      return {
+        type: "message",
+        messageType: "error",
+        content: suggestion ? t(
+          'Unknown setting key: "{{key}}". Did you mean "{{suggestion}}"?',
+          { key, suggestion }
+        ) : t('Unknown setting key: "{{key}}".', { key })
+      };
+    }
+    const currentValue = getNestedProperty(
+      context.services.settings.merged,
+      key
+    );
+    if (isToggle && def.type !== "boolean") {
+      const display = isSensitiveKey(key) ? maskValue(currentValue) : formatValue(currentValue);
+      return {
+        type: "message",
+        messageType: "info",
+        content: `${key} = ${display}`
+      };
+    }
+    if (isToggle && def.type === "boolean") {
+      const newValue = !currentValue;
+      try {
+        context.services.settings.setValues([
+          { scope: "User" /* User */, key, value: newValue }
+        ]);
+      } catch (error) {
+        return {
+          type: "message",
+          messageType: "error",
+          content: t('Failed to set "{{key}}": {{error}}', {
+            key,
+            error: error instanceof Error ? error.message : String(error)
+          })
+        };
+      }
+      let message2 = t("Set {{key}} = {{value}}", {
+        key,
+        value: String(newValue)
+      });
+      if (def.requiresRestart) {
+        message2 += "\n" + t("(This setting requires a restart to take effect.)");
+      }
+      return {
+        type: "message",
+        messageType: "info",
+        content: message2
+      };
+    }
+    const result = coerceValue(def, rawValue);
+    if (result.error) {
+      return {
+        type: "message",
+        messageType: "error",
+        content: result.error
+      };
+    }
+    if (key === "tools.approvalMode" && result.value === "yolo") {
+      return {
+        type: "message",
+        messageType: "error",
+        content: t(
+          'Setting tools.approvalMode to "yolo" is blocked via /config for security reasons. Edit settings.json directly if you understand the risks.'
+        )
+      };
+    }
+    try {
+      context.services.settings.setValues([
+        { scope: "User" /* User */, key, value: result.value }
+      ]);
+    } catch (error) {
+      return {
+        type: "message",
+        messageType: "error",
+        content: t('Failed to set "{{key}}": {{error}}', {
+          key,
+          error: error instanceof Error ? error.message : String(error)
+        })
+      };
+    }
+    const displayValue = isSensitiveKey(key) ? maskValue(result.value) : formatValue(result.value);
+    let message = t("Set {{key}} = {{value}}", {
+      key,
+      value: displayValue
+    });
+    if (def.requiresRestart) {
+      message += "\n" + t("(This setting requires a restart to take effect.)");
+    }
+    if (isSensitiveKey(key)) {
+      message += "\n" + t(
+        "(Security-sensitive setting \u2014 verify you are not exposing credentials.)"
+      );
+    }
+    return {
+      type: "message",
+      messageType: "info",
+      content: message
+    };
+  }, "action"),
+  completion: /* @__PURE__ */ __name(async (_context, partialArg) => {
+    const current = partialArg.trimStart();
+    if (current.includes("=")) return null;
+    const allKeys = getAllSettingKeys();
+    return allKeys.filter((k) => {
+      if (!k.startsWith(current)) return false;
+      const def = getSettingDefinition(k);
+      return def && SETTABLE_TYPES.has(def.type);
+    }).map((k) => {
+      const def = getSettingDefinition(k);
+      return {
+        value: k,
+        description: def?.description ?? ""
+      };
+    });
+  }, "completion")
+};
+
 // packages/cli/src/ui/commands/deleteCommand.ts
 init_esbuild_shims();
 var deleteCommand = {
@@ -5367,7 +5700,7 @@ async function extractArchive(archivePath, destDir, target) {
     validateExtractedPaths(resolvedDest);
   } else {
     const resolvedDest = path5.resolve(destDir);
-    await extract({
+    await So({
       file: archivePath,
       cwd: destDir,
       preservePaths: false,
@@ -6797,7 +7130,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-PNZYGM3R.js");
+    const { getGitRepoName } = await import("./src-OVZLTVVM.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;
@@ -10646,6 +10979,12 @@ init_esbuild_shims();
 var MAIN_MODEL_CONFIGURATION_HINT = "Configure models in settings.modelProviders and ensure the required environment variables are set. In interactive mode, run /auth to configure or switch providers, or run /model without arguments to choose from configured models.";
 var FAST_MODEL_CONFIGURATION_HINT = "Configure models in settings.modelProviders and ensure the required environment variables are set. In interactive mode, run /auth to configure or switch providers, or run /model --fast without a model to choose from configured models.";
 var VISION_MODEL_CONFIGURATION_HINT = "Configure an image-capable model in settings.modelProviders and ensure the required environment variables are set. Run /model --vision <model-id> to set it, or leave it unset to auto-pick a same-provider vision model.";
+function formatVisionModelSettingForDisplay(setting) {
+  const parsed = parseVisionModelSetting(setting);
+  if (!parsed) return setting.replace(/\0/g, "\\0");
+  return parsed.baseUrl ? `${parsed.selector} (${parsed.baseUrl})` : parsed.selector;
+}
+__name(formatVisionModelSettingForDisplay, "formatVisionModelSettingForDisplay");
 function persistSetting(settings, path20, value) {
   settings.setValue(getPersistScopeForModelSelection(settings), path20, value);
 }
@@ -10708,6 +11047,29 @@ function formatUnavailableVisionModelMessage(modelName, availableModels) {
   );
 }
 __name(formatUnavailableVisionModelMessage, "formatUnavailableVisionModelMessage");
+function formatAmbiguousVisionModelMessage(modelName, matchingModels) {
+  const endpoints = matchingModels.map((model) => model.baseUrl ?? "(default endpoint)").join(", ");
+  const qualifiedSelectors = Array.from(
+    new Set(
+      matchingModels.map(
+        (model) => model.authType ? `${model.authType}:${model.id}` : void 0
+      ).filter((selector) => selector !== void 0)
+    )
+  );
+  const scriptedHint = qualifiedSelectors.length > 1 ? `
+${t(
+    "For scripts, pass an auth-qualified selector such as {{selector}}.",
+    {
+      selector: qualifiedSelectors[0]
+    }
+  )}` : "";
+  return t("Vision model '{{modelName}}' matches multiple configured endpoints.", {
+    modelName
+  }) + "\n" + t("Matching endpoints: {{endpoints}}.", { endpoints }) + "\n" + t(
+    "Run /model --vision without an argument and choose the exact endpoint."
+  ) + scriptedHint;
+}
+__name(formatAmbiguousVisionModelMessage, "formatAmbiguousVisionModelMessage");
 function formatNonVisionModelWarning(modelName) {
   return t(
     "\u26A0 '{{model}}' is not a known image-capable model; the vision bridge may fail on images.",
@@ -10948,13 +11310,15 @@ Use "/model --fast <model-id>" to set fast model.`
       const modelName2 = args.replace("--vision", "").trim();
       if (!modelName2) {
         if (context.executionMode !== "interactive") {
-          const visionModel = context.services.settings?.merged?.visionModel?.trim() || t("not set");
+          const visionModel2 = context.services.settings?.merged?.visionModel?.trim();
           return {
             type: "message",
             messageType: "info",
             content: t(
               'Current vision model: {{visionModel}}\nUse "/model --vision <model-id>" to set the vision bridge model.',
-              { visionModel }
+              {
+                visionModel: visionModel2 ? formatVisionModelSettingForDisplay(visionModel2) : t("not set")
+              }
             )
           };
         }
@@ -10985,9 +11349,17 @@ Use "/model --fast <model-id>" to set fast model.`
         };
       }
       const availableModels = (selector.authType ? config.getAvailableModelsForAuthType(selector.authType) : config.getAllConfiguredModels()).filter((m) => !m.fastOnly && !m.voiceOnly);
-      const matched = availableModels.find(
+      const matchingModels = availableModels.filter(
         (model) => model.id === selector.modelId
       );
+      if (matchingModels.length > 1) {
+        return {
+          type: "message",
+          messageType: "error",
+          content: formatAmbiguousVisionModelMessage(modelName2, matchingModels)
+        };
+      }
+      const matched = matchingModels[0];
       if (!matched) {
         return {
           type: "message",
@@ -11010,8 +11382,10 @@ Use "/model --fast <model-id>" to set fast model.`
           )
         };
       }
-      persistSetting(settings, "visionModel", modelName2);
-      config.setVisionModel(modelName2);
+      const qualifiedModelName = `${selector.authType ?? matched.authType}:${selector.modelId}`;
+      const visionModel = matched.baseUrl ? `${qualifiedModelName}\0${matched.baseUrl}` : qualifiedModelName;
+      persistSetting(settings, "visionModel", visionModel);
+      config.setVisionModel(visionModel);
       const visionWarning = isImageCapable(matched) ? "" : `
 ${formatNonVisionModelWarning(modelName2)}`;
       return {
@@ -11148,21 +11522,14 @@ var rememberCommand = {
     }
     const useManagedMemory = config?.isManagedMemoryAvailable() ?? false;
     if (useManagedMemory) {
-      const projectDir = config ? getAutoMemoryRoot(config.getProjectRoot()) : void 0;
-      const userDir = getUserAutoMemoryRoot();
-      const dirHint = projectDir !== void 0 ? ` Choose the destination directory by the type's \`<scope>\`: USER memory at \`${userDir}\` for cross-project facts, PROJECT memory at \`${projectDir}\` for this-project-only facts.` : "";
       return {
         type: "submit_prompt",
-        content: `Please save the following to your memory system.${dirHint} Choose the most appropriate memory type (user, feedback, project, or reference) based on the content:
-
-${fact}`
+        content: buildManagedRememberPrompt(fact, config.getProjectRoot())
       };
     }
     return {
       type: "submit_prompt",
-      content: `Please save the following fact to memory (e.g. append to QWEN.md in the project root):
-
-${fact}`
+      content: buildBareRememberPrompt(fact)
     };
   }, "action")
 };
@@ -15103,6 +15470,7 @@ var BuiltinCommandLoader = class {
       clearCommand,
       compressCommand,
       compressFastCommand,
+      configCommand,
       contextCommand,
       copyCommand,
       diffCommand,