shortcutxl 0.2.0

package/dist/utils/image-resize.js

@@ -0,0 +1,183 @@
+import { loadPhoton } from './photon.js';
+// 4.5MB - provides headroom below Anthropic's 5MB limit
+const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
+const DEFAULT_OPTIONS = {
+    maxWidth: 2000,
+    maxHeight: 2000,
+    maxBytes: DEFAULT_MAX_BYTES,
+    jpegQuality: 80
+};
+/** Helper to pick the smaller of two buffers */
+function pickSmaller(a, b) {
+    return a.buffer.length <= b.buffer.length ? a : b;
+}
+/**
+ * Resize an image to fit within the specified max dimensions and file size.
+ * Returns the original image if it already fits within the limits.
+ *
+ * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
+ * returns the original image unchanged.
+ *
+ * Strategy for staying under maxBytes:
+ * 1. First resize to maxWidth/maxHeight
+ * 2. Try both PNG and JPEG formats, pick the smaller one
+ * 3. If still too large, try JPEG with decreasing quality
+ * 4. If still too large, progressively reduce dimensions
+ */
+export async function resizeImage(img, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const inputBuffer = Buffer.from(img.data, 'base64');
+    const photon = await loadPhoton();
+    if (!photon) {
+        // Photon not available, return original image
+        return {
+            data: img.data,
+            mimeType: img.mimeType,
+            originalWidth: 0,
+            originalHeight: 0,
+            width: 0,
+            height: 0,
+            wasResized: false
+        };
+    }
+    let image;
+    try {
+        image = photon.PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
+        const originalWidth = image.get_width();
+        const originalHeight = image.get_height();
+        const format = img.mimeType?.split('/')[1] ?? 'png';
+        // Check if already within all limits (dimensions AND size)
+        const originalSize = inputBuffer.length;
+        if (originalWidth <= opts.maxWidth &&
+            originalHeight <= opts.maxHeight &&
+            originalSize <= opts.maxBytes) {
+            return {
+                data: img.data,
+                mimeType: img.mimeType ?? `image/${format}`,
+                originalWidth,
+                originalHeight,
+                width: originalWidth,
+                height: originalHeight,
+                wasResized: false
+            };
+        }
+        // Calculate initial dimensions respecting max limits
+        let targetWidth = originalWidth;
+        let targetHeight = originalHeight;
+        if (targetWidth > opts.maxWidth) {
+            targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
+            targetWidth = opts.maxWidth;
+        }
+        if (targetHeight > opts.maxHeight) {
+            targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
+            targetHeight = opts.maxHeight;
+        }
+        // Helper to resize and encode in both formats, returning the smaller one
+        function tryBothFormats(width, height, jpegQuality) {
+            const resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+            try {
+                const pngBuffer = resized.get_bytes();
+                const jpegBuffer = resized.get_bytes_jpeg(jpegQuality);
+                return pickSmaller({ buffer: pngBuffer, mimeType: 'image/png' }, { buffer: jpegBuffer, mimeType: 'image/jpeg' });
+            }
+            finally {
+                resized.free();
+            }
+        }
+        // Try to produce an image under maxBytes
+        const qualitySteps = [85, 70, 55, 40];
+        const scaleSteps = [1.0, 0.75, 0.5, 0.35, 0.25];
+        let best;
+        let finalWidth = targetWidth;
+        let finalHeight = targetHeight;
+        // First attempt: resize to target dimensions, try both formats
+        best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+        if (best.buffer.length <= opts.maxBytes) {
+            return {
+                data: Buffer.from(best.buffer).toString('base64'),
+                mimeType: best.mimeType,
+                originalWidth,
+                originalHeight,
+                width: finalWidth,
+                height: finalHeight,
+                wasResized: true
+            };
+        }
+        // Still too large - try JPEG with decreasing quality
+        for (const quality of qualitySteps) {
+            best = tryBothFormats(targetWidth, targetHeight, quality);
+            if (best.buffer.length <= opts.maxBytes) {
+                return {
+                    data: Buffer.from(best.buffer).toString('base64'),
+                    mimeType: best.mimeType,
+                    originalWidth,
+                    originalHeight,
+                    width: finalWidth,
+                    height: finalHeight,
+                    wasResized: true
+                };
+            }
+        }
+        // Still too large - reduce dimensions progressively
+        for (const scale of scaleSteps) {
+            finalWidth = Math.round(targetWidth * scale);
+            finalHeight = Math.round(targetHeight * scale);
+            if (finalWidth < 100 || finalHeight < 100) {
+                break;
+            }
+            for (const quality of qualitySteps) {
+                best = tryBothFormats(finalWidth, finalHeight, quality);
+                if (best.buffer.length <= opts.maxBytes) {
+                    return {
+                        data: Buffer.from(best.buffer).toString('base64'),
+                        mimeType: best.mimeType,
+                        originalWidth,
+                        originalHeight,
+                        width: finalWidth,
+                        height: finalHeight,
+                        wasResized: true
+                    };
+                }
+            }
+        }
+        // Last resort: return smallest version we produced
+        return {
+            data: Buffer.from(best.buffer).toString('base64'),
+            mimeType: best.mimeType,
+            originalWidth,
+            originalHeight,
+            width: finalWidth,
+            height: finalHeight,
+            wasResized: true
+        };
+    }
+    catch {
+        // Failed to load image
+        return {
+            data: img.data,
+            mimeType: img.mimeType,
+            originalWidth: 0,
+            originalHeight: 0,
+            width: 0,
+            height: 0,
+            wasResized: false
+        };
+    }
+    finally {
+        if (image) {
+            image.free();
+        }
+    }
+}
+/**
+ * Format a dimension note for resized images.
+ * This helps the model understand the coordinate mapping.
+ */
+export function formatDimensionNote(result) {
+    if (!result.wasResized) {
+        return undefined;
+    }
+    const scale = result.originalWidth / result.width;
+    return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}
+//# sourceMappingURL=image-resize.js.map

