@voxframeworks/linetools 1.0.1 → 1.0.5

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "liveServer.settings.port": 5501
+}

package/main.js

@@ -4,10 +4,13 @@ const touch = require('./tools/touch.js');
 const mv = require('./tools/mv.js');
 const tar = require('./tools/tar.js');
 const rmdir = require('./tools/rmdir.js');
+const chmod = require('./tools/chmod.js');
 module.exports = {
     mkdir : mkdir,
     cp : cp,
     touch : touch,
     mv : mv,
-    rmdir : rmdir
+    rmdir : rmdir,
+    tar : tar,
+    chmod : chmod
 }

package/package.json

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

package/readme.md

@@ -20,8 +20,20 @@ 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
+------------------
+Chmod tips:
+7 = read, write, execute
+5 = read, execute
+0 = none
+------------------
 We will be adding more soon!
 
 By VoxFrameworks

package/test.js

@@ -1,2 +1,3 @@
 const linetools = require('linetools');
 linetools.tar('testOUT', 'testDir', 'rezip')
+linetools.chmod('testDir', '755')

package/tools/chmod.js

@@ -0,0 +1,122 @@
+// lib/chmod.js
+/**
+ * Change the permissions of a file or directory.
+ *
+ * @param {string} targetPath               – Path to file or directory.
+ * @param {string|number} mode              – Permission bits.
+ *                                            * If a string: interpreted as octal (e.g. '755')
+ *                                            * If a number: used directly (e.g. 0o755)
+ * @param {object} [options]                – Optional flags.
+ * @param {boolean} [options.recursive]    – If true and target is a directory,
+ *                                            change permissions of every descendant.
+ *
+ * @returns {Promise<void>}
+ *
+ * @example
+ * // change a single file
+ * await chmod('tmp/foo.txt', '644');
+ *
+ * // change a folder recursively
+ * await chmod('tmp/myDir', 0o755, { recursive: true });
+ */
+const { promises: fs } = require('fs');
+const path = require('path');
+
+/**
+ * Convert a user‑provided mode to a proper numeric value.
+ * Accepts:
+ *   • string like "755", "0644", "0o777"
+ *   • number (already a mode)
+ */
+function normalizeMode(mode) {
+  if (typeof mode === 'number') return mode; // already numeric
+  if (typeof mode !== 'string')
+    throw new TypeError('Mode must be a string or a number');
+
+  // Strip common prefixes (0o, 0, etc.) and parse as octal.
+  const clean = mode.replace(/^0o?/, '');
+  const parsed = parseInt(clean, 8);
+  if (Number.isNaN(parsed))
+    throw new Error(`Invalid permission mode: "${mode}"`);
+  return parsed;
+}
+
+/**
+ * Recursively walk a directory tree and collect *all* entries (files + dirs).
+ * Returns an array of absolute paths.
+ */
+async function walkRecursively(dir) {
+  const result = [];
+
+  async function walk(current) {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      result.push(full);
+      if (entry.isDirectory()) await walk(full);
+    }
+  }
+
+  await walk(dir);
+  return result;
+}
+
+/**
+ * The public API – async function.
+ */
+async function chmod(targetPath, mode, options = {}) {
+  const normalizedMode = normalizeMode(mode);
+  const { recursive = false } = options;
+
+  // Verify the target exists first – otherwise `fs.chmod` would throw a less‑friendly ENOENT.
+  let stats;
+  try {
+    stats = await fs.lstat(targetPath);
+  } catch (err) {
+    throw new Error(`Path does not exist: ${targetPath}`);
+  }
+
+  // --------------------------------------------------------------
+  // 1️⃣  Non‑recursive case (file OR directory)
+  // --------------------------------------------------------------
+  if (!recursive) {
+    await fs.chmod(targetPath, normalizedMode);
+    return;
+  }
+
+  // --------------------------------------------------------------
+  // 2️⃣  Recursive case – target must be a directory
+  // --------------------------------------------------------------
+  if (!stats.isDirectory())
+    throw new Error(
+      `Recursive chmod can only be used on directories. "${targetPath}" is not a directory.`
+    );
+
+  // Change the *directory* itself first (so it matches the children afterwards)
+  await fs.chmod(targetPath, normalizedMode);
+
+  // Walk the tree and chmod everything we find.
+  const allPaths = await walkRecursively(targetPath);
+
+  // Use `Promise.all` but limit concurrency a bit to avoid overwhelming the FS on huge trees.
+  const MAX_CONCURRENT = 100;
+  const queue = [...allPaths];
+  const workers = Array.from({ length: MAX_CONCURRENT }, async () => {
+    while (queue.length) {
+      const p = queue.pop();
+      try {
+        await fs.chmod(p, normalizedMode);
+      } catch (e) {
+        // We *continue* on errors so the rest of the tree still gets processed.
+        console.warn(`⚠️  Could not chmod "${p}": ${e.message}`);
+      }
+    }
+  });
+
+  await Promise.all(workers);
+}
+
+/* ------------------------------------------------------------------ */
+/* Export for the public API                                            */
+/* ------------------------------------------------------------------ */
+module.exports = chmod;

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;