@serviceme/devtools-core 0.1.6 → 0.1.8

package/dist/index.mjs

@@ -6,6 +6,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/agents/AgentCatalogClient.ts
+import { createServicemeError } from "@serviceme/devtools-protocol";
 var AgentCatalogClient = class {
   constructor(options = {}) {
     this.fetchImpl = options.fetchImpl ?? fetch;
@@ -13,10 +14,10 @@ var AgentCatalogClient = class {
   }
   async getCatalog() {
     if (!this.baseUrl) {
-      return {
-        agents: [],
-        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      throw createServicemeError(
+        "workspace_not_found",
+        "Agent catalog baseUrl is not configured."
+      );
     }
     const response = await this.fetchImpl(
       `${this.baseUrl}/api/v1/marketplace/agents`
@@ -30,6 +31,30 @@ var AgentCatalogClient = class {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  async downloadAgent(remoteId) {
+    if (!this.baseUrl) {
+      throw createServicemeError(
+        "workspace_not_found",
+        "Agent catalog baseUrl is not configured."
+      );
+    }
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/api/v1/marketplace/agents/download/${remoteId}`
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw createServicemeError(
+          "not_found",
+          `Agent '${remoteId}' not found`
+        );
+      }
+      throw new Error(
+        `Failed to download agent ${remoteId}: ${response.status}`
+      );
+    }
+    const payload = await response.json();
+    return payload.data?.files ?? [];
+  }
 };
 
 // src/permissions/agent-permissions.ts
@@ -289,7 +314,7 @@ var AgentStore = class {
 // src/copilot/doctor.ts
 import {
   COPILOT_ERROR_CODES,
-  createServicemeError
+  createServicemeError as createServicemeError2
 } from "@serviceme/devtools-protocol";
 
 // src/process/runCommand.ts
@@ -434,13 +459,13 @@ async function copilotDoctor() {
   return { installed: true, version, authenticated };
 }
 function createCopilotNotInstalledError() {
-  return createServicemeError(
+  return createServicemeError2(
     COPILOT_ERROR_CODES.NOT_INSTALLED,
     "GitHub Copilot CLI is not installed. Visit https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-in-the-command-line to install."
   );
 }
 function createCopilotAuthRequiredError() {
-  return createServicemeError(
+  return createServicemeError2(
     COPILOT_ERROR_CODES.AUTH_REQUIRED,
     "GitHub Copilot CLI requires authentication. Run `copilot auth login` to sign in."
   );
@@ -449,7 +474,8 @@ function createCopilotAuthRequiredError() {
 // src/copilot/prompt.ts
 import {
   COPILOT_ERROR_CODES as COPILOT_ERROR_CODES2,
-  createServicemeError as createServicemeError2
+  createServicemeError as createServicemeError3,
+  ServicemeProtocolError
 } from "@serviceme/devtools-protocol";
 var COPILOT_COMMAND2 = "copilot";
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -484,7 +510,7 @@ async function copilotPrompt(options) {
     });
     const output = stripAnsi(result.stdout);
     if (output.includes("I'm sorry, but I cannot assist") && result.stderr?.includes("Stream completed without a response")) {
-      throw createServicemeError2(
+      throw createServicemeError3(
         COPILOT_ERROR_CODES2.AUTH_REQUIRED,
         "Copilot CLI returned a refusal response. This typically indicates an expired authentication token. Run `gh auth login` to re-authenticate.",
         { exitCode: 0, output, stderr: result.stderr }
@@ -492,9 +518,12 @@ async function copilotPrompt(options) {
     }
     return { output, exitCode: 0 };
   } catch (error) {
+    if (error instanceof ServicemeProtocolError) {
+      throw error;
+    }
     const err = error;
     if (err.code === "ETIMEDOUT") {
-      throw createServicemeError2(
+      throw createServicemeError3(
         COPILOT_ERROR_CODES2.TIMEOUT,
         `Copilot prompt timed out after ${String(timeout)}ms.`
       );
@@ -503,7 +532,7 @@ async function copilotPrompt(options) {
     const output = stripAnsi(err.stdout ?? "");
     const stderr = err.stderr ?? err.message ?? "";
     if (output.includes("I'm sorry, but I cannot assist") || stderr.includes("Stream completed without a response")) {
-      throw createServicemeError2(
+      throw createServicemeError3(
         COPILOT_ERROR_CODES2.AUTH_REQUIRED,
         "Copilot CLI returned a refusal response. This typically indicates an expired authentication token. Run `gh auth login` to re-authenticate.",
         { exitCode, output, stderr }
@@ -512,7 +541,7 @@ async function copilotPrompt(options) {
     if (exitCode !== 0 && output) {
       return { output, exitCode };
     }
-    throw createServicemeError2(
+    throw createServicemeError3(
       COPILOT_ERROR_CODES2.EXECUTION_FAILED,
       stderr || `Copilot exited with code ${String(exitCode)}.`,
       { exitCode, stderr }
@@ -522,7 +551,7 @@ async function copilotPrompt(options) {
 
 // src/env/environmentInspector.ts
 import {
-  createServicemeError as createServicemeError3,
+  createServicemeError as createServicemeError4,
   KNOWN_ENVIRONMENT_TOOLS
 } from "@serviceme/devtools-protocol";
 var DEFAULT_TOOL_CHECK_TIMEOUT_MS = 5e3;
@@ -540,17 +569,19 @@ var TOOL_CHECK_TIMEOUT_MS = {
 var ERROR_CODE_NOT_FOUND = 127;
 var ERROR_CODE_TIMEOUT = "ETIMEDOUT";
 var EnvironmentInspector = class {
+  constructor(options = {}) {
+    this.runCommandFn = options.runCommand ?? runCommand;
+    this.platform = options.platform ?? process.platform;
+  }
   async checkEnvironment() {
     const results = await Promise.all(
-      KNOWN_ENVIRONMENT_TOOLS.map(
-        async (tool) => [tool, await this.checkTool(tool)]
-      )
+      KNOWN_ENVIRONMENT_TOOLS.map(async (tool) => [tool, await this.checkTool(tool)])
     );
     return Object.fromEntries(results);
   }
   async checkTool(toolName) {
     if (!/^[a-zA-Z0-9-]+$/.test(toolName)) {
-      throw createServicemeError3("invalid_params", "Invalid tool name.");
+      throw createServicemeError4("invalid_params", "Invalid tool name.");
     }
     try {
       if (toolName === "nvm") {
@@ -572,8 +603,8 @@ var EnvironmentInspector = class {
   }
   async getToolPath(toolName) {
     try {
-      const isWindows = process.platform === "win32";
-      const result = await runCommand(isWindows ? "where" : "which", {
+      const isWindows = this.platform === "win32";
+      const result = await this.runCommandFn(isWindows ? "where" : "which", {
         args: [toolName],
         timeoutMs: this.getToolTimeout(toolName)
       });
@@ -590,14 +621,12 @@ var EnvironmentInspector = class {
    */
   async getToolShimPath(toolName) {
     try {
-      const result = await runCommand("where", {
+      const result = await this.runCommandFn("where", {
         args: [toolName],
         timeoutMs: this.getToolTimeout(toolName)
       });
       const candidates = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-      const cmdShim = candidates.find(
-        (line) => line.toLowerCase().endsWith(".cmd")
-      );
+      const cmdShim = candidates.find((line) => line.toLowerCase().endsWith(".cmd"));
       return cmdShim ?? candidates[0];
     } catch {
       return void 0;
@@ -605,16 +634,16 @@ var EnvironmentInspector = class {
   }
   async getToolVersion(toolName) {
     const invocation = await this.getVersionInvocation(toolName);
-    const result = await runCommand(invocation.command, {
+    const result = await this.runCommandFn(invocation.command, {
       args: invocation.args,
       timeoutMs: this.getToolTimeout(toolName)
     });
     return this.parseVersion(toolName, result.stdout || result.stderr);
   }
   async checkNvm() {
-    if (process.platform === "win32") {
+    if (this.platform === "win32") {
       try {
-        const result = await runCommand("cmd.exe", {
+        const result = await this.runCommandFn("cmd.exe", {
           args: ["/c", "nvm version"],
           timeoutMs: this.getToolTimeout("nvm")
         });
@@ -631,7 +660,7 @@ var EnvironmentInspector = class {
       }
     }
     try {
-      const result = await runCommand("/bin/bash", {
+      const result = await this.runCommandFn("/bin/bash", {
         args: [
           "-lc",
           'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; nvm --version'
@@ -659,7 +688,7 @@ var EnvironmentInspector = class {
       };
     }
     try {
-      const result = await runCommand("dotnet", {
+      const result = await this.runCommandFn("dotnet", {
         args: ["nuget", "list", "source"],
         timeoutMs: this.getToolTimeout("nuget")
       });
@@ -680,7 +709,7 @@ var EnvironmentInspector = class {
     }
   }
   async getVersionInvocation(toolName) {
-    const isWindows = process.platform === "win32";
+    const isWindows = this.platform === "win32";
     if (isWindows && ["npm", "pnpm", "nrm"].includes(toolName)) {
       const shim = await this.getToolShimPath(toolName);
       if (shim) {
@@ -734,7 +763,7 @@ var EnvironmentInspector = class {
     const execError = error;
     const message = execError.message || String(error);
     const code = execError.code;
-    const isNotFound = message.includes("command not found") || message.includes("not recognized") || message.includes("ENOENT") || code === "ENOENT" || code === ERROR_CODE_NOT_FOUND;
+    const isNotFound = message.includes("command not found") || message.includes("not recognized") || message.includes("ENOENT") || message.includes("EACCES") || code === "ENOENT" || code === "EACCES" || code === ERROR_CODE_NOT_FOUND;
     const isTimeout = code === ERROR_CODE_TIMEOUT || message.toLowerCase().includes("timed out");
     return {
       installed: false,
@@ -747,7 +776,7 @@ var EnvironmentInspector = class {
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
 import {
-  createServicemeError as createServicemeError4
+  createServicemeError as createServicemeError5
 } from "@serviceme/devtools-protocol";
 var SUPPORTED_FORMATS = [
   ".jpg",
@@ -792,7 +821,7 @@ var ImageTools = class {
   async compress(imagePath, options) {
     const validation = await this.validate(imagePath, options.sharpModulePath);
     if (!validation.valid) {
-      throw createServicemeError4(
+      throw createServicemeError5(
         "invalid_params",
         `Invalid image file: ${imagePath}`
       );
@@ -866,7 +895,7 @@ var ImageTools = class {
     try {
       return sharpModulePath ? __require(sharpModulePath) : __require("sharp");
     } catch (error) {
-      throw createServicemeError4(
+      throw createServicemeError5(
         "internal_error",
         `sharp is required for image operations: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -879,7 +908,7 @@ function createImageTools() {
 
 // src/json/jsonTools.ts
 import {
-  createServicemeError as createServicemeError5,
+  createServicemeError as createServicemeError6,
   DEFAULT_JSON_SORT_OPTIONS
 } from "@serviceme/devtools-protocol";
 import { parse as parseCommentJson } from "comment-json";
@@ -923,7 +952,7 @@ function parseJson(text) {
     } catch {
     }
   }
-  throw createServicemeError5("json_invalid_input", "Invalid JSON format.");
+  throw createServicemeError6("json_invalid_input", "Invalid JSON format.");
 }
 function sortObject(obj, options) {
   if (Array.isArray(obj)) {
@@ -1018,67 +1047,52 @@ function createConsoleLogger(prefix = "serviceme") {
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 import {
-  createServicemeError as createServicemeError6
+  createServicemeError as createServicemeError7
 } from "@serviceme/devtools-protocol";
 
 // src/utils/fileUtils.ts
 import { constants, createWriteStream } from "fs";
-import {
-  access as access2,
-  copyFile,
-  lstat,
-  mkdir,
-  readdir,
-  rename,
-  rm
-} from "fs/promises";
+import { access as access2, copyFile, lstat, mkdir, readdir, rename, rm } from "fs/promises";
 import { dirname as dirname3, join as join3 } from "path";
-import { open } from "yauzl";
+import yauzl from "yauzl";
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve, reject) => {
-    open(
-      zipPath,
-      { lazyEntries: true },
-      (err, zipfile) => {
-        if (err) return reject(err);
-        if (!zipfile) return reject(new Error("Failed to open zip file."));
-        zipfile.readEntry();
-        zipfile.on("entry", (entry) => {
-          if (/\/$/.test(entry.fileName)) {
-            void mkdir(join3(dest, entry.fileName), { recursive: true }).then(() => {
-              zipfile.readEntry();
-            }).catch(reject);
-          } else {
-            const outputPath = join3(dest, entry.fileName);
-            void mkdir(dirname3(outputPath), { recursive: true }).then(() => {
-              zipfile.openReadStream(
-                entry,
-                (streamError, readStream) => {
-                  if (streamError) return reject(streamError);
-                  if (!readStream)
-                    return reject(
-                      new Error("Failed to open zip entry stream.")
-                    );
-                  const writeStream = createWriteStream(outputPath);
-                  readStream.on("error", reject);
-                  writeStream.on("error", reject);
-                  writeStream.on("close", () => {
-                    zipfile.readEntry();
-                  });
-                  readStream.pipe(writeStream);
-                }
-              );
-            }).catch(reject);
-          }
-        });
-        zipfile.on("end", () => {
-          resolve();
-        });
-        zipfile.on("error", (zipError) => {
-          reject(zipError);
-        });
-      }
-    );
+    yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+      if (err) return reject(err);
+      if (!zipfile) return reject(new Error("Failed to open zip file."));
+      zipfile.readEntry();
+      zipfile.on("entry", (entry) => {
+        if (/\/$/.test(entry.fileName)) {
+          void mkdir(join3(dest, entry.fileName), { recursive: true }).then(() => {
+            zipfile.readEntry();
+          }).catch(reject);
+        } else {
+          const outputPath = join3(dest, entry.fileName);
+          void mkdir(dirname3(outputPath), { recursive: true }).then(() => {
+            zipfile.openReadStream(
+              entry,
+              (streamError, readStream) => {
+                if (streamError) return reject(streamError);
+                if (!readStream) return reject(new Error("Failed to open zip entry stream."));
+                const writeStream = createWriteStream(outputPath);
+                readStream.on("error", reject);
+                writeStream.on("error", reject);
+                writeStream.on("close", () => {
+                  zipfile.readEntry();
+                });
+                readStream.pipe(writeStream);
+              }
+            );
+          }).catch(reject);
+        }
+      });
+      zipfile.on("end", () => {
+        resolve();
+      });
+      zipfile.on("error", (zipError) => {
+        reject(zipError);
+      });
+    });
   });
 };
 var tryLstat = async (targetPath) => {
@@ -1102,11 +1116,7 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await mkdir(destPath, { recursive: true });
     const children = await readdir(sourcePath);
     for (const child of children) {
-      await mergeEntry(
-        join3(sourcePath, child),
-        join3(destPath, child),
-        overwrite
-      );
+      await mergeEntry(join3(sourcePath, child), join3(destPath, child), overwrite);
     }
     await rm(sourcePath, { recursive: true, force: true });
     return;
@@ -1183,7 +1193,7 @@ var ProjectTools = class {
   }
   async installDependencies(workspacePath, command) {
     if (!command) {
-      throw createServicemeError6("invalid_params", "Expected install command.");
+      throw createServicemeError7("invalid_params", "Expected install command.");
     }
     await runCommand(command, {
       cwd: workspacePath,
@@ -1196,23 +1206,15 @@ var ProjectTools = class {
   }
   async makeScriptsExecutable(workspacePath) {
     const isWindows = process.platform === "win32";
-    const scripts = await this.findScripts(
-      workspacePath,
-      isWindows ? [".ps1", ".bat"] : [".sh"]
-    );
+    const scripts = await this.findScripts(workspacePath, isWindows ? [".ps1", ".bat"] : [".sh"]);
     let updatedCount = 0;
     if (isWindows) {
-      for (const scriptPath of scripts.filter(
-        (script) => script.endsWith(".ps1")
-      )) {
+      for (const scriptPath of scripts.filter((script) => script.endsWith(".ps1"))) {
         try {
-          await runCommand(
-            `powershell -Command "Unblock-File -Path '${scriptPath}'"`,
-            {
-              cwd: workspacePath,
-              shell: true
-            }
-          );
+          await runCommand(`powershell -Command "Unblock-File -Path '${scriptPath}'"`, {
+            cwd: workspacePath,
+            shell: true
+          });
           updatedCount += 1;
         } catch {
         }
@@ -1246,13 +1248,16 @@ var ProjectTools = class {
   }
   async runScaffoldPrune(workspacePath, preset) {
     if (!preset) {
-      throw createServicemeError6("invalid_params", "Expected scaffold preset.");
+      throw createServicemeError7("invalid_params", "Expected scaffold preset.");
     }
-    const commands = [
-      `pnpm run scaffold:prune -- --preset ${preset} --project-root .`,
-      `pnpm run scaffold:init-metadata -- --preset ${preset} --project-root . --force`
-    ];
+    await this.ensurePresetManifest(workspacePath, preset);
+    const pruneCommand = `pnpm run scaffold:prune -- --preset ${preset} --project-root .`;
+    const initMetadataCommand = `pnpm run scaffold:init-metadata -- --preset ${preset} --project-root . --force`;
+    const commands = [pruneCommand, initMetadataCommand];
     for (const command of commands) {
+      if (command === initMetadataCommand) {
+        await this.ensurePresetManifest(workspacePath, preset);
+      }
       await runCommand(command, {
         cwd: workspacePath,
         shell: true
@@ -1264,6 +1269,40 @@ var ProjectTools = class {
       commands
     };
   }
+  async ensurePresetManifest(workspacePath, preset) {
+    const presetManifestPath = path3.join(
+      workspacePath,
+      ".ms-scaffold",
+      "presets",
+      `${preset}.json`
+    );
+    if (await this.pathExists(presetManifestPath)) {
+      return;
+    }
+    const projectModePath = path3.join(workspacePath, ".ms-scaffold", "project-mode.json");
+    if (!await this.pathExists(projectModePath)) {
+      return;
+    }
+    const projectModeRaw = await fs3.readFile(projectModePath, "utf8");
+    const projectMode = JSON.parse(projectModeRaw);
+    const synthesizedPreset = {
+      preset,
+      selectedModules: Array.isArray(projectMode.selectedModules) ? projectMode.selectedModules : [],
+      prunedModules: Array.isArray(projectMode.prunedModules) ? projectMode.prunedModules : [],
+      exclude: [],
+      recommendedFollowUps: [],
+      managedFiles: [],
+      mergeManagedFiles: [],
+      userOwnedPaths: []
+    };
+    await fs3.mkdir(path3.dirname(presetManifestPath), { recursive: true });
+    await fs3.writeFile(
+      presetManifestPath,
+      `${JSON.stringify(synthesizedPreset, null, 2)}
+`,
+      "utf8"
+    );
+  }
   async findScripts(dir, extensions) {
     const results = [];
     let entries;
@@ -1294,9 +1333,7 @@ var ProjectTools = class {
     if (directoryNames.length === 1) {
       return directoryNames[0] ?? null;
     }
-    const exactMatch = directoryNames.find(
-      (directoryName) => directoryName === expectedDirName
-    );
+    const exactMatch = directoryNames.find((directoryName) => directoryName === expectedDirName);
     if (exactMatch) {
       return exactMatch;
     }
@@ -1537,10 +1574,8 @@ var GithubCopilotCliExecutor = class {
       windowsHide: true
     });
     if (child.pid) {
-      writeDiagnostic(
-        `[GithubCopilotCliExecutor] spawned child PID=${child.pid}
-`
-      );
+      writeDiagnostic(`[GithubCopilotCliExecutor] spawned child PID=${child.pid}
+`);
     }
     const timeoutMs = execution.timeoutMs;
     const timer = timeoutMs != null ? setTimeout(() => {
@@ -1558,15 +1593,13 @@ var GithubCopilotCliExecutor = class {
     child.stdout.on("data", (chunk) => {
       const data = chunk.toString();
       stdoutBuf += data;
-      if (stdoutBuf.length > MAX_OUTPUT_BYTES)
-        stdoutBuf = stdoutBuf.slice(-MAX_OUTPUT_BYTES);
+      if (stdoutBuf.length > MAX_OUTPUT_BYTES) stdoutBuf = stdoutBuf.slice(-MAX_OUTPUT_BYTES);
       onOutput("stdout", data);
     });
     child.stderr.on("data", (chunk) => {
       const data = chunk.toString();
       stderrBuf += data;
-      if (stderrBuf.length > MAX_OUTPUT_BYTES)
-        stderrBuf = stderrBuf.slice(-MAX_OUTPUT_BYTES);
+      if (stderrBuf.length > MAX_OUTPUT_BYTES) stderrBuf = stderrBuf.slice(-MAX_OUTPUT_BYTES);
       onOutput("stderr", data);
     });
     child.on("close", (code) => {
@@ -1884,7 +1917,7 @@ function getExecutor(taskType) {
 import { randomUUID } from "crypto";
 import * as fs8 from "fs";
 import * as path7 from "path";
-import { createServicemeError as createServicemeError7 } from "@serviceme/devtools-protocol";
+import { createServicemeError as createServicemeError8 } from "@serviceme/devtools-protocol";
 var CONFIG_DIR3 = ".serviceme";
 var CONFIG_FILE = "scheduled-tasks.json";
 function emptyConfig() {
@@ -1895,10 +1928,7 @@ function isRecord(value) {
 }
 function requireNonEmptyString(payload, field, taskType) {
   if (!isRecord(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
-    throw createServicemeError7(
-      "invalid_payload",
-      `${taskType} payload ${field} is required`
-    );
+    throw createServicemeError8("invalid_payload", `${taskType} payload ${field} is required`);
   }
 }
 function validateTaskPayload(taskType, payload) {
@@ -2061,9 +2091,7 @@ var TaskExecutionEngine = class {
     if (policy === "reject") {
       const existingIds = this.taskExecutions.get(snapshot.taskId);
       if (existingIds && existingIds.size > 0) {
-        throw new Error(
-          `TASK_ALREADY_RUNNING: Task ${snapshot.taskId} is already running`
-        );
+        throw new Error(`TASK_ALREADY_RUNNING: Task ${snapshot.taskId} is already running`);
       }
     }
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2328,7 +2356,7 @@ var TaskLogManager = class {
 var TICK_INTERVAL = 1e3;
 var MIN_SCHEDULE_INTERVAL = 1e3;
 var SchedulerDaemon = class {
-  constructor(workspacePath) {
+  constructor(workspacePath, options = {}) {
     this.tickTimer = null;
     this.watcher = null;
     this.running = false;
@@ -2341,6 +2369,7 @@ var SchedulerDaemon = class {
     this.logManager = new TaskLogManager(workspacePath);
     this.pidManager = new PidManager(workspacePath);
     this.logger = new DaemonLogger(workspacePath);
+    this.getExecutor = options.getExecutor ?? getExecutor;
   }
   start() {
     if (this.running) return;
@@ -2446,7 +2475,7 @@ var SchedulerDaemon = class {
         this.workspacePath
       );
       validateTaskPayload(task.taskType, executionPayload);
-      const executor = getExecutor(task.taskType);
+      const executor = this.getExecutor(task.taskType);
       const result = await executor.execute(executionPayload);
       const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
       const durationMs = Date.now() - startMs;
@@ -2543,6 +2572,7 @@ function matchCronField(field, value) {
 }
 
 // src/skills/SkillCatalogClient.ts
+import { createServicemeError as createServicemeError9 } from "@serviceme/devtools-protocol";
 var SkillCatalogClient = class {
   constructor(options = {}) {
     this.fetchImpl = options.fetchImpl ?? fetch;
@@ -2550,10 +2580,10 @@ var SkillCatalogClient = class {
   }
   async getCatalog() {
     if (!this.baseUrl) {
-      return {
-        skills: [],
-        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      throw createServicemeError9(
+        "workspace_not_found",
+        "Skill catalog baseUrl is not configured."
+      );
     }
     const response = await this.fetchImpl(
       `${this.baseUrl}/api/v1/marketplace/skills`
@@ -2567,6 +2597,30 @@ var SkillCatalogClient = class {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  async downloadSkill(remoteId) {
+    if (!this.baseUrl) {
+      throw createServicemeError9(
+        "workspace_not_found",
+        "Skill catalog baseUrl is not configured."
+      );
+    }
+    const response = await this.fetchImpl(
+      `${this.baseUrl}/api/v1/marketplace/skills/download/${remoteId}`
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw createServicemeError9(
+          "not_found",
+          `Skill '${remoteId}' not found`
+        );
+      }
+      throw new Error(
+        `Failed to download skill ${remoteId}: ${response.status}`
+      );
+    }
+    const payload = await response.json();
+    return payload.data?.files ?? [];
+  }
 };
 
 // src/skills/SkillReconciler.ts
@@ -2703,6 +2757,22 @@ var SkillStore = class {
       return false;
     }
   }
+  async writeSkillFiles(skillId, scope, files) {
+    const root = scope === "workspace" ? path9.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
+    const targetDir = path9.join(root, skillId);
+    await this.fileSystem.mkdir(targetDir, { recursive: true });
+    for (const file of files) {
+      const filePath = path9.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path9.dirname(filePath), { recursive: true });
+      await this.fileSystem.writeFile(filePath, file.content, "utf-8");
+      if (file.executable) {
+        try {
+          await this.fileSystem.chmod(filePath, 493);
+        } catch {
+        }
+      }
+    }
+  }
 };
 export {
   AgentCatalogClient,