@serviceme/devtools-cli 0.1.7 → 0.1.8

package/dist/cli.js

@@ -312,7 +312,9 @@ var init_metadata = __esm({
       json: 1,
       env: 1,
       image: 1,
-      project: 1
+      project: 1,
+      skills: 1,
+      agents: 1
     };
   }
 });
@@ -357,10 +359,10 @@ var init_AgentCatalogClient = __esm({
       }
       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`
@@ -909,6 +911,9 @@ async function copilotPrompt(options2) {
     }
     return { output, exitCode: 0 };
   } catch (error) {
+    if (error instanceof ServicemeProtocolError) {
+      throw error;
+    }
     const err = error;
     if (err.code === "ETIMEDOUT") {
       throw createServicemeError(
@@ -978,11 +983,13 @@ var init_environmentInspector = __esm({
     ERROR_CODE_NOT_FOUND = 127;
     ERROR_CODE_TIMEOUT = "ETIMEDOUT";
     EnvironmentInspector = class {
+      constructor(options2 = {}) {
+        this.runCommandFn = options2.runCommand ?? runCommand;
+        this.platform = options2.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);
       }
@@ -1010,8 +1017,8 @@ var init_environmentInspector = __esm({
       }
       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)
           });
@@ -1028,14 +1035,12 @@ var init_environmentInspector = __esm({
        */
       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((line2) => line2.trim()).filter((line2) => line2.length > 0);
-          const cmdShim = candidates.find(
-            (line2) => line2.toLowerCase().endsWith(".cmd")
-          );
+          const cmdShim = candidates.find((line2) => line2.toLowerCase().endsWith(".cmd"));
           return cmdShim ?? candidates[0];
         } catch {
           return void 0;
@@ -1043,16 +1048,16 @@ var init_environmentInspector = __esm({
       }
       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")
             });
@@ -1069,7 +1074,7 @@ var init_environmentInspector = __esm({
           }
         }
         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'
@@ -1097,7 +1102,7 @@ var init_environmentInspector = __esm({
           };
         }
         try {
-          const result = await runCommand("dotnet", {
+          const result = await this.runCommandFn("dotnet", {
             args: ["nuget", "list", "source"],
             timeoutMs: this.getToolTimeout("nuget")
           });
@@ -1118,7 +1123,7 @@ var init_environmentInspector = __esm({
         }
       }
       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) {
@@ -11264,7 +11269,7 @@ var require_yauzl = __commonJS({
     var Transform = require("stream").Transform;
     var PassThrough = require("stream").PassThrough;
     var Writable = require("stream").Writable;
-    exports2.open = open2;
+    exports2.open = open;
     exports2.fromFd = fromFd;
     exports2.fromBuffer = fromBuffer;
     exports2.fromRandomAccessReader = fromRandomAccessReader;
@@ -11276,7 +11281,7 @@ var require_yauzl = __commonJS({
     exports2.Entry = Entry;
     exports2.LocalFileHeader = LocalFileHeader;
     exports2.RandomAccessReader = RandomAccessReader;
-    function open2(path15, options2, callback) {
+    function open(path15, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -12004,49 +12009,42 @@ var init_fileUtils = __esm({
     import_yauzl = __toESM(require_yauzl());
     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);
+          });
+        });
       });
     };
     tryLstat = async (targetPath) => {
@@ -12070,11 +12068,7 @@ var init_fileUtils = __esm({
         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;
@@ -12178,23 +12172,15 @@ var init_projectTools = __esm({
       }
       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 {
             }
@@ -12259,11 +12245,7 @@ var init_projectTools = __esm({
         if (await this.pathExists(presetManifestPath)) {
           return;
         }
-        const projectModePath = path3.join(
-          workspacePath,
-          ".ms-scaffold",
-          "project-mode.json"
-        );
+        const projectModePath = path3.join(workspacePath, ".ms-scaffold", "project-mode.json");
         if (!await this.pathExists(projectModePath)) {
           return;
         }
@@ -12317,9 +12299,7 @@ var init_projectTools = __esm({
         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;
         }
@@ -12576,10 +12556,8 @@ var init_GithubCopilotCliExecutor = __esm({
           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(() => {
@@ -12597,15 +12575,13 @@ var init_GithubCopilotCliExecutor = __esm({
         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) => {
@@ -12959,10 +12935,7 @@ function isRecord3(value) {
 }
 function requireNonEmptyString(payload, field, taskType) {
   if (!isRecord3(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
-    throw createServicemeError(
-      "invalid_payload",
-      `${taskType} payload ${field} is required`
-    );
+    throw createServicemeError("invalid_payload", `${taskType} payload ${field} is required`);
   }
 }
 function validateTaskPayload(taskType, payload) {
@@ -13143,9 +13116,7 @@ var init_TaskExecutionEngine = __esm({
         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();
@@ -13469,7 +13440,7 @@ var init_SchedulerDaemon = __esm({
     TICK_INTERVAL = 1e3;
     MIN_SCHEDULE_INTERVAL = 1e3;
     SchedulerDaemon = class {
-      constructor(workspacePath) {
+      constructor(workspacePath, options2 = {}) {
         this.tickTimer = null;
         this.watcher = null;
         this.running = false;
@@ -13482,6 +13453,7 @@ var init_SchedulerDaemon = __esm({
         this.logManager = new TaskLogManager(workspacePath);
         this.pidManager = new PidManager(workspacePath);
         this.logger = new DaemonLogger(workspacePath);
+        this.getExecutor = options2.getExecutor ?? getExecutor;
       }
       start() {
         if (this.running) return;
@@ -13587,7 +13559,7 @@ var init_SchedulerDaemon = __esm({
             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;
@@ -13681,10 +13653,10 @@ var init_SkillCatalogClient = __esm({
       }
       async getCatalog() {
         if (!this.baseUrl) {
-          return {
-            skills: [],
-            fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-          };
+          throw createServicemeError(
+            "workspace_not_found",
+            "Skill catalog baseUrl is not configured."
+          );
         }
         const response = await this.fetchImpl(
           `${this.baseUrl}/api/v1/marketplace/skills`
@@ -13986,10 +13958,7 @@ function parseArgs(argv) {
     const withoutPrefix = token2.slice(2);
     const eqIndex = withoutPrefix.indexOf("=");
     if (eqIndex >= 0) {
-      flags.set(
-        withoutPrefix.slice(0, eqIndex),
-        withoutPrefix.slice(eqIndex + 1)
-      );
+      flags.set(withoutPrefix.slice(0, eqIndex), withoutPrefix.slice(eqIndex + 1));
       continue;
     }
     const next = argv[index + 1];
@@ -14045,10 +14014,7 @@ async function runAgentCommand(parsed) {
   const action = parsed.positionals[1];
   const workspacePath = getStringFlag(parsed, "workspacePath");
   if (!workspacePath) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --workspacePath <path>."
-    );
+    throw createServicemeError("invalid_params", "Expected --workspacePath <path>.");
   }
   const store = new AgentStore({
     workspacePath,
@@ -14066,9 +14032,7 @@ async function runAgentCommand(parsed) {
       writeSuccess(await handleList(store));
       return;
     case "install":
-      writeSuccess(
-        await handleInstall(store, parsed, catalogClient)
-      );
+      writeSuccess(await handleInstall(store, parsed, catalogClient));
       return;
     case "uninstall":
       writeSuccess(await handleUninstall(store, workspacePath, parsed));
@@ -14080,9 +14044,7 @@ async function runAgentCommand(parsed) {
       writeSuccess(await handleMarketplace(store, catalogClient));
       return;
     case "permissions":
-      writeSuccess(
-        await handlePermissions(store, reconciler, workspacePath, parsed)
-      );
+      writeSuccess(await handlePermissions(store, reconciler, workspacePath, parsed));
       return;
     default:
       throw new Error(
@@ -14103,10 +14065,7 @@ async function handleList(store) {
 async function handleInstall(store, parsed, catalogClient) {
   const remoteId = getStringFlag(parsed, "id");
   if (!remoteId) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --id <remoteAgentId>."
-    );
+    throw createServicemeError("invalid_params", "Expected --id <remoteAgentId>.");
   }
   const agentId = normalizeAgentIdOrThrow(store, remoteId);
   if (!getBooleanFlag(parsed, "confirmed")) {
@@ -14170,19 +14129,13 @@ async function handleInstall(store, parsed, catalogClient) {
 async function handleUninstall(store, workspacePath, parsed) {
   const remoteId = getStringFlag(parsed, "id");
   if (!remoteId) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --id <remoteAgentId>."
-    );
+    throw createServicemeError("invalid_params", "Expected --id <remoteAgentId>.");
   }
   const agentId = normalizeAgentIdOrThrow(store, remoteId);
-  await fs12.rm(
-    path10.join(workspacePath, ".github", "agents", `${agentId}.agent.md`),
-    {
-      recursive: true,
-      force: true
-    }
-  );
+  await fs12.rm(path10.join(workspacePath, ".github", "agents", `${agentId}.agent.md`), {
+    recursive: true,
+    force: true
+  });
   await fs12.rm(path10.join(workspacePath, ".github", "agents", agentId), {
     recursive: true,
     force: true
@@ -14211,22 +14164,11 @@ async function handleMove(store, workspacePath, parsed) {
     );
   }
   if (to !== "workspace" && to !== "user") {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --to value to be workspace or user."
-    );
+    throw createServicemeError("invalid_params", "Expected --to value to be workspace or user.");
   }
   const agentId = normalizeAgentIdOrThrow(store, remoteId);
-  const workspaceFlatPath = path10.join(
-    workspacePath,
-    ".github",
-    "agents",
-    `${agentId}.agent.md`
-  );
-  const userFlatPath = path10.join(
-    store.getUserAgentsRootPath(),
-    `${agentId}.agent.md`
-  );
+  const workspaceFlatPath = path10.join(workspacePath, ".github", "agents", `${agentId}.agent.md`);
+  const userFlatPath = path10.join(store.getUserAgentsRootPath(), `${agentId}.agent.md`);
   if (to === "user") {
     await moveEntry(workspaceFlatPath, userFlatPath);
     return {
@@ -14294,16 +14236,10 @@ async function handlePermissions(store, reconciler, workspacePath, parsed) {
   const remoteId = getStringFlag(parsed, "id");
   const scopeFlag = getStringFlag(parsed, "scope");
   if (!remoteId) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --id <remoteAgentId>."
-    );
+    throw createServicemeError("invalid_params", "Expected --id <remoteAgentId>.");
   }
   if (scopeFlag !== void 0 && scopeFlag !== "workspace" && scopeFlag !== "user") {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --scope value to be workspace or user."
-    );
+    throw createServicemeError("invalid_params", "Expected --scope value to be workspace or user.");
   }
   const agentId = normalizeAgentIdOrThrow(store, remoteId);
   const requestedScope = scopeFlag ?? "workspace";
@@ -14337,10 +14273,7 @@ async function readAgentContent(store, workspacePath, agentId, scope) {
     } catch {
     }
   }
-  throw createServicemeError(
-    "not_found",
-    `Agent file not found for ${agentId} in ${scope} scope.`
-  );
+  throw createServicemeError("not_found", `Agent file not found for ${agentId} in ${scope} scope.`);
 }
 
 // src/commands/bridge.ts
@@ -14352,7 +14285,7 @@ init_src();
 
 // src/version.ts
 var SERVICEME_CLI_NAME = "serviceme";
-var SERVICEME_CLI_VERSION = "0.1.7";
+var SERVICEME_CLI_VERSION = "0.1.8";
 
 // src/bridge/AgentBridgeHandler.ts
 var fs13 = __toESM(require("fs/promises"));
@@ -14360,6 +14293,18 @@ var os3 = __toESM(require("os"));
 var path11 = __toESM(require("path"));
 init_src2();
 init_src();
+
+// src/bridge/marketplaceEnv.ts
+var SERVICEME_MARKETPLACE_BASE_URL_ENV = "SERVICEME_MARKETPLACE_BASE_URL";
+function readMarketplaceBaseUrl() {
+  const raw = process.env[SERVICEME_MARKETPLACE_BASE_URL_ENV];
+  if (typeof raw !== "string" || raw.length === 0) {
+    return void 0;
+  }
+  return raw;
+}
+
+// src/bridge/AgentBridgeHandler.ts
 function normalizeAgentIdOrThrow2(store, remoteId) {
   try {
     return store.normalizeRemoteAgentId(remoteId);
@@ -14402,10 +14347,7 @@ var AgentBridgeHandler = class {
           context.workspacePath,
           context.store.getWorkspaceAgentsRootPath(),
           `${agentId}.agent.md`
-        ) : path11.join(
-          context.store.getUserAgentsRootPath(),
-          `${agentId}.agent.md`
-        ) : void 0,
+        ) : path11.join(context.store.getUserAgentsRootPath(), `${agentId}.agent.md`) : void 0,
         canPublish: agent.canPublish,
         workspaceState: this.makeScopeState(
           "workspace",
@@ -14419,10 +14361,7 @@ var AgentBridgeHandler = class {
         userState: this.makeScopeState(
           "user",
           userInstalled,
-          path11.join(
-            context.store.getUserAgentsRootPath(),
-            `${agentId}.agent.md`
-          )
+          path11.join(context.store.getUserAgentsRootPath(), `${agentId}.agent.md`)
         )
       });
     }
@@ -14459,10 +14398,7 @@ var AgentBridgeHandler = class {
         userState: this.makeScopeState(
           "user",
           userSet.has(agentId),
-          path11.join(
-            context.store.getUserAgentsRootPath(),
-            `${agentId}.agent.md`
-          )
+          path11.join(context.store.getUserAgentsRootPath(), `${agentId}.agent.md`)
         )
       });
     }
@@ -14482,10 +14418,7 @@ var AgentBridgeHandler = class {
         hasConflict: false,
         tools: [],
         source: "local",
-        localAgentPath: path11.join(
-          context.store.getUserAgentsRootPath(),
-          `${agentId}.agent.md`
-        ),
+        localAgentPath: path11.join(context.store.getUserAgentsRootPath(), `${agentId}.agent.md`),
         workspaceState: this.makeScopeState(
           "workspace",
           workspaceSet.has(agentId),
@@ -14498,18 +14431,12 @@ var AgentBridgeHandler = class {
         userState: this.makeScopeState(
           "user",
           true,
-          path11.join(
-            context.store.getUserAgentsRootPath(),
-            `${agentId}.agent.md`
-          )
+          path11.join(context.store.getUserAgentsRootPath(), `${agentId}.agent.md`)
         )
       });
     }
     return {
-      configPath: path11.join(
-        context.workspacePath,
-        context.store.getWorkspaceStateFilePath()
-      ),
+      configPath: path11.join(context.workspacePath, context.store.getWorkspaceStateFilePath()),
       userAgentsPath: context.userAgentsRoot,
       agents: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)),
       installedAgentIds: [.../* @__PURE__ */ new Set([...workspaceAgentIds, ...userAgentIds])],
@@ -14556,7 +14483,10 @@ var AgentBridgeHandler = class {
       workspacePath: resolvedWorkspacePath,
       userAgentsRoot
     });
-    const catalogClient = new AgentCatalogClient();
+    const marketplaceBaseUrl = readMarketplaceBaseUrl();
+    const catalogClient = new AgentCatalogClient(
+      marketplaceBaseUrl ? { baseUrl: marketplaceBaseUrl } : {}
+    );
     const reconciler = new AgentReconciler({
       agentStore: store,
       catalogClient
@@ -14654,10 +14584,7 @@ tools:
     );
   }
   async readAgentContent(context, agentId, scope) {
-    const root2 = scope === "workspace" ? path11.join(
-      context.workspacePath,
-      context.store.getWorkspaceAgentsRootPath()
-    ) : context.store.getUserAgentsRootPath();
+    const root2 = scope === "workspace" ? path11.join(context.workspacePath, context.store.getWorkspaceAgentsRootPath()) : context.store.getUserAgentsRootPath();
     const candidates = [
       path11.join(root2, `${agentId}.agent.md`),
       path11.join(root2, agentId, `${agentId}.agent.md`)
@@ -14730,18 +14657,12 @@ var SkillBridgeHandler = class {
         hasScripts: skill.hasScripts,
         hasHooks: skill.hasHooks,
         source: skill.source,
-        localSkillPath: workspaceInstalled || userInstalled ? workspaceInstalled ? path12.join(
-          context.workspacePath,
-          context.store.getWorkspaceSkillPath(skillId)
-        ) : context.store.getUserSkillPath(skillId) : void 0,
+        localSkillPath: workspaceInstalled || userInstalled ? workspaceInstalled ? path12.join(context.workspacePath, context.store.getWorkspaceSkillPath(skillId)) : context.store.getUserSkillPath(skillId) : void 0,
         canPublish: skill.canPublish,
         workspaceState: this.makeScopeState(
           "workspace",
           workspaceInstalled,
-          path12.join(
-            context.workspacePath,
-            context.store.getWorkspaceSkillPath(skillId)
-          )
+          path12.join(context.workspacePath, context.store.getWorkspaceSkillPath(skillId))
         ),
         userState: this.makeScopeState(
           "user",
@@ -14772,10 +14693,7 @@ var SkillBridgeHandler = class {
         workspaceState: this.makeScopeState(
           "workspace",
           true,
-          path12.join(
-            context.workspacePath,
-            context.store.getWorkspaceSkillPath(skillId)
-          )
+          path12.join(context.workspacePath, context.store.getWorkspaceSkillPath(skillId))
         ),
         userState: this.makeScopeState(
           "user",
@@ -14803,23 +14721,13 @@ var SkillBridgeHandler = class {
         workspaceState: this.makeScopeState(
           "workspace",
           workspaceSet.has(skillId),
-          path12.join(
-            context.workspacePath,
-            context.store.getWorkspaceSkillPath(skillId)
-          )
+          path12.join(context.workspacePath, context.store.getWorkspaceSkillPath(skillId))
         ),
-        userState: this.makeScopeState(
-          "user",
-          true,
-          context.store.getUserSkillPath(skillId)
-        )
+        userState: this.makeScopeState("user", true, context.store.getUserSkillPath(skillId))
       });
     }
     return {
-      configPath: path12.join(
-        context.workspacePath,
-        context.store.getWorkspaceMarkerPath()
-      ),
+      configPath: path12.join(context.workspacePath, context.store.getWorkspaceMarkerPath()),
       userSkillsPath: context.userSkillsRoot,
       skills: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)),
       enabledSkillIds: [],
@@ -14873,10 +14781,7 @@ var SkillBridgeHandler = class {
       skills: workspaceSkillIds.map((skillId) => ({
         id: skillId,
         displayName: skillId,
-        path: path12.join(
-          context.workspacePath,
-          context.store.getWorkspaceSkillPath(skillId)
-        )
+        path: path12.join(context.workspacePath, context.store.getWorkspaceSkillPath(skillId))
       }))
     };
   }
@@ -14887,7 +14792,10 @@ var SkillBridgeHandler = class {
       workspacePath: resolvedWorkspacePath,
       userSkillsRoot
     });
-    const catalogClient = new SkillCatalogClient();
+    const marketplaceBaseUrl = readMarketplaceBaseUrl();
+    const catalogClient = new SkillCatalogClient(
+      marketplaceBaseUrl ? { baseUrl: marketplaceBaseUrl } : {}
+    );
     const reconciler = new SkillReconciler({
       skillStore: store,
       catalogClient
@@ -14974,9 +14882,7 @@ var TaskBridgeHandler = class {
   constructor(logger, emitEvent) {
     this.logger = logger;
     this.emitEvent = emitEvent;
-    this.engine = new TaskExecutionEngine(
-      (taskType) => getExecutor(taskType)
-    );
+    this.engine = new TaskExecutionEngine((taskType) => getExecutor(taskType));
     this.engine.setListener({
       onStarted: (params) => this.emitEvent("task.started", params),
       onOutput: (params) => this.emitEvent("task.output", params),
@@ -15113,10 +15019,7 @@ var BridgeServer = class {
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             if (message.includes("TASK_ALREADY_RUNNING")) {
-              this.writeError(
-                request.id,
-                createServicemeError("task_already_running", message)
-              );
+              this.writeError(request.id, createServicemeError("task_already_running", message));
             } else {
               this.writeError(request.id, err);
             }
@@ -15136,9 +15039,7 @@ var BridgeServer = class {
         }
         case "skill.marketplace-state": {
           const skillRequest = request;
-          const result = await this.skillHandler.getMarketplaceState(
-            skillRequest.params
-          );
+          const result = await this.skillHandler.getMarketplaceState(skillRequest.params);
           this.writeSuccess(request.id, result);
           return;
         }
@@ -15156,17 +15057,13 @@ var BridgeServer = class {
         }
         case "skill.publishable": {
           const skillRequest = request;
-          const result = await this.skillHandler.publishable(
-            skillRequest.params
-          );
+          const result = await this.skillHandler.publishable(skillRequest.params);
           this.writeSuccess(request.id, result);
           return;
         }
         case "agent.marketplace-state": {
           const agentRequest = request;
-          const result = await this.agentHandler.getMarketplaceState(
-            agentRequest.params
-          );
+          const result = await this.agentHandler.getMarketplaceState(agentRequest.params);
           this.writeSuccess(request.id, result);
           return;
         }
@@ -15178,19 +15075,14 @@ var BridgeServer = class {
         }
         case "agent.permissions": {
           const agentRequest = request;
-          const result = await this.agentHandler.permissions(
-            agentRequest.params
-          );
+          const result = await this.agentHandler.permissions(agentRequest.params);
           this.writeSuccess(request.id, result);
           return;
         }
         default:
           this.writeError(
             request.id,
-            createServicemeError(
-              "invalid_params",
-              "Unsupported bridge method."
-            )
+            createServicemeError("invalid_params", "Unsupported bridge method.")
           );
       }
     } catch (error) {
@@ -15293,10 +15185,7 @@ async function runEnvCommand(parsed) {
   const tool = getStringFlag(parsed, "tool");
   if (tool) {
     if (!isKnownEnvironmentTool(tool)) {
-      throw createServicemeError(
-        "invalid_params",
-        `Unsupported environment tool: ${tool}`
-      );
+      throw createServicemeError("invalid_params", `Unsupported environment tool: ${tool}`);
     }
     writeSuccess(await inspector.checkTool(tool));
     return;
@@ -15326,10 +15215,7 @@ async function runImageCommand(parsed) {
     case "compress": {
       const format = getStringFlag(parsed, "format");
       if (format && !IMAGE_FORMATS.has(format)) {
-        throw createServicemeError(
-          "invalid_params",
-          `Unsupported image format: ${format}`
-        );
+        throw createServicemeError("invalid_params", `Unsupported image format: ${format}`);
       }
       const options2 = {
         quality: Number(getStringFlag(parsed, "quality") ?? "75"),
@@ -15342,9 +15228,7 @@ async function runImageCommand(parsed) {
       return;
     }
     default:
-      throw new Error(
-        "Unsupported image command. Use validate, info, or compress."
-      );
+      throw new Error("Unsupported image command. Use validate, info, or compress.");
   }
 }
 
@@ -15391,10 +15275,7 @@ async function runJsonCommand(parsed) {
     }
     case "format":
       writeSuccess({
-        output: jsonTools.format(
-          input,
-          Number(getStringFlag(parsed, "indent") ?? "2")
-        )
+        output: jsonTools.format(input, Number(getStringFlag(parsed, "indent") ?? "2"))
       });
       return;
     case "minify":
@@ -15406,9 +15287,7 @@ async function runJsonCommand(parsed) {
       writeSuccess(jsonTools.validate(input));
       return;
     default:
-      throw new Error(
-        "Unsupported json command. Use sort, format, minify, or validate."
-      );
+      throw new Error("Unsupported json command. Use sort, format, minify, or validate.");
   }
 }
 
@@ -15420,10 +15299,7 @@ async function runProjectCommand(parsed) {
   const action = parsed.positionals[1];
   const workspacePath = getStringFlag(parsed, "workspacePath");
   if (!workspacePath) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --workspacePath <path>."
-    );
+    throw createServicemeError("invalid_params", "Expected --workspacePath <path>.");
   }
   switch (action) {
     case "extract-template": {
@@ -15442,21 +15318,13 @@ async function runProjectCommand(parsed) {
         projectFilePattern
       };
       writeSuccess(
-        await projectTools.extractTemplate(
-          zipPath,
-          workspacePath,
-          tempExtractDir,
-          input
-        )
+        await projectTools.extractTemplate(zipPath, workspacePath, tempExtractDir, input)
       );
       return;
     }
     case "install-deps":
       writeSuccess(
-        await projectTools.installDependencies(
-          workspacePath,
-          getStringFlag(parsed, "command")
-        )
+        await projectTools.installDependencies(workspacePath, getStringFlag(parsed, "command"))
       );
       return;
     case "make-scripts-executable":
@@ -15467,10 +15335,7 @@ async function runProjectCommand(parsed) {
       return;
     case "scaffold-prune":
       writeSuccess(
-        await projectTools.runScaffoldPrune(
-          workspacePath,
-          getStringFlag(parsed, "preset")
-        )
+        await projectTools.runScaffoldPrune(workspacePath, getStringFlag(parsed, "preset"))
       );
       return;
     default:
@@ -15525,26 +15390,17 @@ async function runScheduleCommand(parsed) {
 function requireWorkspace(parsed) {
   const wp = getStringFlag(parsed, "workspacePath");
   if (!wp) {
-    throw createServicemeError(
-      "invalid_params",
-      "Missing required flag: --workspacePath"
-    );
+    throw createServicemeError("invalid_params", "Missing required flag: --workspacePath");
   }
   if (!fs16.existsSync(wp)) {
-    throw createServicemeError(
-      "workspace_not_found",
-      `Workspace path does not exist: ${wp}`
-    );
+    throw createServicemeError("workspace_not_found", `Workspace path does not exist: ${wp}`);
   }
   return wp;
 }
 function requireId(parsed) {
   const id = getStringFlag(parsed, "id");
   if (!id) {
-    throw createServicemeError(
-      "invalid_params",
-      "Missing required flag: --id <task-id>"
-    );
+    throw createServicemeError("invalid_params", "Missing required flag: --id <task-id>");
   }
   return id;
 }
@@ -15565,10 +15421,7 @@ function parsePayload(parsed, taskType) {
     try {
       return JSON.parse(payloadJson);
     } catch {
-      throw createServicemeError(
-        "invalid_payload",
-        "Invalid --payload-json: must be valid JSON"
-      );
+      throw createServicemeError("invalid_payload", "Invalid --payload-json: must be valid JSON");
     }
   }
   switch (taskType) {
@@ -15617,10 +15470,7 @@ function parsePayload(parsed, taskType) {
       };
     }
     default:
-      throw createServicemeError(
-        "invalid_payload",
-        `Unknown task type: ${taskType}`
-      );
+      throw createServicemeError("invalid_payload", `Unknown task type: ${taskType}`);
   }
 }
 function parseScheduleType(schedule) {
@@ -15630,9 +15480,7 @@ function parseScheduleType(schedule) {
 function validateSchedule(schedule) {
   const scheduleType = parseScheduleType(schedule);
   if (scheduleType === "interval") {
-    const match = /^every\s+(\d+)\s*(s|sec|m|min|h|hr|d|day)s?$/i.exec(
-      schedule
-    );
+    const match = /^every\s+(\d+)\s*(s|sec|m|min|h|hr|d|day)s?$/i.exec(schedule);
     if (!match) {
       throw createServicemeError(
         "invalid_schedule",
@@ -15663,11 +15511,7 @@ function filterFields(obj, fields) {
 async function handleCreate(parsed) {
   const wp = requireWorkspace(parsed);
   const name = getStringFlag(parsed, "name");
-  if (!name)
-    throw createServicemeError(
-      "invalid_params",
-      "Missing required flag: --name"
-    );
+  if (!name) throw createServicemeError("invalid_params", "Missing required flag: --name");
   const typeStr = getStringFlag(parsed, "type");
   if (!typeStr)
     throw createServicemeError(
@@ -15682,11 +15526,7 @@ async function handleCreate(parsed) {
     );
   }
   const schedule = getStringFlag(parsed, "schedule");
-  if (!schedule)
-    throw createServicemeError(
-      "invalid_params",
-      "Missing required flag: --schedule"
-    );
+  if (!schedule) throw createServicemeError("invalid_params", "Missing required flag: --schedule");
   validateSchedule(schedule);
   const payload = parsePayload(parsed, taskType);
   const description = getStringFlag(parsed, "description");
@@ -15748,16 +15588,10 @@ function handleGet(parsed) {
   const mgr = new TaskConfigManager(wp);
   const task = mgr.getTask(id);
   if (!task) {
-    throw createServicemeError(
-      "task_not_found",
-      `Task '${id}' does not exist in this workspace`
-    );
+    throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
   }
   const fields = getStringFlag(parsed, "fields");
-  const result = filterFields(
-    task,
-    fields
-  );
+  const result = filterFields(task, fields);
   writeSuccess({ task: result });
 }
 async function handleEdit(parsed) {
@@ -15766,10 +15600,7 @@ async function handleEdit(parsed) {
   const mgr = new TaskConfigManager(wp);
   const existing = mgr.getTask(id);
   if (!existing) {
-    throw createServicemeError(
-      "task_not_found",
-      `Task '${id}' does not exist in this workspace`
-    );
+    throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
   }
   const input = {};
   const name = getStringFlag(parsed, "name");
@@ -15791,10 +15622,7 @@ async function handleEdit(parsed) {
     try {
       input.payload = JSON.parse(payloadJson);
     } catch {
-      throw createServicemeError(
-        "invalid_payload",
-        "Invalid --payload-json: must be valid JSON"
-      );
+      throw createServicemeError("invalid_payload", "Invalid --payload-json: must be valid JSON");
     }
   }
   if (getBooleanFlag(parsed, "dry-run")) {
@@ -15817,10 +15645,7 @@ function handleDelete(parsed) {
   const mgr = new TaskConfigManager(wp);
   const existing = mgr.getTask(id);
   if (!existing) {
-    throw createServicemeError(
-      "task_not_found",
-      `Task '${id}' does not exist in this workspace`
-    );
+    throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
   }
   if (getBooleanFlag(parsed, "dry-run")) {
     writeSuccess({ action: "delete", task: existing });
@@ -15834,19 +15659,13 @@ function handleToggle(parsed) {
   const id = requireId(parsed);
   const enabledStr = getStringFlag(parsed, "enabled");
   if (enabledStr === void 0) {
-    throw createServicemeError(
-      "invalid_params",
-      "Missing required flag: --enabled <true|false>"
-    );
+    throw createServicemeError("invalid_params", "Missing required flag: --enabled <true|false>");
   }
   const enabled = enabledStr !== "false";
   const mgr = new TaskConfigManager(wp);
   const existing = mgr.getTask(id);
   if (!existing) {
-    throw createServicemeError(
-      "task_not_found",
-      `Task '${id}' does not exist in this workspace`
-    );
+    throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
   }
   const task = mgr.toggleTask(id, enabled);
   writeSuccess({ task });
@@ -15857,17 +15676,10 @@ async function handleTrigger(parsed) {
   const mgr = new TaskConfigManager(wp);
   const task = mgr.getTask(id);
   if (!task) {
-    throw createServicemeError(
-      "task_not_found",
-      `Task '${id}' does not exist in this workspace`
-    );
+    throw createServicemeError("task_not_found", `Task '${id}' does not exist in this workspace`);
   }
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const executionPayload = resolveTaskExecutionPayload(
-    task.taskType,
-    task.payload,
-    wp
-  );
+  const executionPayload = resolveTaskExecutionPayload(task.taskType, task.payload, wp);
   validateTaskPayload(task.taskType, executionPayload);
   const executor = getExecutor(task.taskType);
   const result = await executor.execute(executionPayload);
@@ -15892,9 +15704,7 @@ function handleLogs(parsed) {
   const fields = getStringFlag(parsed, "fields");
   const logMgr = new TaskLogManager(wp);
   const { logs, total } = logMgr.getLogs({ taskId, limit });
-  const result = logs.map(
-    (l) => filterFields(l, fields)
-  );
+  const result = logs.map((l) => filterFields(l, fields));
   writeSuccess({ logs: result, total });
 }
 function writeDescribe(action) {
@@ -16097,16 +15907,10 @@ async function runSchedulerCommand(parsed) {
 function requireWorkspace2(parsed) {
   const wp = getStringFlag(parsed, "workspacePath");
   if (!wp) {
-    throw createServicemeError(
-      "invalid_params",
-      "Missing required flag: --workspacePath"
-    );
+    throw createServicemeError("invalid_params", "Missing required flag: --workspacePath");
   }
   if (!fs17.existsSync(wp)) {
-    throw createServicemeError(
-      "workspace_not_found",
-      `Workspace path does not exist: ${wp}`
-    );
+    throw createServicemeError("workspace_not_found", `Workspace path does not exist: ${wp}`);
   }
   return wp;
 }
@@ -16124,10 +15928,7 @@ function handleStart(parsed) {
   }
   const cliPath = process.argv[1];
   if (!cliPath) {
-    throw createServicemeError(
-      "internal_error",
-      "Cannot determine CLI path for daemon spawn"
-    );
+    throw createServicemeError("internal_error", "Cannot determine CLI path for daemon spawn");
   }
   const logPath = path13.join(wp, ".serviceme", "scheduler.log");
   const logDir = path13.dirname(logPath);
@@ -16135,15 +15936,7 @@ function handleStart(parsed) {
     fs17.mkdirSync(logDir, { recursive: true });
   }
   const spawnCmd = process.execPath;
-  const spawnArgs = [
-    cliPath,
-    "scheduler",
-    "__daemon",
-    "--workspacePath",
-    wp,
-    "--logPath",
-    logPath
-  ];
+  const spawnArgs = [cliPath, "scheduler", "__daemon", "--workspacePath", wp, "--logPath", logPath];
   if (process.platform === "win32") {
     fs17.appendFileSync(
       logPath,
@@ -16171,10 +15964,7 @@ function handleStart(parsed) {
   child.unref();
   const pid = child.pid;
   if (pid === void 0) {
-    throw createServicemeError(
-      "internal_error",
-      "Failed to spawn daemon process"
-    );
+    throw createServicemeError("internal_error", "Failed to spawn daemon process");
   }
   pidMgr.writePid(pid);
   writeSuccess({ pid, status: "started", workspacePath: wp });
@@ -16356,10 +16146,7 @@ async function runSkillCommand(parsed) {
   const action = parsed.positionals[1];
   const workspacePath = getStringFlag(parsed, "workspacePath");
   if (!workspacePath) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --workspacePath <path>."
-    );
+    throw createServicemeError("invalid_params", "Expected --workspacePath <path>.");
   }
   const store = new SkillStore({
     workspacePath,
@@ -16377,9 +16164,7 @@ async function runSkillCommand(parsed) {
       writeSuccess(await handleList3(store));
       return;
     case "install":
-      writeSuccess(
-        await handleInstall2(store, workspacePath, parsed, catalogClient)
-      );
+      writeSuccess(await handleInstall2(store, workspacePath, parsed, catalogClient));
       return;
     case "uninstall":
       writeSuccess(await handleUninstall2(store, workspacePath, parsed));
@@ -16415,13 +16200,10 @@ async function handleList3(store) {
     ]
   };
 }
-async function handleInstall2(store, workspacePath, parsed, catalogClient) {
+async function handleInstall2(store, _workspacePath, parsed, catalogClient) {
   const remoteId = getStringFlag(parsed, "id");
   if (!remoteId) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --id <remoteSkillId>."
-    );
+    throw createServicemeError("invalid_params", "Expected --id <remoteSkillId>.");
   }
   const skillId = normalizeSkillIdOrThrow2(store, remoteId);
   if (!getBooleanFlag(parsed, "confirmed")) {
@@ -16479,10 +16261,7 @@ async function handleInstall2(store, workspacePath, parsed, catalogClient) {
 async function handleUninstall2(store, workspacePath, parsed) {
   const remoteId = getStringFlag(parsed, "id");
   if (!remoteId) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --id <remoteSkillId>."
-    );
+    throw createServicemeError("invalid_params", "Expected --id <remoteSkillId>.");
   }
   const skillId = normalizeSkillIdOrThrow2(store, remoteId);
   await fs18.rm(path14.join(workspacePath, store.getWorkspaceSkillPath(skillId)), {
@@ -16508,16 +16287,10 @@ async function handleMove2(store, workspacePath, parsed) {
     );
   }
   if (to !== "workspace" && to !== "user") {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --to value to be workspace or user."
-    );
+    throw createServicemeError("invalid_params", "Expected --to value to be workspace or user.");
   }
   const skillId = normalizeSkillIdOrThrow2(store, remoteId);
-  const workspacePathForSkill = path14.join(
-    workspacePath,
-    store.getWorkspaceSkillPath(skillId)
-  );
+  const workspacePathForSkill = path14.join(workspacePath, store.getWorkspaceSkillPath(skillId));
   const userPathForSkill = store.getUserSkillPath(skillId);
   if (to === "user") {
     await moveDirectory(workspacePathForSkill, userPathForSkill);
@@ -16595,10 +16368,7 @@ async function handleMarketplace2(store, catalogClient) {
 async function handleFind(store, catalogClient, parsed) {
   const query = getStringFlag(parsed, "query") ?? getStringFlag(parsed, "q");
   if (!query) {
-    throw createServicemeError(
-      "invalid_params",
-      "Expected --query <text> or --q <text>."
-    );
+    throw createServicemeError("invalid_params", "Expected --query <text> or --q <text>.");
   }
   const marketplace = await handleMarketplace2(store, catalogClient);
   const loweredQuery = query.toLowerCase();
@@ -16626,10 +16396,7 @@ async function handleReconcile(store, reconciler) {
   }
   const firstWorkspaceSkillId = workspaceSkillIds[0];
   if (!firstWorkspaceSkillId) {
-    throw createServicemeError(
-      "not_found",
-      "No workspace skill id available for gate check."
-    );
+    throw createServicemeError("not_found", "No workspace skill id available for gate check.");
   }
   const gateCheck = await reconciler.mutate({
     skillId: firstWorkspaceSkillId,