jpm-pkg 1.0.3

package/src/utils/http.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const https = require('node:https');
+const http = require('node:http');
+const zlib = require('node:zlib');
+const logger = require('./logger');
+
+const DEFAULT_TIMEOUT = 30_000;
+const DEFAULT_RETRIES = 3;
+const RETRY_DELAY = 1_000;
+const USER_AGENT = `jpm/1.0.0 node/${process.version}`;
+
+// Connection pool via keepAlive agents
+const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 20 });
+const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 20 });
+
+const CIRCUIT_THRESHOLD = 5;
+const CIRCUIT_RESET_MS = 60_000;
+const breakerState = {
+    failures: 0,
+    lastFailure: 0,
+    open: false,
+};
+
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function checkBreaker() {
+    if (!breakerState.open) return;
+    if (Date.now() - breakerState.lastFailure > CIRCUIT_RESET_MS) {
+        breakerState.open = false;
+        breakerState.failures = 0;
+        logger.verbose('Circuit Breaker: Resetting to CLOSED');
+    } else {
+        throw new Error('Circuit Breaker is OPEN. Registry might be down.');
+    }
+}
+
+/**
+ * options: { method, headers, timeout, retries, retryDelay, stream }
+ * Returns: { status, headers, body } or a raw IncomingMessage if stream:true
+ */
+function request(url, options = {}) {
+    const {
+        method = 'GET',
+        headers = {},
+        timeout = DEFAULT_TIMEOUT,
+        retries = DEFAULT_RETRIES,
+        retryDelay = RETRY_DELAY,
+        body = null,
+        stream = false,
+        strict = false,
+    } = options;
+
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === 'https:';
+
+    if (strict && !isHttps) {
+        throw new Error(`Insecure protocol "${parsed.protocol}" blocked in strict mode: ${url}`);
+    }
+    const lib = isHttps ? https : http;
+    const agent = isHttps ? httpsAgent : httpAgent;
+
+    checkBreaker();
+
+    const reqOptions = {
+        hostname: parsed.hostname,
+        port: parsed.port || (isHttps ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method,
+        agent,
+        headers: {
+            'User-Agent': USER_AGENT,
+            'Accept-Encoding': 'gzip, deflate',
+            'Accept': 'application/json',
+            ...headers,
+        },
+    };
+
+    function attempt(attemptsLeft) {
+        return new Promise((resolve, reject) => {
+            const req = lib.request(reqOptions, (res) => {
+                // Successful response or redirect clears one failure
+                if (res.statusCode < 400) {
+                    breakerState.failures = Math.max(0, breakerState.failures - 1);
+                }
+
+                // Follow redirects (301, 302, 307, 308)
+                if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
+                    logger.verbose(`Redirect → ${res.headers.location}`);
+                    request(res.headers.location, options).then(resolve, reject);
+                    return;
+                }
+
+                if (stream) { resolve(res); return; }
+
+                // Decompress
+                let pipe = res;
+                const enc = res.headers['content-encoding'];
+                if (enc === 'gzip') pipe = res.pipe(zlib.createGunzip());
+                if (enc === 'deflate') pipe = res.pipe(zlib.createInflate());
+
+                const chunks = [];
+                pipe.on('data', c => chunks.push(c));
+                pipe.on('end', () => {
+                    const raw = Buffer.concat(chunks).toString('utf8');
+                    resolve({ status: res.statusCode, headers: res.headers, body: raw });
+                });
+                pipe.on('error', (err) => {
+                    recordFailure();
+                    reject(err);
+                });
+            });
+
+            req.setTimeout(timeout, () => {
+                recordFailure();
+                req.destroy(new Error(`Timeout after ${timeout}ms: ${url}`));
+            });
+
+            req.on('error', async (err) => {
+                if (attemptsLeft > 1) {
+                    logger.verbose(`Retry (${retries - attemptsLeft + 2}/${retries}) ${url}`);
+                    await delay(retryDelay);
+                    attempt(attemptsLeft - 1).then(resolve, reject);
+                } else {
+                    recordFailure();
+                    reject(err);
+                }
+            });
+
+            if (body) req.write(typeof body === 'string' ? body : JSON.stringify(body));
+            req.end();
+        });
+    }
+
+    /**
+     * Records a failure into the circuit breaker state.
+     * @private
+     */
+    function recordFailure() {
+        breakerState.failures++;
+        breakerState.lastFailure = Date.now();
+        if (breakerState.failures >= CIRCUIT_THRESHOLD) {
+            breakerState.open = true;
+            logger.error('Circuit Breaker: OPENING due to consistent failures');
+        }
+    }
+
+    return attempt(retries);
+}
+
+/**
+ * Convenience method for fetching and parsing JSON from a URL.
+ * 
+ * @param {string} url - Target URL
+ * @param {Object} [opts] - Request options
+ * @returns {Promise<Object>} Parsed JSON object
+ */
+async function getJSON(url, opts = {}) {
+    const { status, body } = await request(url, { ...opts, headers: { Accept: 'application/json', ...(opts.headers || {}) } });
+    if (status < 200 || status >= 300) {
+        const err = new Error(`HTTP ${status}: ${url}`);
+        err.status = status;
+        err.body = body;
+        throw err;
+    }
+    try {
+        return JSON.parse(body);
+    } catch (e) {
+        throw new Error(`Invalid JSON from ${url}: ${e.message}\nBody snippet: ${body.slice(0, 200)}`);
+    }
+}
+
+/**
+ * Downloads a resource and pipes it to a destination stream.
+ * 
+ * @param {string} url - Source URL
+ * @param {import('node:stream').Writable} destStream - Target stream
+ * @param {Object} [opts] - Request options including onProgress callback
+ * @returns {Promise<void>}
+ */
+async function download(url, destStream, opts = {}) {
+    return new Promise((resolve, reject) => {
+        request(url, { ...opts, stream: true }).then(res => {
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+                return;
+            }
+            let pipe = res;
+            const enc = res.headers['content-encoding'];
+            if (enc === 'gzip') pipe = res.pipe(zlib.createGunzip());
+            if (enc === 'deflate') pipe = res.pipe(zlib.createInflate());
+
+            const total = parseInt(res.headers['content-length'] || '0', 10);
+            let received = 0;
+            pipe.on('data', chunk => {
+                received += chunk.length;
+                opts.onProgress?.(received, total);
+            });
+            pipe.pipe(destStream);
+            destStream.on('finish', resolve);
+            destStream.on('error', reject);
+            pipe.on('error', reject);
+        }, reject);
+    });
+}
+
+/**
+ * Retrieves a list of all packages currently stored in the local cache.
+ * 
+ * @returns {{ name: string, version: string }[]}
+ */
+function list() {
+    const root = cacheRoot();
+    if (!fs.existsSync(root)) return [];
+    const result = [];
+    for (const scopeOrName of fs.readdirSync(root)) {
+        const dir = path.join(root, scopeOrName);
+        if (!fs.statSync(dir).isDirectory()) continue;
+        for (const file of fs.readdirSync(dir)) {
+            if (file.endsWith('.tgz')) {
+                const version = file.replace('.tgz', '');
+                const name = scopeOrName.replace('__SCOPE__', '/');
+                result.push({ name, version });
+            }
+        }
+    }
+    return result;
+}
+
+module.exports = { request, getJSON, download, list };

