@qwen-code/qwen-code 0.19.11-nightly.20260718.767a32484 → 0.19.11

package/chunks/{chunk-FSJGBUQI.js → chunk-4IJMTYCB.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-57RWF6R7.js";
+} from "./chunk-K7VD4XLT.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-6ITLKEOZ.js";
+} from "./chunk-BUAXJVNP.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,7 +16,7 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-AEKYFMYE.js";
+} from "./chunk-3M75MSVA.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
@@ -32,7 +32,7 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-X6YQWCIJ.js";
+} from "./chunk-L4Y55KIS.js";
 import {
   BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
@@ -46,38 +46,34 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-URP6O2PP.js";
+} from "./chunk-VFX7EZIR.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-C5NSOSF4.js";
+} from "./chunk-GNBBAQ6J.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-LSFVUGXT.js";
+} from "./chunk-2OG646IN.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
 import {
-  ModelsConfig,
-  SkillManager,
-  require_yauzl
-} from "./chunk-3YJZ6WNY.js";
+  ModelsConfig
+} from "./chunk-NJOFRXTM.js";
 import {
-  Storage,
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
 import {
-  __name,
-  __toESM
+  __name
 } from "./chunk-J2S4EL5Y.js";
 
 // packages/cli/src/serve/workspace-service/index.ts
 init_esbuild_shims();
-import { promises as fs2, constants as fsConstants } from "node:fs";
-import * as path2 from "node:path";
+import { promises as fs, constants as fsConstants } from "node:fs";
+import * as path from "node:path";
 
 // packages/cli/src/services/voice-service.ts
 init_esbuild_shims();
@@ -310,748 +306,18 @@ async function transcribeWorkspaceVoiceAudio(input) {
 }
 __name(transcribeWorkspaceVoiceAudio, "transcribeWorkspaceVoiceAudio");
 
-// packages/cli/src/serve/workspace-skill-management.ts
-init_esbuild_shims();
-import { promises as fs } from "node:fs";
-import { execFile } from "node:child_process";
-import * as os from "node:os";
-import * as path from "node:path";
-import { promisify } from "node:util";
-var import_yauzl = __toESM(require_yauzl(), 1);
-var MAX_FILES = 128;
-var MAX_FILE_BYTES = 2 * 1024 * 1024;
-var MAX_TOTAL_BYTES = 6 * 1024 * 1024;
-var MAX_PATH_LENGTH = 512;
-var MAX_PATH_DEPTH = 16;
-var MAX_WORKSPACE_SKILL_NAME_LENGTH = 256;
-var execFileAsync = promisify(execFile);
-var WorkspaceSkillManagementError = class extends Error {
-  constructor(code, message, statusCode = 400) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "WorkspaceSkillManagementError";
-  }
-  static {
-    __name(this, "WorkspaceSkillManagementError");
-  }
-};
-function skillError(code, message, statusCode = 400) {
-  throw new WorkspaceSkillManagementError(code, message, statusCode);
-}
-__name(skillError, "skillError");
-function validateWorkspaceSkillName(name) {
-  const normalized = name.trim();
-  if (!normalized || normalized === "." || normalized === ".." || normalized.length > MAX_WORKSPACE_SKILL_NAME_LENGTH || !/^[A-Za-z0-9._-]+$/.test(normalized)) {
-    skillError("invalid_skill_name", "Invalid skill name");
-  }
-  return normalized;
-}
-__name(validateWorkspaceSkillName, "validateWorkspaceSkillName");
-function decodeBase64(value) {
-  if (!value || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
-    skillError("invalid_skill_source", "Invalid base64 skill content");
-  }
-  const content = Buffer.from(value, "base64");
-  if (content.length > MAX_TOTAL_BYTES) {
-    skillError(
-      "skill_package_too_large",
-      "Skill package exceeds the allowed size",
-      413
-    );
-  }
-  return content;
-}
-__name(decodeBase64, "decodeBase64");
-function normalizeRelativePath(value) {
-  const normalized = value.replaceAll("\\", "/").replace(/^\.\//, "");
-  const segments = normalized.split("/");
-  if (!normalized || normalized.length > MAX_PATH_LENGTH || normalized.startsWith("/") || segments.length > MAX_PATH_DEPTH || segments.some((segment) => !segment || segment === "." || segment === "..")) {
-    skillError("invalid_skill_package", `Invalid skill file path: ${value}`);
-  }
-  return segments.join("/");
-}
-__name(normalizeRelativePath, "normalizeRelativePath");
-function isPlatformMetadataPath(value) {
-  return value.replaceAll("\\", "/").split("/").some(
-    (segment) => segment === "__MACOSX" || segment === ".DS_Store" || segment.startsWith("._")
-  );
-}
-__name(isPlatformMetadataPath, "isPlatformMetadataPath");
-function normalizePackageFiles(files) {
-  files = files.filter((file) => !isPlatformMetadataPath(file.relativePath));
-  if (!files.length || files.length > MAX_FILES) {
-    skillError(
-      "invalid_skill_package",
-      "Skill package has an invalid file count"
-    );
-  }
-  let normalized = files.map((file) => ({
-    relativePath: normalizeRelativePath(file.relativePath),
-    content: file.content
-  }));
-  if (!normalized.some((file) => file.relativePath === "SKILL.md")) {
-    const roots = new Set(
-      normalized.map((file) => file.relativePath.split("/")[0])
-    );
-    if (roots.size !== 1) {
-      skillError(
-        "skill_manifest_missing",
-        "Skill package must contain a root SKILL.md"
-      );
-    }
-    const [root] = roots;
-    normalized = normalized.map((file) => ({
-      ...file,
-      relativePath: file.relativePath.slice(root.length + 1)
-    }));
-  }
-  const seen = /* @__PURE__ */ new Set();
-  let totalBytes = 0;
-  for (const file of normalized) {
-    file.relativePath = normalizeRelativePath(file.relativePath);
-    if (seen.has(file.relativePath)) {
-      skillError(
-        "invalid_skill_package",
-        `Duplicate skill file path: ${file.relativePath}`
-      );
-    }
-    seen.add(file.relativePath);
-    if (file.content.length > MAX_FILE_BYTES) {
-      skillError(
-        "skill_package_too_large",
-        `Skill file is too large: ${file.relativePath}`,
-        413
-      );
-    }
-    totalBytes += file.content.length;
-    if (totalBytes > MAX_TOTAL_BYTES) {
-      skillError(
-        "skill_package_too_large",
-        "Skill package exceeds the allowed size",
-        413
-      );
-    }
-  }
-  if (!seen.has("SKILL.md")) {
-    skillError(
-      "skill_manifest_missing",
-      "Skill package must contain a root SKILL.md"
-    );
-  }
-  return normalized;
-}
-__name(normalizePackageFiles, "normalizePackageFiles");
-function githubRequestError(code, status, resource) {
-  const message = status === 404 ? `GitHub ${resource} was not found; check the repository URL, branch, and path` : status === 401 ? "GitHub authentication failed; check GH_TOKEN or GITHUB_TOKEN" : status === 403 ? "GitHub access was denied; the repository may be private or API rate-limited" : status === 429 ? "GitHub API rate limit exceeded; try again later or configure GH_TOKEN" : `GitHub request failed (HTTP ${status})`;
-  return new WorkspaceSkillManagementError(
-    code,
-    message,
-    status === 404 ? 404 : 502
-  );
-}
-__name(githubRequestError, "githubRequestError");
-async function fetchBytes(url, githubToken) {
-  const response = await fetch(url, {
-    headers: {
-      Accept: "application/vnd.github+json",
-      "User-Agent": "qwen-code",
-      ...githubToken ? { Authorization: `Bearer ${githubToken}` } : {}
-    }
-  });
-  if (!response.ok) {
-    throw githubRequestError(
-      "github_skill_download_failed",
-      response.status,
-      "Skill file"
-    );
-  }
-  const declared = Number(response.headers.get("content-length"));
-  if (Number.isFinite(declared) && declared > MAX_FILE_BYTES) {
-    skillError("skill_package_too_large", "Skill file is too large", 413);
-  }
-  if (!response.body) return Buffer.alloc(0);
-  const reader = response.body.getReader();
-  const chunks = [];
-  let size = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      size += value.byteLength;
-      if (size > MAX_FILE_BYTES) {
-        await reader.cancel().catch(() => void 0);
-        skillError("skill_package_too_large", "Skill file is too large", 413);
-      }
-      chunks.push(Buffer.from(value));
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return Buffer.concat(chunks, size);
-}
-__name(fetchBytes, "fetchBytes");
-async function downloadGitHubDirectory(owner, repo, ref, directory, githubToken, relativeRoot = "", depth = 0, state = {
-  files: [],
-  totalBytes: 0
-}) {
-  if (depth > MAX_PATH_DEPTH)
-    skillError("invalid_skill_package", "GitHub Skill is nested too deeply");
-  const encodedDirectory = directory.split("/").filter(Boolean).map(encodeURIComponent).join("/");
-  const apiUrl = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents${encodedDirectory ? `/${encodedDirectory}` : ""}?ref=${encodeURIComponent(ref)}`;
-  const response = await fetch(apiUrl, {
-    headers: {
-      Accept: "application/vnd.github+json",
-      "User-Agent": "qwen-code",
-      ...githubToken ? { Authorization: `Bearer ${githubToken}` } : {}
-    }
-  });
-  if (!response.ok) {
-    throw githubRequestError(
-      "github_api_failed",
-      response.status,
-      "Skill path"
-    );
-  }
-  const items = await response.json();
-  if (!Array.isArray(items))
-    skillError("invalid_skill_source", "GitHub URL must point to SKILL.md");
-  for (const item of items) {
-    if (!item || typeof item !== "object") continue;
-    const record = item;
-    const itemName = typeof record["name"] === "string" ? record["name"] : "";
-    const itemPath = typeof record["path"] === "string" ? record["path"] : "";
-    const itemType = typeof record["type"] === "string" ? record["type"] : "";
-    const relativePath = relativeRoot ? `${relativeRoot}/${itemName}` : itemName;
-    if (itemType === "dir") {
-      await downloadGitHubDirectory(
-        owner,
-        repo,
-        ref,
-        itemPath,
-        githubToken,
-        relativePath,
-        depth + 1,
-        state
-      );
-    } else if (itemType === "file") {
-      const downloadUrl = record["download_url"];
-      if (typeof downloadUrl !== "string") continue;
-      const parsedDownloadUrl = new URL(downloadUrl);
-      if (parsedDownloadUrl.protocol !== "https:" || parsedDownloadUrl.hostname !== "raw.githubusercontent.com") {
-        skillError(
-          "github_skill_download_failed",
-          "GitHub returned an invalid Skill file URL",
-          502
-        );
-      }
-      const content = await fetchBytes(downloadUrl, githubToken);
-      state.files.push({ relativePath, content });
-      state.totalBytes += content.length;
-      if (state.files.length > MAX_FILES)
-        skillError("invalid_skill_package", "Skill package has too many files");
-      if (state.totalBytes > MAX_TOTAL_BYTES) {
-        skillError(
-          "skill_package_too_large",
-          "Skill package exceeds the allowed size",
-          413
-        );
-      }
-    }
-  }
-  return state.files;
-}
-__name(downloadGitHubDirectory, "downloadGitHubDirectory");
-async function downloadGitHubDirectoryWithGit(owner, repo, ref, directory) {
-  const checkout = await fs.mkdtemp(path.join(os.tmpdir(), "qwen-skill-git-"));
-  try {
-    await execFileAsync(
-      "git",
-      [
-        "clone",
-        "--depth",
-        "1",
-        "--filter=blob:none",
-        "--sparse",
-        "--branch",
-        ref,
-        `https://github.com/${owner}/${repo}.git`,
-        checkout
-      ],
-      { timeout: 6e4, maxBuffer: 1024 * 1024 }
-    );
-    if (directory) {
-      await execFileAsync(
-        "git",
-        ["-C", checkout, "sparse-checkout", "set", "--cone", directory],
-        { timeout: 3e4, maxBuffer: 1024 * 1024 }
-      );
-    } else {
-      await execFileAsync(
-        "git",
-        ["-C", checkout, "sparse-checkout", "disable"],
-        { timeout: 3e4, maxBuffer: 1024 * 1024 }
-      );
-    }
-    return await filesFromFolder(path.join(checkout, directory));
-  } catch (error) {
-    if (error instanceof WorkspaceSkillManagementError) throw error;
-    throw new WorkspaceSkillManagementError(
-      "github_skill_download_failed",
-      `Failed to download GitHub Skill: ${error instanceof Error ? error.message : String(error)}`,
-      502
-    );
-  } finally {
-    await fs.rm(checkout, { recursive: true, force: true });
-  }
-}
-__name(downloadGitHubDirectoryWithGit, "downloadGitHubDirectoryWithGit");
-async function downloadGitHubSkill(sourceUrl, githubToken) {
-  let url;
-  try {
-    url = new URL(sourceUrl);
-  } catch {
-    skillError("invalid_skill_source", "Invalid GitHub Skill URL");
-  }
-  if (url.protocol !== "https:")
-    skillError("invalid_skill_source", "GitHub URL must use HTTPS");
-  if (url.hostname === "raw.githubusercontent.com") {
-    if (!url.pathname.endsWith("/SKILL.md")) {
-      skillError("invalid_skill_source", "GitHub URL must point to SKILL.md");
-    }
-    return [
-      {
-        relativePath: "SKILL.md",
-        content: await fetchBytes(url.toString(), githubToken)
-      }
-    ];
-  }
-  if (url.hostname !== "github.com") {
-    skillError("invalid_skill_source", "Only GitHub Skill URLs are supported");
-  }
-  let segments;
-  try {
-    segments = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
-  } catch {
-    skillError("invalid_skill_source", "Invalid GitHub Skill URL");
-  }
-  if (segments.length < 5 || segments[2] !== "blob" || segments.at(-1) !== "SKILL.md") {
-    skillError(
-      "invalid_skill_source",
-      "GitHub URL must point to a repository SKILL.md file"
-    );
-  }
-  const [owner, repo, , ref, ...filePath] = segments;
-  if (!owner || !repo || !ref || ref.startsWith("-") || !/^[A-Za-z0-9._/+-]+$/.test(ref) || !/^[A-Za-z0-9._-]+$/.test(owner) || !/^[A-Za-z0-9._-]+$/.test(repo)) {
-    skillError("invalid_skill_source", "Invalid GitHub Skill URL");
-  }
-  const directory = filePath.slice(0, -1).join("/");
-  const directorySegments = directory.split("/");
-  if (directory && (directory.length > MAX_PATH_LENGTH || directory.includes("\\") || directory.startsWith("/") || directorySegments.length > MAX_PATH_DEPTH || directorySegments.some(
-    (segment) => !segment || segment === "." || segment === ".."
-  ))) {
-    skillError("invalid_skill_source", "Invalid GitHub Skill URL path");
-  }
-  try {
-    return await downloadGitHubDirectory(
-      owner,
-      repo,
-      ref,
-      directory,
-      githubToken
-    );
-  } catch (error) {
-    if (!(error instanceof WorkspaceSkillManagementError) || error.code !== "github_api_failed" || error.statusCode === 404) {
-      throw error;
-    }
-    return downloadGitHubDirectoryWithGit(owner, repo, ref, directory);
-  }
-}
-__name(downloadGitHubSkill, "downloadGitHubSkill");
-function openZip(content) {
-  return new Promise((resolve3, reject) => {
-    (0, import_yauzl.fromBuffer)(content, { lazyEntries: true }, (error, zipFile) => {
-      if (error) reject(error);
-      else resolve3(zipFile);
-    });
-  });
-}
-__name(openZip, "openZip");
-function readZipEntry(zipFile, entry) {
-  return new Promise((resolve3, reject) => {
-    zipFile.openReadStream(entry, (error, stream) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      const chunks = [];
-      let size = 0;
-      stream.on("data", (chunk) => {
-        size += chunk.length;
-        if (size > MAX_FILE_BYTES) {
-          stream.destroy(
-            new WorkspaceSkillManagementError(
-              "skill_package_too_large",
-              `Skill ZIP entry is too large: ${entry.fileName}`,
-              413
-            )
-          );
-        } else {
-          chunks.push(chunk);
-        }
-      });
-      stream.on("error", reject);
-      stream.on("end", () => resolve3(Buffer.concat(chunks)));
-    });
-  });
-}
-__name(readZipEntry, "readZipEntry");
-async function filesFromZip(content) {
-  const zipFile = await openZip(content);
-  const files = [];
-  let totalBytes = 0;
-  return new Promise((resolve3, reject) => {
-    let settled = false;
-    const finish = /* @__PURE__ */ __name((error) => {
-      if (settled) return;
-      settled = true;
-      zipFile.close();
-      if (error) reject(error);
-      else resolve3(files);
-    }, "finish");
-    zipFile.on("error", finish);
-    zipFile.on("entry", (entry) => {
-      const mode = entry.externalFileAttributes >>> 16 & 65535;
-      const fileType = mode & 61440;
-      if (fileType === 40960) {
-        finish(new Error("Skill ZIP contains a symbolic link"));
-        return;
-      }
-      if (entry.generalPurposeBitFlag & 1) {
-        finish(new Error("Encrypted Skill ZIP entries are not supported"));
-        return;
-      }
-      if (entry.fileName.endsWith("/") || fileType === 16384) {
-        zipFile.readEntry();
-        return;
-      }
-      if (files.length >= MAX_FILES) {
-        finish(
-          new WorkspaceSkillManagementError(
-            "invalid_skill_package",
-            "Skill ZIP contains too many files"
-          )
-        );
-        return;
-      }
-      if (entry.uncompressedSize > MAX_FILE_BYTES) {
-        finish(
-          new WorkspaceSkillManagementError(
-            "skill_package_too_large",
-            "Skill ZIP entry exceeds the allowed size",
-            413
-          )
-        );
-        return;
-      }
-      if (totalBytes + entry.uncompressedSize > MAX_TOTAL_BYTES) {
-        finish(
-          new WorkspaceSkillManagementError(
-            "skill_package_too_large",
-            "Skill ZIP expands beyond the allowed size",
-            413
-          )
-        );
-        return;
-      }
-      void readZipEntry(zipFile, entry).then((entryContent) => {
-        totalBytes += entryContent.length;
-        if (totalBytes > MAX_TOTAL_BYTES) {
-          finish(
-            new WorkspaceSkillManagementError(
-              "skill_package_too_large",
-              "Skill ZIP expands beyond the allowed size",
-              413
-            )
-          );
-          return;
-        }
-        files.push({ relativePath: entry.fileName, content: entryContent });
-        if (!settled) zipFile.readEntry();
-      }, finish);
-    });
-    zipFile.on("end", () => finish());
-    zipFile.readEntry();
-  });
-}
-__name(filesFromZip, "filesFromZip");
-async function filesFromSource(source, githubToken) {
-  try {
-    if (source.type === "github")
-      return normalizePackageFiles(
-        await downloadGitHubSkill(source.url, githubToken)
-      );
-    if (source.type === "folder")
-      return normalizePackageFiles(await filesFromFolder(source.path));
-    const archive = decodeBase64(source.contentBase64);
-    return normalizePackageFiles(await filesFromZip(archive));
-  } catch (error) {
-    if (error instanceof WorkspaceSkillManagementError) throw error;
-    const code = source.type === "github" ? "github_skill_download_failed" : source.type === "folder" ? "invalid_skill_folder" : "invalid_skill_package";
-    throw new WorkspaceSkillManagementError(
-      code,
-      error instanceof Error ? error.message : String(error),
-      source.type === "github" ? 502 : 400
-    );
-  }
-}
-__name(filesFromSource, "filesFromSource");
-async function filesFromFolder(folderPath) {
-  if (!path.isAbsolute(folderPath)) {
-    skillError("invalid_skill_folder", "Skill folder path must be absolute");
-  }
-  if ((await fs.lstat(folderPath)).isSymbolicLink()) {
-    skillError(
-      "invalid_skill_folder",
-      "Skill folder path must not be a symbolic link"
-    );
-  }
-  const root = await fs.realpath(folderPath);
-  if (!(await fs.stat(root)).isDirectory()) {
-    skillError(
-      "invalid_skill_folder",
-      "Skill folder path must point to a directory"
-    );
-  }
-  const files = [];
-  let totalBytes = 0;
-  const visit = /* @__PURE__ */ __name(async (directory, relativeRoot = "", depth = 0) => {
-    if (depth > MAX_PATH_DEPTH)
-      skillError("invalid_skill_package", "Skill folder is nested too deeply");
-    for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
-      if (depth === 0 && entry.name === ".git") continue;
-      const absolutePath = path.join(directory, entry.name);
-      const relativePath = relativeRoot ? `${relativeRoot}/${entry.name}` : entry.name;
-      if (entry.isSymbolicLink()) {
-        skillError(
-          "unsafe_skill_path",
-          "Skill folder contains a symbolic link"
-        );
-      }
-      if (entry.isDirectory()) {
-        await visit(absolutePath, relativePath, depth + 1);
-        continue;
-      }
-      if (!entry.isFile())
-        skillError("unsafe_skill_path", "Skill folder contains a special file");
-      if (files.length >= MAX_FILES) {
-        skillError("invalid_skill_package", "Skill package has too many files");
-      }
-      const stats = await fs.lstat(absolutePath);
-      if (stats.isSymbolicLink() || !stats.isFile()) {
-        skillError("unsafe_skill_path", "Skill folder contains an unsafe file");
-      }
-      if (stats.size > MAX_FILE_BYTES) {
-        skillError(
-          "skill_package_too_large",
-          `Skill file is too large: ${relativePath}`,
-          413
-        );
-      }
-      totalBytes += stats.size;
-      if (totalBytes > MAX_TOTAL_BYTES) {
-        skillError(
-          "skill_package_too_large",
-          "Skill package exceeds the allowed size",
-          413
-        );
-      }
-      const content = await fs.readFile(absolutePath);
-      if (content.length !== stats.size) {
-        skillError(
-          "invalid_skill_package",
-          `Skill file changed while reading: ${relativePath}`
-        );
-      }
-      files.push({ relativePath, content });
-    }
-  }, "visit");
-  await visit(root);
-  return files;
-}
-__name(filesFromFolder, "filesFromFolder");
-function skillBaseDir(workspace, scope) {
-  return scope === "workspace" ? path.join(workspace, ".qwen", "skills") : path.join(Storage.getGlobalQwenDir(), "skills");
-}
-__name(skillBaseDir, "skillBaseDir");
-async function removeInstallArtifacts(baseDir, skillName) {
-  const workDir = path.dirname(baseDir);
-  const workPrefix = `.${path.basename(baseDir)}-${skillName}`;
-  const locations = [
-    {
-      directory: baseDir,
-      prefixes: [`.${skillName}.installing-`, `.${skillName}.backup-`]
-    },
-    {
-      directory: workDir,
-      prefixes: [`${workPrefix}.installing-`, `${workPrefix}.backup-`]
-    }
-  ];
-  for (const { directory, prefixes } of locations) {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    await Promise.all(
-      entries.filter(
-        (entry) => prefixes.some((prefix) => entry.name.startsWith(prefix))
-      ).map(
-        (entry) => fs.rm(path.join(directory, entry.name), {
-          recursive: true,
-          force: true
-        })
-      )
-    );
-  }
-}
-__name(removeInstallArtifacts, "removeInstallArtifacts");
-async function ensureDirectoryWithoutSymlinks(directory) {
-  const missing = [];
-  let current = directory;
-  while (true) {
-    try {
-      const stats = await fs.lstat(current);
-      if (stats.isSymbolicLink() || !stats.isDirectory()) {
-        skillError("unsafe_skill_path", `Unsafe Skill directory: ${current}`);
-      }
-      break;
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-      missing.push(current);
-      const parent = path.dirname(current);
-      if (parent === current) throw error;
-      current = parent;
-    }
-  }
-  for (const entry of missing.reverse()) await fs.mkdir(entry);
-}
-__name(ensureDirectoryWithoutSymlinks, "ensureDirectoryWithoutSymlinks");
-async function installWorkspaceSkill(workspace, request, githubToken) {
-  const skillName = validateWorkspaceSkillName(request.name);
-  const files = await filesFromSource(request.source, githubToken);
-  const baseDir = skillBaseDir(workspace, request.scope);
-  await ensureDirectoryWithoutSymlinks(baseDir);
-  await removeInstallArtifacts(baseDir, skillName);
-  const destination = path.join(baseDir, skillName);
-  const existing = await fs.lstat(destination).catch(() => void 0);
-  if (existing?.isSymbolicLink() || existing && !existing.isDirectory()) {
-    skillError("unsafe_skill_path", "Refusing to replace an unsafe Skill path");
-  }
-  const workDir = path.dirname(baseDir);
-  const workPrefix = `.${path.basename(baseDir)}-${skillName}`;
-  const staging = await fs.mkdtemp(
-    path.join(workDir, `${workPrefix}.installing-`)
-  );
-  const backup = path.join(workDir, `${workPrefix}.backup-${Date.now()}`);
-  let movedExisting = false;
-  try {
-    for (const file of files) {
-      const target = path.join(staging, ...file.relativePath.split("/"));
-      await fs.mkdir(path.dirname(target), { recursive: true });
-      await fs.writeFile(target, file.content);
-    }
-    const skillFile = path.join(staging, "SKILL.md");
-    let parsed;
-    try {
-      parsed = new SkillManager({}).parseSkillContent(
-        await fs.readFile(skillFile, "utf8"),
-        skillFile,
-        request.scope === "workspace" ? "project" : "user"
-      );
-    } catch (error) {
-      throw new WorkspaceSkillManagementError(
-        "invalid_skill_manifest",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    if (parsed.name !== skillName) {
-      skillError(
-        "skill_name_mismatch",
-        `Skill name "${parsed.name}" does not match requested name "${skillName}"`
-      );
-    }
-    if (existing) {
-      await fs.rename(destination, backup);
-      movedExisting = true;
-    }
-    await fs.rename(staging, destination);
-  } catch (error) {
-    await fs.rm(staging, { recursive: true, force: true }).catch(() => void 0);
-    if (movedExisting) {
-      await fs.rename(backup, destination).catch(() => void 0);
-    }
-    throw error;
-  }
-  if (movedExisting) {
-    await fs.rm(backup, { recursive: true, force: true }).catch(() => void 0);
-  }
-  return {
-    skillName,
-    scope: request.scope,
-    installedPath: path.join(destination, "SKILL.md")
-  };
-}
-__name(installWorkspaceSkill, "installWorkspaceSkill");
-async function deleteWorkspaceSkill(workspace, scope, skillNameInput, installedPath) {
-  const skillName = validateWorkspaceSkillName(skillNameInput);
-  const skillDir = path.resolve(path.dirname(installedPath));
-  const skillFile = path.resolve(installedPath);
-  const allowedBaseDirs = new SkillManager({
-    getProjectRoot: /* @__PURE__ */ __name(() => workspace, "getProjectRoot")
-  }).getSkillsBaseDirs(scope === "workspace" ? "project" : "user").map((directory) => path.resolve(directory));
-  const baseDir = path.dirname(skillDir);
-  if (skillFile !== path.join(skillDir, "SKILL.md") || !allowedBaseDirs.includes(baseDir) || path.basename(skillDir) !== skillName) {
-    skillError(
-      "skill_not_managed",
-      "Skill is not managed in the requested scope",
-      409
-    );
-  }
-  const baseRealPath = await fs.realpath(baseDir);
-  const skillDirStats = await fs.lstat(skillDir);
-  const skillFileStats = await fs.lstat(skillFile);
-  if (skillDirStats.isSymbolicLink() || !skillDirStats.isDirectory() || skillFileStats.isSymbolicLink() || !skillFileStats.isFile()) {
-    skillError("unsafe_skill_path", "Refusing to delete an unsafe Skill path");
-  }
-  const skillDirRealPath = await fs.realpath(skillDir);
-  if (path.dirname(skillDirRealPath) !== baseRealPath) {
-    skillError("unsafe_skill_path", "Refusing to delete an unsafe Skill path");
-  }
-  const parsed = new SkillManager({}).parseSkillContent(
-    await fs.readFile(skillFile, "utf8"),
-    skillFile,
-    scope === "workspace" ? "project" : "user"
-  );
-  if (parsed.name !== skillName) {
-    skillError(
-      "skill_name_mismatch",
-      "Skill name does not match its installed directory"
-    );
-  }
-  await fs.rm(skillDir, { recursive: true, force: true });
-  return { skillName, scope, deleted: true };
-}
-__name(deleteWorkspaceSkill, "deleteWorkspaceSkill");
-
 // packages/cli/src/serve/workspace-service/index.ts
 async function canonicalizeExistingAncestor(inputPath) {
   let current = inputPath;
   while (true) {
     try {
-      return await fs2.realpath(current);
+      return await fs.realpath(current);
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT" && code !== "ENOTDIR" && code !== "ELOOP") {
         throw err;
       }
-      const parent = path2.dirname(current);
+      const parent = path.dirname(current);
       if (parent === current) throw err;
       current = parent;
     }
@@ -1060,9 +326,9 @@ async function canonicalizeExistingAncestor(inputPath) {
 __name(canonicalizeExistingAncestor, "canonicalizeExistingAncestor");
 async function verifyParentPostOpen(target, wsCanonical, _fh) {
   const parentCanonical = await canonicalizeExistingAncestor(
-    path2.dirname(target)
+    path.dirname(target)
   );
-  const within = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path2.sep);
+  const within = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path.sep);
   if (within) return;
   throw new WorkspaceInitSymlinkError(
     target,
@@ -1077,14 +343,14 @@ var TimeoutError = class extends Error {
   }
 };
 async function withTimeout(promise, timeoutMs, label) {
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve2, reject) => {
     const timeout = setTimeout(() => {
       reject(new TimeoutError(`${label} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     promise.then(
       (value) => {
         clearTimeout(timeout);
-        resolve3(value);
+        resolve2(value);
       },
       (err) => {
         clearTimeout(timeout);
@@ -1106,7 +372,6 @@ function createDaemonWorkspaceService(deps) {
     persistDisabledSkills,
     persistSetting,
     persistSettings,
-    skillInstallEnv,
     voiceEnv,
     voiceSettingsScope,
     preheatAcpChild: preheatAcpChildOnBridge,
@@ -1146,23 +411,6 @@ function createDaemonWorkspaceService(deps) {
     }
     return status;
   }, "getWorkspaceSkillsStatus");
-  const refreshWorkspaceSkillsAfterMutation = /* @__PURE__ */ __name(async () => {
-    lastWorkspaceSkillsStatus = void 0;
-    workspaceSkillsStatusProvider?.invalidate?.(boundWorkspace);
-    if (!(isChannelLive?.() ?? false)) return;
-    try {
-      await invokeWorkspaceCommand(
-        SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh,
-        { cwd: boundWorkspace }
-      );
-    } catch (err) {
-      if (!(err instanceof SessionNotFoundError) && !(err instanceof BridgeChannelClosedError)) {
-        writeStderrLine(
-          `qwen serve: workspace skill refresh after mutation failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }, "refreshWorkspaceSkillsAfterMutation");
   return {
     // -- Status queries (delegate to ACP child via queryWorkspaceStatus) --
     async getWorkspaceMcpStatus(_ctx) {
@@ -1502,7 +750,6 @@ function createDaemonWorkspaceService(deps) {
       let sessionsFailed = 0;
       if (persisted.changed) {
         lastWorkspaceSkillsStatus = void 0;
-        workspaceSkillsStatusProvider?.invalidate?.(boundWorkspace);
         if (channelLive) {
           try {
             const refreshed = await invokeWorkspaceCommand(
@@ -1543,51 +790,18 @@ function createDaemonWorkspaceService(deps) {
         sessionsFailed
       };
     },
-    async installWorkspaceSkill(_ctx, request) {
-      const result = await installWorkspaceSkill(
-        boundWorkspace,
-        request,
-        skillInstallEnv?.["GH_TOKEN"] ?? skillInstallEnv?.["GITHUB_TOKEN"]
-      );
-      await refreshWorkspaceSkillsAfterMutation();
-      return result;
-    },
-    async deleteWorkspaceSkill(_ctx, requestedSkillName, scope) {
-      const normalizedName = requestedSkillName.trim().toLowerCase();
-      const status = await getWorkspaceSkillsStatus();
-      const skill = status.skills.find(
-        (candidate) => candidate.name.trim().toLowerCase() === normalizedName
-      );
-      if (!skill) throw new WorkspaceSkillNotFoundError(requestedSkillName);
-      const expectedLevel = scope === "workspace" ? "project" : "user";
-      if (skill.level !== expectedLevel || !skill.installedPath) {
-        throw new WorkspaceSkillManagementError(
-          "skill_not_managed",
-          "Skill is not managed in the requested scope",
-          409
-        );
-      }
-      const result = await deleteWorkspaceSkill(
-        boundWorkspace,
-        scope,
-        skill.name,
-        skill.installedPath
-      );
-      await refreshWorkspaceSkillsAfterMutation();
-      return result;
-    },
     async initWorkspace(ctx, opts) {
       const filename = contextFilename;
-      const target = path2.resolve(boundWorkspace, filename);
-      const withinWorkspace = target === boundWorkspace || target.startsWith(boundWorkspace + path2.sep);
+      const target = path.resolve(boundWorkspace, filename);
+      const withinWorkspace = target === boundWorkspace || target.startsWith(boundWorkspace + path.sep);
       if (!withinWorkspace) {
         throw new WorkspaceInitPathEscapeError(filename, boundWorkspace);
       }
-      const wsCanonical = await fs2.realpath(boundWorkspace);
+      const wsCanonical = await fs.realpath(boundWorkspace);
       const parentCanonical = await canonicalizeExistingAncestor(
-        path2.dirname(target)
+        path.dirname(target)
       );
-      const parentWithinWorkspace = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path2.sep);
+      const parentWithinWorkspace = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path.sep);
       if (!parentWithinWorkspace) {
         throw new WorkspaceInitSymlinkError(
           target,
@@ -1596,7 +810,7 @@ function createDaemonWorkspaceService(deps) {
         );
       }
       try {
-        const lst = await fs2.lstat(target);
+        const lst = await fs.lstat(target);
         if (lst.isSymbolicLink()) {
           throw new WorkspaceInitSymlinkError(
             target,
@@ -1618,7 +832,7 @@ function createDaemonWorkspaceService(deps) {
       }
       let action = "created";
       try {
-        const existing = await fs2.readFile(target, "utf8");
+        const existing = await fs.readFile(target, "utf8");
         if (existing.trim().length > 0) {
           const existingSize = Buffer.byteLength(existing, "utf8");
           if (opts.force !== true) {
@@ -1636,7 +850,7 @@ function createDaemonWorkspaceService(deps) {
       if (action === "created") {
         let fh;
         try {
-          fh = await fs2.open(target, "wx");
+          fh = await fs.open(target, "wx");
         } catch (err) {
           const code = err?.code;
           if (code === "EEXIST") {
@@ -1657,7 +871,7 @@ function createDaemonWorkspaceService(deps) {
       } else if (action === "overwrote") {
         let overwriteFh;
         try {
-          overwriteFh = await fs2.open(
+          overwriteFh = await fs.open(
             target,
             fsConstants.O_WRONLY | (fsConstants.O_NOFOLLOW ?? 0)
           );
@@ -1871,9 +1085,6 @@ export {
   buildWorkspaceVoiceStatus,
   validateWorkspaceVoiceState,
   transcribeWorkspaceVoiceAudio,
-  MAX_WORKSPACE_SKILL_NAME_LENGTH,
-  WorkspaceSkillManagementError,
-  validateWorkspaceSkillName,
   createDaemonWorkspaceService
 };
 /**