packup-cli 1.0.0

package/bin/packup.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// bin/packup.js
+import { pack, unpack, info } from '../src/index.js';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+
+const NAME = 'packup-cli';
+
+function usage() {
+  console.log(`${NAME} ${pkg.version} — Pack folders into portable strings
+
+Usage:
+  ${NAME} pack <folder>                Pack folder, copy string to clipboard
+  ${NAME} pack -o <file> <folder>      Pack folder, write string to file
+  ${NAME} unpack [dest]                Unpack from clipboard to dest (default: .)
+  ${NAME} unpack -i <file> [dest]      Unpack from file to dest
+  ${NAME} info                         Show contents from clipboard
+  ${NAME} info -i <file>               Show contents from file
+
+Pack options:
+  --include-deps    Include dependency dirs (node_modules, vendor, etc.)
+
+General:
+  -h, --help        Show this help
+  -v, --version     Show version`);
+}
+
+function humanSize(bytes) {
+  if (bytes >= 1048576) return `${(bytes / 1048576).toFixed(1)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command || command === '-h' || command === '--help') {
+    usage();
+    return;
+  }
+
+  if (command === '-v' || command === '--version') {
+    console.log(`${NAME} ${pkg.version}`);
+    return;
+  }
+
+  try {
+    if (command === 'pack') {
+      let output = null;
+      let folder = null;
+      let includeDeps = false;
+
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === '-o' || args[i] === '--output') { output = args[++i]; }
+        else if (args[i] === '--include-deps') { includeDeps = true; }
+        else if (!args[i].startsWith('-')) { folder = args[i]; }
+        else { console.error(`Error: Unknown option: ${args[i]}`); process.exit(1); }
+      }
+
+      if (!folder) { console.error('Error: No folder specified.'); process.exit(1); }
+
+      const result = await pack(folder, {
+        clipboard: !output,
+        output: output || undefined,
+        includeDeps,
+      });
+
+      const target = output || 'clipboard';
+      console.log(`Packed '${folder}' -> ${target} (${humanSize(result.zipSize)} zip, ${humanSize(result.stringSize)} string)`);
+
+    } else if (command === 'unpack') {
+      let inputFile = null;
+      let dest = '.';
+
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === '-i' || args[i] === '--input') { inputFile = args[++i]; }
+        else if (!args[i].startsWith('-')) { dest = args[i]; }
+        else { console.error(`Error: Unknown option: ${args[i]}`); process.exit(1); }
+      }
+
+      const result = await unpack(null, dest, {
+        input: inputFile || undefined,
+        clipboard: !inputFile,
+      });
+
+      console.log('Integrity OK');
+      console.log(`Files: ${result.fileCount}`);
+      console.log(`Unpacked -> ${result.dest}/`);
+
+    } else if (command === 'info') {
+      let inputFile = null;
+
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === '-i' || args[i] === '--input') { inputFile = args[++i]; }
+        else { console.error(`Error: Unknown option: ${args[i]}`); process.exit(1); }
+      }
+
+      const details = await info(null, {
+        input: inputFile || undefined,
+        clipboard: !inputFile,
+      });
+
+      console.log(`${NAME} v${details.version} — integrity OK`);
+      console.log(`  Source: ${details.source}/`);
+      console.log(`  Files:  ${details.fileCount}`);
+      console.log(`  Size:   ${humanSize(details.compressedSize)} (compressed)`);
+      console.log('');
+      for (const entry of details.entries) {
+        console.log(`  ${entry}`);
+      }
+
+    } else {
+      console.error(`Unknown command: ${command}`);
+      usage();
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(err.message.includes('Integrity') || err.message.includes('not a valid') || err.message.includes('Unsupported') ? 2 : 1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "packup-cli",
+  "version": "1.0.0",
+  "description": "Pack folders into portable, integrity-verified strings",
+  "type": "module",
+  "bin": {
+    "packup-cli": "bin/packup.js"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test 'test/**/*.test.js'"
+  },
+  "dependencies": {
+    "archiver": "^7.0.0",
+    "adm-zip": "^0.5.0",
+    "clipboardy": "^4.0.0"
+  }
+}

package/src/clipboard.js

@@ -0,0 +1,28 @@
+// src/clipboard.js
+
+let clipboardModule = null;
+
+async function getClipboard() {
+  if (!clipboardModule) {
+    try {
+      clipboardModule = await import('clipboardy');
+    } catch {
+      throw new Error('Clipboard not available. Use -i <file> or -o <file> instead.');
+    }
+  }
+  return clipboardModule;
+}
+
+export async function writeClipboard(text) {
+  const { default: clipboard } = await getClipboard();
+  await clipboard.write(text);
+}
+
+export async function readClipboard() {
+  const { default: clipboard } = await getClipboard();
+  const content = await clipboard.read();
+  if (!content) {
+    throw new Error('Clipboard is empty');
+  }
+  return content;
+}

package/src/compress.js

@@ -0,0 +1,37 @@
+// src/compress.js
+import archiver from 'archiver';
+import { stat } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { getExcludePatterns } from './exclude.js';
+
+export async function createZipBuffer(folderPath, { includeDeps = false } = {}) {
+  const absPath = resolve(folderPath);
+
+  const stats = await stat(absPath).catch(() => null);
+  if (!stats || !stats.isDirectory()) {
+    throw new Error(`Folder not found: ${absPath}`);
+  }
+
+  const excludePatterns = getExcludePatterns({ includeDeps });
+  const folderName = basename(absPath);
+
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const archive = archiver('zip', { zlib: { level: 9 } });
+
+    archive.on('data', (chunk) => chunks.push(chunk));
+    archive.on('end', () => resolve(Buffer.concat(chunks)));
+    archive.on('error', reject);
+    archive.on('warning', (err) => {
+      if (err.code !== 'ENOENT') reject(err);
+    });
+
+    archive.glob('**/*', {
+      cwd: absPath,
+      dot: true,
+      ignore: excludePatterns,
+    }, { prefix: folderName });
+
+    archive.finalize();
+  });
+}

package/src/decompress.js

@@ -0,0 +1,46 @@
+// src/decompress.js
+import AdmZip from 'adm-zip';
+import { mkdir } from 'node:fs/promises';
+
+const MAX_FILES = 10_000;
+const MAX_UNCOMPRESSED = 500 * 1024 * 1024; // 500 MB
+
+export async function extractZipBuffer(zipBuffer, dest) {
+  let zip;
+  try {
+    zip = new AdmZip(zipBuffer);
+  } catch {
+    throw new Error('Invalid zip data — cannot extract');
+  }
+
+  const allEntries = zip.getEntries();
+  if (allEntries.length > MAX_FILES) {
+    throw new Error(`Archive contains too many entries (${allEntries.length}, max ${MAX_FILES})`);
+  }
+  const totalSize = allEntries.reduce((sum, e) => sum + (e.header?.size || 0), 0);
+  if (totalSize > MAX_UNCOMPRESSED) {
+    throw new Error(`Archive uncompressed size too large (${totalSize} bytes, max ${MAX_UNCOMPRESSED})`);
+  }
+
+  const entries = allEntries
+    .filter(e => !e.isDirectory)
+    .map(e => e.entryName);
+
+  await mkdir(dest, { recursive: true });
+  zip.extractAllTo(dest, true);
+
+  return { fileCount: entries.length, entries };
+}
+
+export function listZipEntries(zipBuffer) {
+  let zip;
+  try {
+    zip = new AdmZip(zipBuffer);
+  } catch {
+    throw new Error('Invalid zip data — cannot list entries');
+  }
+
+  return zip.getEntries()
+    .filter(e => !e.isDirectory)
+    .map(e => e.entryName);
+}

package/src/exclude.js

@@ -0,0 +1,30 @@
+// src/exclude.js
+
+export const ALWAYS_EXCLUDE = [
+  '.git', '.git/**',
+  '**/.DS_Store',
+  '**/.env', '**/.env.*',
+  '__MACOSX', '__MACOSX/**',
+  '**/Thumbs.db', '**/desktop.ini',
+  '**/$RECYCLE.BIN', '**/$RECYCLE.BIN/**',
+];
+
+export const DEPS_EXCLUDE = [
+  'node_modules', 'node_modules/**',
+  'vendor', 'vendor/**',
+  '.venv', '.venv/**', 'venv', 'venv/**',
+  '__pycache__', '__pycache__/**',
+  '.dart_tool', '.dart_tool/**',
+  'build', 'build/**', 'dist', 'dist/**',
+  '.next', '.next/**', '.nuxt', '.nuxt/**',
+  'target', 'target/**',
+  'Pods', 'Pods/**',
+];
+
+export function getExcludePatterns({ includeDeps = false } = {}) {
+  const patterns = [...ALWAYS_EXCLUDE];
+  if (!includeDeps) {
+    patterns.push(...DEPS_EXCLUDE);
+  }
+  return patterns;
+}

package/src/format.js

@@ -0,0 +1,44 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+
+const PREFIX = 'PACKUP';
+const VERSION = 1;
+
+export function buildString(base64Data) {
+  const hash = createHash('sha256').update(base64Data).digest('hex');
+  return `${PREFIX}:${VERSION}:${hash}:${base64Data}`;
+}
+
+export function parseString(raw) {
+  if (!raw.startsWith(`${PREFIX}:`)) {
+    throw new Error('Not a valid packup string (missing PACKUP prefix)');
+  }
+
+  const firstColon = raw.indexOf(':');
+  const secondColon = raw.indexOf(':', firstColon + 1);
+  const thirdColon = raw.indexOf(':', secondColon + 1);
+
+  if (secondColon === -1 || thirdColon === -1) {
+    throw new Error('Not a valid packup string (malformed)');
+  }
+
+  const version = parseInt(raw.slice(firstColon + 1, secondColon), 10);
+  const hash = raw.slice(secondColon + 1, thirdColon);
+  const data = raw.slice(thirdColon + 1);
+
+  if (version !== VERSION) {
+    throw new Error(`Unsupported packup version: ${version}`);
+  }
+
+  if (!hash || !data) {
+    throw new Error('Not a valid packup string (missing hash or data)');
+  }
+
+  const computedHash = createHash('sha256').update(data).digest('hex');
+  const hashBuf = Buffer.from(hash);
+  const computedBuf = Buffer.from(computedHash);
+  if (hashBuf.length !== computedBuf.length || !timingSafeEqual(hashBuf, computedBuf)) {
+    throw new Error('Integrity check FAILED (hash mismatch). Data may be corrupted or tampered with.');
+  }
+
+  return { version, hash, data };
+}

package/src/index.js

@@ -0,0 +1,87 @@
+// src/index.js
+import { createZipBuffer } from './compress.js';
+import { extractZipBuffer, listZipEntries } from './decompress.js';
+import { buildString, parseString } from './format.js';
+import { readClipboard, writeClipboard } from './clipboard.js';
+import { readFile, writeFile } from 'node:fs/promises';
+import { gzip, gunzip } from 'node:zlib';
+import { promisify } from 'node:util';
+
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
+
+export async function pack(folder, { clipboard = false, output, includeDeps = false } = {}) {
+  const zipBuffer = await createZipBuffer(folder, { includeDeps });
+  const gzipped = await gzipAsync(zipBuffer, { level: 9 });
+  const base64Data = gzipped.toString('base64');
+  const packupString = buildString(base64Data);
+
+  const fileCount = listZipEntries(zipBuffer).length;
+  const result = {
+    string: packupString,
+    zipSize: zipBuffer.length,
+    stringSize: packupString.length,
+    fileCount,
+  };
+
+  if (output) {
+    await writeFile(output, packupString);
+  }
+
+  if (clipboard) {
+    await writeClipboard(packupString);
+  }
+
+  return result;
+}
+
+export async function unpack(input, dest = '.', options = {}) {
+  let raw = input;
+
+  if (!raw) {
+    if (options.input) {
+      raw = await readFile(options.input, 'utf8');
+    } else if (options.clipboard !== false) {
+      raw = await readClipboard();
+    } else {
+      throw new Error('No input provided');
+    }
+  }
+
+  const parsed = parseString(raw);
+  const gzipped = Buffer.from(parsed.data, 'base64');
+  const zipBuffer = await gunzipAsync(gzipped, { maxOutputLength: 500 * 1024 * 1024 });
+
+  const result = await extractZipBuffer(zipBuffer, dest);
+  return { fileCount: result.fileCount, dest };
+}
+
+export async function info(input, options = {}) {
+  let raw = input;
+
+  if (!raw) {
+    if (options.input) {
+      raw = await readFile(options.input, 'utf8');
+    } else if (options.clipboard !== false) {
+      raw = await readClipboard();
+    } else {
+      throw new Error('No input provided');
+    }
+  }
+
+  const parsed = parseString(raw);
+  const gzipped = Buffer.from(parsed.data, 'base64');
+  const zipBuffer = await gunzipAsync(gzipped, { maxOutputLength: 500 * 1024 * 1024 });
+
+  const entries = listZipEntries(zipBuffer);
+  const source = entries.length > 0 ? entries[0].split('/')[0] : 'unknown';
+
+  return {
+    version: parsed.version,
+    hash: parsed.hash,
+    source,
+    fileCount: entries.length,
+    compressedSize: zipBuffer.length,
+    entries,
+  };
+}