package/dist/utils/mime.js

@@ -0,0 +1,26 @@
+import { fileTypeFromBuffer } from 'file-type';
+import { open } from 'node:fs/promises';
+const IMAGE_MIME_TYPES = new Set(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
+const FILE_TYPE_SNIFF_BYTES = 4100;
+export async function detectSupportedImageMimeTypeFromFile(filePath) {
+    const fileHandle = await open(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
+        const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);
+        if (bytesRead === 0) {
+            return null;
+        }
+        const fileType = await fileTypeFromBuffer(buffer.subarray(0, bytesRead));
+        if (!fileType) {
+            return null;
+        }
+        if (!IMAGE_MIME_TYPES.has(fileType.mime)) {
+            return null;
+        }
+        return fileType.mime;
+    }
+    finally {
+        await fileHandle.close();
+    }
+}
+//# sourceMappingURL=mime.js.map

package/dist/utils/photon.js

@@ -0,0 +1,121 @@
+/**
+ * Photon image processing wrapper.
+ *
+ * This module provides a unified interface to @silvia-odwyer/photon-node that works in:
+ * 1. Node.js (development, npm run build)
+ * 2. Bun compiled binaries (standalone distribution)
+ *
+ * The challenge: photon-node's CJS entry uses fs.readFileSync(__dirname + '/photon_rs_bg.wasm')
+ * which bakes the build machine's absolute path into Bun compiled binaries.
+ *
+ * Solution:
+ * 1. Patch fs.readFileSync to redirect missing photon_rs_bg.wasm reads
+ * 2. Copy photon_rs_bg.wasm next to the executable in build:binary
+ */
+import { createRequire } from 'module';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const require = createRequire(import.meta.url);
+const fs = require('fs');
+const WASM_FILENAME = 'photon_rs_bg.wasm';
+// Lazy-loaded photon module
+let photonModule = null;
+let loadPromise = null;
+function pathOrNull(file) {
+    if (typeof file === 'string') {
+        return file;
+    }
+    if (file instanceof URL) {
+        return fileURLToPath(file);
+    }
+    return null;
+}
+function getFallbackWasmPaths() {
+    const execDir = path.dirname(process.execPath);
+    return [
+        path.join(execDir, WASM_FILENAME),
+        path.join(execDir, 'photon', WASM_FILENAME),
+        path.join(process.cwd(), WASM_FILENAME)
+    ];
+}
+function patchPhotonWasmRead() {
+    const originalReadFileSync = fs.readFileSync.bind(fs);
+    const fallbackPaths = getFallbackWasmPaths();
+    const mutableFs = fs;
+    const patchedReadFileSync = ((...args) => {
+        const [file, options] = args;
+        const resolvedPath = pathOrNull(file);
+        if (resolvedPath?.endsWith(WASM_FILENAME)) {
+            try {
+                return originalReadFileSync(...args);
+            }
+            catch (error) {
+                const err = error;
+                if (err?.code && err.code !== 'ENOENT') {
+                    throw error;
+                }
+                for (const fallbackPath of fallbackPaths) {
+                    if (!fs.existsSync(fallbackPath)) {
+                        continue;
+                    }
+                    if (options === undefined) {
+                        return originalReadFileSync(fallbackPath);
+                    }
+                    return originalReadFileSync(fallbackPath, options);
+                }
+                throw error;
+            }
+        }
+        return originalReadFileSync(...args);
+    });
+    try {
+        mutableFs.readFileSync = patchedReadFileSync;
+    }
+    catch {
+        Object.defineProperty(fs, 'readFileSync', {
+            value: patchedReadFileSync,
+            writable: true,
+            configurable: true
+        });
+    }
+    return () => {
+        try {
+            mutableFs.readFileSync = originalReadFileSync;
+        }
+        catch {
+            Object.defineProperty(fs, 'readFileSync', {
+                value: originalReadFileSync,
+                writable: true,
+                configurable: true
+            });
+        }
+    };
+}
+/**
+ * Load the photon module asynchronously.
+ * Returns cached module on subsequent calls.
+ */
+export async function loadPhoton() {
+    if (photonModule) {
+        return photonModule;
+    }
+    if (loadPromise) {
+        return loadPromise;
+    }
+    loadPromise = (async () => {
+        const restoreReadFileSync = patchPhotonWasmRead();
+        try {
+            photonModule = await import('@silvia-odwyer/photon-node');
+            return photonModule;
+        }
+        catch {
+            photonModule = null;
+            return photonModule;
+        }
+        finally {
+            restoreReadFileSync();
+        }
+    })();
+    return loadPromise;
+}
+//# sourceMappingURL=photon.js.map

