@serviceme/devtools-core 0.1.6 → 0.1.8

package/dist/index.js

@@ -72,6 +72,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/agents/AgentCatalogClient.ts
+var import_devtools_protocol = require("@serviceme/devtools-protocol");
 var AgentCatalogClient = class {
   constructor(options = {}) {
     this.fetchImpl = options.fetchImpl ?? fetch;
@@ -79,10 +80,10 @@ var AgentCatalogClient = class {
   }
   async getCatalog() {
     if (!this.baseUrl) {
-      return {
-        agents: [],
-        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      throw (0, import_devtools_protocol.createServicemeError)(
+        "workspace_not_found",
+        "Agent catalog baseUrl is not configured."
+      );
     }
     const response = await this.fetchImpl(
       `${this.baseUrl}/api/v1/marketplace/agents`
@@ -96,6 +97,30 @@ var AgentCatalogClient = class {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  async downloadAgent(remoteId) {
+    if (!this.baseUrl) {
+      throw (0, import_devtools_protocol.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 (0, import_devtools_protocol.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
@@ -353,7 +378,7 @@ var AgentStore = class {
 };
 
 // src/copilot/doctor.ts
-var import_devtools_protocol = require("@serviceme/devtools-protocol");
+var import_devtools_protocol2 = require("@serviceme/devtools-protocol");
 
 // src/process/runCommand.ts
 var import_node_child_process = require("child_process");
@@ -497,20 +522,20 @@ async function copilotDoctor() {
   return { installed: true, version, authenticated };
 }
 function createCopilotNotInstalledError() {
-  return (0, import_devtools_protocol.createServicemeError)(
-    import_devtools_protocol.COPILOT_ERROR_CODES.NOT_INSTALLED,
+  return (0, import_devtools_protocol2.createServicemeError)(
+    import_devtools_protocol2.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 (0, import_devtools_protocol.createServicemeError)(
-    import_devtools_protocol.COPILOT_ERROR_CODES.AUTH_REQUIRED,
+  return (0, import_devtools_protocol2.createServicemeError)(
+    import_devtools_protocol2.COPILOT_ERROR_CODES.AUTH_REQUIRED,
     "GitHub Copilot CLI requires authentication. Run `copilot auth login` to sign in."
   );
 }
 
 // src/copilot/prompt.ts
-var import_devtools_protocol2 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol3 = require("@serviceme/devtools-protocol");
 var COPILOT_COMMAND2 = "copilot";
 var DEFAULT_TIMEOUT_MS = 12e4;
 function stripAnsi(text) {
@@ -544,18 +569,21 @@ 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 (0, import_devtools_protocol2.createServicemeError)(
-        import_devtools_protocol2.COPILOT_ERROR_CODES.AUTH_REQUIRED,
+      throw (0, import_devtools_protocol3.createServicemeError)(
+        import_devtools_protocol3.COPILOT_ERROR_CODES.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 }
       );
     }
     return { output, exitCode: 0 };
   } catch (error) {
+    if (error instanceof import_devtools_protocol3.ServicemeProtocolError) {
+      throw error;
+    }
     const err = error;
     if (err.code === "ETIMEDOUT") {
-      throw (0, import_devtools_protocol2.createServicemeError)(
-        import_devtools_protocol2.COPILOT_ERROR_CODES.TIMEOUT,
+      throw (0, import_devtools_protocol3.createServicemeError)(
+        import_devtools_protocol3.COPILOT_ERROR_CODES.TIMEOUT,
         `Copilot prompt timed out after ${String(timeout)}ms.`
       );
     }
@@ -563,8 +591,8 @@ 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 (0, import_devtools_protocol2.createServicemeError)(
-        import_devtools_protocol2.COPILOT_ERROR_CODES.AUTH_REQUIRED,
+      throw (0, import_devtools_protocol3.createServicemeError)(
+        import_devtools_protocol3.COPILOT_ERROR_CODES.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 }
       );
@@ -572,8 +600,8 @@ async function copilotPrompt(options) {
     if (exitCode !== 0 && output) {
       return { output, exitCode };
     }
-    throw (0, import_devtools_protocol2.createServicemeError)(
-      import_devtools_protocol2.COPILOT_ERROR_CODES.EXECUTION_FAILED,
+    throw (0, import_devtools_protocol3.createServicemeError)(
+      import_devtools_protocol3.COPILOT_ERROR_CODES.EXECUTION_FAILED,
       stderr || `Copilot exited with code ${String(exitCode)}.`,
       { exitCode, stderr }
     );
@@ -581,7 +609,7 @@ async function copilotPrompt(options) {
 }
 
 // src/env/environmentInspector.ts
-var import_devtools_protocol3 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol4 = require("@serviceme/devtools-protocol");
 var DEFAULT_TOOL_CHECK_TIMEOUT_MS = 5e3;
 var TOOL_CHECK_TIMEOUT_MS = {
   nuget: 12e3,
@@ -597,17 +625,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(
-      import_devtools_protocol3.KNOWN_ENVIRONMENT_TOOLS.map(
-        async (tool) => [tool, await this.checkTool(tool)]
-      )
+      import_devtools_protocol4.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 (0, import_devtools_protocol3.createServicemeError)("invalid_params", "Invalid tool name.");
+      throw (0, import_devtools_protocol4.createServicemeError)("invalid_params", "Invalid tool name.");
     }
     try {
       if (toolName === "nvm") {
@@ -629,8 +659,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)
       });
@@ -647,14 +677,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;
@@ -662,16 +690,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")
         });
@@ -688,7 +716,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'
@@ -716,7 +744,7 @@ var EnvironmentInspector = class {
       };
     }
     try {
-      const result = await runCommand("dotnet", {
+      const result = await this.runCommandFn("dotnet", {
         args: ["nuget", "list", "source"],
         timeoutMs: this.getToolTimeout("nuget")
       });
@@ -737,7 +765,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) {
@@ -791,7 +819,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,
@@ -803,7 +831,7 @@ var EnvironmentInspector = class {
 // src/image/imageTools.ts
 var fs2 = __toESM(require("fs/promises"));
 var path2 = __toESM(require("path"));
-var import_devtools_protocol4 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol5 = require("@serviceme/devtools-protocol");
 var SUPPORTED_FORMATS = [
   ".jpg",
   ".jpeg",
@@ -847,7 +875,7 @@ var ImageTools = class {
   async compress(imagePath, options) {
     const validation = await this.validate(imagePath, options.sharpModulePath);
     if (!validation.valid) {
-      throw (0, import_devtools_protocol4.createServicemeError)(
+      throw (0, import_devtools_protocol5.createServicemeError)(
         "invalid_params",
         `Invalid image file: ${imagePath}`
       );
@@ -921,7 +949,7 @@ var ImageTools = class {
     try {
       return sharpModulePath ? require(sharpModulePath) : require("sharp");
     } catch (error) {
-      throw (0, import_devtools_protocol4.createServicemeError)(
+      throw (0, import_devtools_protocol5.createServicemeError)(
         "internal_error",
         `sharp is required for image operations: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -933,13 +961,13 @@ function createImageTools() {
 }
 
 // src/json/jsonTools.ts
-var import_devtools_protocol5 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol6 = require("@serviceme/devtools-protocol");
 var import_comment_json = require("comment-json");
 var import_json5 = __toESM(require("json5"));
 function createJsonTools() {
   return {
     sort(text, options) {
-      const finalOptions = { ...import_devtools_protocol5.DEFAULT_JSON_SORT_OPTIONS, ...options };
+      const finalOptions = { ...import_devtools_protocol6.DEFAULT_JSON_SORT_OPTIONS, ...options };
       const json = parseJson(text);
       const sorted = sortObject(json, finalOptions);
       return JSON.stringify(sorted, null, detectIndent(text));
@@ -975,7 +1003,7 @@ function parseJson(text) {
     } catch {
     }
   }
-  throw (0, import_devtools_protocol5.createServicemeError)("json_invalid_input", "Invalid JSON format.");
+  throw (0, import_devtools_protocol6.createServicemeError)("json_invalid_input", "Invalid JSON format.");
 }
 function sortObject(obj, options) {
   if (Array.isArray(obj)) {
@@ -1069,58 +1097,51 @@ function createConsoleLogger(prefix = "serviceme") {
 // src/project/projectTools.ts
 var fs3 = __toESM(require("fs/promises"));
 var path3 = __toESM(require("path"));
-var import_devtools_protocol6 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol7 = require("@serviceme/devtools-protocol");
 
 // src/utils/fileUtils.ts
 var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
-var import_yauzl = require("yauzl");
+var import_yauzl = __toESM(require("yauzl"));
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve, reject) => {
-    (0, import_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 (0, import_promises.mkdir)((0, import_node_path.join)(dest, entry.fileName), { recursive: true }).then(() => {
-              zipfile.readEntry();
-            }).catch(reject);
-          } else {
-            const outputPath = (0, import_node_path.join)(dest, entry.fileName);
-            void (0, import_promises.mkdir)((0, import_node_path.dirname)(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 = (0, import_node_fs.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);
-        });
-      }
-    );
+    import_yauzl.default.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 (0, import_promises.mkdir)((0, import_node_path.join)(dest, entry.fileName), { recursive: true }).then(() => {
+            zipfile.readEntry();
+          }).catch(reject);
+        } else {
+          const outputPath = (0, import_node_path.join)(dest, entry.fileName);
+          void (0, import_promises.mkdir)((0, import_node_path.dirname)(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 = (0, import_node_fs.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) => {
@@ -1144,11 +1165,7 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await (0, import_promises.mkdir)(destPath, { recursive: true });
     const children = await (0, import_promises.readdir)(sourcePath);
     for (const child of children) {
-      await mergeEntry(
-        (0, import_node_path.join)(sourcePath, child),
-        (0, import_node_path.join)(destPath, child),
-        overwrite
-      );
+      await mergeEntry((0, import_node_path.join)(sourcePath, child), (0, import_node_path.join)(destPath, child), overwrite);
     }
     await (0, import_promises.rm)(sourcePath, { recursive: true, force: true });
     return;
@@ -1225,7 +1242,7 @@ var ProjectTools = class {
   }
   async installDependencies(workspacePath, command) {
     if (!command) {
-      throw (0, import_devtools_protocol6.createServicemeError)("invalid_params", "Expected install command.");
+      throw (0, import_devtools_protocol7.createServicemeError)("invalid_params", "Expected install command.");
     }
     await runCommand(command, {
       cwd: workspacePath,
@@ -1238,23 +1255,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 {
         }
@@ -1288,13 +1297,16 @@ var ProjectTools = class {
   }
   async runScaffoldPrune(workspacePath, preset) {
     if (!preset) {
-      throw (0, import_devtools_protocol6.createServicemeError)("invalid_params", "Expected scaffold preset.");
+      throw (0, import_devtools_protocol7.createServicemeError)("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
@@ -1306,6 +1318,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;
@@ -1336,9 +1382,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;
     }
@@ -1579,10 +1623,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(() => {
@@ -1600,15 +1642,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) => {
@@ -1926,7 +1966,7 @@ function getExecutor(taskType) {
 var import_node_crypto = require("crypto");
 var fs8 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
-var import_devtools_protocol7 = require("@serviceme/devtools-protocol");
+var import_devtools_protocol8 = require("@serviceme/devtools-protocol");
 var CONFIG_DIR3 = ".serviceme";
 var CONFIG_FILE = "scheduled-tasks.json";
 function emptyConfig() {
@@ -1937,10 +1977,7 @@ function isRecord(value) {
 }
 function requireNonEmptyString(payload, field, taskType) {
   if (!isRecord(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
-    throw (0, import_devtools_protocol7.createServicemeError)(
-      "invalid_payload",
-      `${taskType} payload ${field} is required`
-    );
+    throw (0, import_devtools_protocol8.createServicemeError)("invalid_payload", `${taskType} payload ${field} is required`);
   }
 }
 function validateTaskPayload(taskType, payload) {
@@ -2103,9 +2140,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();
@@ -2370,7 +2405,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;
@@ -2383,6 +2418,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;
@@ -2488,7 +2524,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;
@@ -2585,6 +2621,7 @@ function matchCronField(field, value) {
 }
 
 // src/skills/SkillCatalogClient.ts
+var import_devtools_protocol9 = require("@serviceme/devtools-protocol");
 var SkillCatalogClient = class {
   constructor(options = {}) {
     this.fetchImpl = options.fetchImpl ?? fetch;
@@ -2592,10 +2629,10 @@ var SkillCatalogClient = class {
   }
   async getCatalog() {
     if (!this.baseUrl) {
-      return {
-        skills: [],
-        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      throw (0, import_devtools_protocol9.createServicemeError)(
+        "workspace_not_found",
+        "Skill catalog baseUrl is not configured."
+      );
     }
     const response = await this.fetchImpl(
       `${this.baseUrl}/api/v1/marketplace/skills`
@@ -2609,6 +2646,30 @@ var SkillCatalogClient = class {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  async downloadSkill(remoteId) {
+    if (!this.baseUrl) {
+      throw (0, import_devtools_protocol9.createServicemeError)(
+        "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 (0, import_devtools_protocol9.createServicemeError)(
+          "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
@@ -2745,6 +2806,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 {
+        }
+      }
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {