openclawmp 0.1.2 → 0.1.4

package/lib/api.js

@@ -1,6 +1,7 @@
 // ============================================================================
 // api.js — HTTP request helpers for the OpenClaw Marketplace API
 //
+// Uses V1 API endpoints for lightweight responses (AssetCompact).
 // Uses Node.js built-in fetch (available since Node 18)
 // ============================================================================
 
@@ -22,7 +23,7 @@ function authHeaders() {
 
 /**
  * Make a GET request to the API
- * @param {string} apiPath - API path (e.g., '/api/assets')
+ * @param {string} apiPath - API path (e.g., '/api/v1/assets')
  * @param {object} [params] - Query parameters
  * @returns {Promise<object>} Parsed JSON response
  */
@@ -107,40 +108,53 @@ async function download(apiPath) {
 }
 
 /**
- * Search assets
+ * Search assets via V1 API (returns lightweight AssetCompact items).
+ *
+ * V1 response shape: { query, total, items: AssetCompact[], nextCursor }
+ * AssetCompact fields: id, name, displayName, type, description, tags,
+ *   installs, rating, author (string), authorId, version, installCommand,
+ *   updatedAt, category
+ *
  * @param {string} query
  * @param {object} [opts] - { type, limit }
- * @returns {Promise<object>}
+ * @returns {Promise<object>} V1 search response
  */
 async function searchAssets(query, opts = {}) {
   const params = { q: query, limit: opts.limit || 20 };
   if (opts.type) params.type = opts.type;
-  return get('/api/assets', params);
+  return get('/api/v1/search', params);
 }
 
 /**
- * Find an asset by type and slug (with optional author filter)
+ * Find an asset by type and slug (with optional author filter).
+ * Uses V1 list endpoint for lightweight data.
+ *
  * @param {string} type
  * @param {string} slug
- * @param {string} [authorFilter]
+ * @param {string} [authorFilter] - author ID or author name to filter by
  * @returns {Promise<object|null>}
  */
 async function findAsset(type, slug, authorFilter) {
-  const result = await get('/api/assets', { q: slug, limit: 50 });
-  const assets = result?.data?.assets || [];
+  const result = await get('/api/v1/assets', { q: slug, type, limit: 50 });
+  const assets = result?.items || [];
 
-  // Exact match on type + name
-  let matches = assets.filter(a => a.type === type && a.name === slug);
+  // Exact match on name
+  let matches = assets.filter(a => a.name === slug);
   if (authorFilter) {
-    const authorMatches = matches.filter(a => (a.author?.id || '') === authorFilter);
+    // authorFilter could be an authorId or author name
+    const authorMatches = matches.filter(a =>
+      a.authorId === authorFilter || a.author === authorFilter
+    );
     if (authorMatches.length > 0) matches = authorMatches;
   }
 
-  // Fallback: partial match
+  // Fallback: partial match on name
   if (matches.length === 0) {
-    matches = assets.filter(a => a.type === type && a.name.includes(slug));
+    matches = assets.filter(a => a.name.includes(slug));
     if (authorFilter) {
-      const authorMatches = matches.filter(a => (a.author?.id || '') === authorFilter);
+      const authorMatches = matches.filter(a =>
+        a.authorId === authorFilter || a.author === authorFilter
+      );
       if (authorMatches.length > 0) matches = authorMatches;
     }
   }
@@ -148,10 +162,26 @@ async function findAsset(type, slug, authorFilter) {
   if (matches.length === 0) return null;
 
   // Prefer the one with an author ID
-  matches.sort((a, b) => (b.author?.id || '').localeCompare(a.author?.id || ''));
+  matches.sort((a, b) => (b.authorId || '').localeCompare(a.authorId || ''));
   return matches[0];
 }
 
+/**
+ * Get asset detail (L2) by ID via V1 API.
+ * Returns full detail including readme, files, versions.
+ *
+ * @param {string} id - Asset ID
+ * @returns {Promise<object|null>}
+ */
+async function getAssetById(id) {
+  try {
+    return await get(`/api/v1/assets/${id}`);
+  } catch (e) {
+    if (e.message.includes('404')) return null;
+    throw e;
+  }
+}
+
 /**
  * Make a DELETE request to the API
  * @param {string} apiPath
@@ -178,18 +208,21 @@ async function del(apiPath, body) {
 /**
  * Resolve an asset reference to a full asset object.
  * Accepts:
- *   - Direct ID: "tr-fc617094de29f938"
+ *   - Direct ID: "s-abc123", "tr-fc617094de29f938"
  *   - type/@author/slug: "trigger/@xiaoyue/pdf-watcher"
+ *
+ * Uses V1 API: GET /api/v1/assets/:id for ID lookups,
+ * findAsset() (V1 search) for type/slug lookups.
+ *
  * @param {string} ref
  * @returns {Promise<object>} asset object with at least { id, name, ... }
  */
 async function resolveAssetRef(ref) {
-  // Direct ID pattern: known prefix + dash + hex (sk-/pl-/tr-/ch-/ex-)
-  if (/^(sk|pl|tr|ch|ex)-[0-9a-f]+$/.test(ref)) {
-    // Fetch by ID directly
-    const result = await get(`/api/assets/${ref}`);
-    // API may return { data: { asset } } or the asset directly
-    return result?.data?.asset || result?.data || result;
+  // Direct ID pattern: prefix + dash + hex
+  if (/^[a-z]+-[0-9a-f]{8,}$/.test(ref)) {
+    const result = await getAssetById(ref);
+    if (!result) throw new Error(`Asset not found: ${ref}`);
+    return result;
   }
 
   // type/@author/slug format
@@ -223,5 +256,6 @@ module.exports = {
   download,
   searchAssets,
   findAsset,
+  getAssetById,
   resolveAssetRef,
 };

package/lib/archive.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+
+const TAR_BLOCK_SIZE = 512;
+const TAR_END_BLOCKS = Buffer.alloc(TAR_BLOCK_SIZE * 2, 0);
+const ZIP_LOCAL_FILE_HEADER = 0x04034b50;
+const ZIP_CENTRAL_DIRECTORY_HEADER = 0x02014b50;
+const ZIP_END_OF_CENTRAL_DIRECTORY = 0x06054b50;
+
+function normalizeArchivePath(filePath) {
+  return filePath.split(path.sep).join('/');
+}
+
+function withDotPrefix(filePath) {
+  const normalized = normalizeArchivePath(filePath);
+  if (!normalized || normalized === '.') return './';
+  return normalized.startsWith('./') ? normalized : `./${normalized}`;
+}
+
+function posixModeForStat(stat) {
+  return stat.mode & 0o7777;
+}
+
+function writeString(buffer, value, offset, length) {
+  const source = Buffer.from(value, 'utf8');
+  source.copy(buffer, offset, 0, Math.min(source.length, length));
+}
+
+function writeOctal(buffer, value, offset, length) {
+  const octal = Math.max(0, value).toString(8);
+  const padded = octal.padStart(length - 2, '0');
+  writeString(buffer, `${padded}\0 `, offset, length);
+}
+
+function writeChecksumPlaceholder(buffer) {
+  buffer.fill(0x20, 148, 156);
+}
+
+function finalizeChecksum(buffer) {
+  let checksum = 0;
+  for (const byte of buffer) checksum += byte;
+  const octal = checksum.toString(8).padStart(6, '0');
+  writeString(buffer, `${octal}\0 `, 148, 8);
+}
+
+function buildTarHeader(name, stat, typeflag) {
+  const header = Buffer.alloc(TAR_BLOCK_SIZE, 0);
+  const normalizedName = normalizeArchivePath(name);
+  const prefixCut = normalizedName.length > 100 ? normalizedName.lastIndexOf('/', 100) : -1;
+  let entryName = normalizedName;
+  let prefix = '';
+
+  if (normalizedName.length > 100) {
+    if (prefixCut <= 0 || normalizedName.length - prefixCut - 1 > 100 || prefixCut > 155) {
+      throw new Error(`Path too long for tar header: ${normalizedName}`);
+    }
+    prefix = normalizedName.slice(0, prefixCut);
+    entryName = normalizedName.slice(prefixCut + 1);
+  }
+
+  writeString(header, entryName, 0, 100);
+  writeOctal(header, posixModeForStat(stat), 100, 8);
+  writeOctal(header, 0, 108, 8);
+  writeOctal(header, 0, 116, 8);
+  writeOctal(header, typeflag === '5' ? 0 : stat.size, 124, 12);
+  writeOctal(header, Math.floor(stat.mtimeMs / 1000), 136, 12);
+  writeChecksumPlaceholder(header);
+  writeString(header, typeflag, 156, 1);
+  writeString(header, 'ustar', 257, 6);
+  writeString(header, '00', 263, 2);
+  if (prefix) writeString(header, prefix, 345, 155);
+  finalizeChecksum(header);
+  return header;
+}
+
+function collectEntries(rootDir, currentDir = rootDir, entries = []) {
+  const children = fs.readdirSync(currentDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const child of children) {
+    const absPath = path.join(currentDir, child.name);
+    const relPath = path.relative(rootDir, absPath);
+    const stat = fs.lstatSync(absPath);
+
+    if (stat.isDirectory()) {
+      entries.push({ path: relPath, stat, typeflag: '5' });
+      collectEntries(rootDir, absPath, entries);
+      continue;
+    }
+
+    if (stat.isFile()) {
+      entries.push({ path: relPath, stat, typeflag: '0' });
+    }
+  }
+  return entries;
+}
+
+function createTarBuffer(sourceDir) {
+  const chunks = [];
+  const entries = collectEntries(sourceDir);
+  const rootStat = fs.lstatSync(sourceDir);
+
+  chunks.push(buildTarHeader('./', rootStat, '5'));
+
+  for (const entry of entries) {
+    const archivePath = withDotPrefix(entry.path);
+    const headerPath = entry.typeflag === '5' ? `${archivePath}/` : archivePath;
+    chunks.push(buildTarHeader(headerPath, entry.stat, entry.typeflag));
+
+    if (entry.typeflag === '0') {
+      const content = fs.readFileSync(path.join(sourceDir, entry.path));
+      chunks.push(content);
+      const remainder = content.length % TAR_BLOCK_SIZE;
+      if (remainder !== 0) {
+        chunks.push(Buffer.alloc(TAR_BLOCK_SIZE - remainder, 0));
+      }
+    }
+  }
+
+  chunks.push(TAR_END_BLOCKS);
+  return Buffer.concat(chunks);
+}
+
+function createTarGzFromDirectory(sourceDir, targetFile) {
+  const tarBuffer = createTarBuffer(sourceDir);
+  const gzipBuffer = zlib.gzipSync(tarBuffer);
+  fs.writeFileSync(targetFile, gzipBuffer);
+}
+
+function isTarBuffer(buffer) {
+  if (buffer.length < 265) return false;
+  const magic = buffer.toString('utf8', 257, 262);
+  return magic === 'ustar';
+}
+
+function pathSegments(filePath) {
+  return normalizeArchivePath(filePath).split('/').filter(segment => segment && segment !== '.');
+}
+
+function stripCommonRoot(entries) {
+  const fileEntries = entries.filter(entry => entry.name && entry.segments.length > 0);
+  if (fileEntries.length === 0) return entries;
+
+  const firstRoot = fileEntries[0].segments[0];
+  if (!firstRoot) return entries;
+  if (!fileEntries.every(entry => entry.segments[0] === firstRoot)) return entries;
+
+  const hasRootFile = fileEntries.some(entry => entry.segments.length === 1 && entry.type !== 'directory');
+  if (hasRootFile) return entries;
+
+  return entries.map(entry => ({
+    ...entry,
+    segments: entry.segments.slice(1),
+  }));
+}
+
+function ensureWithinTarget(targetDir, segments) {
+  const destination = path.resolve(targetDir, ...segments);
+  const root = path.resolve(targetDir);
+  if (destination !== root && !destination.startsWith(`${root}${path.sep}`)) {
+    throw new Error(`Archive entry escapes target directory: ${segments.join('/')}`);
+  }
+  return destination;
+}
+
+function applyMode(destination, mode, isDirectory) {
+  if (process.platform === 'win32') return;
+  const fallback = isDirectory ? 0o755 : 0o644;
+  try {
+    fs.chmodSync(destination, mode || fallback);
+  } catch {}
+}
+
+function extractEntries(entries, targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+  const normalizedEntries = stripCommonRoot(entries).filter(entry => entry.segments.length > 0);
+
+  for (const entry of normalizedEntries) {
+    const destination = ensureWithinTarget(targetDir, entry.segments);
+    if (entry.type === 'directory') {
+      fs.mkdirSync(destination, { recursive: true });
+      applyMode(destination, entry.mode, true);
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    fs.writeFileSync(destination, entry.content);
+    applyMode(destination, entry.mode, false);
+  }
+
+  return normalizedEntries.length > 0;
+}
+
+function parseTarOctal(buffer, offset, length) {
+  const raw = buffer.toString('utf8', offset, offset + length).replace(/\0.*$/, '').trim();
+  return raw ? parseInt(raw, 8) : 0;
+}
+
+function extractTar(buffer, targetDir) {
+  const entries = [];
+  let offset = 0;
+
+  while (offset + TAR_BLOCK_SIZE <= buffer.length) {
+    const header = buffer.subarray(offset, offset + TAR_BLOCK_SIZE);
+    if (header.every(byte => byte === 0)) break;
+
+    const name = header.toString('utf8', 0, 100).replace(/\0.*$/, '');
+    const prefix = header.toString('utf8', 345, 500).replace(/\0.*$/, '');
+    const fullName = prefix ? `${prefix}/${name}` : name;
+    const typeflag = header.toString('utf8', 156, 157) || '0';
+    const size = parseTarOctal(header, 124, 12);
+    const mode = parseTarOctal(header, 100, 8);
+    offset += TAR_BLOCK_SIZE;
+
+    const content = buffer.subarray(offset, offset + size);
+    const segments = pathSegments(fullName);
+    if (typeflag === '5') {
+      entries.push({ name: fullName, segments, type: 'directory', mode });
+    } else if (typeflag === '0' || typeflag === '\0') {
+      entries.push({ name: fullName, segments, type: 'file', mode, content: Buffer.from(content) });
+    }
+
+    offset += Math.ceil(size / TAR_BLOCK_SIZE) * TAR_BLOCK_SIZE;
+  }
+
+  return extractEntries(entries, targetDir);
+}
+
+function locateZipEnd(buffer) {
+  const minimumOffset = Math.max(0, buffer.length - 0xffff - 22);
+  for (let offset = buffer.length - 22; offset >= minimumOffset; offset--) {
+    if (buffer.readUInt32LE(offset) === ZIP_END_OF_CENTRAL_DIRECTORY) {
+      return offset;
+    }
+  }
+  throw new Error('Invalid zip: end of central directory not found');
+}
+
+function extractZip(buffer, targetDir) {
+  const eocdOffset = locateZipEnd(buffer);
+  const centralDirectorySize = buffer.readUInt32LE(eocdOffset + 12);
+  const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + 16);
+  const entries = [];
+
+  let offset = centralDirectoryOffset;
+  const end = centralDirectoryOffset + centralDirectorySize;
+
+  while (offset < end) {
+    if (buffer.readUInt32LE(offset) !== ZIP_CENTRAL_DIRECTORY_HEADER) {
+      throw new Error('Invalid zip: malformed central directory');
+    }
+
+    const compressionMethod = buffer.readUInt16LE(offset + 10);
+    const compressedSize = buffer.readUInt32LE(offset + 20);
+    const uncompressedSize = buffer.readUInt32LE(offset + 24);
+    const fileNameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const externalAttributes = buffer.readUInt32LE(offset + 38);
+    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+    const fileName = buffer.toString('utf8', offset + 46, offset + 46 + fileNameLength);
+    const isDirectory = fileName.endsWith('/');
+    const mode = (externalAttributes >>> 16) & 0xffff;
+
+    if (buffer.readUInt32LE(localHeaderOffset) !== ZIP_LOCAL_FILE_HEADER) {
+      throw new Error('Invalid zip: missing local file header');
+    }
+
+    const localNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+    const dataOffset = localHeaderOffset + 30 + localNameLength + localExtraLength;
+    const compressedData = buffer.subarray(dataOffset, dataOffset + compressedSize);
+
+    let content = Buffer.alloc(0);
+    if (!isDirectory) {
+      if (compressionMethod === 0) {
+        content = Buffer.from(compressedData);
+      } else if (compressionMethod === 8) {
+        content = zlib.inflateRawSync(compressedData);
+      } else {
+        throw new Error(`Unsupported zip compression method: ${compressionMethod}`);
+      }
+
+      if (content.length !== uncompressedSize) {
+        throw new Error('Invalid zip: uncompressed size mismatch');
+      }
+    }
+
+    entries.push({
+      name: fileName,
+      segments: pathSegments(fileName),
+      type: isDirectory ? 'directory' : 'file',
+      mode,
+      content,
+    });
+
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+
+  return extractEntries(entries, targetDir);
+}
+
+function extractPackage(buffer, targetDir) {
+  const isZip = buffer.length >= 4 && buffer.readUInt32LE(0) === ZIP_LOCAL_FILE_HEADER;
+  if (isZip) {
+    return extractZip(buffer, targetDir);
+  }
+
+  let tarBuffer = buffer;
+  try {
+    tarBuffer = zlib.gunzipSync(buffer);
+  } catch {}
+
+  if (!isTarBuffer(tarBuffer)) return false;
+  return extractTar(tarBuffer, targetDir);
+}
+
+module.exports = {
+  createTarGzFromDirectory,
+  extractPackage,
+};

package/lib/commands/info.js

@@ -27,8 +27,9 @@ async function run(args) {
     process.exit(1);
   }
 
-  const authorName = asset.author?.name || 'unknown';
-  const authorId = asset.author?.id || '';
+  // V1 AssetCompact: author is a string, authorId is separate
+  const authorName = asset.author || 'unknown';
+  const authorId = asset.authorId || '';
   const tags = (asset.tags || []).join(', ');
 
   console.log('');
@@ -38,8 +39,7 @@ async function run(args) {
   console.log(`  Package:   ${asset.name}`);
   console.log(`  Version:   ${asset.version}`);
   console.log(`  Author:    ${c('cyan', authorName)} ${c('dim', `(${authorId})`)}`);
-  console.log(`  Score:     ${asset.hubScore || 0}`);
-  console.log(`  Downloads: ${asset.downloads || 0}`);
+  console.log(`  Installs:  ${asset.installs || 0}`);
   if (tags) {
     console.log(`  Tags:      ${tags}`);
   }

package/lib/commands/install.js

@@ -6,8 +6,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 const api = require('../api.js');
+const { extractPackage } = require('../archive.js');
 const config = require('../config.js');
 const { fish, info, ok, warn, err, c, detail } = require('../ui.js');
 
@@ -42,48 +42,6 @@ function parseSpec(spec) {
   return { type, slug, authorFilter };
 }
 
-/**
- * Extract a tar.gz or zip buffer to a directory
- */
-function extractPackage(buffer, targetDir) {
-  const tmpFile = path.join(require('os').tmpdir(), `openclawmp-pkg-${process.pid}-${Date.now()}`);
-  fs.writeFileSync(tmpFile, buffer);
-
-  try {
-    // Try tar first
-    try {
-      execSync(`tar xzf "${tmpFile}" -C "${targetDir}" --strip-components=1 2>/dev/null`, { stdio: 'pipe' });
-      return true;
-    } catch {
-      // Try without --strip-components
-      try {
-        execSync(`tar xzf "${tmpFile}" -C "${targetDir}" 2>/dev/null`, { stdio: 'pipe' });
-        return true;
-      } catch {
-        // Try unzip
-        try {
-          execSync(`unzip -o -q "${tmpFile}" -d "${targetDir}" 2>/dev/null`, { stdio: 'pipe' });
-          // If single subdirectory, move contents up
-          const entries = fs.readdirSync(targetDir);
-          const dirs = entries.filter(e => fs.statSync(path.join(targetDir, e)).isDirectory());
-          if (dirs.length === 1 && entries.length === 1) {
-            const subdir = path.join(targetDir, dirs[0]);
-            for (const f of fs.readdirSync(subdir)) {
-              fs.renameSync(path.join(subdir, f), path.join(targetDir, f));
-            }
-            fs.rmdirSync(subdir);
-          }
-          return true;
-        } catch {
-          return false;
-        }
-      }
-    }
-  } finally {
-    try { fs.unlinkSync(tmpFile); } catch {}
-  }
-}
-
 /**
  * Count files recursively in a directory
  */
@@ -106,7 +64,8 @@ function writeManifest(asset, targetDir, hasPackage) {
     name: asset.name,
     displayName: asset.displayName || '',
     version: asset.version,
-    author: asset.author,
+    author: asset.author || '',
+    authorId: asset.authorId || '',
     description: asset.description || '',
     tags: asset.tags || [],
     category: asset.category || '',
@@ -167,8 +126,8 @@ async function run(args, flags) {
 
   const displayName = asset.displayName || asset.name;
   const version = asset.version;
-  const authorName = asset.author?.name || 'unknown';
-  const authorId = asset.author?.id || '';
+  const authorName = asset.author || 'unknown';
+  const authorId = asset.authorId || '';
 
   console.log(`  ${c('bold', displayName)} ${c('dim', `v${version}`)}`);
   console.log(`  by ${c('cyan', authorName)} ${c('dim', `(${authorId})`)}`);
@@ -203,7 +162,7 @@ async function run(args, flags) {
 
   // Try downloading the actual package
   let hasPackage = false;
-  const pkgBuffer = await api.download(`/api/assets/${asset.id}/download`);
+  const pkgBuffer = await api.download(`/api/v1/assets/${asset.id}/download`);
 
   if (pkgBuffer && pkgBuffer.length > 0) {
     info('📦 Downloading package from registry...');

package/lib/commands/publish.js

@@ -6,8 +6,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 const api = require('../api.js');
+const { createTarGzFromDirectory } = require('../archive.js');
 const config = require('../config.js');
 const { fish, info, ok, warn, err, c, detail } = require('../ui.js');
 
@@ -268,7 +268,7 @@ async function run(args, flags) {
   // Create tarball
   const tarball = path.join(require('os').tmpdir(), `openclawmp-publish-${Date.now()}.tar.gz`);
   try {
-    execSync(`tar czf "${tarball}" -C "${skillDir}" .`, { stdio: 'pipe' });
+    createTarGzFromDirectory(skillDir, tarball);
   } catch (e) {
     err('Failed to create package tarball');
     process.exit(1);

package/lib/commands/search.js

@@ -18,8 +18,8 @@ async function run(args) {
   console.log('');
 
   const result = await api.searchAssets(query);
-  const assets = result?.data?.assets || [];
-  const total = result?.data?.total || 0;
+  const assets = result?.items || [];
+  const total = result?.total || 0;
 
   if (assets.length === 0) {
     console.log('  No results found.');
@@ -31,12 +31,12 @@ async function run(args) {
 
   for (const a of assets) {
     const icon = typeIcon(a.type);
-    const score = a.hubScore || 0;
-    const author = a.author?.name || 'unknown';
-    const authorId = a.author?.id || 'unknown';
+    const installs = a.installs || 0;
+    const author = a.author || 'unknown';
+    const authorId = a.authorId || 'unknown';
 
     console.log(`  ${icon} ${c('bold', a.displayName)}`);
-    console.log(`     ${a.type}/@${authorId}/${a.name}  •  v${a.version}  •  by ${c('cyan', author)}  •  Score: ${score}`);
+    console.log(`     ${a.type}/@${authorId}/${a.name}  •  v${a.version}  •  by ${c('cyan', author)}  •  Installs: ${installs}`);
 
     const desc = (a.description || '').slice(0, 80);
     if (desc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclawmp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "\ud83d\udc1f OpenClaw Marketplace CLI \u2014 \u6c34\u4ea7\u5e02\u573a\u547d\u4ee4\u884c\u5de5\u5177",
   "bin": {
     "openclawmp": "./bin/openclawmp.js"