@penadidik/meo-agent 1.2.0

package/lib/args.js

@@ -0,0 +1,134 @@
+'use strict';
+
+function parseArgs(argv) {
+    const opts = {
+        url: null,
+        output: null,
+        continue: false,
+        json: false,
+        quiet: false,
+        timeout: null,
+        help: false,
+        version: false,
+        sha256: null,
+        mirror: false,
+        mirrorDepth: null,
+        mirrorLimit: null,
+        config: null,
+        pluginList: false
+    };
+
+    const positional = [];
+    for (let i = 2; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            case '-h':
+            case '--help':
+                opts.help = true;
+                break;
+            case '-V':
+            case '--version':
+                opts.version = true;
+                break;
+            case '-o':
+            case '--output':
+                opts.output = argv[++i];
+                break;
+            case '-c':
+            case '--continue':
+                opts.continue = true;
+                break;
+            case '-j':
+            case '--json':
+                opts.json = true;
+                break;
+            case '-q':
+            case '--quiet':
+                opts.quiet = true;
+                break;
+            case '-m':
+            case '--mirror':
+                opts.mirror = true;
+                break;
+            case '--sha256':
+                opts.sha256 = argv[++i];
+                break;
+            case '--mirror-depth':
+                opts.mirrorDepth = parseInt(argv[++i], 10);
+                break;
+            case '--mirror-limit':
+                opts.mirrorLimit = parseInt(argv[++i], 10);
+                break;
+            case '--config':
+                opts.config = argv[++i];
+                break;
+            case '--list-plugins':
+                opts.pluginList = true;
+                break;
+            case '--timeout':
+                opts.timeout = parseInt(argv[++i], 10);
+                break;
+            default:
+                positional.push(a);
+        }
+    }
+
+    if (positional.length > 0 && !opts.url) {
+        opts.url = positional[0];
+    }
+
+    return opts;
+}
+
+function printHelp() {
+    const help = `
+meo-agent — wget-like CLI for downloading files (Meo Code Labs)
+
+Usage:
+  meo-agent [options] <URL>
+  meo-agent [options] doctor
+  meo-agent [options] mirror <URL> -o <dir>
+  meo-agent [options] plugins
+
+Options:
+  -o, --output <name>      Save to a custom filename or directory (for mirror)
+  -c, --continue           Resume a partial download via HTTP Range
+  -m, --mirror             Recursive mirror mode (downloads HTML pages + assets)
+      --mirror-depth <N>   Max recursion depth (default: 2)
+      --mirror-limit <N>   Max total pages to download (default: 50)
+      --sha256 <hash>      Verify downloaded file SHA256
+  -j, --json               Emit machine-readable JSON events to stdout
+  -q, --quiet              Suppress progress output (errors only)
+      --timeout <sec>      Network timeout in seconds (default: 30)
+      --config <path>      Load config from custom path
+      --list-plugins       List loaded plugins and exit
+  -V, --version            Print version and exit
+  -h, --help               Print this help and exit
+
+Config file lookup order:
+  1. --config <path>        (explicit override)
+  2. ./.meo-agent.json      (current directory)
+  3. ~/.meo-agent.json      (home directory)
+  4. ~/.config/meo-agent/config.json (XDG)
+
+Plugin directories (auto-loaded):
+  - ./.meo-agent/plugins/
+  - ~/.meo-agent/plugins/
+  - ~/.config/meo-agent/plugins/
+
+Examples:
+  meo-agent https://example.com/file.zip
+  meo-agent -o backup.zip https://example.com/file.zip
+  meo-agent --sha256=abc123... https://example.com/file.zip
+  meo-agent --continue https://example.com/large.iso
+  meo-agent --mirror https://docs.example.com/ -o ./docs
+  meo-agent --json https://example.com/file.zip | jq
+  meo-agent doctor
+  meo-agent plugins
+
+Repository: https://github.com/meocode-labs/meo-agent
+`.trim();
+    console.log(help);
+}
+
+module.exports = { parseArgs, printHelp };

package/lib/checksum.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+
+function verifyFile(filePath, expectedSha256) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('sha256');
+        const stream = fs.createReadStream(filePath);
+
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => {
+            const actual = hash.digest('hex');
+            const ok = actual.toLowerCase() === expectedSha256.toLowerCase();
+            resolve({ ok, actual, expected: expectedSha256 });
+        });
+        stream.on('error', reject);
+    });
+}
+
+function parseChecksumArg(arg) {
+    if (arg.includes('=')) {
+        const [_, hash] = arg.split('=');
+        return hash;
+    }
+    return arg;
+}
+
+module.exports = { verifyFile, parseChecksumArg };

