@voxframeworks/linetools 1.0.1 → 1.0.2

package/main.js

@@ -9,5 +9,6 @@ module.exports = {
     cp : cp,
     touch : touch,
     mv : mv,
-    rmdir : rmdir
+    rmdir : rmdir,
+    tar : tar
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxframeworks/linetools",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "command line tools for js",
   "main": "main.js",
   "scripts": {

package/readme.md

@@ -20,8 +20,15 @@ The list of commands we have is:
 • cp
 • mv
 • touch
-• tar (not working)
-
+• tar (fixed)
+-----------------
+Tar usage:
+linetools.tar('testOUT', 'testDir', 'rezip')
+TestDir = Directory to be zipped
+TestOut = Directory for the zip to be put in
+rezip = zip
+unzip = unzip
+------------------
 We will be adding more soon!
 
 By VoxFrameworks

package/tools/tar.js

@@ -1,69 +1,141 @@
-const tarModule = require('tar');
+// lib/tar.js
+/**
+ * Tiny wrapper around the `tar` package.
+ *
+ *   linetools.tar(target, source, type)
+ *
+ *   target  – where the archive should be written (for "rezip")
+ *            OR the archive to read (for "unzip").
+ *            It may be:
+ *              • a full filename, e.g. "out/pkg.tar.gz"
+ *              • a directory name – the function will create
+ *                "archive.tar" (or "archive.tar.gz") inside it.
+ *
+ *   source – folder to pack / file to pack (rezip)   OR
+ *            destination folder for extraction (unzip)
+ *
+ *   type   – "rezip" (create) or "unzip" (extract)
+ *
+ * Supports g‑zipped archives when the target ends with ".gz" or ".tar.gz".
+ *
+ * @param {string} targetPath
+ * @param {string} sourcePath
+ * @param {'unzip'|'rezip'} type
+ * @returns {Promise<void>}
+ */
+const tar = require('tar');
 const fs = require('fs').promises;
 const path = require('path');
 
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+/**
+ * Resolve a *file* name for the archive.
+ * If `targetPath` already points to an existing directory,
+ * a default filename (`archive.tar` or `archive.tar.gz`) is added.
+ * If no extension is supplied, `.tar` (or `.tar.gz` for gzip) is appended.
+ */
+async function resolveTargetFile(targetPath, mode) {
+  const stat = await fs.lstat(targetPath).catch(() => null);
+
+  // ── target is an existing directory → add a default filename ──
+  if (stat && stat.isDirectory()) {
+    if (mode !== 'rezip')
+      throw new Error(
+        'When extracting, targetPath must be a file (the tarball).'
+      );
+    const defaultName = targetPath.endsWith('.gz')
+      ? 'archive.tar.gz'
+      : 'archive.tar';
+    return path.join(targetPath, defaultName);
+  }
+
+  // ── target does NOT exist – make sure its parent directory exists ──
+  const parent = path.dirname(targetPath);
+  await ensureDir(parent);
+
+  // ── does it already have a proper .tar/.tar.gz extension? ──
+  const hasTarExt = targetPath.endsWith('.tar') || targetPath.endsWith('.tar.gz');
+  if (hasTarExt) return targetPath;
+
+  // ── no extension – infer one.  If the caller added a trailing ".gz"
+  //    (e.g. "out/.gz") we treat it as a request for gzip compression.
+  const inferred = targetPath + (mode === 'rezip' && targetPath.endsWith('.gz')
+    ? '.tar.gz'
+    : '.tar');
+  return inferred;
+}
+
 /**
- * Handles tar archive operations (unzip/rezip) for files and folders.
- * @param {string} targetPath - The path to the tarball file (output for rezip, input for unzip).
- * @param {string} sourcePath - The source directory/files for rezip, or the destination directory for unzip.
- * @param {'unzip' | 'rezip'} type - The operation type.
+ * Core operation – create (`rezip`) or extract (`unzip`) a tarball.
  */
-async function tar(targetPath, sourcePath, type) {
-    try {
-        if (type === 'unzip') {
-            // Ensure the destination directory exists
-            await fs.mkdir(sourcePath, { recursive: true });
-            console.log(`Starting extraction of '${targetPath}' to '${sourcePath}'...`);
-            // Extracting from a tarball (handles .tar, .tar.gz automatically with modern 'tar')
-            await tarModule.extract({
-                file: targetPath,
-                cwd: sourcePath, // Extract *into* this directory
-            });
-            console.log('Extraction completed successfully!');
-        } else if (type === 'rezip') {
-            const tarballDir = path.dirname(targetPath);
-            await fs.mkdir(tarballDir, { recursive: true }); // Ensure output dir exists
-
-            // For zipping folders, use tar.pack() with streams for better control & recursion
-            // or tar.create() if you prefer the object API and ensure 'gzip: true' for .tar.gz
-console.log(`Starting creation of tarball '${targetPath}' from '${sourcePath}'...`);
-    // Use tar.create or tar.c for creating streams
-    const archiveStream = tarModule.create({ gzip: targetPath.endsWith('.gz') }, sourcePath);
-            
-          fileHandle = await fs.open(targetPath, 'w');
-
-        // Create the write stream from the file handle
-        const writeStream = fileHandle.createWriteStream();
-            
-            // If you need .tar.gz, pipe through gzip stream
-            if (targetPath.endsWith('.gz')) {
-                const zlib = require('zlib');
-                await new Promise((resolve, reject) => {
-                    archiveStream
-                        .pipe(zlib.createGzip()) // Add gzip compression
-                        .pipe(outputStream)
-                        .on('finish', resolve)
-                        .on('error', reject);
-                });
-            } else {
-                // For plain .tar
-                await new Promise((resolve, reject) => {
-                    archiveStream
-                        .pipe(outputStream)
-                        .on('finish', resolve)
-                        .on('error', reject);
-                });
-            }
-            
-            console.log('Tarball creation completed successfully!');
-
-        } else {
-            throw new Error('Invalid type specified. Use "unzip" or "rezip".');
-        }
-    } catch (error) {
-        console.error(`Failed to perform tar operation (${type}):`, error.message);
-        throw error; // Rethrow to allow the calling function to handle the error
-    }
+async function tarOperation(targetPath, sourcePath, type) {
+  // -----------------------------------------------------------------
+  // 1️⃣  UNZIP  – extract archive into a directory
+  // -----------------------------------------------------------------
+  if (type === 'unzip') {
+    await ensureDir(sourcePath);
+    console.log(`🔽 Extracting '${targetPath}' → '${sourcePath}' …`);
+
+    await tar.extract({
+      file: targetPath,
+      cwd: sourcePath, // extract *into* this folder
+    });
+
+    console.log('✅ Extraction finished.');
+    return;
+  }
+
+  // -----------------------------------------------------------------
+  // 2️⃣  REZIP – create a tarball from a folder *or* a single file
+  // -----------------------------------------------------------------
+  if (type === 'rezip') {
+    // Resolve a real filename for the archive (adds .tar/.tar.gz if needed)
+    const finalTarget = await resolveTargetFile(targetPath, 'rezip');
+
+    // Determine if the source is a file or a directory
+    const srcStat = await fs.lstat(sourcePath).catch(() => {
+      throw new Error(`Source path does not exist: ${sourcePath}`);
+    });
+
+    // tar.create() needs:
+    //   - cwd : where the files are looked up
+    //   - file: the output tarball
+    //   - gzip: true if we want *.tar.gz
+    const tarOpts = {
+      cwd: srcStat.isDirectory() ? sourcePath : path.dirname(sourcePath),
+      file: finalTarget,
+      gzip: finalTarget.endsWith('.gz'), // true for .tar.gz, false for .tar
+      portable: true, // reproducible timestamps
+    };
+
+    // Decide which entries to feed to tar:
+    //   • directory → pack everything inside it (['.'])
+    //   • file      → pack only that one file (basename)
+    const entries = srcStat.isDirectory()
+      ? ['.']
+      : [path.basename(sourcePath)];
+
+    console.log(
+      `📦 Creating ${tarOpts.gzip ? 'gzip‑compressed ' : ''}` +
+        `tarball '${finalTarget}' from ${srcStat.isDirectory() ? 'folder' : 'file'} ` +
+        `'${sourcePath}' …`
+    );
+
+    // `tar.create` returns a promise that resolves when the stream finishes.
+    await tar.create(tarOpts, entries);
+
+    console.log('✅ Tarball created successfully.');
+    return;
+  }
+
+  // -----------------------------------------------------------------
+  // 3️⃣  WRONG TYPE
+  // -----------------------------------------------------------------
+  throw new Error('Invalid type – use "unzip" or "rezip".');
 }
 
-module.exports = tar;
+// Export the function that the consumer will receive as `linetools.tar`
+module.exports = tarOperation;