@qwen-code/qwen-code 0.19.11 → 0.19.12-preview.0

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

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-K7VD4XLT.js";
+} from "./chunk-LHEQDKAR.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-BUAXJVNP.js";
+} from "./chunk-XACBIZJB.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,7 +16,7 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-3M75MSVA.js";
+} from "./chunk-SMASS3CY.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
@@ -32,7 +32,7 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-L4Y55KIS.js";
+} from "./chunk-X6YQWCIJ.js";
 import {
   BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
@@ -46,34 +46,38 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-VFX7EZIR.js";
+} from "./chunk-TFV3XVAZ.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-GNBBAQ6J.js";
+} from "./chunk-ILQ42UG6.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-2OG646IN.js";
+} from "./chunk-XFJU7SVP.js";
 import {
   writeStderrLine
-} from "./chunk-YUZI3WAC.js";
+} from "./chunk-OWAK7LMW.js";
 import {
-  ModelsConfig
-} from "./chunk-NJOFRXTM.js";
+  ModelsConfig,
+  SkillManager,
+  require_yauzl
+} from "./chunk-6TDA4EVC.js";
 import {
+  Storage,
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
 import {
-  __name
+  __name,
+  __toESM
 } from "./chunk-J2S4EL5Y.js";
 
 // packages/cli/src/serve/workspace-service/index.ts
 init_esbuild_shims();
-import { promises as fs, constants as fsConstants } from "node:fs";
-import * as path from "node:path";
+import { promises as fs2, constants as fsConstants } from "node:fs";
+import * as path2 from "node:path";
 
 // packages/cli/src/services/voice-service.ts
 init_esbuild_shims();
@@ -306,18 +310,748 @@ 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 fs.realpath(current);
+      return await fs2.realpath(current);
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT" && code !== "ENOTDIR" && code !== "ELOOP") {
         throw err;
       }
-      const parent = path.dirname(current);
+      const parent = path2.dirname(current);
       if (parent === current) throw err;
       current = parent;
     }
@@ -326,9 +1060,9 @@ async function canonicalizeExistingAncestor(inputPath) {
 __name(canonicalizeExistingAncestor, "canonicalizeExistingAncestor");
 async function verifyParentPostOpen(target, wsCanonical, _fh) {
   const parentCanonical = await canonicalizeExistingAncestor(
-    path.dirname(target)
+    path2.dirname(target)
   );
-  const within = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path.sep);
+  const within = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path2.sep);
   if (within) return;
   throw new WorkspaceInitSymlinkError(
     target,
@@ -343,14 +1077,14 @@ var TimeoutError = class extends Error {
   }
 };
 async function withTimeout(promise, timeoutMs, label) {
-  return await new Promise((resolve2, reject) => {
+  return await new Promise((resolve3, reject) => {
     const timeout = setTimeout(() => {
       reject(new TimeoutError(`${label} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     promise.then(
       (value) => {
         clearTimeout(timeout);
-        resolve2(value);
+        resolve3(value);
       },
       (err) => {
         clearTimeout(timeout);
@@ -372,6 +1106,7 @@ function createDaemonWorkspaceService(deps) {
     persistDisabledSkills,
     persistSetting,
     persistSettings,
+    skillInstallEnv,
     voiceEnv,
     voiceSettingsScope,
     preheatAcpChild: preheatAcpChildOnBridge,
@@ -411,6 +1146,23 @@ 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) {
@@ -750,6 +1502,7 @@ function createDaemonWorkspaceService(deps) {
       let sessionsFailed = 0;
       if (persisted.changed) {
         lastWorkspaceSkillsStatus = void 0;
+        workspaceSkillsStatusProvider?.invalidate?.(boundWorkspace);
         if (channelLive) {
           try {
             const refreshed = await invokeWorkspaceCommand(
@@ -790,18 +1543,51 @@ 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 = path.resolve(boundWorkspace, filename);
-      const withinWorkspace = target === boundWorkspace || target.startsWith(boundWorkspace + path.sep);
+      const target = path2.resolve(boundWorkspace, filename);
+      const withinWorkspace = target === boundWorkspace || target.startsWith(boundWorkspace + path2.sep);
       if (!withinWorkspace) {
         throw new WorkspaceInitPathEscapeError(filename, boundWorkspace);
       }
-      const wsCanonical = await fs.realpath(boundWorkspace);
+      const wsCanonical = await fs2.realpath(boundWorkspace);
       const parentCanonical = await canonicalizeExistingAncestor(
-        path.dirname(target)
+        path2.dirname(target)
       );
-      const parentWithinWorkspace = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path.sep);
+      const parentWithinWorkspace = parentCanonical === wsCanonical || parentCanonical.startsWith(wsCanonical + path2.sep);
       if (!parentWithinWorkspace) {
         throw new WorkspaceInitSymlinkError(
           target,
@@ -810,7 +1596,7 @@ function createDaemonWorkspaceService(deps) {
         );
       }
       try {
-        const lst = await fs.lstat(target);
+        const lst = await fs2.lstat(target);
         if (lst.isSymbolicLink()) {
           throw new WorkspaceInitSymlinkError(
             target,
@@ -832,7 +1618,7 @@ function createDaemonWorkspaceService(deps) {
       }
       let action = "created";
       try {
-        const existing = await fs.readFile(target, "utf8");
+        const existing = await fs2.readFile(target, "utf8");
         if (existing.trim().length > 0) {
           const existingSize = Buffer.byteLength(existing, "utf8");
           if (opts.force !== true) {
@@ -850,7 +1636,7 @@ function createDaemonWorkspaceService(deps) {
       if (action === "created") {
         let fh;
         try {
-          fh = await fs.open(target, "wx");
+          fh = await fs2.open(target, "wx");
         } catch (err) {
           const code = err?.code;
           if (code === "EEXIST") {
@@ -871,7 +1657,7 @@ function createDaemonWorkspaceService(deps) {
       } else if (action === "overwrote") {
         let overwriteFh;
         try {
-          overwriteFh = await fs.open(
+          overwriteFh = await fs2.open(
             target,
             fsConstants.O_WRONLY | (fsConstants.O_NOFOLLOW ?? 0)
           );
@@ -1085,6 +1871,9 @@ export {
   buildWorkspaceVoiceStatus,
   validateWorkspaceVoiceState,
   transcribeWorkspaceVoiceAudio,
+  MAX_WORKSPACE_SKILL_NAME_LENGTH,
+  WorkspaceSkillManagementError,
+  validateWorkspaceSkillName,
   createDaemonWorkspaceService
 };
 /**