package/src/utils/logger.js

@@ -0,0 +1,128 @@
+'use strict';
+
+// ANSI color codes — no external dep
+const C = {
+  reset:   '\x1b[0m',
+  bold:    '\x1b[1m',
+  dim:     '\x1b[2m',
+  red:     '\x1b[31m',
+  green:   '\x1b[32m',
+  yellow:  '\x1b[33m',
+  blue:    '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan:    '\x1b[36m',
+  white:   '\x1b[37m',
+  gray:    '\x1b[90m',
+  bgRed:   '\x1b[41m',
+  bgGreen: '\x1b[42m',
+};
+
+const isTTY = process.stdout.isTTY;
+const noColor = process.env.NO_COLOR || process.env.JPM_NO_COLOR;
+
+function colorize(code, text) {
+  if (noColor || !isTTY) return text;
+  return `${code}${text}${C.reset}`;
+}
+
+// Log levels: silent=0, error=1, warn=2, info=3, verbose=4, debug=5
+let logLevel = 3;
+
+function setLevel(level) {
+  const levels = { silent: 0, error: 1, warn: 2, info: 3, verbose: 4, debug: 5 };
+  logLevel = typeof level === 'string' ? (levels[level] ?? 3) : level;
+}
+
+const prefix = {
+  error:   colorize(C.red,     '✖ error'),
+  warn:    colorize(C.yellow,  '⚠ warn '),
+  info:    colorize(C.cyan,    'ℹ info '),
+  success: colorize(C.green,   '✔ '),
+  verbose: colorize(C.gray,    '… verb '),
+  debug:   colorize(C.magenta, '⬡ debug'),
+};
+
+const logger = {
+  setLevel,
+
+  error(...args) {
+    if (logLevel >= 1) process.stderr.write(`${prefix.error}  ${args.join(' ')}\n`);
+  },
+
+  warn(...args) {
+    if (logLevel >= 2) process.stderr.write(`${prefix.warn}  ${args.join(' ')}\n`);
+  },
+
+  info(...args) {
+    if (logLevel >= 3) process.stdout.write(`${prefix.info}  ${args.join(' ')}\n`);
+  },
+
+  success(...args) {
+    if (logLevel >= 3) process.stdout.write(`${prefix.success}${args.join(' ')}\n`);
+  },
+
+  verbose(...args) {
+    if (logLevel >= 4) process.stdout.write(`${prefix.verbose}  ${args.join(' ')}\n`);
+  },
+
+  debug(...args) {
+    if (logLevel >= 5) process.stdout.write(`${prefix.debug}  ${args.join(' ')}\n`);
+  },
+
+  // Plain output — always printed unless silent
+  log(...args) {
+    if (logLevel >= 1) process.stdout.write(`${args.join(' ')}\n`);
+  },
+
+  // Highlighted section header
+  section(title) {
+    if (logLevel >= 3) process.stdout.write(`\n${colorize(C.bold + C.cyan, title)}\n`);
+  },
+
+  // Render a 2-column table
+  table(rows, headers) {
+    if (logLevel < 3) return;
+    const cols = headers || Object.keys(rows[0] || {});
+    const widths = cols.map(c => Math.max(c.length, ...rows.map(r => String(r[c] ?? '').length)));
+    const hr = widths.map(w => '─'.repeat(w + 2)).join('┼');
+    const fmt = (row, isHead = false) => cols
+      .map((c, i) => {
+        const cell = String(row[c] ?? '').padEnd(widths[i]);
+        return isHead ? colorize(C.bold, ` ${cell} `) : ` ${cell} `;
+      })
+      .join('│');
+    process.stdout.write(`┌${hr.replace(/┼/g, '┬')}┐\n`);
+    process.stdout.write(`│${fmt(Object.fromEntries(cols.map(c => [c, c])), true)}│\n`);
+    process.stdout.write(`├${hr}┤\n`);
+    rows.forEach(r => process.stdout.write(`│${fmt(r)}│\n`));
+    process.stdout.write(`└${hr.replace(/┼/g, '┴')}┘\n`);
+  },
+
+  // Render a dependency tree
+  tree(node, prefix_ = '', isLast = true) {
+    if (logLevel < 3) return;
+    const connector = isLast ? '└── ' : '├── ';
+    const ext       = isLast ? '    ' : '│   ';
+    const name = colorize(C.bold, node.name);
+    const ver  = colorize(C.gray, `@${node.version}`);
+    process.stdout.write(`${prefix_}${prefix_ ? connector : ''}${name}${ver}\n`);
+    const children = node.dependencies || [];
+    children.forEach((child, i) => {
+      logger.tree(child, prefix_ + (prefix_ ? ext : ''), i === children.length - 1);
+    });
+  },
+
+  // Colorize helpers exposed for other modules
+  c: {
+    red:     (t) => colorize(C.red, t),
+    green:   (t) => colorize(C.green, t),
+    yellow:  (t) => colorize(C.yellow, t),
+    blue:    (t) => colorize(C.blue, t),
+    cyan:    (t) => colorize(C.cyan, t),
+    gray:    (t) => colorize(C.gray, t),
+    bold:    (t) => colorize(C.bold, t),
+    magenta: (t) => colorize(C.magenta, t),
+  },
+};
+
+module.exports = logger;

package/src/utils/lru-cache.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * A simple Least Recently Used (LRU) cache implementation.
+ */
+class LRUCache {
+    /**
+     * @param {number} [maxSize=500] - Maximum number of items in the cache.
+     */
+    constructor(maxSize = 500) {
+        this.maxSize = maxSize;
+        this.cache = new Map();
+    }
+
+    /**
+     * Gets an item from the cache.
+     * 
+     * @param {string} key - The key to retrieve.
+     * @returns {*} The cached value, or undefined if not found.
+     */
+    get(key) {
+        if (!this.cache.has(key)) return undefined;
+
+        // Refresh position (move to most recently used)
+        const val = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, val);
+        return val;
+    }
+
+    /**
+     * Sets an item in the cache.
+     * 
+     * @param {string} key - The key to store.
+     * @param {*} value - The value to store.
+     */
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        } else if (this.cache.size >= this.maxSize) {
+            // Evict least recently used (first item in Map iterator)
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+        }
+        this.cache.set(key, value);
+    }
+
+    /**
+     * Checks if a key exists in the cache.
+     * 
+     * @param {string} key - The key to check.
+     * @returns {boolean}
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+
+    /**
+     * Clears the cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+
+module.exports = LRUCache;

package/src/utils/progress.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const isTTY = process.stdout.isTTY;
+
+// ── Spinner ───────────────────────────────────────────────────────────────────
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+class Spinner {
+    constructor(text = '') {
+        this.text = text;
+        this._frame = 0;
+        this._timer = null;
+        this._active = false;
+    }
+
+    start(text) {
+        if (text) this.text = text;
+        if (!isTTY) { process.stdout.write(`${this.text}...\n`); return this; }
+        this._active = true;
+        this._render();
+        this._timer = setInterval(() => this._render(), 80);
+        return this;
+    }
+
+    _render() {
+        const frame = FRAMES[this._frame++ % FRAMES.length];
+        process.stdout.write(`\r\x1b[36m${frame}\x1b[0m ${this.text}\x1b[K`);
+    }
+
+    update(text) {
+        this.text = text;
+        return this;
+    }
+
+    succeed(text) {
+        this._stop();
+        const msg = text || this.text;
+        process.stdout.write(`\r\x1b[32m✔\x1b[0m ${msg}\x1b[K\n`);
+        return this;
+    }
+
+    fail(text) {
+        this._stop();
+        const msg = text || this.text;
+        process.stderr.write(`\r\x1b[31m✖\x1b[0m ${msg}\x1b[K\n`);
+        return this;
+    }
+
+    warn(text) {
+        this._stop();
+        const msg = text || this.text;
+        process.stdout.write(`\r\x1b[33m⚠\x1b[0m ${msg}\x1b[K\n`);
+        return this;
+    }
+
+    _stop() {
+        if (this._timer) { clearInterval(this._timer); this._timer = null; }
+        this._active = false;
+        if (isTTY) process.stdout.write('\r\x1b[K');
+    }
+}
+
+// ── Progress Bar ─────────────────────────────────────────────────────────────
+class ProgressBar {
+    constructor({ total = 100, width = 30, label = '' } = {}) {
+        this.total = total;
+        this.width = width;
+        this.label = label;
+        this.current = 0;
+    }
+
+    tick(amount = 1) {
+        this.current = Math.min(this.current + amount, this.total);
+        this._render();
+        if (this.current >= this.total) process.stdout.write('\n');
+    }
+
+    set(value) {
+        this.current = Math.min(value, this.total);
+        this._render();
+        if (this.current >= this.total) process.stdout.write('\n');
+    }
+
+    _render() {
+        if (!isTTY) return;
+        const pct = this.current / this.total;
+        const filled = Math.round(this.width * pct);
+        const bar = `\x1b[32m${'█'.repeat(filled)}\x1b[90m${'░'.repeat(this.width - filled)}\x1b[0m`;
+        const pctStr = `${Math.round(pct * 100)}%`.padStart(4);
+        const cur = String(this.current).padStart(String(this.total).length);
+        process.stdout.write(`\r ${bar} ${pctStr}  ${cur}/${this.total}  ${this.label}\x1b[K`);
+    }
+}
+
+// ── Multi-line download tracker ───────────────────────────────────────────────
+class MultiBar {
+    constructor() {
+        this._bars = new Map();
+        this._lines = 0;
+    }
+
+    add(name, total) {
+        this._bars.set(name, { current: 0, total, name });
+        this._render();
+        return name;
+    }
+
+    update(name, current) {
+        const bar = this._bars.get(name);
+        if (bar) { bar.current = current; this._render(); }
+    }
+
+    remove(name) {
+        this._bars.delete(name);
+        this._render();
+    }
+
+    _render() {
+        if (!isTTY) return;
+        // Move cursor up to overwrite previous output
+        if (this._lines > 0) process.stdout.write(`\x1b[${this._lines}A`);
+        let out = '';
+        for (const bar of this._bars.values()) {
+            const pct = bar.total ? bar.current / bar.total : 0;
+            const filled = Math.round(20 * pct);
+            const b = `\x1b[32m${'█'.repeat(filled)}\x1b[90m${'░'.repeat(20 - filled)}\x1b[0m`;
+            const name = bar.name.slice(0, 30).padEnd(30);
+            const pctStr = `${Math.round(pct * 100)}%`.padStart(4);
+            out += `\r ${b} ${pctStr}  ${name}\x1b[K\n`;
+        }
+        process.stdout.write(out);
+        this._lines = this._bars.size;
+    }
+
+    stop() {
+        if (isTTY && this._lines > 0) process.stdout.write('\n');
+        this._bars.clear();
+        this._lines = 0;
+    }
+}
+
+module.exports = { Spinner, ProgressBar, MultiBar };