cssprobe-cli 0.2.26 → 0.3.1

package/dist/cli/program.js

@@ -13,6 +13,8 @@ const commands_1 = require("./commands");
 const output_1 = require("./output");
 const config_1 = require("../config/config");
 const session_1 = require("../daemon/session");
+const session_ops_1 = require("./session-ops");
+const mcp_1 = require("../mcp");
 const globalOptions = ['json', 'raw', 'help', 'h', 'version', 'v', 'p', 'profile'];
 const booleanGlobalOptions = ['help', 'json', 'raw', 'version', 'v', 'h'];
 async function program() {
@@ -37,8 +39,13 @@ async function program() {
         return;
     if (handleSkillCommands(commandName, command, rawArgs, output))
         return;
+    if (handleMcpInstallCommands(commandName, command, rawArgs, output))
+        return;
     // Session-based commands
     switch (commandName) {
+        case 'mcp':
+            await (0, mcp_1.runMcpServer)();
+            return;
         case 'open':
             await handleOpen(command, rawArgs, output);
             return;
@@ -63,8 +70,15 @@ async function program() {
         case 'eval':
         case 'resize':
         case 'playwright':
+        case 'click':
+        case 'hover':
+        case 'type':
+        case 'wait-for':
             await handleSessionCommand(commandName, command, rawArgs, output);
             return;
+        case 'run':
+            await handleRun(command, rawArgs, output);
+            return;
     }
     output.error(`Unknown command: ${commandName}. Run 'cssprobe-cli --help' for usage.`);
 }
@@ -111,12 +125,8 @@ async function handleOpen(command, args, output) {
     try {
         const cmdArgs = splitArgs(args);
         const parsed = (0, command_1.parseCommand)(command, cmdArgs);
-        const url = parsed.url || 'about:blank';
-        const browser = parsed.browser || 'chromium';
-        const headed = !!parsed.headed;
-        const viewportStr = parsed.viewport;
-        const state = parsed.state;
         // Parse viewport
+        const viewportStr = parsed.viewport;
         let viewport;
         if (viewportStr) {
             const parts = viewportStr.split('x');
@@ -132,90 +142,41 @@ async function handleOpen(command, args, output) {
             }
             viewport = { width, height };
         }
-        // Start daemon
-        const { pid } = await session_1.Session.startDaemon({
-            browser,
-            headed,
+        const result = await (0, session_ops_1.openSession)({
+            url: parsed.url,
+            browser: parsed.browser,
+            headed: !!parsed.headed,
             viewport,
-            state,
-            _: ['open', url],
-        }, 'open');
-        // Wait for the daemon to be ready (poll session file instead of fixed delay)
-        const session = await waitForSession(5000);
-        if (!session)
-            throw new Error('Daemon failed to become ready within 5s. Check the daemon log for errors.');
-        await session.run({ _: ['goto', url] });
-        const result = {
-            sessionId: 'default',
-            pid,
-            url,
-            viewport: viewport || { width: 1280, height: 720 },
-        };
+            state: parsed.state,
+        });
         if (output.json) {
             console.log(JSON.stringify(result, null, 2));
         }
         else {
-            console.log(`Browser opened at ${url}`);
-            console.log(`Session ID: default`);
-            console.log(`PID: ${pid}`);
-            console.log(`Viewport: ${viewport?.width || 1280}x${viewport?.height || 720}`);
+            console.log(`Browser opened at ${result.url}`);
+            console.log(`Session ID: ${result.sessionId}`);
+            console.log(`PID: ${result.pid}`);
+            console.log(`Viewport: ${result.viewport.width}x${result.viewport.height}`);
         }
     }
     catch (e) {
         output.error(e instanceof Error ? e.message : String(e));
     }
 }
-async function waitForSession(timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const session = await (0, session_1.loadSession)();
-        if (session && await session.canConnect())
-            return session;
-        await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    return undefined;
-}
 async function handleClose(command, args, output) {
     try {
         const cmdArgs = splitArgs(args);
         const parsed = (0, command_1.parseCommand)(command, cmdArgs);
-        if (parsed.all) {
-            const sessions = await (0, session_1.listAllSessions)();
-            if (sessions.length === 0) {
-                output.error('No active sessions found.');
-                return;
-            }
-            const results = [];
-            for (const session of sessions) {
-                try {
-                    await session.stop();
-                    results.push({ sessionId: session.name, closed: true });
-                }
-                catch (e) {
-                    results.push({ sessionId: session.name, closed: false, error: e.message });
-                }
-            }
-            if (output.json) {
-                console.log(JSON.stringify({ closed: results }, null, 2));
-            }
-            else {
-                const closedCount = results.filter(r => r.closed).length;
-                console.log(`Closed ${closedCount} session(s).`);
-            }
+        const result = await (0, session_ops_1.closeSession)(!!parsed.all);
+        if (output.json) {
+            console.log(JSON.stringify(parsed.all ? { closed: result.sessions } : { closed: true, sessionId: 'default' }, null, 2));
+        }
+        else if (parsed.all) {
+            const closedCount = result.sessions.filter(r => r.closed).length;
+            console.log(`Closed ${closedCount} session(s).`);
         }
         else {
-            const session = await (0, session_1.loadSession)();
-            if (!session) {
-                output.error('No active session. Run: cssprobe-cli open <url>');
-                return;
-            }
-            await session.stop();
-            if (output.json) {
-                console.log(JSON.stringify({ closed: true, sessionId: 'default' }, null, 2));
-            }
-            else {
-                console.log('Browser closed.');
-            }
+            console.log('Browser closed.');
         }
     }
     catch (e) {
@@ -224,83 +185,43 @@ async function handleClose(command, args, output) {
 }
 async function handleStatus(output) {
     try {
-        const session = await (0, session_1.loadSession)();
-        if (!session) {
-            const result = { sessionId: 'default', alive: false };
-            if (output.json) {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log('No active session.');
-            }
-            return;
-        }
-        const canConnect = await session.canConnect();
-        const result = {
-            sessionId: 'default',
-            alive: canConnect,
-            config: session.config,
-        };
+        const result = await (0, session_ops_1.getSessionStatus)();
         if (output.json) {
             console.log(JSON.stringify(result, null, 2));
+            return;
         }
-        else {
-            console.log(`Session: default`);
-            console.log(`Status: ${canConnect ? 'alive' : 'dead'}`);
-            if (canConnect) {
-                console.log(`Browser: ${session.config.browser.browserName}`);
-            }
+        if (!result.config) {
+            console.log('No active session.');
+            return;
+        }
+        console.log(`Session: default`);
+        console.log(`Status: ${result.alive ? 'alive' : 'dead'}`);
+        if (result.alive) {
+            console.log(`Browser: ${result.config.browser.browserName}`);
         }
     }
     catch (e) {
         output.error(e instanceof Error ? e.message : String(e));
     }
 }
+async function handleRun(command, args, output) {
+    const fileArg = args._[1];
+    if (!fileArg)
+        output.error('Usage: cssprobe-cli run <file>');
+    const file = path_1.default.resolve(fileArg);
+    if (!fs_1.default.existsSync(file))
+        output.error(`Flow script not found: ${file}`);
+    args._ = ['run', file];
+    await handleSessionCommand('run', command, args, output);
+}
 async function handleSessionCommand(commandName, command, args, output) {
     try {
-        const session = await (0, session_1.loadSession)();
-        if (!session) {
-            output.error('No active session. Run: cssprobe-cli open <url>');
-            return;
-        }
         const cmdArgs = splitArgs(args);
         const parsed = (0, command_1.parseCommand)(command, cmdArgs);
-        // Build command args for daemon
-        const daemonArgs = [commandName];
-        // Add positional args
-        if (command.args) {
-            const argsSchema = command.args;
-            const argNames = Object.keys(argsSchema.shape);
-            for (const name of argNames) {
-                if (parsed[name] !== undefined) {
-                    daemonArgs.push(String(parsed[name]));
-                }
-            }
-        }
-        // Add options
-        if (command.options) {
-            const optionsSchema = command.options;
-            const optionNames = Object.keys(optionsSchema.shape);
-            for (const name of optionNames) {
-                if (parsed[name] !== undefined) {
-                    if (typeof parsed[name] === 'boolean') {
-                        if (parsed[name])
-                            daemonArgs.push(`--${name}`);
-                    }
-                    else {
-                        daemonArgs.push(`--${name}=${parsed[name]}`);
-                    }
-                }
-            }
-        }
-        // Run command in session
-        const runArgs = { ...cmdArgs, _: daemonArgs };
-        if (args.json)
-            runArgs.json = true;
-        const result = await session.run(runArgs);
+        const result = await (0, session_ops_1.runSessionCommand)(commandName, command, parsed, !!args.json);
         // Screenshot: save the base64 data URL to a file and report the path
         if (commandName === 'screenshot' && typeof result.text === 'string' && result.text.startsWith('data:image/png;base64,')) {
-            const saved = saveScreenshotFile(result.text, parsed.out);
+            const saved = (0, session_ops_1.saveScreenshotFile)(result.text, parsed.out);
             if (output.json) {
                 console.log(JSON.stringify({ saved }, null, 2));
             }
@@ -310,29 +231,13 @@ async function handleSessionCommand(commandName, command, args, output) {
             return;
         }
         console.log(result.text);
+        if (typeof result.exitCode === 'number' && result.exitCode !== 0)
+            process.exit(result.exitCode);
     }
     catch (e) {
         output.error(e instanceof Error ? e.message : String(e));
     }
 }
-function saveScreenshotFile(dataUrl, out) {
-    const base64 = dataUrl.replace(/^data:image\/png;base64,/, '');
-    const buffer = Buffer.from(base64, 'base64');
-    const resolvedOut = out
-        ? path_1.default.resolve(out)
-        : (() => {
-            const dir = path_1.default.join(os_1.default.homedir(), '.cssprobe-cli', 'screenshots');
-            if (!fs_1.default.existsSync(dir))
-                fs_1.default.mkdirSync(dir, { recursive: true });
-            const ts = new Date().toISOString().replace(/[:.]/g, '-');
-            return path_1.default.join(dir, `screenshot-${ts}.png`);
-        })();
-    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, buffer);
-    return resolvedOut;
-}
 // ── config commands ──
 function handleConfigCommands(commandName, command, args, output) {
     try {
@@ -426,6 +331,27 @@ function handleSkillCommands(commandName, command, args, output) {
     }
     return false;
 }
+// ── mcp-install commands ──
+function handleMcpInstallCommands(commandName, command, args, output) {
+    if (commandName !== 'mcp-install' && commandName !== 'mcp-uninstall')
+        return false;
+    const targetFlag = args.target || 'auto';
+    const loc = args.local ? 'local' : 'global';
+    try {
+        const result = commandName === 'mcp-install'
+            ? (0, installer_1.installMcpConfig)(loc, targetFlag)
+            : (0, installer_1.uninstallMcpConfig)(loc, targetFlag);
+        const summary = result.files.map(f => `${f.agent}: ${f.action} ${f.path}`);
+        for (const note of result.notes)
+            summary.push(`note: ${note}`);
+        console.log(output.format({ files: summary }));
+        return true;
+    }
+    catch (e) {
+        output.error(e instanceof Error ? e.message : String(e));
+    }
+    return false;
+}
 function parseNetscapeCookies(content) {
     const cookies = [];
     const lines = content.split('\n');

package/dist/cli/session-ops.d.ts

@@ -0,0 +1,44 @@
+import { Session } from '../daemon/session';
+import type { SessionConfig } from '../daemon/session';
+import type { AnyCommandSchema } from './command';
+export { saveScreenshotFile } from '../utils/screenshot';
+export interface OpenOptions {
+    url?: string;
+    browser?: string;
+    headed?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    state?: string;
+}
+export interface OpenResult {
+    sessionId: string;
+    pid?: number;
+    url: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+export declare function openSession(opts: OpenOptions): Promise<OpenResult>;
+export declare function waitForSession(timeoutMs: number): Promise<Session | undefined>;
+export interface CloseResult {
+    sessions: Array<{
+        sessionId: string;
+        closed: boolean;
+        error?: string;
+    }>;
+}
+export declare function closeSession(all?: boolean): Promise<CloseResult>;
+export interface StatusResult {
+    sessionId: string;
+    alive: boolean;
+    config?: SessionConfig;
+}
+export declare function getSessionStatus(): Promise<StatusResult>;
+export declare function buildDaemonArgs(commandName: string, command: AnyCommandSchema, parsed: Record<string, unknown>): string[];
+export declare function runSessionCommand(commandName: string, command: AnyCommandSchema, parsed: Record<string, unknown>, json?: boolean): Promise<{
+    text: string;
+    exitCode?: number;
+}>;

package/dist/cli/session-ops.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveScreenshotFile = void 0;
+exports.openSession = openSession;
+exports.waitForSession = waitForSession;
+exports.closeSession = closeSession;
+exports.getSessionStatus = getSessionStatus;
+exports.buildDaemonArgs = buildDaemonArgs;
+exports.runSessionCommand = runSessionCommand;
+const session_1 = require("../daemon/session");
+var screenshot_1 = require("../utils/screenshot");
+Object.defineProperty(exports, "saveScreenshotFile", { enumerable: true, get: function () { return screenshot_1.saveScreenshotFile; } });
+async function openSession(opts) {
+    const url = opts.url || 'about:blank';
+    const browser = opts.browser || 'chromium';
+    const { pid } = await session_1.Session.startDaemon({
+        browser,
+        headed: !!opts.headed,
+        viewport: opts.viewport,
+        state: opts.state,
+        _: ['open', url],
+    }, 'open');
+    const session = await waitForSession(5000);
+    if (!session)
+        throw new Error('Daemon failed to become ready within 5s. Check the daemon log for errors.');
+    await session.run({ _: ['goto', url] });
+    return {
+        sessionId: 'default',
+        pid,
+        url,
+        viewport: opts.viewport || { width: 1280, height: 720 },
+    };
+}
+async function waitForSession(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const session = await (0, session_1.loadSession)();
+        if (session && await session.canConnect())
+            return session;
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    return undefined;
+}
+async function closeSession(all = false) {
+    if (all) {
+        const sessions = await (0, session_1.listAllSessions)();
+        if (sessions.length === 0)
+            throw new Error('No active sessions found.');
+        const results = [];
+        for (const session of sessions) {
+            try {
+                await session.stop();
+                results.push({ sessionId: session.name, closed: true });
+            }
+            catch (e) {
+                results.push({ sessionId: session.name, closed: false, error: e.message });
+            }
+        }
+        return { sessions: results };
+    }
+    const session = await (0, session_1.loadSession)();
+    if (!session)
+        throw new Error('No active session. Run: cssprobe-cli open <url>');
+    await session.stop();
+    return { sessions: [{ sessionId: 'default', closed: true }] };
+}
+async function getSessionStatus() {
+    const session = await (0, session_1.loadSession)();
+    if (!session)
+        return { sessionId: 'default', alive: false };
+    const canConnect = await session.canConnect();
+    return {
+        sessionId: 'default',
+        alive: canConnect,
+        config: session.config,
+    };
+}
+function buildDaemonArgs(commandName, command, parsed) {
+    const daemonArgs = [commandName];
+    if (command.args) {
+        for (const name of Object.keys(command.args.shape)) {
+            if (parsed[name] !== undefined)
+                daemonArgs.push(String(parsed[name]));
+        }
+    }
+    if (command.options) {
+        for (const name of Object.keys(command.options.shape)) {
+            if (parsed[name] === undefined)
+                continue;
+            if (typeof parsed[name] === 'boolean') {
+                if (parsed[name])
+                    daemonArgs.push(`--${name}`);
+            }
+            else {
+                daemonArgs.push(`--${name}=${parsed[name]}`);
+            }
+        }
+    }
+    return daemonArgs;
+}
+async function runSessionCommand(commandName, command, parsed, json = false) {
+    const session = await (0, session_1.loadSession)();
+    if (!session)
+        throw new Error('No active session. Run: cssprobe-cli open <url>');
+    const daemonArgs = buildDaemonArgs(commandName, command, parsed);
+    const runArgs = { ...parsed, _: daemonArgs };
+    if (json)
+        runArgs.json = true;
+    return await session.run(runArgs);
+}
+//# sourceMappingURL=session-ops.js.map

package/dist/daemon/daemon.js

@@ -17,6 +17,9 @@ const launcher_1 = require("../browser/launcher");
 const analyzer_1 = require("../engine/analyzer");
 const renderer_1 = require("../engine/renderer");
 const dom_tree_1 = require("../engine/renderers/dom-tree");
+const interactions_1 = require("../browser/interactions");
+const evalSerializer_1 = require("../engine/evalSerializer");
+const flowRunner_1 = require("./flowRunner");
 const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
 async function startDaemon(sessionName, clientInfo, options) {
     const sessionConfig = createSessionConfig(clientInfo, sessionName, options);
@@ -173,12 +176,18 @@ async function executeCommand(launcher, args) {
             const page = launcher.getPage();
             if (!page)
                 throw new Error('Browser is not open. Run: cssprobe-cli open <url>');
-            const result = await page.evaluate(expression);
-            if (typeof result === 'string')
-                return { text: result };
-            if (result === undefined)
-                return { text: 'undefined' };
-            return { text: JSON.stringify(result, null, 2) };
+            const handle = await page.evaluateHandle(expression);
+            try {
+                const result = await handle.evaluate(evalSerializer_1.serializeEvalResult);
+                if (typeof result === 'string')
+                    return { text: result };
+                if (result === undefined)
+                    return { text: 'undefined' };
+                return { text: JSON.stringify(result, null, 2) };
+            }
+            finally {
+                await handle.dispose();
+            }
         }
         case 'resize': {
             const width = parseInt(params[0], 10);
@@ -206,6 +215,79 @@ async function executeCommand(launcher, args) {
                 return { text: JSON.stringify({ ok: true, value: null, note: 'call returned no value' }) };
             return { text: JSON.stringify(result, null, 2) };
         }
+        case 'click':
+        case 'hover': {
+            const selector = params[0];
+            if (!selector)
+                throw new Error(`Selector is required for ${command} command`);
+            const page = requirePage(launcher);
+            const opts = { nth: args.nth, force: args.force, timeout: args.timeout };
+            const result = command === 'click'
+                ? await (0, interactions_1.clickElement)(page, selector, opts)
+                : await (0, interactions_1.hoverElement)(page, selector, opts);
+            if (args.json) {
+                return { text: JSON.stringify({ ok: true, selector, matches: result.matches, nth: result.nth }, null, 2) };
+            }
+            return { text: formatTargetAction(command === 'click' ? 'Clicked' : 'Hovered', selector, result) };
+        }
+        case 'type': {
+            const selector = params[0];
+            const text = params[1];
+            if (!selector || text === undefined)
+                throw new Error('Usage: type <selector> <text>');
+            await (0, interactions_1.typeInto)(requirePage(launcher), selector, text, {
+                press: args.press,
+                sequential: args.sequential,
+                clear: args.clear,
+                delay: args.delay,
+                nth: args.nth,
+                timeout: args.timeout,
+            });
+            if (args.json) {
+                const payload = { ok: true, selector, length: text.length };
+                if (args.press)
+                    payload.pressed = args.press;
+                return { text: JSON.stringify(payload, null, 2) };
+            }
+            const pressedNote = args.press ? ` then pressed ${args.press}` : '';
+            return { text: `Typed ${text.length} chars into ${selector}${pressedNote}` };
+        }
+        case 'wait-for': {
+            // selector is read from the parsed object: option flags are appended to
+            // the argv array after positional args, so params[0] is not reliable here.
+            const selector = args.selector;
+            const timeout = args.timeout ?? 30000;
+            const target = (0, interactions_1.resolveWaitTarget)(selector, {
+                js: args.js,
+                networkIdle: args['network-idle'],
+                state: args.state,
+            });
+            let elapsedMs;
+            try {
+                elapsedMs = await (0, interactions_1.waitForCondition)(requirePage(launcher), target, timeout);
+            }
+            catch (e) {
+                throw new Error(`wait-for failed for ${(0, interactions_1.describeWaitTarget)(target)} within ${timeout}ms: ${e.message}`);
+            }
+            if (args.json) {
+                const payload = {
+                    ok: true,
+                    waitedFor: target.kind === 'networkIdle' ? 'networkidle' : target.kind,
+                    elapsedMs,
+                };
+                if (target.kind === 'selector')
+                    payload.state = target.state;
+                return { text: JSON.stringify(payload, null, 2) };
+            }
+            const label = target.kind === 'selector' ? `${selector} (${target.state})` : (0, interactions_1.describeWaitTarget)(target);
+            return { text: `Wait satisfied: ${label} (${elapsedMs}ms)` };
+        }
+        case 'run': {
+            const absPath = params[0];
+            if (!absPath)
+                throw new Error('Flow script path is required');
+            return await (0, flowRunner_1.runFlow)(launcher, absPath, { timeout: args.timeout, json: !!args.json });
+        }
         case 'state-save': {
             const context = launcher.getContext();
             if (!context)
@@ -217,6 +299,20 @@ async function executeCommand(launcher, args) {
             throw new Error(`Unknown command: ${command}`);
     }
 }
+function requirePage(launcher) {
+    const page = launcher.getPage();
+    if (!page)
+        throw new Error('Browser is not open. Run: cssprobe-cli open <url>');
+    return page;
+}
+function formatTargetAction(verb, selector, result) {
+    const descriptor = result.descriptor
+        ? ` → ${result.descriptor.tag}${result.descriptor.classes.map(c => `.${c}`).join('')}${result.descriptor.text ? ` "${result.descriptor.text}"` : ''}`
+        : '';
+    const matchNote = result.matches === 1 ? '1 match' : `${result.matches} matches`;
+    const nthNote = result.matches > 1 ? `, used #${result.nth}` : '';
+    return `${verb} ${selector}${descriptor} (${matchNote}${nthNote})`;
+}
 async function socketExists(socketPath) {
     try {
         const stat = await fs_1.default.promises.stat(socketPath);

package/dist/daemon/flowRunner.d.ts

@@ -0,0 +1,62 @@
+import type { Page } from 'playwright-core';
+import type { BrowserLauncher } from '../browser/launcher';
+import { type TargetResult, type TypeOptions, type WaitState } from '../browser/interactions';
+import type { Finding, Snapshot } from '../engine/types';
+export interface FlowEnvelope {
+    ok: boolean;
+    logs: string[];
+    result?: unknown;
+    error?: string;
+    elapsedMs: number;
+}
+export interface WaitForOptions {
+    state?: WaitState;
+    timeout?: number;
+}
+export interface WaitOutcome {
+    waitedFor: 'selector' | 'js' | 'networkidle';
+    state?: WaitState;
+    elapsedMs: number;
+}
+export interface FlowApi {
+    page: Page;
+    click(selector: string, opts?: {
+        nth?: number;
+        force?: boolean;
+        timeout?: number;
+    }): Promise<TargetResult>;
+    hover(selector: string, opts?: {
+        nth?: number;
+        force?: boolean;
+        timeout?: number;
+    }): Promise<TargetResult>;
+    type(selector: string, text: string, opts?: TypeOptions): Promise<void>;
+    waitFor(target: string | {
+        js: string;
+        timeout?: number;
+    } | {
+        networkIdle: true;
+        timeout?: number;
+    }, opts?: WaitForOptions): Promise<WaitOutcome>;
+    inspect(selector: string, opts?: {
+        format?: 'json' | 'markdown';
+    }): Promise<{
+        snapshot: Snapshot;
+        findings: Finding[];
+    } | string>;
+    screenshot(opts?: {
+        path?: string;
+        fullPage?: boolean;
+    }): Promise<string>;
+    log(...args: unknown[]): void;
+}
+type FlowFn = (api: FlowApi) => Promise<unknown> | unknown;
+export declare function loadFlowScript(absPath: string): Promise<FlowFn>;
+export declare function runFlow(launcher: BrowserLauncher, absPath: string, opts?: {
+    timeout?: number;
+    json?: boolean;
+}): Promise<{
+    text: string;
+    exitCode: number;
+}>;
+export {};