openclawmp 0.1.3 → 0.1.5

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/comment.js

@@ -2,118 +2,136 @@
 // commands/comment.js — Post / list comments on an asset
 // ============================================================================
 
-'use strict';
+"use strict";
 
-const api = require('../api.js');
-const auth = require('../auth.js');
-const { ok, info, err, c, detail } = require('../ui.js');
+const api = require("../api.js");
+const auth = require("../auth.js");
+const { ok, info, err, c, detail } = require("../ui.js");
 
 /**
  * Format a timestamp to a readable date string
  */
 function fmtDate(ts) {
-  if (!ts) return '?';
-  const d = new Date(ts);
-  if (isNaN(d.getTime())) return String(ts);
-  return d.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+    if (!ts) return "?";
+    const d = new Date(ts);
+    if (isNaN(d.getTime())) return String(ts);
+    return d.toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
 }
 
 /**
  * Render star rating: ★★★★☆
  */
 function renderRating(rating) {
-  if (!rating) return '';
-  const n = Math.max(0, Math.min(5, Math.round(rating)));
-  return c('yellow', '★'.repeat(n)) + c('dim', '☆'.repeat(5 - n));
+    if (!rating) return "";
+    const n = Math.max(0, Math.min(5, Math.round(rating)));
+    return c("yellow", "★".repeat(n)) + c("dim", "☆".repeat(5 - n));
 }
 
 /**
  * openclawmp comment <assetRef> <content> [--rating N] [--as-agent]
  */
 async function runComment(args, flags) {
-  if (args.length < 2) {
-    err('Usage: openclawmp comment <assetRef> <content> [--rating 5] [--as-agent]');
-    console.log('  Example: openclawmp comment trigger/@xiaoyue/pdf-watcher "非常好用！"');
-    process.exit(1);
-  }
-
-  if (!auth.isAuthenticated()) {
-    err('Authentication required. Run: openclawmp login');
-    process.exit(1);
-  }
-
-  const asset = await api.resolveAssetRef(args[0]);
-  const content = args.slice(1).join(' ');
-  const displayName = asset.displayName || asset.name || args[0];
-
-  const body = {
-    content,
-    commenterType: flags['as-agent'] ? 'agent' : 'user',
-  };
-
-  if (flags.rating !== undefined) {
-    const rating = parseInt(flags.rating, 10);
-    if (isNaN(rating) || rating < 1 || rating > 5) {
-      err('Rating must be between 1 and 5');
-      process.exit(1);
+    if (args.length < 2) {
+        err(
+            "Usage: openclawmp comment <assetRef> <content> [--rating 5] [--as-agent]",
+        );
+        console.log(
+            '  Example: openclawmp comment trigger/@xiaoyue/pdf-watcher "非常好用！"',
+        );
+        process.exit(1);
     }
-    body.rating = rating;
-  }
 
-  const { status, data } = await api.post(`/api/assets/${asset.id}/comments`, body);
+    if (!auth.isAuthenticated()) {
+        err("Authentication required. Run: openclawmp login");
+        process.exit(1);
+    }
+
+    const asset = await api.resolveAssetRef(args[0]);
+    const content = args.slice(1).join(" ");
+    const displayName = asset.displayName || asset.name || args[0];
+
+    const body = {
+        content,
+        commenterType: flags["as-agent"] ? "agent" : "user",
+    };
+
+    if (flags.rating !== undefined) {
+        const rating = parseInt(flags.rating, 10);
+        if (isNaN(rating) || rating < 1 || rating > 5) {
+            err("Rating must be between 1 and 5");
+            process.exit(1);
+        }
+        body.rating = rating;
+    }
 
-  if (status >= 200 && status < 300) {
-    const comment = data.comment || data;
-    console.log('');
-    ok(`评论已发布到 ${c('bold', displayName)}`);
-    if (body.rating) {
-      detail('评分', renderRating(body.rating));
+    const { status, data } = await api.post(
+        `/api/assets/${asset.id}/comments`,
+        body,
+    );
+
+    if (status >= 200 && status < 300) {
+        const comment = data.comment || data;
+        console.log("");
+        ok(`评论审核成功后自动发布 ${c("bold", displayName)}`);
+        if (body.rating) {
+            detail("评分", renderRating(body.rating));
+        }
+        detail("内容", content);
+        console.log("");
+    } else {
+        err(
+            `评论失败 (${status}): ${data.error || data.message || JSON.stringify(data)}`,
+        );
+        process.exit(1);
     }
-    detail('内容', content);
-    console.log('');
-  } else {
-    err(`评论失败 (${status}): ${data.error || data.message || JSON.stringify(data)}`);
-    process.exit(1);
-  }
 }
 
 /**
  * openclawmp comments <assetRef>
  */
 async function runComments(args) {
-  if (args.length === 0) {
-    err('Usage: openclawmp comments <assetRef>');
-    console.log('  Example: openclawmp comments trigger/@xiaoyue/pdf-watcher');
-    process.exit(1);
-  }
-
-  const asset = await api.resolveAssetRef(args[0]);
-  const displayName = asset.displayName || asset.name || args[0];
-
-  const result = await api.get(`/api/assets/${asset.id}/comments`);
-  const comments = result?.data?.comments || result?.comments || [];
-
-  console.log('');
-  info(`${c('bold', displayName)} 的评论（${comments.length} 条）`);
-  console.log(`  ${'─'.repeat(50)}`);
-
-  if (comments.length === 0) {
-    console.log(`  ${c('dim', '暂无评论。成为第一个评论者吧！')}`);
-    console.log('');
-    console.log(`  openclawmp comment ${args[0]} "你的评论"`);
-  } else {
-    for (const cm of comments) {
-      const author = cm.author?.name || cm.authorName || cm.commenterType || 'anonymous';
-      const rating = cm.rating ? ` ${renderRating(cm.rating)}` : '';
-      const badge = cm.commenterType === 'agent' ? c('magenta', ' 🤖') : '';
-      const time = fmtDate(cm.createdAt || cm.created_at);
-
-      console.log('');
-      console.log(`  ${c('cyan', author)}${badge}${rating}  ${c('dim', time)}`);
-      console.log(`  ${cm.content}`);
+    if (args.length === 0) {
+        err("Usage: openclawmp comments <assetRef>");
+        console.log(
+            "  Example: openclawmp comments trigger/@xiaoyue/pdf-watcher",
+        );
+        process.exit(1);
+    }
+
+    const asset = await api.resolveAssetRef(args[0]);
+    const displayName = asset.displayName || asset.name || args[0];
+
+    const result = await api.get(`/api/assets/${asset.id}/comments`);
+    const comments = result?.data?.comments || result?.comments || [];
+
+    console.log("");
+    info(`${c("bold", displayName)} 的评论（${comments.length} 条）`);
+    console.log(`  ${"─".repeat(50)}`);
+
+    if (comments.length === 0) {
+        console.log(`  ${c("dim", "暂无评论。成为第一个评论者吧！")}`);
+        console.log("");
+        console.log(`  openclawmp comment ${args[0]} "你的评论"`);
+    } else {
+        for (const cm of comments) {
+            const author =
+                cm.author?.name ||
+                cm.authorName ||
+                cm.commenterType ||
+                "anonymous";
+            const rating = cm.rating ? ` ${renderRating(cm.rating)}` : "";
+            const badge =
+                cm.commenterType === "agent" ? c("magenta", " 🤖") : "";
+            const time = fmtDate(cm.createdAt || cm.created_at);
+
+            console.log("");
+            console.log(
+                `  ${c("cyan", author)}${badge}${rating}  ${c("dim", time)}`,
+            );
+            console.log(`  ${cm.content}`);
+        }
     }
-  }
-  console.log('');
+    console.log("");
 }
 
 module.exports = { runComment, runComments };

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
  */