package/dist/utils/shell.js

@@ -0,0 +1,217 @@
+import { spawn, spawnSync } from 'child_process';
+import { existsSync } from 'node:fs';
+import { delimiter } from 'node:path';
+import { getBinDir, getSettingsPath } from '../config.js';
+let cachedShellConfig = null;
+/**
+ * Clear cached shell config so the next getShellConfig() call re-detects.
+ * Call after installing Git so subsequent commands use the new bash.
+ */
+export function resetShellConfig() {
+    cachedShellConfig = null;
+}
+/**
+ * Find bash executable on PATH (cross-platform)
+ */
+/**
+ * Verify a bash executable actually works by running a simple command.
+ * Guards against WSL stubs that fall back to cmd.exe when WSL isn't configured.
+ */
+function isBashWorking(bashPath) {
+    try {
+        const result = spawnSync(bashPath, ['-c', 'echo __bash_ok__'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        return result.status === 0 && result.stdout.includes('__bash_ok__');
+    }
+    catch {
+        return false;
+    }
+}
+function findBashOnPath() {
+    if (process.platform === 'win32') {
+        // Windows: Use 'where' and verify file exists (where can return non-existent paths)
+        try {
+            const result = spawnSync('where', ['bash.exe'], { encoding: 'utf-8', timeout: 5000 });
+            if (result.status === 0 && result.stdout) {
+                // Try each match — skip WSL stubs and broken installs
+                for (const match of result.stdout.trim().split(/\r?\n/)) {
+                    const trimmed = match.trim();
+                    if (trimmed && existsSync(trimmed) && isBashWorking(trimmed)) {
+                        return trimmed;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return null;
+    }
+    // Unix: Use 'which' and trust its output (handles Termux and special filesystems)
+    try {
+        const result = spawnSync('which', ['bash'], { encoding: 'utf-8', timeout: 5000 });
+        if (result.status === 0 && result.stdout) {
+            const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+            if (firstMatch) {
+                return firstMatch;
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Get shell configuration based on platform.
+ * Resolution order:
+ * 1. User-specified shellPath in settings.json
+ * 2. On Windows: Git Bash in known locations, then bash on PATH
+ * 3. On Unix: /bin/bash, then bash on PATH, then fallback to sh
+ */
+export function getShellConfig(customShellPath) {
+    if (cachedShellConfig) {
+        return cachedShellConfig;
+    }
+    // 1. Check user-specified shell path
+    if (customShellPath) {
+        // Reject cmd.exe / powershell — the bash tool requires a POSIX shell
+        const shellBasename = customShellPath.replace(/.*[/\\]/, '').toLowerCase();
+        if (['cmd.exe', 'cmd', 'powershell.exe', 'powershell', 'pwsh.exe', 'pwsh'].includes(shellBasename)) {
+            throw new Error(`shellPath is set to "${customShellPath}" but Shortcut requires a bash-compatible shell.\n` +
+                `Please remove shellPath from ${getSettingsPath()} or set it to a bash executable.\n` +
+                `Install Git for Windows if needed: https://git-scm.com/download/win`);
+        }
+        if (existsSync(customShellPath)) {
+            cachedShellConfig = { shell: customShellPath, args: ['-c'] };
+            return cachedShellConfig;
+        }
+        throw new Error(`Custom shell path not found: ${customShellPath}\nPlease update shellPath in ${getSettingsPath()}`);
+    }
+    if (process.platform === 'win32') {
+        // 2. Try Git Bash in known locations
+        const paths = [];
+        const programFiles = process.env.ProgramFiles;
+        if (programFiles) {
+            paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+        }
+        const programFilesX86 = process.env['ProgramFiles(x86)'];
+        if (programFilesX86) {
+            paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+        }
+        for (const path of paths) {
+            if (existsSync(path)) {
+                cachedShellConfig = { shell: path, args: ['-c'] };
+                return cachedShellConfig;
+            }
+        }
+        // 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
+        const bashOnPath = findBashOnPath();
+        if (bashOnPath) {
+            cachedShellConfig = { shell: bashOnPath, args: ['-c'] };
+            return cachedShellConfig;
+        }
+        // 4. No bash at all — fall back to cmd.exe for bootstrapping.
+        // Do NOT cache this result so we auto-detect bash once Git is installed.
+        return { shell: 'cmd.exe', args: ['/c'] };
+    }
+    // Unix: try /bin/bash, then bash on PATH, then fallback to sh
+    if (existsSync('/bin/bash')) {
+        cachedShellConfig = { shell: '/bin/bash', args: ['-c'] };
+        return cachedShellConfig;
+    }
+    const bashOnPath = findBashOnPath();
+    if (bashOnPath) {
+        cachedShellConfig = { shell: bashOnPath, args: ['-c'] };
+        return cachedShellConfig;
+    }
+    cachedShellConfig = { shell: 'sh', args: ['-c'] };
+    return cachedShellConfig;
+}
+export function getShellEnv() {
+    const binDir = getBinDir();
+    const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+    const currentPath = process.env[pathKey] ?? '';
+    const pathEntries = currentPath.split(delimiter).filter(Boolean);
+    const hasBinDir = pathEntries.includes(binDir);
+    const updatedPath = hasBinDir
+        ? currentPath
+        : [binDir, currentPath].filter(Boolean).join(delimiter);
+    return {
+        ...process.env,
+        [pathKey]: updatedPath
+    };
+}
+/**
+ * Sanitize binary output for display/storage.
+ * Removes characters that crash string-width or cause display issues:
+ * - Control characters (except tab, newline, carriage return)
+ * - Lone surrogates
+ * - Unicode Format characters (crash string-width due to a bug)
+ * - Characters with undefined code points
+ */
+export function sanitizeBinaryOutput(str) {
+    // Use Array.from to properly iterate over code points (not code units)
+    // This handles surrogate pairs correctly and catches edge cases where
+    // codePointAt() might return undefined
+    return Array.from(str)
+        .filter((char) => {
+        // Filter out characters that cause string-width to crash
+        // This includes:
+        // - Unicode format characters
+        // - Lone surrogates (already filtered by Array.from)
+        // - Control chars except \t \n \r
+        // - Characters with undefined code points
+        const code = char.codePointAt(0);
+        // Skip if code point is undefined (edge case with invalid strings)
+        if (code === undefined)
+            return false;
+        // Allow tab, newline, carriage return
+        if (code === 0x09 || code === 0x0a || code === 0x0d)
+            return true;
+        // Filter out control characters (0x00-0x1F, except 0x09, 0x0a, 0x0x0d)
+        if (code <= 0x1f)
+            return false;
+        // Filter out Unicode format characters
+        if (code >= 0xfff9 && code <= 0xfffb)
+            return false;
+        return true;
+    })
+        .join('');
+}
+/**
+ * Kill a process and all its children (cross-platform)
+ */
+export function killProcessTree(pid) {
+    if (process.platform === 'win32') {
+        // Use taskkill on Windows to kill process tree
+        try {
+            spawn('taskkill', ['/F', '/T', '/PID', String(pid)], {
+                stdio: 'ignore',
+                detached: true
+            });
+        }
+        catch {
+            // Ignore errors if taskkill fails
+        }
+    }
+    else {
+        // Use SIGKILL on Unix/Linux/Mac
+        try {
+            process.kill(-pid, 'SIGKILL');
+        }
+        catch {
+            // Fallback to killing just the child if process group kill fails
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // Process already dead
+            }
+        }
+    }
+}
+//# sourceMappingURL=shell.js.map

package/dist/utils/sleep.js

@@ -0,0 +1,17 @@
+/**
+ * Sleep helper that respects abort signal.
+ */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error('Aborted'));
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            reject(new Error('Aborted'));
+        });
+    });
+}
+//# sourceMappingURL=sleep.js.map