cssprobe-cli 0.1.0

package/dist/cli/commands.d.ts

@@ -0,0 +1,42 @@
+import * as z from 'zod';
+import type { AnyCommandSchema } from './command';
+export declare const commands: {
+    [k: string]: AnyCommandSchema;
+};
+export declare const inspectCommand: import("./command").CommandSchema<z.ZodObject<{
+    url: z.ZodString;
+    selector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    selector?: string | undefined;
+}, {
+    url: string;
+    selector?: string | undefined;
+}>, z.ZodObject<{
+    json: z.ZodOptional<z.ZodBoolean>;
+    headed: z.ZodOptional<z.ZodBoolean>;
+    browser: z.ZodOptional<z.ZodEnum<["chromium", "firefox", "webkit"]>>;
+    zoom: z.ZodOptional<z.ZodBoolean>;
+    depth: z.ZodOptional<z.ZodEffects<z.ZodNumber, number, unknown>>;
+    'max-nodes': z.ZodOptional<z.ZodEffects<z.ZodNumber, number, unknown>>;
+    'up-to': z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    json?: boolean | undefined;
+    headed?: boolean | undefined;
+    browser?: "chromium" | "firefox" | "webkit" | undefined;
+    zoom?: boolean | undefined;
+    depth?: number | undefined;
+    'max-nodes'?: number | undefined;
+    'up-to'?: string | undefined;
+    state?: string | undefined;
+}, {
+    json?: boolean | undefined;
+    headed?: boolean | undefined;
+    browser?: "chromium" | "firefox" | "webkit" | undefined;
+    zoom?: boolean | undefined;
+    depth?: unknown;
+    'max-nodes'?: unknown;
+    'up-to'?: string | undefined;
+    state?: string | undefined;
+}>>;

package/dist/cli/commands.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectCommand = exports.commands = void 0;
+const z = __importStar(require("zod"));
+const command_1 = require("./command");
+const numberArg = z.preprocess((val, ctx) => {
+    const number = Number(val);
+    if (Number.isNaN(number)) {
+        ctx.addIssue({ code: 'custom', message: `expected number, received '${val}'` });
+    }
+    return number;
+}, z.number());
+const urlArg = z.string().describe('URL, file:// path, or local HTML file path');
+// ── core ──
+const inspect = (0, command_1.declareCommand)({
+    name: 'inspect',
+    category: 'core',
+    description: 'Inspect the runtime CSS of a page (layout, scroll, colors, fonts, backgrounds)',
+    args: z.object({
+        url: urlArg,
+        selector: z.string().optional().describe('CSS selector for the root element (auto-detected if omitted)'),
+    }),
+    options: z.object({
+        json: z.boolean().optional().describe('output structured JSON instead of Markdown'),
+        headed: z.boolean().optional().describe('show the browser window'),
+        browser: z.enum(['chromium', 'firefox', 'webkit']).optional().describe('browser engine (default chromium)'),
+        zoom: z.boolean().optional().describe('run 1x/0.5x viewport diagnosis'),
+        depth: numberArg.optional().describe('DOM tree depth (default 6)'),
+        'max-nodes': numberArg.optional().describe('node count cap (default 60)'),
+        'up-to': z.string().optional().describe('ancestor stop tag (default html)'),
+        state: z.string().optional().describe('path to saved state file (cookies + localStorage)'),
+    }),
+});
+const login = (0, command_1.declareCommand)({
+    name: 'login',
+    category: 'core',
+    description: 'Open browser for interactive login, then save state for later use',
+    args: z.object({
+        url: urlArg,
+    }),
+    options: z.object({
+        browser: z.enum(['chromium', 'firefox', 'webkit']).optional().describe('browser engine (default chromium)'),
+        out: z.string().optional().describe('output state file path (default: ~/.cssprobe-cli/states/<domain>.json)'),
+    }),
+});
+// ── config ──
+const configShow = (0, command_1.declareCommand)({
+    name: 'config-show',
+    category: 'config',
+    description: 'Show current configuration',
+    options: z.object({
+        profile: z.string().optional().describe('profile name'),
+    }),
+});
+const configSet = (0, command_1.declareCommand)({
+    name: 'config-set',
+    category: 'config',
+    description: 'Set a configuration value',
+    args: z.object({
+        key: z.string().describe('Config key (browser, depth, headed)'),
+        value: z.string().describe('Config value'),
+    }),
+    options: z.object({
+        profile: z.string().optional().describe('profile name'),
+    }),
+});
+const configList = (0, command_1.declareCommand)({
+    name: 'config-list',
+    category: 'config',
+    description: 'List all profiles',
+});
+const configUse = (0, command_1.declareCommand)({
+    name: 'config-use',
+    category: 'config',
+    description: 'Switch active profile',
+    args: z.object({
+        name: z.string().describe('Profile name'),
+    }),
+});
+const configNew = (0, command_1.declareCommand)({
+    name: 'config-new',
+    category: 'config',
+    description: 'Create a new profile',
+    args: z.object({
+        name: z.string().describe('Profile name'),
+    }),
+});
+const configPath = (0, command_1.declareCommand)({
+    name: 'config-path',
+    category: 'config',
+    description: 'Show configuration file path',
+});
+// ── skill ──
+const skillInstall = (0, command_1.declareCommand)({
+    name: 'skill-install',
+    category: 'skill',
+    description: 'Install Agent Skill for cssprobe-cli (teaches agents how to use the CLI)',
+    options: z.object({
+        target: z.string().optional().describe('agent target: auto, all, opencode, claude, codex, cursor, hermes, gemini (default: auto)'),
+        local: z.boolean().optional().describe('install to current directory instead of home'),
+        path: z.string().optional().describe('custom base directory (overrides home/current)'),
+    }),
+});
+const skillUninstall = (0, command_1.declareCommand)({
+    name: 'skill-uninstall',
+    category: 'skill',
+    description: 'Remove Agent Skill for cssprobe-cli',
+    options: z.object({
+        target: z.string().optional().describe('agent target: auto, all, opencode, claude, codex, cursor, hermes, gemini (default: auto)'),
+        local: z.boolean().optional().describe('remove from current directory instead of home'),
+        path: z.string().optional().describe('custom base directory'),
+    }),
+});
+const stateImport = (0, command_1.declareCommand)({
+    name: 'state-import',
+    category: 'core',
+    description: 'Import cookies from Netscape format file into a Playwright state file',
+    args: z.object({
+        file: z.string().optional().describe('Netscape cookie file path (reads from stdin if omitted)'),
+    }),
+    options: z.object({
+        out: z.string().optional().describe('output state file path (default: ~/.cssprobe-cli/states/imported.json)'),
+        merge: z.string().optional().describe('existing state file to merge into'),
+    }),
+});
+const commandsArray = [
+    inspect, login, stateImport,
+    configShow, configSet, configList, configUse, configNew, configPath,
+    skillInstall, skillUninstall,
+];
+exports.commands = Object.fromEntries(commandsArray.map(cmd => [cmd.name, cmd]));
+exports.inspectCommand = inspect;
+//# sourceMappingURL=commands.js.map

