nextclaw 0.9.13 → 0.9.15

package/dist/cli/index.js

@@ -26,7 +26,7 @@ import {
   resolvePluginChannelMessageToolHints as resolvePluginChannelMessageToolHints2,
   setPluginRuntimeBridge as setPluginRuntimeBridge2
 } from "@nextclaw/openclaw-compat";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
 import { join as join7, resolve as resolve9 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -185,15 +185,13 @@ function parseSessionKey(sessionKey) {
   };
 }
 
-// src/cli/skills/clawhub.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { isAbsolute, join, resolve as resolve2 } from "path";
-async function installClawHubSkill(options) {
-  const slug = options.slug.trim();
-  if (!slug) {
-    throw new Error("Skill slug is required.");
-  }
+// src/cli/skills/marketplace.ts
+import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve as resolve2 } from "path";
+import { SkillsLoader } from "@nextclaw/core";
+var DEFAULT_MARKETPLACE_API_BASE = "https://marketplace-api.nextclaw.io";
+async function installMarketplaceSkill(options) {
+  const slug = validateSkillSlug(options.slug.trim(), "slug");
   const workdir = resolve2(options.workdir);
   if (!existsSync2(workdir)) {
     throw new Error(`Workdir does not exist: ${workdir}`);
@@ -205,62 +203,256 @@ async function installClawHubSkill(options) {
     if (existsSync2(skillFile)) {
       return {
         slug,
-        version: options.version,
-        registry: options.registry,
         destinationDir,
-        alreadyInstalled: true
+        alreadyInstalled: true,
+        source: "marketplace"
       };
     }
     throw new Error(`Skill directory already exists: ${destinationDir} (use --force)`);
   }
-  const args = buildClawHubArgs(slug, options);
-  const result = spawnSync("npx", args, {
-    cwd: workdir,
-    stdio: "pipe",
-    env: process.env
-  });
-  if (result.error) {
-    throw new Error(`Failed to run npx clawhub: ${String(result.error)}`);
+  const apiBase = resolveMarketplaceApiBase(options.apiBaseUrl);
+  const item = await fetchMarketplaceSkillItem(apiBase, slug);
+  if (item.install.kind === "builtin") {
+    if (existsSync2(destinationDir) && options.force) {
+      rmSync2(destinationDir, { recursive: true, force: true });
+    }
+    installBuiltinSkill(workdir, destinationDir, slug);
+    return {
+      slug,
+      destinationDir,
+      source: "builtin"
+    };
+  }
+  const filesPayload = await fetchMarketplaceSkillFiles(apiBase, slug);
+  if (existsSync2(destinationDir) && options.force) {
+    rmSync2(destinationDir, { recursive: true, force: true });
   }
-  if (result.status !== 0) {
-    const stdout = result.stdout ? String(result.stdout).trim() : "";
-    const stderr = result.stderr ? String(result.stderr).trim() : "";
-    const details = [stderr, stdout].filter(Boolean).join("\n");
-    throw new Error(details || `clawhub install failed with code ${result.status ?? 1}`);
+  mkdirSync2(destinationDir, { recursive: true });
+  for (const file of filesPayload.files) {
+    const targetPath = resolve2(destinationDir, ...file.path.split("/"));
+    const rel = relative(destinationDir, targetPath);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      throw new Error(`Invalid marketplace file path: ${file.path}`);
+    }
+    mkdirSync2(dirname(targetPath), { recursive: true });
+    writeFileSync2(targetPath, Buffer.from(file.contentBase64, "base64"));
+  }
+  if (!existsSync2(join(destinationDir, "SKILL.md"))) {
+    throw new Error(`Marketplace skill ${slug} does not include SKILL.md`);
   }
   return {
     slug,
-    version: options.version,
-    registry: options.registry,
-    destinationDir
+    destinationDir,
+    source: "marketplace"
   };
 }
-function buildClawHubArgs(slug, options) {
-  const args = ["--yes", "clawhub", "install", slug];
-  if (options.version) {
-    args.push("--version", options.version);
+async function publishMarketplaceSkill(options) {
+  const skillDir = resolve2(options.skillDir);
+  if (!existsSync2(skillDir)) {
+    throw new Error(`Skill directory not found: ${skillDir}`);
+  }
+  const files = collectFiles(skillDir);
+  if (!files.some((file) => file.path === "SKILL.md")) {
+    throw new Error(`Skill directory must include SKILL.md: ${skillDir}`);
+  }
+  const parsedFrontmatter = parseSkillFrontmatter(readFileSync2(join(skillDir, "SKILL.md"), "utf8"));
+  const slug = validateSkillSlug(options.slug?.trim() || basename(skillDir), "slug");
+  const name = options.name?.trim() || parsedFrontmatter.name || slug;
+  const description = options.description?.trim() || parsedFrontmatter.description;
+  const summary = options.summary?.trim() || parsedFrontmatter.summary || description || `${slug} skill`;
+  const author = options.author?.trim() || parsedFrontmatter.author || "nextclaw";
+  const tags = normalizeTags(options.tags && options.tags.length > 0 ? options.tags : parsedFrontmatter.tags);
+  const apiBase = resolveMarketplaceApiBase(options.apiBaseUrl);
+  const token = resolveMarketplaceAdminToken(options.token);
+  if (options.requireExisting) {
+    await fetchMarketplaceSkillItem(apiBase, slug);
+  }
+  const response = await fetch(`${apiBase}/api/v1/admin/skills/upsert`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify({
+      slug,
+      name,
+      summary,
+      description,
+      author,
+      tags,
+      sourceRepo: options.sourceRepo?.trim() || void 0,
+      homepage: options.homepage?.trim() || void 0,
+      publishedAt: options.publishedAt?.trim() || void 0,
+      updatedAt: options.updatedAt?.trim() || void 0,
+      files
+    })
+  });
+  const payload = await readMarketplaceEnvelope(response);
+  if (!payload.ok || !payload.data) {
+    const message = payload.error?.message || `marketplace publish failed: HTTP ${response.status}`;
+    throw new Error(message);
   }
-  if (options.registry) {
-    args.push("--registry", options.registry);
+  return {
+    created: payload.data.created,
+    slug,
+    fileCount: payload.data.fileCount
+  };
+}
+function collectFiles(rootDir) {
+  const output = [];
+  const walk = (dir, prefix) => {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = join(dir, entry.name);
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(absolute, relativePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const content = readFileSync2(absolute);
+      output.push({
+        path: relativePath,
+        contentBase64: content.toString("base64")
+      });
+    }
+  };
+  walk(rootDir, "");
+  return output;
+}
+function installBuiltinSkill(workdir, destinationDir, skillName) {
+  const loader = new SkillsLoader(workdir);
+  const builtin = loader.listSkills(false).find((skill) => skill.name === skillName && skill.source === "builtin");
+  if (!builtin) {
+    throw new Error(`Builtin skill not found in local core bundle: ${skillName}`);
   }
-  if (options.workdir) {
-    args.push("--workdir", options.workdir);
+  cpSync(dirname(builtin.path), destinationDir, { recursive: true, force: true });
+}
+async function fetchMarketplaceSkillItem(apiBase, slug) {
+  const response = await fetch(`${apiBase}/api/v1/skills/items/${encodeURIComponent(slug)}`, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  const payload = await readMarketplaceEnvelope(response);
+  if (!payload.ok || !payload.data) {
+    const message = payload.error?.message || `marketplace skill fetch failed: ${response.status}`;
+    throw new Error(message);
   }
-  if (options.dir) {
-    args.push("--dir", options.dir);
+  const kind = payload.data.install?.kind;
+  if (kind !== "builtin" && kind !== "marketplace") {
+    throw new Error(`Unsupported skill install kind from marketplace: ${String(kind)}`);
   }
-  if (options.force) {
-    args.push("--force");
+  return {
+    install: {
+      kind
+    }
+  };
+}
+async function fetchMarketplaceSkillFiles(apiBase, slug) {
+  const response = await fetch(`${apiBase}/api/v1/skills/items/${encodeURIComponent(slug)}/files`, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  const payload = await readMarketplaceEnvelope(response);
+  if (!payload.ok || !payload.data) {
+    const message = payload.error?.message || `marketplace skill file fetch failed: ${response.status}`;
+    throw new Error(message);
   }
-  return args;
+  return payload.data;
+}
+async function readMarketplaceEnvelope(response) {
+  const raw = await response.text();
+  let payload;
+  try {
+    payload = raw.length > 0 ? JSON.parse(raw) : null;
+  } catch {
+    throw new Error(`Invalid marketplace response: ${response.status}`);
+  }
+  if (!isRecord(payload) || typeof payload.ok !== "boolean") {
+    throw new Error(`Invalid marketplace response shape: ${response.status}`);
+  }
+  return payload;
+}
+function resolveMarketplaceApiBase(explicitBase) {
+  const raw = explicitBase?.trim() || process.env.NEXTCLAW_MARKETPLACE_API_BASE?.trim() || DEFAULT_MARKETPLACE_API_BASE;
+  return raw.replace(/\/+$/, "");
+}
+function resolveMarketplaceAdminToken(explicitToken) {
+  const token = explicitToken?.trim() || process.env.NEXTCLAW_MARKETPLACE_ADMIN_TOKEN?.trim();
+  return token && token.length > 0 ? token : void 0;
+}
+function validateSkillSlug(raw, fieldName) {
+  if (!/^[A-Za-z0-9._-]+$/.test(raw)) {
+    throw new Error(`Invalid ${fieldName}: ${raw}`);
+  }
+  return raw;
+}
+function normalizeTags(rawTags) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const rawTag of rawTags ?? []) {
+    const tag = rawTag.trim();
+    if (!tag || seen.has(tag)) {
+      continue;
+    }
+    seen.add(tag);
+    output.push(tag);
+  }
+  return output.length > 0 ? output : ["skill"];
+}
+function parseSkillFrontmatter(raw) {
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  if (!match || !match[1]) {
+    return {};
+  }
+  const metadata = /* @__PURE__ */ new Map();
+  for (const line of match[1].split("\n")) {
+    const parsed = line.match(/^([A-Za-z0-9_-]+):\s*(.+)$/);
+    if (!parsed) {
+      continue;
+    }
+    const key = parsed[1]?.trim().toLowerCase();
+    const value = parsed[2]?.trim();
+    if (!key || !value) {
+      continue;
+    }
+    metadata.set(key, trimYamlString(value));
+  }
+  const rawTags = metadata.get("tags");
+  let tags;
+  if (rawTags) {
+    if (rawTags.startsWith("[") && rawTags.endsWith("]")) {
+      tags = rawTags.slice(1, -1).split(",").map((entry) => trimYamlString(entry)).filter(Boolean);
+    } else {
+      tags = rawTags.split(",").map((entry) => entry.trim()).filter(Boolean);
+    }
+  }
+  return {
+    name: metadata.get("name"),
+    summary: metadata.get("summary"),
+    description: metadata.get("description"),
+    author: metadata.get("author"),
+    tags
+  };
+}
+function trimYamlString(raw) {
+  return raw.replace(/^['"]/, "").replace(/['"]$/, "").trim();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/cli/update/runner.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 import { resolve as resolve4 } from "path";
 
 // src/cli/utils.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, rmSync as rmSync3 } from "fs";
 import { join as join2, resolve as resolve3 } from "path";
 import { spawn } from "child_process";
 import { isIP } from "net";
@@ -319,7 +511,7 @@ function readServiceState() {
     return null;
   }
   try {
-    const raw = readFileSync2(path, "utf-8");
+    const raw = readFileSync3(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -327,13 +519,13 @@ function readServiceState() {
 }
 function writeServiceState(state) {
   const path = resolveServiceStatePath();
-  mkdirSync2(resolve3(path, ".."), { recursive: true });
-  writeFileSync2(path, JSON.stringify(state, null, 2));
+  mkdirSync3(resolve3(path, ".."), { recursive: true });
+  writeFileSync3(path, JSON.stringify(state, null, 2));
 }
 function clearServiceState() {
   const path = resolveServiceStatePath();
   if (existsSync3(path)) {
-    rmSync2(path, { force: true });
+    rmSync3(path, { force: true });
   }
 }
 function resolveServiceStatePath() {
@@ -467,7 +659,7 @@ function resolveVersionFromPackageTree(startDir, expectedName) {
     const pkgPath = join2(current, "package.json");
     if (existsSync3(pkgPath)) {
       try {
-        const raw = readFileSync2(pkgPath, "utf-8");
+        const raw = readFileSync3(pkgPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (typeof parsed.version === "string") {
           if (!expectedName || parsed.name === expectedName) {
@@ -514,7 +706,7 @@ function runSelfUpdate(options = {}) {
     return { cmd: process.env.SHELL || "sh", args: ["-c", command] };
   };
   const runStep = (cmd, args, cwd) => {
-    const result = spawnSync2(cmd, args, {
+    const result = spawnSync(cmd, args, {
       cwd,
       encoding: "utf-8",
       timeout: timeoutMs,
@@ -1389,7 +1581,7 @@ var ConfigCommands = class {
 };
 
 // src/cli/commands/secrets.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import {
   buildReloadPlan as buildReloadPlan2,
   diffConfigPaths as diffConfigPaths2,
@@ -1632,7 +1824,7 @@ var SecretsCommands = class {
       nextConfig.secrets.enabled = false;
     }
     if (opts.file) {
-      const raw = readFileSync3(opts.file, "utf-8");
+      const raw = readFileSync4(opts.file, "utf-8");
       const patch = parseApplyFile(raw);
       if (patch.defaults) {
         nextConfig.secrets.defaults = patch.defaults;
@@ -1712,7 +1904,7 @@ var SecretsCommands = class {
 };
 
 // src/cli/commands/channels.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { getWorkspacePath as getWorkspacePath2, loadConfig as loadConfig4, saveConfig as saveConfig4 } from "@nextclaw/core";
 import { BUILTIN_CHANNEL_PLUGIN_IDS, builtinProviderIds as builtinProviderIds2 } from "@nextclaw/runtime";
 import { buildPluginStatusReport as buildPluginStatusReport2, enablePluginInConfig as enablePluginInConfig2, getPluginChannelBindings } from "@nextclaw/openclaw-compat";
@@ -1762,7 +1954,7 @@ var ChannelCommands = class {
     const bridgeDir = this.deps.getBridgeDir();
     console.log(`${this.deps.logo} Starting bridge...`);
     console.log("Scan the QR code to connect.\n");
-    const result = spawnSync3("npm", ["start"], { cwd: bridgeDir, stdio: "inherit" });
+    const result = spawnSync2("npm", ["start"], { cwd: bridgeDir, stdio: "inherit" });
     if (result.status !== 0) {
       console.error(`Bridge failed: ${result.status ?? 1}`);
     }
@@ -1903,7 +2095,7 @@ var CronCommands = class {
 
 // src/cli/commands/diagnostics.ts
 import { createServer as createNetServer } from "net";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { resolve as resolve6 } from "path";
 import {
   APP_NAME,
@@ -2212,7 +2404,7 @@ var DiagnosticsCommands = class {
       return [];
     }
     try {
-      const lines = readFileSync4(path, "utf-8").split(/\r?\n/).filter(Boolean);
+      const lines = readFileSync5(path, "utf-8").split(/\r?\n/).filter(Boolean);
       if (lines.length <= maxLines) {
         return lines;
       }
@@ -2252,9 +2444,8 @@ import {
   stopPluginChannelGateways
 } from "@nextclaw/openclaw-compat";
 import { startUiServer } from "@nextclaw/server";
-import { appendFileSync, closeSync, cpSync, existsSync as existsSync8, mkdirSync as mkdirSync4, mkdtempSync, openSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname, isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve7 } from "path";
-import { tmpdir } from "os";
+import { appendFileSync, closeSync, cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, openSync, rmSync as rmSync4 } from "fs";
+import { dirname as dirname2, join as join5, resolve as resolve7 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
@@ -2263,7 +2454,7 @@ import chokidar from "chokidar";
 
 // src/cli/gateway/controller.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 import {
   buildConfigSchema,
   ConfigSchema,
@@ -2276,7 +2467,7 @@ var readConfigSnapshot = (getConfigPath5) => {
   let raw = "";
   let parsed = {};
   if (existsSync6(path)) {
-    raw = readFileSync5(path, "utf-8");
+    raw = readFileSync6(path, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -2715,6 +2906,7 @@ var MissingProvider = class extends LLMProvider {
 // src/cli/commands/agent-runtime-pool.ts
 import {
   NativeAgentEngine,
+  CommandRegistry,
   AgentRouteResolver,
   getWorkspacePath as getWorkspacePath4,
   parseAgentScopedSessionKey
@@ -2804,6 +2996,14 @@ var GatewayAgentRuntimePool = class {
       metadata: params.metadata,
       agentId: params.agentId
     });
+    const commandResult = await this.executeDirectCommand(params.content, {
+      channel: message.channel,
+      chatId: message.chatId,
+      sessionKey: route.sessionKey
+    });
+    if (commandResult) {
+      return commandResult;
+    }
     const runtime2 = this.resolveRuntime(route.agentId);
     return runtime2.engine.processDirect({
       content: params.content,
@@ -2816,6 +3016,42 @@ var GatewayAgentRuntimePool = class {
       onSessionEvent: params.onSessionEvent
     });
   }
+  async executeDirectCommand(rawContent, ctx) {
+    const trimmed = rawContent.trim();
+    if (!trimmed.startsWith("/")) {
+      return null;
+    }
+    const registry = new CommandRegistry(this.options.config, this.options.sessionManager);
+    const executeText = registry.executeText;
+    if (typeof executeText === "function") {
+      const result2 = await executeText.call(registry, rawContent, {
+        channel: ctx.channel,
+        chatId: ctx.chatId,
+        senderId: "user",
+        sessionKey: ctx.sessionKey
+      });
+      return result2?.content ?? null;
+    }
+    const commandRaw = trimmed.slice(1).trim();
+    if (!commandRaw) {
+      return null;
+    }
+    const [nameToken, ...restTokens] = commandRaw.split(/\s+/);
+    const commandName = nameToken.trim().toLowerCase();
+    if (!commandName) {
+      return null;
+    }
+    const commandTail = restTokens.join(" ").trim();
+    const specs = registry.listSlashCommands();
+    const args = parseCommandArgsFromText(commandName, commandTail, specs);
+    const result = await registry.execute(commandName, args, {
+      channel: ctx.channel,
+      chatId: ctx.chatId,
+      senderId: "user",
+      sessionKey: ctx.sessionKey
+    });
+    return result?.content ?? null;
+  }
   supportsTurnAbort(params) {
     const { route } = this.resolveDirectRoute({
       content: "",
@@ -2988,9 +3224,57 @@ var GatewayAgentRuntimePool = class {
     this.runtimes = nextRuntimes;
   }
 };
+function parseCommandArgsFromText(commandName, rawTail, specs) {
+  if (!rawTail) {
+    return {};
+  }
+  const command = specs.find((item) => item.name.trim().toLowerCase() === commandName);
+  const options = command?.options;
+  if (!options || options.length === 0) {
+    return {};
+  }
+  const tokens = rawTail.split(/\s+/).filter(Boolean);
+  const args = {};
+  let cursor = 0;
+  for (let i = 0; i < options.length; i += 1) {
+    if (cursor >= tokens.length) {
+      break;
+    }
+    const option = options[i];
+    const isLastOption = i === options.length - 1;
+    const rawValue = isLastOption ? tokens.slice(cursor).join(" ") : tokens[cursor];
+    cursor += isLastOption ? tokens.length - cursor : 1;
+    const parsedValue = parseCommandOptionValue(option.type, rawValue);
+    if (parsedValue !== void 0) {
+      args[option.name] = parsedValue;
+    }
+  }
+  return args;
+}
+function parseCommandOptionValue(type, rawValue) {
+  const value = rawValue.trim();
+  if (!value) {
+    return void 0;
+  }
+  if (type === "number") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  if (type === "boolean") {
+    const lowered = value.toLowerCase();
+    if (["1", "true", "yes", "on"].includes(lowered)) {
+      return true;
+    }
+    if (["0", "false", "no", "off"].includes(lowered)) {
+      return false;
+    }
+    return void 0;
+  }
+  return value;
+}
 
 // src/cli/commands/ui-chat-run-coordinator.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
 import {
   getDataDir as getDataDir5,
@@ -3004,7 +3288,7 @@ function createRunId() {
   const rand = Math.random().toString(36).slice(2, 10);
   return `run-${now}-${rand}`;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalString(value) {
@@ -3035,7 +3319,7 @@ function cloneEvent(event) {
 var UiChatRunCoordinator = class {
   constructor(options) {
     this.options = options;
-    mkdirSync3(RUNS_DIR, { recursive: true });
+    mkdirSync4(RUNS_DIR, { recursive: true });
     this.loadPersistedRuns();
   }
   runs = /* @__PURE__ */ new Map();
@@ -3172,7 +3456,7 @@ var UiChatRunCoordinator = class {
     const parsedAgentId = parseAgentScopedSessionKey2(sessionKey)?.agentId;
     const agentId = explicitAgentId ?? readOptionalString(parsedAgentId);
     const model = readOptionalString(input.model);
-    const metadata = isRecord(input.metadata) ? { ...input.metadata } : {};
+    const metadata = isRecord2(input.metadata) ? { ...input.metadata } : {};
     if (model) {
       metadata.model = model;
     }
@@ -3414,20 +3698,20 @@ var UiChatRunCoordinator = class {
       ...typeof run.reply === "string" ? { reply: run.reply } : {},
       events: run.events
     };
-    writeFileSync3(this.getRunPath(run.runId), `${JSON.stringify(persisted, null, 2)}
+    writeFileSync4(this.getRunPath(run.runId), `${JSON.stringify(persisted, null, 2)}
 `);
   }
   loadPersistedRuns() {
     if (!existsSync7(RUNS_DIR)) {
       return;
     }
-    for (const entry of readdirSync(RUNS_DIR, { withFileTypes: true })) {
+    for (const entry of readdirSync2(RUNS_DIR, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
       }
       const path = join4(RUNS_DIR, entry.name);
       try {
-        const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+        const parsed = JSON.parse(readFileSync7(path, "utf-8"));
         const runId = readOptionalString(parsed.runId);
         const sessionKey = readOptionalString(parsed.sessionKey);
         if (!runId || !sessionKey) {
@@ -3508,6 +3792,42 @@ function createSkillsLoader(workspace) {
   }
   return new ctor(workspace);
 }
+function containsAbsoluteFsPath(line) {
+  const normalized = line.trim();
+  if (!normalized) {
+    return false;
+  }
+  const lowered = normalized.toLowerCase();
+  if (lowered.includes("http://") || lowered.includes("https://")) {
+    return false;
+  }
+  if (/^[A-Za-z]:\\/.test(normalized)) {
+    return true;
+  }
+  return /(?:^|\s)(?:~\/|\/[^\s]+)/.test(normalized);
+}
+function pickUserFacingCommandSummary(output, fallback) {
+  const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) {
+    return fallback;
+  }
+  const visibleLines = lines.filter((line) => {
+    if (/^(path|install path|source path|destination|location)\s*:/i.test(line)) {
+      return false;
+    }
+    if (containsAbsoluteFsPath(line)) {
+      return false;
+    }
+    return true;
+  });
+  if (visibleLines.length === 0) {
+    return fallback;
+  }
+  const preferred = [...visibleLines].reverse().find(
+    (line) => /\b(installed|enabled|disabled|uninstalled|published|updated|already installed|removed)\b/i.test(line)
+  );
+  return preferred ?? visibleLines[visibleLines.length - 1] ?? fallback;
+}
 var ServiceCommands = class {
   constructor(deps) {
     this.deps = deps;
@@ -3911,7 +4231,7 @@ var ServiceCommands = class {
     }
     const logPath = resolveServiceLogPath();
     const logDir = resolve7(logPath, "..");
-    mkdirSync4(logDir, { recursive: true });
+    mkdirSync5(logDir, { recursive: true });
     const logFd = openSync(logPath, "a");
     const readinessTimeoutMs = this.resolveStartupTimeoutMs(options.startupTimeoutMs);
     const quickPhaseTimeoutMs = Math.min(8e3, readinessTimeoutMs);
@@ -4311,8 +4631,8 @@ var ServiceCommands = class {
   }
   async installMarketplacePlugin(spec) {
     const output = await this.runCliSubcommand(["plugins", "install", spec]);
-    const summary = this.pickLastOutputLine(output) ?? `Installed plugin: ${spec}`;
-    return { message: summary, output };
+    const summary = pickUserFacingCommandSummary(output, `Installed plugin: ${spec}`);
+    return { message: summary };
   }
   async installMarketplaceSkill(params) {
     if (params.kind === "builtin") {
@@ -4322,23 +4642,17 @@ var ServiceCommands = class {
       }
       return result;
     }
-    if (params.kind === "git") {
-      return await this.installGitMarketplaceSkill(params);
+    if (params.kind && params.kind !== "marketplace") {
+      throw new Error(`Unsupported marketplace skill kind: ${params.kind}`);
     }
     const args = ["skills", "install", params.slug];
-    if (params.version) {
-      args.push("--version", params.version);
-    }
-    if (params.registry) {
-      args.push("--registry", params.registry);
-    }
     if (params.force) {
       args.push("--force");
     }
     try {
       const output = await this.runCliSubcommand(args);
-      const summary = this.pickLastOutputLine(output) ?? `Installed skill: ${params.slug}`;
-      return { message: summary, output };
+      const summary = pickUserFacingCommandSummary(output, `Installed skill: ${params.slug}`);
+      return { message: summary };
     } catch (error) {
       const fallback = this.installBuiltinMarketplaceSkill(params.slug, params.force);
       if (!fallback) {
@@ -4347,258 +4661,20 @@ var ServiceCommands = class {
       return fallback;
     }
   }
-  async installGitMarketplaceSkill(params) {
-    const source = params.slug.trim();
-    if (!source) {
-      throw new Error("Git skill source is required");
-    }
-    const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
-    const skillName = this.resolveGitSkillName(params.skill, source);
-    const destination = this.resolveSkillInstallPath(workspace, params.installPath, skillName);
-    const destinationSkillFile = join5(destination, "SKILL.md");
-    if (existsSync8(destinationSkillFile) && !params.force) {
-      return {
-        message: `${skillName} is already installed`,
-        output: destination
-      };
-    }
-    if (existsSync8(destination) && !params.force) {
-      throw new Error(`Skill install path already exists: ${destination} (use force to overwrite)`);
-    }
-    if (existsSync8(destination) && params.force) {
-      rmSync3(destination, { recursive: true, force: true });
-    }
-    const materialized = await this.materializeMarketplaceGitSkillSource({ source, skillName });
-    try {
-      const installSkillFile = join5(materialized.skillDir, "SKILL.md");
-      if (!existsSync8(installSkillFile)) {
-        throw new Error(`git skill source does not contain SKILL.md for ${skillName}`);
-      }
-      mkdirSync4(dirname(destination), { recursive: true });
-      cpSync(materialized.skillDir, destination, { recursive: true, force: true });
-      return {
-        message: `Installed skill: ${skillName}`,
-        output: [
-          `Source: ${source}`,
-          `Materialized skill: ${materialized.skillDir}`,
-          `Workspace target: ${destination}`,
-          materialized.commandOutput
-        ].filter(Boolean).join("\n")
-      };
-    } finally {
-      rmSync3(materialized.tempRoot, { recursive: true, force: true });
-    }
-  }
-  async materializeMarketplaceGitSkillSource(params) {
-    const parsed = this.parseMarketplaceGitSkillSource(params.source);
-    const gitPath = this.resolveGitExecutablePath();
-    const fallbackNotes = [];
-    if (gitPath) {
-      try {
-        return await this.materializeMarketplaceGitSkillViaGit({ gitPath, parsed });
-      } catch (error) {
-        fallbackNotes.push(`Git fast path failed: ${String(error)}`);
-      }
-    } else {
-      fallbackNotes.push("Git fast path unavailable: git executable not found");
-    }
-    const httpResult = await this.materializeMarketplaceGitSkillViaGithubApi(parsed);
-    return {
-      ...httpResult,
-      commandOutput: [...fallbackNotes, httpResult.commandOutput].filter(Boolean).join("\n")
-    };
-  }
-  resolveGitExecutablePath() {
-    return findExecutableOnPath("git");
-  }
-  async materializeMarketplaceGitSkillViaGit(params) {
-    const tempRoot = mkdtempSync(join5(tmpdir(), "nextclaw-marketplace-skill-"));
-    const repoDir = join5(tempRoot, "repo");
-    try {
-      const cloneArgs = ["clone", "--depth", "1", "--filter=blob:none", "--sparse"];
-      if (params.parsed.ref) {
-        cloneArgs.push("--branch", params.parsed.ref);
-      }
-      cloneArgs.push(params.parsed.repoUrl, repoDir);
-      const cloneResult = await this.runCommand(params.gitPath, cloneArgs, {
-        cwd: tempRoot,
-        timeoutMs: 18e4
-      });
-      const sparseResult = await this.runCommand(params.gitPath, ["-C", repoDir, "sparse-checkout", "set", params.parsed.skillPath], {
-        cwd: tempRoot,
-        timeoutMs: 6e4
-      });
-      const skillDir = join5(repoDir, params.parsed.skillPath);
-      return {
-        tempRoot,
-        skillDir,
-        commandOutput: [
-          "Installer path: git-sparse",
-          `Git repository: ${params.parsed.repoUrl}`,
-          `Git path: ${params.parsed.skillPath}`,
-          this.mergeCommandOutput(cloneResult.stdout, cloneResult.stderr),
-          this.mergeCommandOutput(sparseResult.stdout, sparseResult.stderr)
-        ].filter(Boolean).join("\n")
-      };
-    } catch (error) {
-      rmSync3(tempRoot, { recursive: true, force: true });
-      throw error;
-    }
-  }
-  async materializeMarketplaceGitSkillViaGithubApi(parsed) {
-    const tempRoot = mkdtempSync(join5(tmpdir(), "nextclaw-marketplace-skill-"));
-    const skillDir = join5(tempRoot, "skill");
-    const downloadedFiles = [];
-    try {
-      mkdirSync4(skillDir, { recursive: true });
-      await this.downloadGithubDirectoryToPath({
-        parsed,
-        remotePath: parsed.skillPath,
-        localDir: skillDir,
-        relativePrefix: "",
-        downloadedFiles
-      });
-      return {
-        tempRoot,
-        skillDir,
-        commandOutput: [
-          "Installer path: github-http",
-          `Git repository: ${parsed.repoUrl}`,
-          `Git path: ${parsed.skillPath}`,
-          `Downloaded files: ${downloadedFiles.length}`
-        ].join("\n")
-      };
-    } catch (error) {
-      rmSync3(tempRoot, { recursive: true, force: true });
-      throw error;
-    }
-  }
-  async downloadGithubDirectoryToPath(params) {
-    const encodedPath = params.remotePath.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
-    const apiUrl = new URL(`https://api.github.com/repos/${params.parsed.owner}/${params.parsed.repo}/contents/${encodedPath}`);
-    if (params.parsed.ref) {
-      apiUrl.searchParams.set("ref", params.parsed.ref);
-    }
-    const payload = await this.fetchJsonWithHeaders(apiUrl.toString(), {
-      Accept: "application/vnd.github+json",
-      "User-Agent": `${APP_NAME2}/${getPackageVersion()}`
-    });
-    if (!Array.isArray(payload)) {
-      throw new Error(`GitHub path is not a directory: ${params.remotePath}`);
-    }
-    for (const entry of payload) {
-      if (!entry || typeof entry !== "object") {
-        continue;
-      }
-      const item = entry;
-      const itemName = typeof item.name === "string" ? item.name.trim() : "";
-      const itemPath = typeof item.path === "string" ? item.path.trim() : "";
-      if (!itemName || !itemPath) {
-        continue;
-      }
-      if (item.type === "dir") {
-        const childLocalDir = join5(params.localDir, itemName);
-        mkdirSync4(childLocalDir, { recursive: true });
-        await this.downloadGithubDirectoryToPath({
-          parsed: params.parsed,
-          remotePath: itemPath,
-          localDir: childLocalDir,
-          relativePrefix: params.relativePrefix ? `${params.relativePrefix}/${itemName}` : itemName,
-          downloadedFiles: params.downloadedFiles
-        });
-        continue;
-      }
-      if (item.type !== "file") {
-        throw new Error(`Unsupported GitHub skill entry type: ${item.type ?? "unknown"}`);
-      }
-      if (!item.download_url) {
-        throw new Error(`GitHub skill file missing download_url: ${itemPath}`);
-      }
-      const content = await this.fetchBinaryWithHeaders(item.download_url, {
-        "User-Agent": `${APP_NAME2}/${getPackageVersion()}`
-      });
-      const localFile = join5(params.localDir, itemName);
-      writeFileSync4(localFile, content);
-      params.downloadedFiles.push(params.relativePrefix ? `${params.relativePrefix}/${itemName}` : itemName);
-    }
-  }
-  async fetchJsonWithHeaders(url, headers) {
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status} when fetching ${url}`);
-    }
-    return await response.json();
-  }
-  async fetchBinaryWithHeaders(url, headers) {
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status} when downloading ${url}`);
-    }
-    const bytes = await response.arrayBuffer();
-    return Buffer.from(bytes);
-  }
-  parseMarketplaceGitSkillSource(source) {
-    const trimmed = source.trim();
-    if (!trimmed) {
-      throw new Error("Git skill source is required");
-    }
-    if (trimmed.includes("://")) {
-      const parsedUrl = new URL(trimmed);
-      if (parsedUrl.hostname !== "github.com") {
-        throw new Error(`Unsupported git skill source host: ${parsedUrl.hostname}`);
-      }
-      const parts2 = parsedUrl.pathname.split("/").filter(Boolean);
-      if (parts2.length < 5 || parts2[2] !== "tree" && parts2[2] !== "blob") {
-        throw new Error(`Unsupported GitHub skill source URL: ${source}`);
-      }
-      const [owner2, repoRaw, , ref2, ...pathParts2] = parts2;
-      const repo2 = repoRaw.replace(/\.git$/i, "");
-      if (!owner2 || !repo2 || !ref2 || pathParts2.length === 0) {
-        throw new Error(`Unsupported GitHub skill source URL: ${source}`);
-      }
-      return {
-        owner: owner2,
-        repo: repo2,
-        repoUrl: `https://github.com/${owner2}/${repo2}.git`,
-        skillPath: pathParts2.join("/"),
-        ref: ref2
-      };
-    }
-    const parts = trimmed.split("/").filter(Boolean);
-    if (parts.length < 3) {
-      throw new Error(`Unsupported git skill source: ${source}`);
-    }
-    const owner = parts[0] ?? "";
-    const repoWithOptionalRef = parts[1] ?? "";
-    const pathParts = parts.slice(2);
-    const atIndex = repoWithOptionalRef.indexOf("@");
-    const repo = (atIndex >= 0 ? repoWithOptionalRef.slice(0, atIndex) : repoWithOptionalRef).replace(/\.git$/i, "");
-    const ref = atIndex >= 0 ? repoWithOptionalRef.slice(atIndex + 1) : void 0;
-    if (!owner || !repo || pathParts.length === 0) {
-      throw new Error(`Unsupported git skill source: ${source}`);
-    }
-    return {
-      owner,
-      repo,
-      repoUrl: `https://github.com/${owner}/${repo}.git`,
-      skillPath: pathParts.join("/"),
-      ref: ref && ref.trim().length > 0 ? ref.trim() : void 0
-    };
-  }
   async enableMarketplacePlugin(id) {
     const output = await this.runCliSubcommand(["plugins", "enable", id]);
-    const summary = this.pickLastOutputLine(output) ?? `Enabled plugin: ${id}`;
-    return { message: summary, output };
+    const summary = pickUserFacingCommandSummary(output, `Enabled plugin: ${id}`);
+    return { message: summary };
   }
   async disableMarketplacePlugin(id) {
     const output = await this.runCliSubcommand(["plugins", "disable", id]);
-    const summary = this.pickLastOutputLine(output) ?? `Disabled plugin: ${id}`;
-    return { message: summary, output };
+    const summary = pickUserFacingCommandSummary(output, `Disabled plugin: ${id}`);
+    return { message: summary };
   }
   async uninstallMarketplacePlugin(id) {
     const output = await this.runCliSubcommand(["plugins", "uninstall", id, "--force"]);
-    const summary = this.pickLastOutputLine(output) ?? `Uninstalled plugin: ${id}`;
-    return { message: summary, output };
+    const summary = pickUserFacingCommandSummary(output, `Uninstalled plugin: ${id}`);
+    return { message: summary };
   }
   async uninstallMarketplaceSkill(slug) {
     const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
@@ -4606,10 +4682,9 @@ var ServiceCommands = class {
     if (!existsSync8(targetDir)) {
       throw new Error(`Skill not installed in workspace: ${slug}`);
     }
-    rmSync3(targetDir, { recursive: true, force: true });
+    rmSync4(targetDir, { recursive: true, force: true });
     return {
-      message: `Uninstalled skill: ${slug}`,
-      output: `Removed ${targetDir}`
+      message: `Uninstalled skill: ${slug}`
     };
   }
   installBuiltinMarketplaceSkill(slug, force) {
@@ -4618,8 +4693,7 @@ var ServiceCommands = class {
     const destinationSkillFile = join5(destination, "SKILL.md");
     if (existsSync8(destinationSkillFile) && !force) {
       return {
-        message: `${slug} is already installed`,
-        output: destination
+        message: `${slug} is already installed`
       };
     }
     const loader = createSkillsLoader(workspace);
@@ -4627,50 +4701,17 @@ var ServiceCommands = class {
     if (!builtin) {
       if (existsSync8(destinationSkillFile)) {
         return {
-          message: `${slug} is already installed`,
-          output: destination
+          message: `${slug} is already installed`
         };
       }
       return null;
     }
-    mkdirSync4(join5(workspace, "skills"), { recursive: true });
-    cpSync(dirname(builtin.path), destination, { recursive: true, force: true });
+    mkdirSync5(join5(workspace, "skills"), { recursive: true });
+    cpSync2(dirname2(builtin.path), destination, { recursive: true, force: true });
     return {
-      message: `Installed skill: ${slug}`,
-      output: `Copied builtin skill to ${destination}`
+      message: `Installed skill: ${slug}`
     };
   }
-  resolveGitSkillName(skill, source) {
-    const fromRequest = typeof skill === "string" ? skill.trim() : "";
-    if (fromRequest) {
-      return this.validateSkillName(fromRequest);
-    }
-    const normalizedSource = source.replace(/[?#].*$/, "").replace(/\/+$/, "");
-    const parts = normalizedSource.split("/").filter(Boolean);
-    const inferred = parts.length > 0 ? parts[parts.length - 1] : "";
-    if (!inferred) {
-      throw new Error("Git skill install requires a specific skill name");
-    }
-    return this.validateSkillName(inferred);
-  }
-  validateSkillName(skillName) {
-    if (!/^[A-Za-z0-9._-]+$/.test(skillName)) {
-      throw new Error(`Invalid skill name: ${skillName}`);
-    }
-    return skillName;
-  }
-  resolveSkillInstallPath(workspace, installPath, skillName) {
-    const requested = typeof installPath === "string" && installPath.trim().length > 0 ? installPath.trim() : join5("skills", skillName);
-    if (isAbsolute2(requested)) {
-      throw new Error("installPath must be relative to workspace");
-    }
-    const destination = resolve7(workspace, requested);
-    const rel = relative(workspace, destination);
-    if (rel.startsWith("..") || isAbsolute2(rel)) {
-      throw new Error("installPath escapes workspace");
-    }
-    return destination;
-  }
   mergeCommandOutput(stdout, stderr) {
     return `${stdout}
 ${stderr}`.trim();
@@ -4682,22 +4723,6 @@ ${stderr}`.trim();
       timeoutMs
     }).then((result) => this.mergeCommandOutput(result.stdout, result.stderr));
   }
-  async runCommandWithFallback(commandCandidates, args, options = {}) {
-    let lastError = null;
-    for (const command of commandCandidates) {
-      try {
-        return await this.runCommand(command, args, options);
-      } catch (error) {
-        const message = String(error);
-        lastError = error instanceof Error ? error : new Error(message);
-        if (message.startsWith("failed to start command:")) {
-          continue;
-        }
-        throw error;
-      }
-    }
-    throw lastError ?? new Error("failed to start command");
-  }
   runCommand(command, args, options = {}) {
     const timeoutMs = options.timeoutMs ?? 18e4;
     return new Promise((resolvePromise, rejectPromise) => {
@@ -4735,19 +4760,15 @@ ${stderr}`.trim();
       });
     });
   }
-  pickLastOutputLine(output) {
-    const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
-    return lines.length > 0 ? lines[lines.length - 1] : null;
-  }
 };
 
 // src/cli/workspace.ts
-import { cpSync as cpSync2, existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync2, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { cpSync as cpSync3, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readdirSync as readdirSync3, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname2, join as join6, resolve as resolve8 } from "path";
+import { dirname as dirname3, join as join6, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { APP_NAME as APP_NAME3, getDataDir as getDataDir7 } from "@nextclaw/core";
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 var WorkspaceManager = class {
   constructor(logo) {
     this.logo = logo;
@@ -4783,20 +4804,20 @@ var WorkspaceManager = class {
         console.warn(`Warning: Template file missing: ${templatePath}`);
         continue;
       }
-      const raw = readFileSync7(templatePath, "utf-8");
+      const raw = readFileSync8(templatePath, "utf-8");
       const content = raw.replace(/\$\{APP_NAME\}/g, APP_NAME3);
-      mkdirSync5(dirname2(filePath), { recursive: true });
+      mkdirSync6(dirname3(filePath), { recursive: true });
       writeFileSync5(filePath, content);
       created.push(entry.target);
     }
     const memoryDir = join6(workspace, "memory");
     if (!existsSync9(memoryDir)) {
-      mkdirSync5(memoryDir, { recursive: true });
+      mkdirSync6(memoryDir, { recursive: true });
       created.push(join6("memory", ""));
     }
     const skillsDir = join6(workspace, "skills");
     if (!existsSync9(skillsDir)) {
-      mkdirSync5(skillsDir, { recursive: true });
+      mkdirSync6(skillsDir, { recursive: true });
       created.push(join6("skills", ""));
     }
     const seeded = this.seedBuiltinSkills(skillsDir, { force });
@@ -4812,7 +4833,7 @@ var WorkspaceManager = class {
     }
     const force = Boolean(options.force);
     let seeded = 0;
-    for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
+    for (const entry of readdirSync3(sourceDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
       }
@@ -4824,7 +4845,7 @@ var WorkspaceManager = class {
       if (!force && existsSync9(dest)) {
         continue;
       }
-      cpSync2(src, dest, { recursive: true, force: true });
+      cpSync3(src, dest, { recursive: true, force: true });
       seeded += 1;
     }
     return seeded;
@@ -4833,7 +4854,7 @@ var WorkspaceManager = class {
     try {
       const require2 = createRequire(import.meta.url);
       const entry = require2.resolve("@nextclaw/core");
-      const pkgRoot = resolve8(dirname2(entry), "..");
+      const pkgRoot = resolve8(dirname3(entry), "..");
       const distSkills = join6(pkgRoot, "dist", "skills");
       if (existsSync9(distSkills)) {
         return distSkills;
@@ -4886,15 +4907,15 @@ var WorkspaceManager = class {
       process.exit(1);
     }
     console.log(`${this.logo} Setting up bridge...`);
-    mkdirSync5(resolve8(userBridge, ".."), { recursive: true });
+    mkdirSync6(resolve8(userBridge, ".."), { recursive: true });
     if (existsSync9(userBridge)) {
-      rmSync4(userBridge, { recursive: true, force: true });
+      rmSync5(userBridge, { recursive: true, force: true });
     }
-    cpSync2(source, userBridge, {
+    cpSync3(source, userBridge, {
       recursive: true,
       filter: (src) => !src.includes("node_modules") && !src.includes("dist")
     });
-    const install = spawnSync4("npm", ["install"], { cwd: userBridge, stdio: "pipe" });
+    const install = spawnSync3("npm", ["install"], { cwd: userBridge, stdio: "pipe" });
     if (install.status !== 0) {
       console.error(`Bridge install failed: ${install.status ?? 1}`);
       if (install.stderr) {
@@ -4902,7 +4923,7 @@ var WorkspaceManager = class {
       }
       process.exit(1);
     }
-    const build = spawnSync4("npm", ["run", "build"], { cwd: userBridge, stdio: "pipe" });
+    const build = spawnSync3("npm", ["run", "build"], { cwd: userBridge, stdio: "pipe" });
     if (build.status !== 0) {
       console.error(`Bridge build failed: ${build.status ?? 1}`);
       if (build.stderr) {
@@ -5155,7 +5176,7 @@ var CliRuntime = class {
     const workspaceSetting = config2.agents.defaults.workspace;
     const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join7(getDataDir8(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
     const workspaceExisted = existsSync10(workspacePath);
-    mkdirSync6(workspacePath, { recursive: true });
+    mkdirSync7(workspacePath, { recursive: true });
     const templateResult = this.workspaceManager.createWorkspaceTemplates(
       workspacePath,
       { force }
@@ -5344,8 +5365,8 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
       );
       const historyFile = join7(getDataDir8(), "history", "cli_history");
       const historyDir = resolve9(historyFile, "..");
-      mkdirSync6(historyDir, { recursive: true });
-      const history = existsSync10(historyFile) ? readFileSync8(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+      mkdirSync7(historyDir, { recursive: true });
+      const history = existsSync10(historyFile) ? readFileSync9(historyFile, "utf-8").split("\n").filter(Boolean) : [];
       const rl = createInterface2({
         input: process.stdin,
         output: process.stdout
@@ -5501,25 +5522,58 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
   }
   async skillsInstall(options) {
     const workdir = options.workdir ? expandHome2(options.workdir) : getWorkspacePath6();
-    const result = await installClawHubSkill({
+    const result = await installMarketplaceSkill({
       slug: options.slug,
-      version: options.version,
-      registry: options.registry,
       workdir,
       dir: options.dir,
-      force: options.force
+      force: options.force,
+      apiBaseUrl: options.apiBaseUrl
     });
-    const versionLabel = result.version ?? "latest";
     if (result.alreadyInstalled) {
       console.log(`\u2713 ${result.slug} is already installed`);
     } else {
-      console.log(`\u2713 Installed ${result.slug}@${versionLabel}`);
-    }
-    if (result.registry) {
-      console.log(`  Registry: ${result.registry}`);
+      console.log(`\u2713 Installed ${result.slug} (${result.source})`);
     }
     console.log(`  Path: ${result.destinationDir}`);
   }
+  async skillsPublish(options) {
+    const result = await publishMarketplaceSkill({
+      skillDir: expandHome2(options.dir),
+      slug: options.slug,
+      name: options.name,
+      summary: options.summary,
+      description: options.description,
+      author: options.author,
+      tags: options.tag,
+      sourceRepo: options.sourceRepo,
+      homepage: options.homepage,
+      publishedAt: options.publishedAt,
+      updatedAt: options.updatedAt,
+      apiBaseUrl: options.apiBaseUrl,
+      token: options.token
+    });
+    console.log(result.created ? `\u2713 Published new skill: ${result.slug}` : `\u2713 Updated skill: ${result.slug}`);
+    console.log(`  Files: ${result.fileCount}`);
+  }
+  async skillsUpdate(options) {
+    const result = await publishMarketplaceSkill({
+      skillDir: expandHome2(options.dir),
+      slug: options.slug,
+      name: options.name,
+      summary: options.summary,
+      description: options.description,
+      author: options.author,
+      tags: options.tag,
+      sourceRepo: options.sourceRepo,
+      homepage: options.homepage,
+      updatedAt: options.updatedAt,
+      apiBaseUrl: options.apiBaseUrl,
+      token: options.token,
+      requireExisting: true
+    });
+    console.log(`\u2713 Updated skill: ${result.slug}`);
+    console.log(`  Files: ${result.fileCount}`);
+  }
 };
 
 // src/cli/index.ts
@@ -5536,13 +5590,11 @@ program.command("serve").description(`Run the ${APP_NAME5} gateway + UI in the f
 program.command("stop").description(`Stop the ${APP_NAME5} background service`).action(async () => runtime.stop());
 program.command("agent").description("Interact with the agent directly").option("-m, --message <message>", "Message to send to the agent").option("-s, --session <session>", "Session ID", "cli:default").option("--model <model>", "Session model override for this run").option("--no-markdown", "Disable Markdown rendering").action(async (opts) => runtime.agent(opts));
 program.command("update").description(`Update ${APP_NAME5}`).option("--timeout <ms>", "Update command timeout in milliseconds").action(async (opts) => runtime.update(opts));
-var registerClawHubInstall = (cmd) => {
-  cmd.command("install <slug>").description("Install a skill from ClawHub").option("--version <version>", "Skill version (default: latest)").option("--registry <url>", "ClawHub registry base URL").option("--workdir <dir>", "Workspace directory to install into").option("--dir <dir>", "Skills directory name (default: skills)").option("-f, --force", "Overwrite existing skill files", false).action(async (slug, opts) => runtime.skillsInstall({ slug, ...opts }));
-};
 var skills = program.command("skills").description("Manage skills");
-registerClawHubInstall(skills);
-var clawhub = program.command("clawhub").description("Install skills from ClawHub");
-registerClawHubInstall(clawhub);
+skills.command("install <slug>").description("Install a skill from NextClaw marketplace").option("--api-base <url>", "Marketplace API base URL").option("--workdir <dir>", "Workspace directory to install into").option("--dir <dir>", "Skills directory name (default: skills)").option("-f, --force", "Overwrite existing skill files", false).action(async (slug, opts) => runtime.skillsInstall({ slug, ...opts, apiBaseUrl: opts.apiBase }));
+var withRepeatableTag = (value, previous = []) => [...previous, value];
+skills.command("publish <dir>").description("Upload or create a skill in marketplace").option("--slug <slug>", "Skill slug (default: directory name)").option("--name <name>", "Skill display name").option("--summary <summary>", "Skill summary").option("--description <description>", "Skill description").option("--author <author>", "Skill author").option("--tag <tag>", "Skill tag (repeatable)", withRepeatableTag, []).option("--source-repo <url>", "Source repository URL").option("--homepage <url>", "Homepage URL").option("--published-at <datetime>", "Published time (ISO datetime)").option("--updated-at <datetime>", "Updated time (ISO datetime)").option("--api-base <url>", "Marketplace API base URL").option("--token <token>", "Marketplace admin token").action(async (dir, opts) => runtime.skillsPublish({ dir, ...opts, apiBaseUrl: opts.apiBase }));
+skills.command("update <dir>").description("Update an existing skill in marketplace").option("--slug <slug>", "Skill slug (default: directory name)").option("--name <name>", "Skill display name").option("--summary <summary>", "Skill summary").option("--description <description>", "Skill description").option("--author <author>", "Skill author").option("--tag <tag>", "Skill tag (repeatable)", withRepeatableTag, []).option("--source-repo <url>", "Source repository URL").option("--homepage <url>", "Homepage URL").option("--updated-at <datetime>", "Updated time (ISO datetime)").option("--api-base <url>", "Marketplace API base URL").option("--token <token>", "Marketplace admin token").action(async (dir, opts) => runtime.skillsUpdate({ dir, ...opts, apiBaseUrl: opts.apiBase }));
 var plugins = program.command("plugins").description("Manage OpenClaw-compatible plugins");
 plugins.command("list").description("List discovered plugins").option("--json", "Print JSON").option("--enabled", "Only show enabled plugins", false).option("--verbose", "Show detailed entries", false).action((opts) => runtime.pluginsList(opts));
 plugins.command("info <id>").description("Show plugin details").option("--json", "Print JSON").action((id, opts) => runtime.pluginsInfo(id, opts));