mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/connection-string.d.ts

@@ -0,0 +1,18 @@
+export interface ConnectionStringOptions {
+    message: string;
+    protocols?: string[];
+    defaults?: Record<string, number>;
+}
+export interface ConnectionStringResult {
+    raw: string;
+    parts: {
+        protocol: string;
+        host?: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database?: string;
+        filePath?: string;
+    };
+}
+export declare function connectionString(options: ConnectionStringOptions): Promise<ConnectionStringResult>;

package/dist/prompts/connection-string.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionString = connectionString;
+const select_1 = require("./select");
+const text_1 = require("./text");
+const number_1 = require("./number");
+const confirm_1 = require("./confirm");
+const file_1 = require("./file");
+const DEFAULT_PROTOCOLS = ['postgres', 'mysql', 'mongodb', 'redis', 'amqp', 'sqlite'];
+const DEFAULT_PORTS = {
+    postgres: 5432,
+    mysql: 3306,
+    mongodb: 27017,
+    redis: 6379,
+    amqp: 5672,
+};
+async function connectionString(options) {
+    const protocols = options.protocols || DEFAULT_PROTOCOLS;
+    const defaults = { ...DEFAULT_PORTS, ...options.defaults };
+    // 1. Protocol Selection
+    const protocol = await new select_1.SelectPrompt({
+        message: options.message,
+        choices: protocols.map(p => ({ title: p, value: p })),
+    }).run();
+    const parts = { protocol };
+    let raw = '';
+    if (protocol === 'sqlite') {
+        // SQLite: File Path
+        const filePath = await new file_1.FilePrompt({
+            message: 'Database file path',
+        }).run();
+        parts.filePath = filePath;
+        // Construct SQLite URI
+        raw = `sqlite://${filePath}`;
+    }
+    else {
+        // Network Database
+        // 2. Host
+        const host = await new text_1.TextPrompt({
+            message: 'Host',
+            initial: 'localhost',
+            placeholder: 'localhost',
+        }).run();
+        parts.host = host;
+        // 3. Port
+        const defaultPort = defaults[protocol];
+        const port = await new number_1.NumberPrompt({
+            message: 'Port',
+            initial: defaultPort,
+        }).run();
+        parts.port = port;
+        // 4. Auth
+        const hasAuth = await new confirm_1.ConfirmPrompt({
+            message: 'Authentication required?',
+            initial: true,
+        }).run();
+        if (hasAuth) {
+            const user = await new text_1.TextPrompt({
+                message: 'Username',
+                initial: 'root', // Common default
+            }).run();
+            parts.user = user;
+            // Use TextPrompt with empty mask for secret handling
+            const password = await new text_1.TextPrompt({
+                message: 'Password',
+                mask: '*', // Mask with asterisks
+            }).run();
+            parts.password = password;
+        }
+        // 5. Database
+        const database = await new text_1.TextPrompt({
+            message: 'Database name',
+        }).run();
+        parts.database = database;
+        // Construct URL
+        try {
+            // Use URL object for safe construction and encoding
+            const u = new URL(`${protocol}://${host}:${port}/${database}`);
+            if (parts.user)
+                u.username = parts.user;
+            if (parts.password)
+                u.password = parts.password;
+            raw = u.toString();
+        }
+        catch (_e) {
+            // Fallback manual construction with encoding
+            const userEncoded = parts.user ? encodeURIComponent(parts.user) : '';
+            const passEncoded = parts.password ? encodeURIComponent(parts.password) : '';
+            let authPart = '';
+            if (userEncoded || passEncoded) {
+                authPart = `${userEncoded}:${passEncoded}@`;
+            }
+            raw = `${protocol}://${authPart}${host}:${port}/${parts.database}`;
+        }
+    }
+    return { raw, parts };
+}

package/dist/prompts/curl.d.ts