package/dist/cli/minimist.d.ts

@@ -0,0 +1,9 @@
+export interface MinimistOptions {
+    string?: string | string[];
+    boolean?: string | string[];
+}
+export interface MinimistArgs {
+    _: string[];
+    [key: string]: string | boolean | string[] | undefined;
+}
+export declare function minimist(args: string[], opts?: MinimistOptions): MinimistArgs;

package/dist/cli/minimist.js

@@ -0,0 +1,120 @@
+"use strict";
+// Arguments parser — minimal minimist fork (same as playwright-cli / glitchtip-cli).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minimist = minimist;
+function minimist(args, opts) {
+    if (!opts)
+        opts = {};
+    const bools = {};
+    const strings = {};
+    for (const key of toArray(opts.boolean))
+        bools[key] = true;
+    for (const key of toArray(opts.string))
+        strings[key] = true;
+    const argv = { _: [] };
+    function setArg(key, val) {
+        if (argv[key] === undefined || bools[key] || typeof argv[key] === 'boolean')
+            argv[key] = val;
+        else if (Array.isArray(argv[key]))
+            argv[key].push(val);
+        else
+            argv[key] = [argv[key], val];
+    }
+    let notFlags = [];
+    const doubleDashIndex = args.indexOf('--');
+    if (doubleDashIndex !== -1) {
+        notFlags = args.slice(doubleDashIndex + 1);
+        args = args.slice(0, doubleDashIndex);
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        let key;
+        let next;
+        if ((/^--.+=/).test(arg)) {
+            const m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            key = m[1];
+            if (bools[key])
+                throw new Error(`boolean option '--${key}' should not be passed with '=value', use '--${key}' or '--no-${key}' instead`);
+            setArg(key, m[2]);
+        }
+        else if ((/^--no-.+/).test(arg)) {
+            key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false);
+        }
+        else if ((/^--.+/).test(arg)) {
+            key = arg.match(/^--(.+)/)[1];
+            next = args[i + 1];
+            if (next !== undefined
+                && !(/^(-|--)[^-]/).test(next)
+                && !bools[key]) {
+                setArg(key, next);
+                i += 1;
+            }
+            else if ((/^(true|false)$/).test(next)) {
+                setArg(key, next === 'true');
+                i += 1;
+            }
+            else {
+                setArg(key, strings[key] ? '' : true);
+            }
+        }
+        else if ((/^-[^-]+/).test(arg)) {
+            const letters = arg.slice(1, -1).split('');
+            let broken = false;
+            for (let j = 0; j < letters.length; j++) {
+                next = arg.slice(j + 2);
+                if (next === '-') {
+                    setArg(letters[j], next);
+                    continue;
+                }
+                if ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') {
+                    setArg(letters[j], next.slice(1));
+                    broken = true;
+                    break;
+                }
+                if ((/[A-Za-z]/).test(letters[j])
+                    && (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next)) {
+                    setArg(letters[j], next);
+                    broken = true;
+                    break;
+                }
+                if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j + 2));
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], strings[letters[j]] ? '' : true);
+                }
+            }
+            key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i + 1]
+                    && !(/^(-|--)[^-]/).test(args[i + 1])
+                    && !bools[key]) {
+                    setArg(key, args[i + 1]);
+                    i += 1;
+                }
+                else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) {
+                    setArg(key, args[i + 1] === 'true');
+                    i += 1;
+                }
+                else {
+                    setArg(key, strings[key] ? '' : true);
+                }
+            }
+        }
+        else {
+            argv._.push(arg);
+        }
+    }
+    for (const k of notFlags)
+        argv._.push(k);
+    return argv;
+}
+function toArray(value) {
+    if (!value)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+//# sourceMappingURL=minimist.js.map

package/dist/cli/output.d.ts

@@ -0,0 +1,26 @@
+export interface Output {
+    readonly json: boolean;
+    readonly raw: boolean;
+    format(data: any): string;
+    error(message: string): never;
+    help(text: string): void;
+    version(version: string): void;
+}
+export declare class TextOutput implements Output {
+    readonly json = false;
+    readonly raw: boolean;
+    constructor(raw?: boolean);
+    format(data: any): string;
+    private _formatTable;
+    error(message: string): never;
+    help(text: string): void;
+    version(version: string): void;
+}
+export declare class JsonOutput implements Output {
+    readonly json = true;
+    readonly raw = false;
+    format(data: any): string;
+    error(message: string): never;
+    help(text: string): void;
+    version(version: string): void;
+}

package/dist/cli/output.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonOutput = exports.TextOutput = void 0;
+class TextOutput {
+    json = false;
+    raw;
+    constructor(raw = false) {
+        this.raw = raw;
+    }
+    format(data) {
+        if (this.raw)
+            return typeof data === 'string' ? data : JSON.stringify(data);
+        if (data === null || data === undefined)
+            return '(empty)';
+        if (Array.isArray(data))
+            return this._formatTable(data);
+        if (typeof data === 'object')
+            return JSON.stringify(data, null, 2);
+        return String(data);
+    }
+    _formatTable(rows) {
+        if (rows.length === 0)
+            return '(empty list)';
+        const allColumns = Object.keys(rows[0] || {});
+        const columns = allColumns.filter(col => {
+            const val = rows[0][col];
+            return val === null || val === undefined || typeof val !== 'object';
+        });
+        if (columns.length === 0)
+            return JSON.stringify(rows, null, 2);
+        const cells = rows.map((item) => columns.map((col) => {
+            const v = item[col];
+            if (v === null || v === undefined)
+                return '';
+            if (typeof v === 'object')
+                return JSON.stringify(v);
+            return String(v);
+        }));
+        cells.unshift(columns);
+        const widths = columns.map((_, ci) => Math.max(...cells.map((r) => String(r[ci]).length)));
+        return cells
+            .map((row, ri) => {
+            const line = row.map((cell, ci) => String(cell).padEnd(widths[ci])).join('  ');
+            if (ri === 0)
+                return line + '\n' + widths.map((w) => '-'.repeat(w)).join('  ');
+            return line;
+        })
+            .join('\n');
+    }
+    error(message) {
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+    help(text) {
+        console.log(text);
+    }
+    version(version) {
+        console.log(version);
+    }
+}
+exports.TextOutput = TextOutput;
+class JsonOutput {
+    json = true;
+    raw = false;
+    format(data) {
+        return JSON.stringify(data, null, 2);
+    }
+    error(message) {
+        console.log(JSON.stringify({ isError: true, error: message }));
+        process.exit(1);
+    }
+    help(text) {
+        console.log(JSON.stringify({ help: text }));
+    }
+    version(version) {
+        console.log(JSON.stringify({ version }));
+    }
+}
+exports.JsonOutput = JsonOutput;
+//# sourceMappingURL=output.js.map

package/dist/cli/program.d.ts

@@ -0,0 +1 @@
+export declare function program(): Promise<void>;