package/lib/config.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_PATHS = [
+    path.join(process.cwd(), '.meo-agent.json'),
+    path.join(os.homedir(), '.meo-agent.json'),
+    path.join(os.homedir(), '.config', 'meo-agent', 'config.json')
+];
+
+const DEFAULT_CONFIG = {
+    outputDir: null,
+    timeout: 30,
+    retries: 0,
+    headers: {},
+    plugins: [],
+    defaultChecksum: null,
+    mirrorMaxDepth: 2,
+    mirrorLimit: 50
+};
+
+function loadConfig(customPath) {
+    let config = { ...DEFAULT_CONFIG };
+
+    const pathsToCheck = customPath ? [customPath] : CONFIG_PATHS;
+
+    for (const p of pathsToCheck) {
+        try {
+            if (fs.existsSync(p)) {
+                const content = fs.readFileSync(p, 'utf8');
+                const parsed = JSON.parse(content);
+                config = { ...config, ...parsed };
+                config._loadedFrom = p;
+                break;
+            }
+        } catch (err) {
+            // ignore malformed config
+        }
+    }
+
+    return config;
+}
+
+function saveConfig(configPath, config) {
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+module.exports = { loadConfig, saveConfig, DEFAULT_CONFIG, CONFIG_PATHS };

package/lib/doctor.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const http = require('http');
+
+async function check(label, fn) {
+    try {
+        const result = await fn();
+        return { label, status: 'ok', detail: result };
+    } catch (err) {
+        return { label, status: 'fail', detail: err.message };
+    }
+}
+
+function doctor() {
+    return new Promise(async (resolve) => {
+        const checks = [];
+
+        checks.push(await check('Node.js version', async () => {
+            const v = process.version;
+            const major = parseInt(v.slice(1), 10);
+            if (major < 18) throw new Error(`${v} — requires Node 18+`);
+            return v;
+        }));
+
+        checks.push(await check('Platform', async () => `${os.platform()} ${os.arch()} (${os.release()})`));
+
+        checks.push(await check('Current directory writable', async () => {
+            const testFile = path.join(process.cwd(), '.meo-agent-doctor.tmp');
+            fs.writeFileSync(testFile, 'ok');
+            fs.unlinkSync(testFile);
+            return process.cwd();
+        }));
+
+        checks.push(await check('Temp directory writable', async () => {
+            const testFile = path.join(os.tmpdir(), '.meo-agent-doctor.tmp');
+            fs.writeFileSync(testFile, 'ok');
+            fs.unlinkSync(testFile);
+            return os.tmpdir();
+        }));
+
+        checks.push(await check('HTTPS connectivity (github.com)', async () => {
+            return new Promise((res, rej) => {
+                const req = https.get('https://github.com', { timeout: 10000 }, (r) => {
+                    r.resume();
+                    if (r.statusCode >= 200 && r.statusCode < 500) res(`HTTP ${r.statusCode}`);
+                    else rej(new Error(`HTTP ${r.statusCode}`));
+                });
+                req.on('timeout', () => req.destroy(new Error('timeout')));
+                req.on('error', rej);
+            });
+        }));
+
+        checks.push(await check('HTTP connectivity (example.com)', async () => {
+            return new Promise((res, rej) => {
+                const req = http.get('http://example.com', { timeout: 10000 }, (r) => {
+                    r.resume();
+                    if (r.statusCode >= 200 && r.statusCode < 500) res(`HTTP ${r.statusCode}`);
+                    else rej(new Error(`HTTP ${r.statusCode}`));
+                });
+                req.on('timeout', () => req.destroy(new Error('timeout')));
+                req.on('error', rej);
+            });
+        }));
+
+        checks.push(await check('Disk space', async () => {
+            const df = require('child_process').execSync('df -k . 2>/dev/null || echo ""').toString();
+            const lines = df.split('\n').filter(Boolean);
+            if (lines.length < 2) return 'unknown';
+            const parts = lines[1].split(/\s+/);
+            const available = parseInt(parts[3] || '0', 10);
+            const availableMB = (available / 1024).toFixed(0);
+            if (available < 100 * 1024) throw new Error(`Only ${availableMB} MB available`);
+            return `${availableMB} MB available`;
+        }));
+
+        resolve(checks);
+    });
+}
+
+module.exports = { doctor };

package/lib/downloader.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+function pickClient(parsedUrl) {
+    return parsedUrl.protocol === 'https:' ? https : http;
+}
+
+function sanitizeFilename(name) {
+    return name.replace(/[\\/:*?"<>|]/g, '_').slice(0, 255) || 'index.html';
+}
+
+function deriveFilename(urlString) {
+    try {
+        const u = new URL(urlString);
+        const last = u.pathname.split('/').pop();
+        return sanitizeFilename(last || 'index.html');
+    } catch (e) {
+        return 'index.html';
+    }
+}
+
+function checkExisting(output, continueFlag) {
+    if (!fs.existsSync(output)) {
+        return { exists: false, offset: 0 };
+    }
+    if (!continueFlag) {
+        return { exists: true, offset: 0 };
+    }
+    const stat = fs.statSync(output);
+    return { exists: true, offset: stat.size };
+}
+
+function download(opts, reporter) {
+    return new Promise((resolve, reject) => {
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(opts.url);
+        } catch (e) {
+            return reject(new Error(`Invalid URL: ${opts.url}`));
+        }
+
+        const client = pickClient(parsedUrl);
+        const headers = { 'User-Agent': `meo-agent/1.0 (+https://github.com/meocode-labs/meo-agent)` };
+
+        if (opts.continue && fs.existsSync(opts.output)) {
+            const offset = fs.statSync(opts.output).size;
+            headers['Range'] = `bytes=${offset}-`;
+            reporter.info(`Resuming from byte ${offset}`);
+        }
+
+        const req = client.get(parsedUrl, { headers, timeout: opts.timeout }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                const redirectUrl = new URL(res.headers.location, parsedUrl).toString();
+                reporter.info(`Redirect → ${redirectUrl}`);
+                res.resume();
+                return resolve(download({ ...opts, url: redirectUrl }, reporter));
+            }
+
+            if (res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode} ${res.statusMessage || ''}`.trim()));
+            }
+
+            const totalBytes = parseInt(res.headers['content-length'] || '0', 10) + (opts.continue ? checkExisting(opts.output, true).offset : 0);
+            reporter.setTotal(totalBytes);
+
+            const flags = (res.statusCode === 206 || (opts.continue && fs.existsSync(opts.output))) ? 'a' : 'w';
+            const fileStream = fs.createWriteStream(opts.output, { flags });
+
+            let received = (flags === 'a' && fs.existsSync(opts.output)) ? fs.statSync(opts.output).size : 0;
+            reporter.progress(received);
+
+            res.on('data', (chunk) => {
+                received += chunk.length;
+                reporter.progress(received);
+            });
+
+            res.pipe(fileStream);
+
+            fileStream.on('finish', () => {
+                fileStream.close();
+                reporter.finish({
+                    statusCode: res.statusCode,
+                    resumed: flags === 'a'
+                });
+                resolve({
+                    output: opts.output,
+                    url: opts.url,
+                    bytes: received,
+                    statusCode: res.statusCode,
+                    resumed: flags === 'a'
+                });
+            });
+
+            fileStream.on('error', (err) => {
+                fs.unlink(opts.output, () => {});
+                reject(err);
+            });
+        });
+
+        req.on('timeout', () => {
+            req.destroy(new Error(`Network timeout after ${opts.timeout / 1000}s`));
+        });
+
+        req.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+module.exports = { download, deriveFilename, sanitizeFilename };

package/lib/mirror.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+function pickClient(u) {
+    return u.protocol === 'https:' ? https : http;
+}
+
+const SKIP_PATTERNS = [
+    /\?/,            // query strings
+    /#/,             // fragments
+    /\.(zip|tar|gz|tgz|7z|rar|exe|dmg|pkg|deb|rpm|iso)$/i
+];
+
+function shouldSkip(href) {
+    return SKIP_PATTERNS.some((re) => re.test(href));
+}
+
+function isSameOrigin(a, b) {
+    return a.host === b.host;
+}
+
+function fetchHtml(urlString, redirects = 0) {
+    return new Promise((resolve, reject) => {
+        if (redirects > 5) return reject(new Error('Too many redirects'));
+        let u;
+        try { u = new URL(urlString); } catch (e) { return reject(e); }
+
+        const client = pickClient(u);
+        const req = client.get(u, { timeout: 15000 }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                const next = new URL(res.headers.location, u).toString();
+                return resolve(fetchHtml(next, redirects + 1));
+            }
+            if (res.statusCode !== 200) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => resolve({ html: body, base: u }));
+            res.on('error', reject);
+        });
+        req.on('timeout', () => req.destroy(new Error('timeout')));
+        req.on('error', reject);
+    });
+}
+
+function extractLinks(html, base) {
+    const links = new Set();
+    const hrefRe = /href\s*=\s*["']([^"']+)["']/gi;
+    const srcRe = /src\s*=\s*["']([^"']+)["']/gi;
+
+    const seen = new Set();
+    for (const re of [hrefRe, srcRe]) {
+        let m;
+        while ((m = re.exec(html)) !== null) {
+            seen.add(m[1]);
+        }
+    }
+
+    for (const raw of seen) {
+        if (raw.startsWith('mailto:') || raw.startsWith('javascript:') || raw.startsWith('#')) continue;
+        try {
+            const u = new URL(raw, base);
+            u.hash = '';
+            links.add(u.toString());
+        } catch (e) {
+            // ignore invalid URLs
+        }
+    }
+    return Array.from(links);
+}
+
+async function mirror(baseUrlString, outputDir, opts = {}) {
+    const visited = new Set();
+    const queue = [baseUrlString];
+    const downloaded = [];
+    const maxDepth = opts.maxDepth || 2;
+    const limit = opts.limit || 50;
+
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    while (queue.length > 0 && downloaded.length < limit) {
+        const url = queue.shift();
+        if (visited.has(url)) continue;
+        visited.add(url);
+
+        if (shouldSkip(url)) continue;
+
+        let result;
+        try {
+            result = await fetchHtml(url);
+        } catch (err) {
+            continue;
+        }
+
+        const baseU = result.base;
+        const parsed = new URL(url);
+
+        let relPath;
+        if (url === baseUrlString) {
+            relPath = 'index.html';
+        } else {
+            relPath = parsed.pathname.replace(/^\//, '') || 'index.html';
+        }
+
+        const outPath = path.join(outputDir, relPath);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, result.html);
+
+        downloaded.push({ url, output: outPath });
+
+        if (downloaded.length - 1 < maxDepth) {
+            const links = extractLinks(result.html, baseU);
+            for (const link of links) {
+                try {
+                    const lu = new URL(link);
+                    if (isSameOrigin(lu, baseU) && !visited.has(link)) {
+                        queue.push(link);
+                    }
+                } catch (e) {
+                    // ignore
+                }
+            }
+        }
+    }
+
+    return downloaded;
+}
+
+module.exports = { mirror, fetchHtml, extractLinks };

package/lib/plugins.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PLUGIN_DIRS = [
+    path.join(process.cwd(), '.meo-agent', 'plugins'),
+    path.join(os.homedir(), '.meo-agent', 'plugins'),
+    path.join(os.homedir(), '.config', 'meo-agent', 'plugins')
+];
+
+class PluginManager {
+    constructor(reporter) {
+        this.reporter = reporter;
+        this.plugins = [];
+        this.hooks = {};
+    }
+
+    register(plugin) {
+        if (!plugin || typeof plugin.name !== 'string') {
+            throw new Error('Plugin must have a name');
+        }
+        this.plugins.push(plugin);
+        for (const hook of plugin.hooks || []) {
+            if (!this.hooks[hook.name]) this.hooks[hook.name] = [];
+            this.hooks[hook.name].push(hook.handler);
+        }
+        if (this.reporter && this.reporter.info) {
+            this.reporter.info(`Plugin loaded: ${plugin.name} v${plugin.version || '0.0.0'}`);
+        }
+    }
+
+    async trigger(hookName, context = {}) {
+        const handlers = this.hooks[hookName] || [];
+        for (const handler of handlers) {
+            try {
+                await handler(context);
+            } catch (err) {
+                if (this.reporter) {
+                    this.reporter.error(`Plugin hook '${hookName}' failed: ${err.message}`);
+                }
+            }
+        }
+    }
+
+    loadFromDir(dir) {
+        if (!fs.existsSync(dir)) return 0;
+        let loaded = 0;
+        for (const entry of fs.readdirSync(dir)) {
+            const full = path.join(dir, entry);
+            try {
+                const stat = fs.statSync(full);
+                let pluginModule;
+                if (stat.isDirectory()) {
+                    const pkg = path.join(full, 'package.json');
+                    const main = path.join(full, fs.existsSync(pkg) ? require(pkg).main || 'index.js' : 'index.js');
+                    pluginModule = require(path.resolve(main));
+                } else if (entry.endsWith('.js')) {
+                    pluginModule = require(path.resolve(full));
+                } else {
+                    continue;
+                }
+                this.register(pluginModule);
+                loaded++;
+            } catch (err) {
+                if (this.reporter) {
+                    this.reporter.error(`Failed to load plugin from ${full}: ${err.message}`);
+                }
+            }
+        }
+        return loaded;
+    }
+
+    loadAll() {
+        let total = 0;
+        for (const dir of PLUGIN_DIRS) {
+            total += this.loadFromDir(dir);
+        }
+        return total;
+    }
+
+    list() {
+        return this.plugins.map((p) => ({
+            name: p.name,
+            version: p.version || '0.0.0',
+            description: p.description || '',
+            hooks: (p.hooks || []).map((h) => h.name)
+        }));
+    }
+}
+
+module.exports = { PluginManager, PLUGIN_DIRS };