cssprobe-cli 0.1.0

package/dist/cli/program.js

@@ -0,0 +1,381 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = program;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const minimist_1 = require("./minimist");
+const command_1 = require("./command");
+const commands_1 = require("./commands");
+const output_1 = require("./output");
+const config_1 = require("../config/config");
+const launcher_1 = require("../browser/launcher");
+const analyzer_1 = require("../engine/analyzer");
+const renderer_1 = require("../engine/renderer");
+const globalOptions = ['json', 'raw', 'help', 'h', 'version', 'v', 'p', 'profile'];
+const booleanGlobalOptions = ['help', 'json', 'raw', 'version', 'v', 'h'];
+async function program() {
+    const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+    const help = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'help.json'), 'utf-8'));
+    const rawArgs = parseArgs(help);
+    if (rawArgs.p && !rawArgs.profile) {
+        rawArgs.profile = rawArgs.p;
+        delete rawArgs.p;
+    }
+    const output = rawArgs.json
+        ? new output_1.JsonOutput()
+        : new output_1.TextOutput(!!rawArgs.raw);
+    const commandName = rawArgs._[0];
+    const cmdEntry = commandName ? help.commands[commandName] : undefined;
+    const command = commands_1.commands[commandName];
+    handleGlobalFlags(rawArgs, commandName, cmdEntry, help, output, pkg.version);
+    if (!cmdEntry || !command)
+        output.error(`Unknown command: ${commandName}. Run 'cssprobe-cli --help' for usage.`);
+    validateFlags(rawArgs, cmdEntry);
+    if (handleConfigCommands(commandName, command, rawArgs, output))
+        return;
+    if (handleSkillCommands(commandName, command, rawArgs, output))
+        return;
+    if (commandName === 'login') {
+        await handleLogin(command, cmdEntry, rawArgs, output);
+        return;
+    }
+    if (commandName === 'state-import') {
+        await handleStateImport(command, cmdEntry, rawArgs, output);
+        return;
+    }
+    await handleInspect(command, cmdEntry, rawArgs, output);
+}
+function parseArgs(help) {
+    return (0, minimist_1.minimist)(process.argv.slice(2), {
+        boolean: [...help.booleanOptions, ...booleanGlobalOptions],
+        string: ['_'],
+    });
+}
+function handleGlobalFlags(args, commandName, cmdEntry, help, output, version) {
+    if (args.version || args.v) {
+        output.version(version);
+        process.exit(0);
+    }
+    if (args.help || args.h || !commandName) {
+        output.help(cmdEntry ? cmdEntry.help : help.global);
+        process.exit(0);
+    }
+}
+function splitArgs(args) {
+    const result = { _: args._ };
+    for (const key of Object.keys(args)) {
+        if (key === '_' || globalOptions.includes(key))
+            continue;
+        result[key] = args[key];
+    }
+    return result;
+}
+function validateFlags(args, cmdEntry) {
+    const unknownFlags = [];
+    for (const key of Object.keys(args)) {
+        if (key === '_')
+            continue;
+        if (globalOptions.includes(key))
+            continue;
+        if (!(key in cmdEntry.flags))
+            unknownFlags.push(key);
+    }
+    if (unknownFlags.length)
+        throw new Error(`Unknown option${unknownFlags.length > 1 ? 's' : ''}: ${unknownFlags.map(f => `--${f}`).join(', ')}`);
+}
+// ── inspect ──
+async function handleInspect(command, cmdEntry, args, output) {
+    if (command.name !== 'inspect') {
+        output.error(`Unknown command: ${command.name}`);
+        return;
+    }
+    try {
+        const cmdArgs = splitArgs(args);
+        const parsed = (0, command_1.parseCommand)(command, cmdArgs);
+        const config = (0, config_1.loadConfig)(args);
+        const url = parsed.url;
+        const selector = parsed.selector;
+        const zoom = !!parsed.zoom;
+        const depth = parsed.depth || config.depth;
+        const maxNodes = parsed['max-nodes'] || 60;
+        const upTo = parsed['up-to'] || 'html';
+        const headed = !!parsed.headed || config.headed;
+        const browser = parsed.browser || config.browser;
+        const state = parsed.state || undefined;
+        if (!url)
+            output.error('URL is required. Usage: cssprobe-cli inspect <url> [selector]');
+        // Auto-detect root selector if not provided
+        let rootSelector = selector;
+        if (!rootSelector) {
+            const detected = await autoDetectRoot(url, { browser, headed, state });
+            if (!detected) {
+                output.error('Could not auto-detect a root element. Please provide a selector: cssprobe-cli inspect <url> <selector>');
+                return;
+            }
+            rootSelector = detected;
+            console.error(`Auto-detected root: ${rootSelector}`);
+        }
+        const collectCfg = {
+            rootSelector,
+            upTo,
+            downDepth: depth,
+            maxNodes,
+        };
+        const launcher = new launcher_1.BrowserLauncher({ browser, headed, state });
+        await launcher.open(url);
+        const snapshot = await launcher.collect(collectCfg);
+        await launcher.close();
+        const findings = (0, analyzer_1.analyze)(snapshot);
+        if (output.json) {
+            console.log(output.format((0, renderer_1.renderJSON)(snapshot, findings)));
+        }
+        else {
+            console.log((0, renderer_1.renderMarkdown)(snapshot, findings));
+        }
+    }
+    catch (e) {
+        output.error(e instanceof Error ? e.message : String(e));
+    }
+}
+async function autoDetectRoot(url, opts) {
+    const launcher = new launcher_1.BrowserLauncher(opts);
+    try {
+        await launcher.open(url);
+        const candidates = await launcher.autoDetectRoot();
+        if (candidates.length > 0)
+            return candidates[0];
+        return null;
+    }
+    finally {
+        await launcher.close();
+    }
+}
+// ── login ──
+async function handleLogin(command, cmdEntry, args, output) {
+    try {
+        const cmdArgs = splitArgs(args);
+        const parsed = (0, command_1.parseCommand)(command, cmdArgs);
+        const config = (0, config_1.loadConfig)(args);
+        const url = parsed.url;
+        const browser = parsed.browser || config.browser;
+        const outPath = parsed.out || defaultStatePath(url);
+        if (!url)
+            output.error('URL is required. Usage: cssprobe-cli login <url>');
+        const launcher = new launcher_1.BrowserLauncher({ browser, headed: true });
+        const savedPath = await launcher.loginAndSave(url, outPath);
+        await launcher.close();
+        console.log(output.format({ saved: savedPath, usage: `cssprobe-cli inspect <url> --state ${savedPath}` }));
+    }
+    catch (e) {
+        output.error(e instanceof Error ? e.message : String(e));
+    }
+}
+function defaultStatePath(url) {
+    try {
+        const hostname = new URL(url).hostname.replace(/[^a-z0-9.-]/g, '_');
+        const dir = path_1.default.join(os_1.default.homedir(), '.cssprobe-cli', 'states');
+        return path_1.default.join(dir, `${hostname}.json`);
+    }
+    catch {
+        return path_1.default.join(os_1.default.homedir(), '.cssprobe-cli', 'states', 'default.json');
+    }
+}
+// ── config commands ──
+function handleConfigCommands(commandName, command, args, output) {
+    try {
+        const cmdArgs = splitArgs(args);
+        const parsed = (0, command_1.parseCommand)(command, cmdArgs);
+        switch (commandName) {
+            case 'config-show': {
+                const profileName = parsed.profile || args.profile || undefined;
+                if (profileName) {
+                    const rc = (0, config_1.getRcConfig)();
+                    const profile = rc.profiles[profileName];
+                    if (!profile)
+                        output.error(`Profile '${profileName}' not found`);
+                    console.log(output.format({ active: rc.active, profile: profileName, ...profile }));
+                    return true;
+                }
+                const config = (0, config_1.loadConfig)(args);
+                console.log(output.format((0, config_1.maskConfig)(config)));
+                return true;
+            }
+            case 'config-set': {
+                const profileName = parsed.profile || args.profile || undefined;
+                const result = (0, config_1.writeRcConfig)(parsed.key, parsed.value, profileName);
+                console.log(output.format(result));
+                return true;
+            }
+            case 'config-path': {
+                console.log(output.format(config_1.rcFilePath));
+                return true;
+            }
+            case 'config-list': {
+                const rc = (0, config_1.getRcConfig)();
+                const profiles = Object.entries(rc.profiles).map(([name, p]) => ({
+                    name,
+                    active: name === rc.active,
+                    ...p,
+                }));
+                console.log(output.format(profiles));
+                return true;
+            }
+            case 'config-use': {
+                (0, config_1.setActiveProfile)(parsed.name);
+                console.log(output.format({ active: parsed.name }));
+                return true;
+            }
+            case 'config-new': {
+                (0, config_1.createProfile)(parsed.name);
+                console.log(output.format({ created: parsed.name }));
+                return true;
+            }
+        }
+    }
+    catch (e) {
+        output.error(e instanceof Error ? e.message : String(e));
+    }
+    return false;
+}
+// ── skill commands ──
+const installer_1 = require("../installer");
+function handleSkillCommands(commandName, command, args, output) {
+    if (commandName !== 'skill-install' && commandName !== 'skill-uninstall')
+        return false;
+    const targetFlag = args.target || 'auto';
+    const loc = args.local ? 'local' : 'global';
+    const baseDir = args.path || os_1.default.homedir();
+    try {
+        const targets = (0, installer_1.resolveTargetFlag)(targetFlag, loc);
+        if (targets.length === 0) {
+            console.log(output.format({ installed: [], note: 'no targets selected (--target=none)' }));
+            return true;
+        }
+        const files = [];
+        for (const target of targets) {
+            const result = commandName === 'skill-install'
+                ? target.install(loc)
+                : target.uninstall(loc);
+            for (const f of result.files) {
+                if (args.path) {
+                    const rel = f.path.replace(os_1.default.homedir(), '').replace(/^\//, '');
+                    f.path = path_1.default.join(baseDir, rel);
+                }
+                files.push({ ...f, agent: target.displayName });
+            }
+        }
+        const summary = files.map(f => `${f.agent}: ${f.action} ${f.path}`);
+        console.log(output.format({ files: summary }));
+        return true;
+    }
+    catch (e) {
+        output.error(e instanceof Error ? e.message : String(e));
+    }
+    return false;
+}
+/**
+ * Parse Netscape cookie format (tab-separated):
+ * domain  flag  path  secure  expires  name  value
+ *
+ * Also supports lines starting with # as comments, and blank lines.
+ */
+function parseNetscapeCookies(content) {
+    const cookies = [];
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const parts = trimmed.split('\t');
+        if (parts.length < 7)
+            continue;
+        const [domain, flag, path, secure, expires, name, ...valueParts] = parts;
+        const value = valueParts.join('\t'); // value may contain tabs
+        const expiresNum = parseInt(expires, 10);
+        cookies.push({
+            name,
+            value,
+            domain,
+            path: path || '/',
+            expires: isNaN(expiresNum) || expiresNum === 0 ? -1 : expiresNum,
+            httpOnly: false,
+            secure: secure === 'TRUE',
+            sameSite: secure === 'TRUE' ? 'None' : 'Lax',
+        });
+    }
+    return cookies;
+}
+async function handleStateImport(command, cmdEntry, args, output) {
+    try {
+        const cmdArgs = splitArgs(args);
+        const parsed = (0, command_1.parseCommand)(command, cmdArgs);
+        const filePath = parsed.file;
+        const outPath = parsed.out || path_1.default.join(os_1.default.homedir(), '.cssprobe-cli', 'states', 'imported.json');
+        const mergePath = parsed.merge;
+        // Read cookie content from file or stdin
+        let content;
+        if (filePath) {
+            const resolved = path_1.default.resolve(filePath);
+            if (!fs_1.default.existsSync(resolved)) {
+                output.error(`File not found: ${resolved}`);
+                return;
+            }
+            content = fs_1.default.readFileSync(resolved, 'utf-8');
+        }
+        else {
+            // Read from stdin
+            content = '';
+            for await (const chunk of process.stdin) {
+                content += chunk;
+            }
+        }
+        if (!content.trim()) {
+            output.error('No cookie data provided. Provide a file path or pipe data to stdin.');
+            return;
+        }
+        // Parse cookies
+        const newCookies = parseNetscapeCookies(content);
+        if (newCookies.length === 0) {
+            output.error('No valid cookies found. Expected Netscape format (tab-separated: domain\\tflag\\tpath\\tsecure\\texpires\\tname\\tvalue)');
+            return;
+        }
+        // Load existing state if merging
+        let state;
+        if (mergePath && fs_1.default.existsSync(mergePath)) {
+            state = JSON.parse(fs_1.default.readFileSync(mergePath, 'utf-8'));
+            console.error(`Merging into existing state: ${mergePath} (${state.cookies.length} cookies)`);
+        }
+        else {
+            state = { cookies: [], origins: [] };
+        }
+        // Merge cookies (new cookies override existing ones with same domain+name+path)
+        const keyed = {};
+        for (const c of state.cookies) {
+            keyed[`${c.domain}|${c.name}|${c.path}`] = c;
+        }
+        for (const nc of newCookies) {
+            keyed[`${nc.domain}|${nc.name}|${nc.path}`] = nc;
+        }
+        state.cookies = Object.values(keyed);
+        // Write output
+        const resolvedOut = path_1.default.resolve(outPath);
+        const dir = path_1.default.dirname(resolvedOut);
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(resolvedOut, JSON.stringify(state, null, 2) + '\n');
+        console.log(output.format({
+            saved: resolvedOut,
+            cookies: state.cookies.length,
+            imported: newCookies.length,
+            usage: `cssprobe-cli inspect <url> <selector> --state ${resolvedOut}`,
+        }));
+    }
+    catch (e) {
+        output.error(e instanceof Error ? e.message : String(e));
+    }
+}
+//# sourceMappingURL=program.js.map