@qwen-code/qwen-code 0.19.12 → 0.20.0-nightly.20260721.cda0e0348

package/chunks/{chunk-UCTCDLDS.js → chunk-LWQ4IAOJ.js}

@@ -124,6 +124,7 @@ __name(resolveWorkspaceInputs, "resolveWorkspaceInputs");
 var SCHEMA_VERSION = 1;
 var MAX_SECONDARY_WORKSPACES = MAX_REGISTERED_WORKSPACES - 1;
 var MAX_STORE_BYTES = 256 * 1024;
+var MAX_WORKSPACE_DISPLAY_NAME_LENGTH = 256;
 var LOCK_OPTIONS = {
   realpath: false,
   stale: 1e4,
@@ -136,6 +137,43 @@ var LOCK_OPTIONS = {
     randomize: true
   }
 };
+var WorkspaceDisplayNameValidationError = class extends Error {
+  static {
+    __name(this, "WorkspaceDisplayNameValidationError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "WorkspaceDisplayNameValidationError";
+  }
+};
+function containsDisplayNameControlCharacter(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 31 || codePoint === 127) return true;
+  }
+  return false;
+}
+__name(containsDisplayNameControlCharacter, "containsDisplayNameControlCharacter");
+function normalizeWorkspaceDisplayName(value) {
+  if (typeof value !== "string") {
+    throw new WorkspaceDisplayNameValidationError(
+      "Workspace display name must be a string"
+    );
+  }
+  const trimmed = value.trim();
+  if (trimmed.length > MAX_WORKSPACE_DISPLAY_NAME_LENGTH) {
+    throw new WorkspaceDisplayNameValidationError(
+      `Workspace display name exceeds ${MAX_WORKSPACE_DISPLAY_NAME_LENGTH} characters`
+    );
+  }
+  if (containsDisplayNameControlCharacter(trimmed)) {
+    throw new WorkspaceDisplayNameValidationError(
+      "Workspace display name contains control characters"
+    );
+  }
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+__name(normalizeWorkspaceDisplayName, "normalizeWorkspaceDisplayName");
 var WorkspaceRegistrationStoreError = class extends Error {
   static {
     __name(this, "WorkspaceRegistrationStoreError");
@@ -196,6 +234,38 @@ function validateWorkspacePath(value, label) {
   return value;
 }
 __name(validateWorkspacePath, "validateWorkspacePath");
+function validateStoredDisplayName(value, label) {
+  let displayName;
+  try {
+    displayName = normalizeWorkspaceDisplayName(value);
+  } catch (err) {
+    throw new WorkspaceRegistrationStoreError(
+      `${label} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (displayName === void 0) {
+    throw new WorkspaceRegistrationStoreError(`${label} must not be empty`);
+  }
+  return displayName;
+}
+__name(validateStoredDisplayName, "validateStoredDisplayName");
+function setSnapshotDisplayName(snapshot, registrationId, displayName) {
+  if (displayName === void 0) {
+    if (!snapshot.displayNames || !Object.hasOwn(snapshot.displayNames, registrationId)) {
+      return false;
+    }
+    delete snapshot.displayNames[registrationId];
+    if (Object.keys(snapshot.displayNames).length === 0) {
+      delete snapshot.displayNames;
+    }
+    return true;
+  }
+  if (snapshot.displayNames?.[registrationId] === displayName) return false;
+  snapshot.displayNames ??= {};
+  snapshot.displayNames[registrationId] = displayName;
+  return true;
+}
+__name(setSnapshotDisplayName, "setSnapshotDisplayName");
 function parseSnapshot(raw, primaryWorkspace) {
   let value;
   try {
@@ -252,7 +322,34 @@ function parseSnapshot(raw, primaryWorkspace) {
     seen.add(normalizedWorkspace);
     return workspace;
   });
-  return { schemaVersion: SCHEMA_VERSION, primaryWorkspace, workspaces };
+  const rawDisplayNames = record["displayNames"];
+  let displayNames;
+  if (rawDisplayNames !== void 0) {
+    if (typeof rawDisplayNames !== "object" || rawDisplayNames === null || Array.isArray(rawDisplayNames)) {
+      throw new WorkspaceRegistrationStoreError(
+        "Workspace registration store displayNames must be an object"
+      );
+    }
+    const registrationIds = new Set(workspaces.map(workspaceRegistrationId));
+    for (const [registrationId, value2] of Object.entries(rawDisplayNames)) {
+      if (!registrationIds.has(registrationId)) {
+        throw new WorkspaceRegistrationStoreError(
+          `Workspace registration store displayNames contains unknown registration id ${JSON.stringify(registrationId)}`
+        );
+      }
+      displayNames ??= {};
+      displayNames[registrationId] = validateStoredDisplayName(
+        value2,
+        `displayNames[${JSON.stringify(registrationId)}]`
+      );
+    }
+  }
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    primaryWorkspace,
+    workspaces,
+    ...displayNames ? { displayNames } : {}
+  };
 }
 __name(parseSnapshot, "parseSnapshot");
 var updateChains = /* @__PURE__ */ new Map();
@@ -391,8 +488,9 @@ var WorkspaceRegistrationStore = class {
       await file.close();
     }
   }
-  async add(workspace) {
+  async add(workspace, displayName) {
     validateWorkspacePath(workspace, "workspace");
+    const normalizedDisplayName = displayName === void 0 ? void 0 : normalizeWorkspaceDisplayName(displayName);
     if (normalizedScopePath(workspace) === normalizedScopePath(this.primaryWorkspace)) {
       throw new WorkspaceRegistrationStoreError(
         "Primary workspace cannot be stored as a secondary registration"
@@ -411,30 +509,61 @@ var WorkspaceRegistrationStore = class {
         );
       }
       snapshot.workspaces.push(workspace);
+      if (normalizedDisplayName !== void 0) {
+        snapshot.displayNames ??= {};
+        snapshot.displayNames[workspaceRegistrationId(workspace)] = normalizedDisplayName;
+      }
       return true;
     });
   }
   async removeById(id) {
     return await this.removeByIds([id]) > 0;
   }
+  async setDisplayNameByIds(ids, displayName) {
+    const normalizedDisplayName = displayName === void 0 ? void 0 : normalizeWorkspaceDisplayName(displayName);
+    const requested = new Set(ids);
+    if (requested.size === 0) return 0;
+    let matched = 0;
+    await this.update((snapshot) => {
+      let changed = false;
+      for (const workspace of snapshot.workspaces) {
+        const registrationId = workspaceRegistrationId(workspace);
+        if (!requested.has(registrationId)) continue;
+        matched++;
+        changed = setSnapshotDisplayName(
+          snapshot,
+          registrationId,
+          normalizedDisplayName
+        ) || changed;
+      }
+      return changed;
+    });
+    return matched;
+  }
   async removeByIds(ids) {
     const requested = new Set(ids);
     if (requested.size === 0) return 0;
     let removed = 0;
     await this.update((snapshot) => {
+      const removedIds = /* @__PURE__ */ new Set();
       const retained = snapshot.workspaces.filter((workspace) => {
-        if (!requested.has(workspaceRegistrationId(workspace))) return true;
+        const registrationId = workspaceRegistrationId(workspace);
+        if (!requested.has(registrationId)) return true;
         removed++;
+        removedIds.add(registrationId);
         return false;
       });
       if (removed === 0) return false;
       snapshot.workspaces.splice(0, snapshot.workspaces.length, ...retained);
+      for (const registrationId of removedIds) {
+        setSnapshotDisplayName(snapshot, registrationId, void 0);
+      }
       return true;
     });
     return removed;
   }
   async update(mutate) {
-    const { atomicWriteFile } = await import("./src-75ZPXO7B.js");
+    const { atomicWriteFile } = await import("./src-Q4XB6SVD.js");
     return withInProcessLock(this.filePath, async () => {
       const lock = await acquireFileLock(this.filePath);
       let committed = false;
@@ -478,6 +607,9 @@ var WorkspaceRegistrationStore = class {
 export {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
+  MAX_WORKSPACE_DISPLAY_NAME_LENGTH,
+  WorkspaceDisplayNameValidationError,
+  normalizeWorkspaceDisplayName,
   WorkspaceRegistrationStoreError,
   WorkspaceRegistrationStoreLimitError,
   WorkspaceRegistrationStoreCommittedError,