@@ -0,0 +1,39 @@
+import { Prompt } from '../base';
+export interface CurlOptions {
+    message: string;
+    defaultMethod?: string;
+    defaultUrl?: string;
+    defaultHeaders?: Record<string, string>;
+    defaultBody?: string;
+}
+export interface CurlResult {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+    command: string;
+}
+export declare class CurlPrompt extends Prompt<CurlResult, CurlOptions> {
+    private section;
+    private methodIndex;
+    private url;
+    private headers;
+    private body;
+    private urlCursor;
+    private lastLinesUp;
+    constructor(options: CurlOptions);
+    private get currentMethod();
+    private get hasBody();
+    /**
+     * Escape a string for safe inclusion inside a double-quoted shell argument.
+     * This escapes backslashes first, then double quotes.
+     */
+    private shellEscapeDoubleQuoted;
+    private generateCommand;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string, _buffer: Buffer): void;
+    private cycleSection;
+    private editHeaders;
+    private editBody;
+    private submitResult;
+}

package/dist/prompts/curl.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurlPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const map_1 = require("./map");
+const code_1 = require("./code");
+var Section;
+(function (Section) {
+    Section[Section["METHOD"] = 0] = "METHOD";
+    Section[Section["URL"] = 1] = "URL";
+    Section[Section["HEADERS"] = 2] = "HEADERS";
+    Section[Section["BODY"] = 3] = "BODY";
+})(Section || (Section = {}));
+const METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+class CurlPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.section = Section.METHOD;
+        this.methodIndex = 0;
+        this.url = '';
+        this.headers = {};
+        this.body = '';
+        // For URL input
+        this.urlCursor = 0;
+        this.lastLinesUp = 0;
+        this.warnExperimental();
+        // Initialize state
+        if (options.defaultMethod) {
+            const idx = METHODS.indexOf(options.defaultMethod.toUpperCase());
+            if (idx >= 0)
+                this.methodIndex = idx;
+        }
+        this.url = options.defaultUrl || '';
+        this.urlCursor = this.url.length;
+        this.headers = { ...options.defaultHeaders };
+        this.body = options.defaultBody || '';
+        // Auto-select URL if method is GET (default)
+        if (this.methodIndex === 0) {
+            this.section = Section.URL;
+        }
+    }
+    get currentMethod() {
+        return METHODS[this.methodIndex];
+    }
+    get hasBody() {
+        return this.currentMethod !== 'GET' && this.currentMethod !== 'HEAD';
+    }
+    /**
+     * Escape a string for safe inclusion inside a double-quoted shell argument.
+     * This escapes backslashes first, then double quotes.
+     */
+    shellEscapeDoubleQuoted(value) {
+        return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    }
+    generateCommand() {
+        let cmd = `curl -X ${this.currentMethod}`;
+        // Headers
+        Object.entries(this.headers).forEach(([k, v]) => {
+            cmd += ` -H "${k}: ${v}"`;
+        });
+        // Body
+        if (this.hasBody && this.body) {
+            // Escape body for shell
+            const escapedBody = this.shellEscapeDoubleQuoted(this.body);
+            cmd += ` -d "${escapedBody}"`;
+        }
+        // URL
+        if (this.url) {
+            cmd += ` "${this.url}"`;
+        }
+        else {
+            cmd += ` "http://localhost..."`;
+        }
+        return cmd;
+    }
+    render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
+        let output = '';
+        // Title
+        output += `${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // 1. Method
+        const methodLabel = this.section === Section.METHOD
+            ? `${theme_1.theme.main}${ansi_1.ANSI.REVERSE} ${this.currentMethod} ${ansi_1.ANSI.RESET}`
+            : `${ansi_1.ANSI.BOLD}[${this.currentMethod}]${ansi_1.ANSI.RESET}`;
+        output += `\n${methodLabel}`;
+        // 2. URL
+        const urlActive = this.section === Section.URL;
+        const urlPrefix = urlActive ? `${theme_1.theme.main}${ansi_1.ANSI.BOLD} URL: ${ansi_1.ANSI.RESET}` : ` URL: `;
+        let urlDisplay = this.url;
+        if (!urlDisplay && urlActive) {
+            urlDisplay = `${theme_1.theme.muted}http://localhost:3000${ansi_1.ANSI.RESET}`;
+        }
+        // Insert cursor for URL
+        if (urlActive) {
+            const beforeCursor = urlDisplay.slice(0, this.urlCursor);
+            const atCursor = urlDisplay.slice(this.urlCursor, this.urlCursor + 1) || ' ';
+            const afterCursor = urlDisplay.slice(this.urlCursor + 1);
+            urlDisplay = `${beforeCursor}${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${atCursor}${ansi_1.ANSI.RESET}${afterCursor}`;
+        }
+        output += `${urlPrefix}${urlDisplay}\n`;
+        // 3. Headers
+        const headersCount = Object.keys(this.headers).length;
+        const headersActive = this.section === Section.HEADERS;
+        const headersPointer = headersActive ? `${theme_1.theme.main}${symbols_1.symbols.pointer} ` : '  ';
+        const headersStyle = headersActive ? `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}` : '';
+        output += `${headersPointer}${headersStyle}HEADERS${ansi_1.ANSI.RESET} (${headersCount} defined)\n`;
+        // 4. Body
+        if (this.hasBody) {
+            const bodyActive = this.section === Section.BODY;
+            const bodyPointer = bodyActive ? `${theme_1.theme.main}${symbols_1.symbols.pointer} ` : '  ';
+            const bodyStyle = bodyActive ? `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}` : '';
+            let bodyPreview = '';
+            if (this.body) {
+                const oneLiner = this.body.replace(/\n/g, ' ').substring(0, 40);
+                bodyPreview = `${theme_1.theme.muted} ${oneLiner}...${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                bodyPreview = `${theme_1.theme.muted} (empty)${ansi_1.ANSI.RESET}`;
+            }
+            output += `${bodyPointer}${bodyStyle}BODY${ansi_1.ANSI.RESET}${bodyPreview}\n`;
+        }
+        else {
+            output += `  ${theme_1.theme.muted}BODY (Disabled for ${this.currentMethod})${ansi_1.ANSI.RESET}\n`;
+        }
+        // Preview
+        output += `\n${ansi_1.ANSI.BOLD}Preview:${ansi_1.ANSI.RESET}\n`;
+        const cmd = this.generateCommand();
+        // Syntax highlight command (basic)
+        output += `${ansi_1.ANSI.FG_CYAN}${cmd}${ansi_1.ANSI.RESET}\n`;
+        // Instructions
+        output += `\n${theme_1.theme.muted}(Tab: Nav, Space: Toggle Method, Enter: Edit/Submit)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+        // Cursor Positioning
+        if (this.section === Section.URL) {
+            const prefixLen = 6; // " URL: "
+            // We need to move cursor to (row 3, prefixLen + this.urlCursor)
+            const lines = output.split('\n');
+            const urlLineIndex = lines.findIndex(l => l.includes(' URL: '));
+            const linesFromBottom = lines.length - 1 - urlLineIndex;
+            this.print(ansi_1.ANSI.SHOW_CURSOR);
+            if (linesFromBottom > 0) {
+                this.print(`\x1b[${linesFromBottom}A`);
+                this.lastLinesUp = linesFromBottom;
+            }
+            const targetCol = prefixLen + this.urlCursor;
+            this.print(`\r\x1b[${targetCol}C`);
+        }
+        else {
+            this.print(ansi_1.ANSI.HIDE_CURSOR);
+        }
+    }
+    handleInput(char, _buffer) {
+        // Navigation
+        if (char === '\t') {
+            this.cycleSection(1);
+            this.render(false);
+            return;
+        }
+        if (char === '\u001b[Z') { // Shift+Tab
+            this.cycleSection(-1);
+            this.render(false);
+            return;
+        }
+        // Section Specifics
+        switch (this.section) {
+            case Section.METHOD:
+                if (char === ' ' || this.isRight(char) || this.isDown(char)) {
+                    this.methodIndex = (this.methodIndex + 1) % METHODS.length;
+                    this.render(false);
+                }
+                else if (this.isLeft(char) || this.isUp(char)) {
+                    this.methodIndex = (this.methodIndex - 1 + METHODS.length) % METHODS.length;
+                    this.render(false);
+                }
+                else if (char === '\r' || char === '\n') {
+                    // Enter on Method -> Submit
+                    this.submitResult();
+                }
+                break;
+            case Section.URL:
+                if (char === '\r' || char === '\n') {
+                    this.submitResult();
+                    return;
+                }
+                // Typing
+                if (char === '\u0008' || char === '\x7f') { // Backspace
+                    if (this.urlCursor > 0) {
+                        this.url = this.url.slice(0, this.urlCursor - 1) + this.url.slice(this.urlCursor);
+                        this.urlCursor--;
+                        this.render(false);
+                    }
+                }
+                else if (this.isLeft(char)) {
+                    if (this.urlCursor > 0) {
+                        this.urlCursor--;
+                        this.render(false);
+                    }
+                }
+                else if (this.isRight(char)) {
+                    if (this.urlCursor < this.url.length) {
+                        this.urlCursor++;
+                        this.render(false);
+                    }
+                }
+                else if (!/^[\x00-\x1F]/.test(char)) {
+                    this.url = this.url.slice(0, this.urlCursor) + char + this.url.slice(this.urlCursor);
+                    this.urlCursor += char.length;
+                    this.render(false);
+                }
+                break;
+            case Section.HEADERS:
+                if (char === '\r' || char === '\n') {
+                    this.editHeaders();
+                }
+                break;
+            case Section.BODY:
+                if (char === '\r' || char === '\n') {
+                    this.editBody();
+                }
+                break;
+        }
+    }
+    cycleSection(direction) {
+        // Logic to skip disabled Body
+        let next = this.section + direction;
+        // Loop
+        if (next > Section.BODY)
+            next = Section.METHOD;
+        if (next < Section.METHOD)
+            next = Section.BODY;
+        // If Body is disabled and we landed on it
+        if (next === Section.BODY && !this.hasBody) {
+            next = direction === 1 ? Section.METHOD : Section.HEADERS;
+        }
+        this.section = next;
+    }
+    async editHeaders() {
+        this.pauseInput();
+        try {
+            const result = await new map_1.MapPrompt({
+                message: 'Edit Headers',
+                initial: this.headers,
+            }).run();
+            this.headers = result;
+        }
+        catch (_e) {
+            // Cancelled or error
+        }
+        this.resumeInput();
+        this.render(false); // Re-render our UI
+    }
+    async editBody() {
+        this.pauseInput();
+        try {
+            const result = await new code_1.CodePrompt({
+                message: 'Edit Body (JSON)',
+                template: '${json}',
+                highlight: true,
+                values: this.body ? { json: this.body } : undefined
+            }).run();
+            this.body = result;
+        }
+        catch (_e) {
+            // Cancelled
+        }
+        this.resumeInput();
+        this.render(false);
+    }
+    submitResult() {
+        this.submit({
+            method: this.currentMethod,
+            url: this.url,
+            headers: this.headers,
+            body: this.hasBody ? this.body : undefined,
+            command: this.generateCommand()
+        });
+    }
+}
+exports.CurlPrompt = CurlPrompt;

package/dist/prompts/data-inspector.d.ts

@@ -0,0 +1,22 @@
+import { Prompt } from '../base';
+import { DataInspectorOptions, MouseEvent } from '../types';
+export declare class DataInspectorPrompt extends Prompt<any, DataInspectorOptions> {
+    private cursor;
+    private flatList;
+    private expandedPaths;
+    private scrollTop;
+    private readonly pageSize;
+    private editMode;
+    private editBuffer;
+    private rootData;
+    constructor(options: DataInspectorOptions);
+    private getType;
+    private recalculateFlatList;
+    private traverse;
+    private getValueColor;
+    private formatValue;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, key: Buffer): void;
+    private handleEditInput;
+    protected handleMouse(event: MouseEvent): void;
+}