dexto 1.3.0 → 1.4.0

package/dist/cli/ink-cli/utils/clipboardUtils.js

@@ -0,0 +1,356 @@
+/**
+ * Clipboard utilities for reading images from system clipboard
+ *
+ * Supports macOS, Windows/WSL, and Linux (Wayland + X11).
+ *
+ */
+import { spawn } from 'node:child_process';
+import { platform, release } from 'node:os';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+/**
+ * Execute a command and return stdout as a buffer
+ * @param command - The command to execute
+ * @param args - Command arguments
+ * @param timeoutMs - Timeout in milliseconds (default: 10000)
+ */
+async function execCommand(command, args, timeoutMs = 10000) {
+    return new Promise((resolve) => {
+        let timedOut = false;
+        const proc = spawn(command, args);
+        const stdoutChunks = [];
+        let stderr = '';
+        const timer = setTimeout(() => {
+            timedOut = true;
+            proc.kill();
+            resolve({
+                stdout: Buffer.concat(stdoutChunks),
+                stderr: stderr + '\nCommand timed out',
+                exitCode: 1,
+            });
+        }, timeoutMs);
+        proc.stdout.on('data', (chunk) => {
+            stdoutChunks.push(chunk);
+        });
+        proc.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('close', (exitCode) => {
+            if (timedOut)
+                return;
+            clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdoutChunks),
+                stderr,
+                exitCode: exitCode ?? 1,
+            });
+        });
+        proc.on('error', () => {
+            if (timedOut)
+                return;
+            clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdoutChunks),
+                stderr,
+                exitCode: 1,
+            });
+        });
+    });
+}
+/**
+ * Execute an osascript command and return stdout as string
+ */
+async function execOsascript(script) {
+    const result = await execCommand('osascript', ['-e', script]);
+    return {
+        stdout: result.stdout.toString().trim(),
+        success: result.exitCode === 0,
+    };
+}
+/**
+ * Read image from clipboard on macOS
+ * Uses osascript to save clipboard image to temp file, reads it, then cleans up
+ */
+async function readClipboardImageMacOS() {
+    const tmpFile = path.join(os.tmpdir(), `dexto-clipboard-${Date.now()}-${process.pid}.png`);
+    try {
+        // AppleScript to save clipboard image as PNG to temp file
+        const script = `
+            set imageData to the clipboard as "PNGf"
+            set fileRef to open for access POSIX file "${tmpFile}" with write permission
+            set eof fileRef to 0
+            write imageData to fileRef
+            close access fileRef
+        `;
+        const result = await execOsascript(script);
+        if (!result.success) {
+            return undefined;
+        }
+        // Read the temp file
+        const buffer = await fs.readFile(tmpFile);
+        if (buffer.length === 0) {
+            return undefined;
+        }
+        return {
+            data: buffer.toString('base64'),
+            mimeType: 'image/png',
+        };
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        // Clean up temp file
+        try {
+            await fs.unlink(tmpFile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Read image from clipboard on Windows (including WSL)
+ * Uses PowerShell to get clipboard image and convert to base64
+ */
+async function readClipboardImageWindows() {
+    try {
+        // PowerShell script to get clipboard image as base64 PNG
+        const script = `
+            Add-Type -AssemblyName System.Windows.Forms
+            $img = [System.Windows.Forms.Clipboard]::GetImage()
+            if ($img) {
+                $ms = New-Object System.IO.MemoryStream
+                $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+                [System.Convert]::ToBase64String($ms.ToArray())
+            }
+        `.trim();
+        // Use powershell.exe for both native Windows and WSL (works on both)
+        const powershellCmd = 'powershell.exe';
+        const result = await execCommand(powershellCmd, ['-command', script]);
+        const base64 = result.stdout.toString().trim();
+        if (!base64 || result.exitCode !== 0) {
+            return undefined;
+        }
+        // Validate it's actually base64 data
+        const buffer = Buffer.from(base64, 'base64');
+        if (buffer.length === 0) {
+            return undefined;
+        }
+        return {
+            data: base64,
+            mimeType: 'image/png',
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Check if current environment is WSL (Windows Subsystem for Linux)
+ * Checks for both 'wsl' (WSL2) and 'microsoft' (WSL1) in kernel release
+ */
+function isWSL() {
+    if (platform() !== 'linux')
+        return false;
+    const rel = release().toLowerCase();
+    return rel.includes('wsl') || rel.includes('microsoft');
+}
+/**
+ * Read image from clipboard on Linux
+ * Tries Wayland (wl-paste) first, then X11 (xclip)
+ */
+async function readClipboardImageLinux() {
+    // Try Wayland first (wl-paste)
+    try {
+        const result = await execCommand('wl-paste', ['-t', 'image/png']);
+        if (result.exitCode === 0 && result.stdout.length > 0) {
+            return {
+                data: result.stdout.toString('base64'),
+                mimeType: 'image/png',
+            };
+        }
+    }
+    catch {
+        // wl-paste not available or failed, try xclip
+    }
+    // Try X11 (xclip)
+    try {
+        const result = await execCommand('xclip', [
+            '-selection',
+            'clipboard',
+            '-t',
+            'image/png',
+            '-o',
+        ]);
+        if (result.exitCode === 0 && result.stdout.length > 0) {
+            return {
+                data: result.stdout.toString('base64'),
+                mimeType: 'image/png',
+            };
+        }
+    }
+    catch {
+        // xclip not available or failed
+    }
+    return undefined;
+}
+/**
+ * Read image from system clipboard
+ *
+ * @returns ClipboardImageContent if clipboard contains an image, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const image = await readClipboardImage();
+ * if (image) {
+ *     console.log(`Got ${image.mimeType} image, ${image.data.length} bytes base64`);
+ * }
+ * ```
+ */
+export async function readClipboardImage() {
+    const os = platform();
+    if (os === 'darwin') {
+        return readClipboardImageMacOS();
+    }
+    if (os === 'win32' || isWSL()) {
+        return readClipboardImageWindows();
+    }
+    if (os === 'linux') {
+        return readClipboardImageLinux();
+    }
+    return undefined;
+}
+/**
+ * Write text to system clipboard
+ *
+ * @param text - The text to copy to clipboard
+ * @returns true if successful, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const success = await writeToClipboard('Hello, World!');
+ * if (success) {
+ *     console.log('Copied to clipboard');
+ * }
+ * ```
+ */
+export async function writeToClipboard(text) {
+    const os = platform();
+    try {
+        if (os === 'darwin') {
+            // macOS: use pbcopy
+            const proc = spawn('pbcopy');
+            proc.stdin.write(text);
+            proc.stdin.end();
+            return new Promise((resolve) => {
+                proc.on('close', (code) => resolve(code === 0));
+                proc.on('error', () => resolve(false));
+            });
+        }
+        if (os === 'win32' || isWSL()) {
+            // Windows/WSL: use clip.exe (simpler than PowerShell)
+            const proc = spawn('clip.exe');
+            proc.stdin.write(text);
+            proc.stdin.end();
+            return new Promise((resolve) => {
+                proc.on('close', (code) => resolve(code === 0));
+                proc.on('error', () => resolve(false));
+            });
+        }
+        if (os === 'linux') {
+            // Try Wayland first (wl-copy), fall back to X11 (xclip)
+            const tryClipboardTool = (cmd, args = []) => {
+                return new Promise((resolve) => {
+                    const proc = spawn(cmd, args);
+                    let errorOccurred = false;
+                    proc.on('error', () => {
+                        errorOccurred = true;
+                        resolve(false);
+                    });
+                    proc.stdin.write(text);
+                    proc.stdin.end();
+                    proc.on('close', (code) => {
+                        if (!errorOccurred) {
+                            resolve(code === 0);
+                        }
+                    });
+                });
+            };
+            // Try wl-copy first, then xclip
+            const wlResult = await tryClipboardTool('wl-copy');
+            if (wlResult)
+                return true;
+            return tryClipboardTool('xclip', ['-selection', 'clipboard']);
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if clipboard contains an image (without reading it)
+ * This is a lighter-weight check that doesn't require reading the full image data.
+ *
+ * @returns true if clipboard likely contains an image
+ */
+export async function clipboardHasImage() {
+    const os = platform();
+    if (os === 'darwin') {
+        try {
+            const result = await execOsascript('clipboard info');
+            // Check for image types in clipboard info
+            const imageRegex = /«class PNGf»|TIFF picture|JPEG picture|GIF picture|«class JPEG»|«class TIFF»/;
+            return imageRegex.test(result.stdout);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (os === 'win32' || isWSL()) {
+        try {
+            // Quick check if clipboard has an image
+            const script = `
+                Add-Type -AssemblyName System.Windows.Forms
+                [System.Windows.Forms.Clipboard]::ContainsImage()
+            `.trim();
+            const powershellCmd = 'powershell.exe';
+            const result = await execCommand(powershellCmd, ['-command', script]);
+            return result.stdout.toString().trim().toLowerCase() === 'true';
+        }
+        catch {
+            return false;
+        }
+    }
+    if (os === 'linux') {
+        // Try Wayland first
+        try {
+            const result = await execCommand('wl-paste', ['--list-types']);
+            if (result.exitCode === 0 && result.stdout.toString().includes('image/')) {
+                return true;
+            }
+        }
+        catch {
+            // Try X11
+        }
+        // Try X11
+        try {
+            const result = await execCommand('xclip', [
+                '-selection',
+                'clipboard',
+                '-t',
+                'TARGETS',
+                '-o',
+            ]);
+            if (result.exitCode === 0 && result.stdout.toString().includes('image/')) {
+                return true;
+            }
+        }
+        catch {
+            // xclip not available
+        }
+    }
+    return false;
+}

package/dist/cli/ink-cli/utils/commandOverlays.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Command Overlay Registry
+ *
+ * Central source of truth for command-to-overlay mappings.
+ * When adding a new interactive command, add it here - no other files need changes.
+ */
+import type { OverlayType } from '../state/types.js';
+/**
+ * Get the overlay for a command submission (with parsed args).
+ * Used by InputContainer.handleSubmit
+ *
+ * @param command - The base command name (e.g., 'mcp', 'search')
+ * @param args - Arguments passed to the command
+ * @returns Overlay type to show, or null to execute command handler
+ */
+export declare function getCommandOverlay(command: string, args: string[]): OverlayType | null;
+/**
+ * Get the overlay for a command selected from autocomplete.
+ * Used by OverlayContainer.handleSystemCommandSelect
+ *
+ * When selecting from autocomplete, there are never args -
+ * we just need to know if this command has an overlay.
+ *
+ * @param command - The command name selected from autocomplete
+ * @returns Overlay type to show, or null to execute command
+ */
+export declare function getCommandOverlayForSelect(command: string): OverlayType | null;
+/**
+ * Check if a command has any overlay behavior.
+ * Useful for determining if a command should be handled specially.
+ */
+export declare function isInteractiveCommand(command: string): boolean;
+//# sourceMappingURL=commandOverlays.d.ts.map

package/dist/cli/ink-cli/utils/commandOverlays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandOverlays.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/commandOverlays.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA2BrD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,GAAG,IAAI,CAYrF;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAU9E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE7D"}

package/dist/cli/ink-cli/utils/commandOverlays.js

@@ -0,0 +1,78 @@
+/**
+ * Command Overlay Registry
+ *
+ * Central source of truth for command-to-overlay mappings.
+ * When adding a new interactive command, add it here - no other files need changes.
+ */
+/**
+ * Commands that ALWAYS show an overlay when invoked.
+ * These commands have no handler logic - the overlay IS the functionality.
+ */
+const ALWAYS_OVERLAY = {
+    search: 'search',
+    find: 'search', // alias
+    model: 'model-selector',
+    resume: 'session-selector',
+    switch: 'session-selector',
+    stream: 'stream-selector',
+    tools: 'tool-browser',
+    mcp: 'mcp-server-list',
+};
+/**
+ * Commands that show an overlay ONLY when invoked without arguments.
+ * With arguments, they execute their handler instead.
+ */
+const NO_ARGS_OVERLAY = {
+    session: 'session-subcommand-selector',
+    log: 'log-level-selector',
+    prompts: 'prompt-list',
+};
+/**
+ * Get the overlay for a command submission (with parsed args).
+ * Used by InputContainer.handleSubmit
+ *
+ * @param command - The base command name (e.g., 'mcp', 'search')
+ * @param args - Arguments passed to the command
+ * @returns Overlay type to show, or null to execute command handler
+ */
+export function getCommandOverlay(command, args) {
+    // Commands that always show overlay
+    const alwaysOverlay = ALWAYS_OVERLAY[command];
+    if (alwaysOverlay)
+        return alwaysOverlay;
+    // Commands that show overlay only when no args
+    if (args.length === 0) {
+        const noArgsOverlay = NO_ARGS_OVERLAY[command];
+        if (noArgsOverlay)
+            return noArgsOverlay;
+    }
+    return null;
+}
+/**
+ * Get the overlay for a command selected from autocomplete.
+ * Used by OverlayContainer.handleSystemCommandSelect
+ *
+ * When selecting from autocomplete, there are never args -
+ * we just need to know if this command has an overlay.
+ *
+ * @param command - The command name selected from autocomplete
+ * @returns Overlay type to show, or null to execute command
+ */
+export function getCommandOverlayForSelect(command) {
+    // Check "always overlay" commands first
+    const alwaysOverlay = ALWAYS_OVERLAY[command];
+    if (alwaysOverlay)
+        return alwaysOverlay;
+    // Check "no args overlay" commands (selecting = no args)
+    const noArgsOverlay = NO_ARGS_OVERLAY[command];
+    if (noArgsOverlay)
+        return noArgsOverlay;
+    return null;
+}
+/**
+ * Check if a command has any overlay behavior.
+ * Useful for determining if a command should be handled specially.
+ */
+export function isInteractiveCommand(command) {
+    return command in ALWAYS_OVERLAY || command in NO_ARGS_OVERLAY;
+}

package/dist/cli/ink-cli/utils/debugLog.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Debug Logging Utility
+ *
+ * Cross-platform debug logging that writes to temp directory.
+ * Controlled via environment variables for easy enable/disable.
+ *
+ * Usage:
+ *   import { createDebugLogger } from './debugLog.js';
+ *   const debug = createDebugLogger('stream');
+ *   debug.log('EVENT', { foo: 'bar' });
+ *
+ * Enable via environment:
+ *   DEXTO_DEBUG_STREAM=true dexto
+ *   DEXTO_DEBUG_ALL=true dexto  (enables all debug loggers)
+ */
+export interface DebugLogger {
+    /** Log a message with optional data */
+    log: (msg: string, data?: Record<string, unknown>) => void;
+    /** Check if debug logging is enabled */
+    isEnabled: () => boolean;
+    /** Get the log file path */
+    getLogPath: () => string;
+    /** Clear the log file and write a header */
+    reset: (header?: string) => void;
+}
+/**
+ * Creates a debug logger for a specific component.
+ *
+ * @param name Component name (used in env var and filename)
+ * @returns Debug logger instance
+ *
+ * @example
+ * const debug = createDebugLogger('stream');
+ * // Enabled via DEXTO_DEBUG_STREAM=true or DEXTO_DEBUG_ALL=true
+ * // Writes to: {tmpdir}/dexto-debug-stream.log
+ */
+export declare function createDebugLogger(name: string): DebugLogger;
+//# sourceMappingURL=debugLog.d.ts.map

package/dist/cli/ink-cli/utils/debugLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugLog.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/debugLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,WAAW,WAAW;IACxB,uCAAuC;IACvC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3D,wCAAwC;IACxC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,4BAA4B;IAC5B,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,4CAA4C;IAC5C,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAsC3D"}

package/dist/cli/ink-cli/utils/debugLog.js

@@ -0,0 +1,66 @@
+/**
+ * Debug Logging Utility
+ *
+ * Cross-platform debug logging that writes to temp directory.
+ * Controlled via environment variables for easy enable/disable.
+ *
+ * Usage:
+ *   import { createDebugLogger } from './debugLog.js';
+ *   const debug = createDebugLogger('stream');
+ *   debug.log('EVENT', { foo: 'bar' });
+ *
+ * Enable via environment:
+ *   DEXTO_DEBUG_STREAM=true dexto
+ *   DEXTO_DEBUG_ALL=true dexto  (enables all debug loggers)
+ */
+import { appendFileSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+/**
+ * Creates a debug logger for a specific component.
+ *
+ * @param name Component name (used in env var and filename)
+ * @returns Debug logger instance
+ *
+ * @example
+ * const debug = createDebugLogger('stream');
+ * // Enabled via DEXTO_DEBUG_STREAM=true or DEXTO_DEBUG_ALL=true
+ * // Writes to: {tmpdir}/dexto-debug-stream.log
+ */
+export function createDebugLogger(name) {
+    const envVar = `DEXTO_DEBUG_${name.toUpperCase()}`;
+    const logPath = join(tmpdir(), `dexto-debug-${name.toLowerCase()}.log`);
+    const isEnabled = () => {
+        return process.env[envVar] === 'true' || process.env.DEXTO_DEBUG_ALL === 'true';
+    };
+    const log = (msg, data) => {
+        if (!isEnabled())
+            return;
+        try {
+            const timestamp = new Date().toISOString().split('T')[1];
+            const dataStr = data ? ` ${JSON.stringify(data)}` : '';
+            const line = `[${timestamp}] ${msg}${dataStr}\n`;
+            appendFileSync(logPath, line);
+        }
+        catch {
+            // Silently ignore serialization and write errors in debug logging
+        }
+    };
+    const reset = (header) => {
+        if (!isEnabled())
+            return;
+        const defaultHeader = `=== DEXTO DEBUG [${name.toUpperCase()}] ${new Date().toISOString()} ===`;
+        try {
+            writeFileSync(logPath, `${header ?? defaultHeader}\n`);
+        }
+        catch {
+            // Silently ignore write errors in debug logging
+        }
+    };
+    return {
+        log,
+        isEnabled,
+        getLogPath: () => logPath,
+        reset,
+    };
+}

package/dist/cli/ink-cli/utils/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * Utils module exports
  */
-export { type AutocompleteType, type InteractiveSelectorType, detectAutocompleteType, detectInteractiveSelector, extractSlashQuery, extractResourceQuery, findActiveAtIndex, } from './inputParsing.js';
+export { type AutocompleteType, detectAutocompleteType, extractSlashQuery, extractResourceQuery, findActiveAtIndex, } from './inputParsing.js';
+export { getCommandOverlay, getCommandOverlayForSelect, isInteractiveCommand, } from './commandOverlays.js';
 export { createUserMessage, createSystemMessage, createErrorMessage, createToolMessage, createStreamingMessage, convertHistoryToUIMessages, getStartupInfo, } from './messageFormatting.js';
 export { generateMessageId } from './idGenerator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/ink-cli/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACH,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,GACpB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACH,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACjB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACH,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,GACpB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACH,iBAAiB,EACjB,0BAA0B,EAC1B,oBAAoB,GACvB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACH,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACjB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/cli/ink-cli/utils/index.js

@@ -2,7 +2,9 @@
  * Utils module exports
  */
 // Input parsing
-export { detectAutocompleteType, detectInteractiveSelector, extractSlashQuery, extractResourceQuery, findActiveAtIndex, } from './inputParsing.js';
+export { detectAutocompleteType, extractSlashQuery, extractResourceQuery, findActiveAtIndex, } from './inputParsing.js';
+// Command overlays (central registry)
+export { getCommandOverlay, getCommandOverlayForSelect, isInteractiveCommand, } from './commandOverlays.js';
 // Message formatting
 export { createUserMessage, createSystemMessage, createErrorMessage, createToolMessage, createStreamingMessage, convertHistoryToUIMessages, getStartupInfo, } from './messageFormatting.js';
 // ID generation

package/dist/cli/ink-cli/utils/input.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Input Utilities
+ * Constants and helpers for parsing terminal input sequences.
+ */
+export declare const ESC = "\u001B";
+export declare const SGR_EVENT_PREFIX = "\u001B[<";
+export declare const X11_EVENT_PREFIX = "\u001B[M";
+export declare const FOCUS_IN = "\u001B[I";
+export declare const FOCUS_OUT = "\u001B[O";
+export declare const SGR_MOUSE_REGEX: RegExp;
+export declare const X11_MOUSE_REGEX: RegExp;
+/**
+ * Check if buffer could be a SGR mouse sequence (or prefix thereof)
+ */
+export declare function couldBeSGRMouseSequence(buffer: string): boolean;
+/**
+ * Check if buffer could be any mouse sequence (or prefix thereof)
+ */
+export declare function couldBeMouseSequence(buffer: string): boolean;
+/**
+ * Get the length of a complete mouse sequence at the start of buffer.
+ * Returns 0 if no complete sequence found.
+ */
+export declare function getMouseSequenceLength(buffer: string): number;
+//# sourceMappingURL=input.d.ts.map

package/dist/cli/ink-cli/utils/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/input.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,GAAG,WAAW,CAAC;AAC5B,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAC3C,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAG3C,eAAO,MAAM,QAAQ,aAAa,CAAC;AACnC,eAAO,MAAM,SAAS,aAAa,CAAC;AAKpC,eAAO,MAAM,eAAe,QAA2D,CAAC;AACxF,eAAO,MAAM,eAAe,QAA8C,CAAC;AAE3E;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAO/D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAS5D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAQ7D"}