starmux 0.12.0 → 0.13.0

package/dist/vendor/desktop-commander/dist/tools/mime-types.js

@@ -0,0 +1,28 @@
+// Simple MIME type detection based on file extension
+export function getMimeType(filePath) {
+    const extension = filePath.toLowerCase().split('.').pop() || '';
+    if (extension === "pdf") {
+        return "application/pdf";
+    }
+    // Image types - only the formats we can display
+    const imageTypes = {
+        'png': 'image/png',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'gif': 'image/gif',
+        'webp': 'image/webp'
+    };
+    // Check if the file is an image
+    if (extension in imageTypes) {
+        return imageTypes[extension];
+    }
+    // Default to text/plain for all other files
+    return 'text/plain';
+}
+export function isPdfFile(mimeType) {
+    const [baseType] = mimeType.toLowerCase().split(';');
+    return baseType.trim() === 'application/pdf';
+}
+export function isImageFile(mimeType) {
+    return mimeType.startsWith('image/');
+}

package/dist/vendor/desktop-commander/dist/tools/pdf/extract-images.js

@@ -0,0 +1,131 @@
+import { LazyPackage } from '../../utils/lazy-package.js';
+import { closePdfDocument } from './utils.js';
+// import(): unpdf is an ES module only. If it fails, Node keeps it failed until a restart.
+export const unpdfPackage = new LazyPackage('unpdf', 'PDF reading support', () => import('unpdf'), true);
+/**
+ * Optimized image extraction from PDF using unpdf's built-in extractImages method
+ * @param pdfBuffer PDF file as Uint8Array
+ * @param pageNumbers Optional array of specific page numbers to process
+ * @param compressionOptions Image compression settings
+ * @returns Record of page numbers to extracted images
+ */
+export async function extractImagesFromPdf(pdfBuffer, pageNumbers, compressionOptions = {}) {
+    const { getDocumentProxy, extractImages } = await unpdfPackage.load();
+    const pdfDocument = await getDocumentProxy(pdfBuffer);
+    const pagesToProcess = pageNumbers || Array.from({ length: pdfDocument.numPages }, (_, i) => i + 1);
+    const pageResults = {};
+    try {
+        // Process pages in parallel batches for better performance
+        const batchSize = 5; // Process 5 pages at a time
+        const batches = [];
+        for (let i = 0; i < pagesToProcess.length; i += batchSize) {
+            batches.push(pagesToProcess.slice(i, i + batchSize));
+        }
+        for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+            const batch = batches[batchIndex];
+            const batchPromises = batch.map(async (pageNum) => {
+                if (pageNum < 1 || pageNum > pdfDocument.numPages) {
+                    return { pageNum, images: [] };
+                }
+                try {
+                    // Use unpdf's built-in extractImages
+                    const extractedImages = await extractImages(pdfDocument, pageNum);
+                    const pageImages = [];
+                    for (let index = 0; index < extractedImages.length; index++) {
+                        const img = extractedImages[index];
+                        const originalSize = img.data.length;
+                        try {
+                            const compressionResult = await convertRawImageToBase64(img.data, img.width, img.height, img.channels, compressionOptions);
+                            if (compressionResult) {
+                                pageImages.push({
+                                    objId: index, // Use index as objId since unpdf doesn't provide original objId
+                                    width: img.width,
+                                    height: img.height,
+                                    data: compressionResult.data,
+                                    mimeType: compressionResult.mimeType,
+                                    originalSize,
+                                    compressedSize: Math.round(compressionResult.data.length * 0.75) // Approximate base64 overhead
+                                });
+                            }
+                        }
+                        catch (err) {
+                            // Ignore conversion errors as requested
+                            console.warn(`Failed to convert image ${index} on page ${pageNum}:`, err instanceof Error ? err.message : String(err));
+                        }
+                    }
+                    return { pageNum, images: pageImages };
+                }
+                catch (error) {
+                    console.warn(`Failed to extract images from page ${pageNum}:`, error instanceof Error ? error.message : String(error));
+                    return { pageNum, images: [] };
+                }
+            });
+            // Wait for the current batch to complete
+            const batchResults = await Promise.all(batchPromises);
+            // Store results
+            for (const { pageNum, images } of batchResults) {
+                pageResults[pageNum] = images;
+            }
+        }
+    }
+    finally {
+        // Clean up document
+        try {
+            if (typeof pdfDocument.cleanup === 'function') {
+                await pdfDocument.cleanup(false);
+            }
+        }
+        catch (e) { /* Ignore cleanup errors */ }
+        await closePdfDocument(pdfDocument);
+    }
+    return pageResults;
+}
+/**
+ * Convert raw image data to compressed base64 using sharp
+ */
+async function convertRawImageToBase64(data, width, height, channels, options = {}) {
+    const { format = 'webp', quality = 85, maxDimension = 1200 } = options;
+    // Smart resizing - only resize large images
+    let targetWidth = width;
+    let targetHeight = height;
+    if (width > maxDimension || height > maxDimension) {
+        const scale = maxDimension / Math.max(width, height);
+        targetWidth = Math.round(width * scale);
+        targetHeight = Math.round(height * scale);
+    }
+    try {
+        // Try to dynamically import sharp
+        const sharp = (await import('sharp')).default;
+        // sharp takes Buffer, Uint8Array, etc.
+        // unpdf returns Uint8ClampedArray, which works with Buffer.from()
+        let pipeline = sharp(Buffer.from(data), {
+            raw: {
+                width,
+                height,
+                channels: channels
+            }
+        });
+        if (targetWidth !== width || targetHeight !== height) {
+            pipeline = pipeline.resize(targetWidth, targetHeight);
+        }
+        let outputBuffer;
+        let mimeType;
+        if (format === 'jpeg') {
+            outputBuffer = await pipeline.jpeg({ quality }).toBuffer();
+            mimeType = 'image/jpeg';
+        }
+        else {
+            // Default to webp
+            outputBuffer = await pipeline.webp({ quality }).toBuffer();
+            mimeType = 'image/webp';
+        }
+        return {
+            data: outputBuffer.toString('base64'),
+            mimeType
+        };
+    }
+    catch (error) {
+        console.warn('Image conversion failed (likely missing sharp or invalid data):', error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}

package/dist/vendor/desktop-commander/dist/tools/pdf/index.js

@@ -0,0 +1,4 @@
+export { editPdf, insertRenderOptions, pdfLibPackage } from './manipulations.js';
+export { parsePdfToMarkdown, parseMarkdownToPdf, resolveRender, mdToPdfPackage } from './markdown.js';
+export { pdf2mdPackage } from './lib/pdf2md.js';
+export { extractImagesFromPdf, unpdfPackage } from './extract-images.js';

package/dist/vendor/desktop-commander/dist/tools/pdf/lib/pdf2md.js

@@ -0,0 +1,78 @@
+import { createRequire } from 'module';
+import { LazyPackage } from '../../../utils/lazy-package.js';
+import { closePdfDocument, generatePageNumbers } from '../utils.js';
+import { extractImagesFromPdf } from '../extract-images.js';
+const require = createRequire(import.meta.url);
+export const pdf2mdPackage = new LazyPackage('@opendocsg/pdf2md', 'PDF reading support', () => {
+    const { parse } = require('@opendocsg/pdf2md/lib/util/pdf');
+    const { makeTransformations, transform } = require('@opendocsg/pdf2md/lib/util/transformations');
+    return { parse, makeTransformations, transform };
+});
+/**
+ * Extracts metadata from a PDF document.
+ * @param pdfDocument The PDF document to extract metadata from.
+ * @returns A PdfMetadata object containing the extracted metadata.
+ */
+const extractMetadata = ({ pdfDocument, metadata }) => ({
+    totalPages: pdfDocument.numPages,
+    title: metadata.Title,
+    author: metadata.Author,
+    creator: metadata.Creator,
+    producer: metadata.Producer,
+    version: metadata.PDFFormatVersion,
+    creationDate: metadata.CreationDate,
+    modificationDate: metadata.ModDate,
+    isEncrypted: metadata.IsEncrypted,
+});
+/**
+ * Reads a PDF and converts it to Markdown, returning structured data.
+ * @param pdfBuffer The PDF buffer to convert.
+ * @param pageNumbers The page numbers to extract. If an empty array, all pages are extracted;
+ * a range that selects no pages (offset past the last page, length 0) extracts none.
+ * @returns A Promise that resolves to a PdfParseResult object containing the parsed data.
+ */
+export async function pdf2md(pdfBuffer, pageNumbers = []) {
+    const { parse, makeTransformations, transform } = pdf2mdPackage.load();
+    const result = await parse(pdfBuffer);
+    const { fonts, pages, pdfDocument } = result;
+    try {
+        // Calculate which pages to process
+        const allPages = Array.isArray(pageNumbers) && pageNumbers.length === 0;
+        const filterPageNumbers = Array.isArray(pageNumbers) ?
+            pageNumbers :
+            generatePageNumbers(pageNumbers.offset, pageNumbers.length, pages.length);
+        // Filter and transform pages
+        const pagesToProcess = allPages ?
+            pages :
+            pages.filter((_, index) => filterPageNumbers.includes(index + 1));
+        const pageNumberMap = allPages ?
+            pages.map((_, index) => index + 1) :
+            filterPageNumbers.filter(pageNum => pageNum >= 1 && pageNum <= pages.length);
+        const transformations = makeTransformations(fonts.map);
+        const parseResult = transform(pagesToProcess, transformations);
+        // Extract images
+        const imagesByPage = await extractImagesFromPdf(pdfBuffer, pageNumberMap, { format: 'webp', quality: 85 });
+        // Create pages without images for now
+        const processedPages = parseResult.pages.map((page, index) => {
+            const pageNumber = pageNumberMap[index];
+            return {
+                pageNumber,
+                text: page.items.join('\n') + '\n',
+                images: imagesByPage[pageNumber] || [],
+            };
+        });
+        const metadata = extractMetadata(result);
+        return { pages: processedPages, metadata };
+    }
+    finally {
+        if (pdfDocument) {
+            try {
+                if (typeof pdfDocument.cleanup === 'function') {
+                    await pdfDocument.cleanup(false);
+                }
+            }
+            catch (e) { }
+            await closePdfDocument(pdfDocument);
+        }
+    }
+}

package/dist/vendor/desktop-commander/dist/tools/pdf/manipulations.js

@@ -0,0 +1,112 @@
+import fs from 'fs/promises';
+import { createRequire } from 'module';
+import { LazyPackage } from '../../utils/lazy-package.js';
+import { normalizePageIndexes } from './utils.js';
+import { parseMarkdownToPdf } from './markdown.js';
+// Use createRequire to load pdf-lib as CJS (works around Node 25 ESM resolution issues)
+const require = createRequire(import.meta.url);
+export const pdfLibPackage = new LazyPackage('pdf-lib', 'PDF editing support', () => require('pdf-lib'));
+async function loadPdfDocumentFromBuffer(filePathOrBuffer) {
+    const { PDFDocument } = pdfLibPackage.load();
+    const buffer = typeof filePathOrBuffer === 'string' ? await fs.readFile(filePathOrBuffer) : filePathOrBuffer;
+    const pdfBytes = new Uint8Array(buffer);
+    return await PDFDocument.load(pdfBytes);
+}
+/**
+ * The render options for an inserted page's markdown: the call's options, with
+ * the page size and margins of the original first page (pageLayout), then the
+ * call's pdf_options, then the insert's own pdfOptions, each over the one before.
+ */
+export function insertRenderOptions(op, options = {}, pageLayout) {
+    return { ...options, pdf_options: { ...pageLayout, ...options.pdf_options, ...op.pdfOptions } };
+}
+/**
+ * Delete pages from a PDF document
+ * @param pdfDoc PDF document to delete pages from
+ * @param pageIndexes Page indices to delete, negative indices are from end
+ */
+function deletePages(pdfDoc, pageIndexes) {
+    const pageCount = pdfDoc.getPageCount();
+    // A page that doesn't exist is an error, as for an insert: nothing is deleted
+    if (pageIndexes.some(idx => !Number.isInteger(idx) || idx >= pageCount || idx < -pageCount)) {
+        throw new Error('Invalid page index');
+    }
+    // Transform negative indices to absolute and filter valid ones
+    const normalizedIndexes = normalizePageIndexes(pageIndexes, pageCount).sort((a, b) => b - a);
+    for (const pageIndex of normalizedIndexes) {
+        pdfDoc.removePage(pageIndex);
+    }
+    return pdfDoc;
+}
+function getPageLayout(page) {
+    const { width, height } = page.getSize();
+    const mediaBox = page.getMediaBox(); // Full page area
+    const cropBox = page.getCropBox(); // Visible area (may indicate margins)
+    // Calculate margins (if CropBox differs from MediaBox)
+    let marginLeft = cropBox.x - mediaBox.x;
+    let marginBottom = cropBox.y - mediaBox.y;
+    let marginRight = (mediaBox.x + mediaBox.width) - (cropBox.x + cropBox.width);
+    let marginTop = (mediaBox.y + mediaBox.height) - (cropBox.y + cropBox.height);
+    if (marginLeft === 0 && marginRight === 0 && marginTop === 0 && marginBottom === 0) {
+        marginLeft = 72;
+        marginBottom = 72;
+        marginRight = 72;
+        marginTop = 72;
+    }
+    // Convert points to inches (1 inch = 72 points)
+    // Puppeteer requires standard units and doesn't accept decimal points
+    const pointsToInches = (pts) => (pts / 72).toFixed(4);
+    return {
+        format: undefined, // Explicitly disable format to use custom dimensions
+        width: `${pointsToInches(width)}in`,
+        height: `${pointsToInches(height)}in`,
+        margin: {
+            top: `${pointsToInches(marginTop)}in`,
+            right: `${pointsToInches(marginRight)}in`,
+            bottom: `${pointsToInches(marginBottom)}in`,
+            left: `${pointsToInches(marginLeft)}in`
+        }
+    };
+}
+async function insertPages(destPdfDocument, pageIndex, sourcePdfDocument) {
+    let insertPosition = pageIndex < 0 ? destPdfDocument.getPageCount() + pageIndex : pageIndex;
+    if (insertPosition < 0 || insertPosition > destPdfDocument.getPageCount()) {
+        throw new Error('Invalid page index');
+    }
+    const copiedPages = await destPdfDocument.copyPages(sourcePdfDocument, sourcePdfDocument.getPageIndices());
+    for (let i = 0; i < copiedPages.length; i++) {
+        destPdfDocument.insertPage(insertPosition + i, copiedPages[i]);
+    }
+    return destPdfDocument;
+}
+/**
+ * Edit an existing PDF by deleting or inserting pages
+ * @param pdfPath Path to the PDF file to edit
+ * @param operations List of operations to perform
+ * @returns The modified PDF as a Uint8Array
+ */
+export async function editPdf(pdfPath, operations, options = {}) {
+    const pdfDoc = await loadPdfDocumentFromBuffer(pdfPath);
+    // Get page layout from the ORIGINAL first page
+    const pageLayout = pdfDoc.getPageCount() > 0 ? getPageLayout(pdfDoc.getPage(0)) : undefined;
+    for (const op of operations) {
+        if (op.type === 'delete') {
+            deletePages(pdfDoc, op.pageIndexes);
+        }
+        else if (op.type == 'insert') {
+            let sourcePdfDocument;
+            if (op.markdown !== undefined) {
+                const pdfBuffer = await parseMarkdownToPdf(op.markdown, insertRenderOptions(op, options, pageLayout));
+                sourcePdfDocument = await loadPdfDocumentFromBuffer(pdfBuffer);
+            }
+            else if (op.sourcePdfPath) {
+                sourcePdfDocument = await loadPdfDocumentFromBuffer(op.sourcePdfPath);
+            }
+            else {
+                throw new Error('No source provided for insert operation');
+            }
+            await insertPages(pdfDoc, op.pageIndex, sourcePdfDocument);
+        }
+    }
+    return await pdfDoc.save();
+}

package/dist/vendor/desktop-commander/dist/tools/pdf/markdown.js

@@ -0,0 +1,30 @@
+import fs from 'fs/promises';
+import { pdf2md } from './lib/pdf2md.js';
+import { LazyPackage } from '../../utils/lazy-package.js';
+
+const isUrl = (source) => source.startsWith('http://') || source.startsWith('https://');
+
+export const mdToPdfPackage = new LazyPackage('md-to-pdf', 'PDF writing support', () => ({}));
+
+export function ensureChromeAvailable() {}
+
+export function resolveRender(markdown, options = {}) {
+  return { body: markdown, options: { ...options }, ignoredOptions: [] };
+}
+
+async function loadPdfToBuffer(source) {
+  if (isUrl(source)) {
+    const response = await fetch(source);
+    return await response.arrayBuffer();
+  }
+  return await fs.readFile(source);
+}
+
+export async function parsePdfToMarkdown(source, pageNumbers = []) {
+  const data = await loadPdfToBuffer(source);
+  return await pdf2md(new Uint8Array(data), pageNumbers);
+}
+
+export async function parseMarkdownToPdf() {
+  throw new Error('Headless browser PDF rendering (Puppeteer/Chrome) is stripped in Starmux for security and privacy.');
+}

package/dist/vendor/desktop-commander/dist/tools/pdf/utils.js

@@ -0,0 +1,45 @@
+/**
+ * Normalize page indexes, handling negative indices and removing duplicates
+ */
+export const normalizePageIndexes = (pageIndexes, pageCount) => {
+    const normalizedIndexes = pageIndexes
+        .map(idx => idx < 0 ? pageCount + idx : idx)
+        .filter(idx => idx >= 0 && idx < pageCount);
+    // Use Set to remove duplicates
+    return [...new Set(normalizedIndexes)];
+};
+/**
+ * Generate page numbers based on offset and length
+ * @param offset Zero-based offset or negative for the last pages (length is then ignored, as for lines)
+ * @param length Number of pages to generate
+ * @param totalPages Total number of pages in the document
+ * @returns Array of page numbers (empty when the offset is past the last page or length is 0)
+ */
+export function generatePageNumbers(offset, length, totalPages) {
+    // Compute 1-based start page
+    const startPage = offset < 0
+        ? totalPages + offset + 1
+        : offset + 1;
+    // Clamp start page
+    if (startPage > totalPages)
+        return [];
+    const safeStart = Math.max(1, startPage);
+    // Compute final page (inclusive), truncated by totalPages; a negative offset reads to the last page
+    const endPage = offset < 0 ? totalPages : Math.min(safeStart + length - 1, totalPages);
+    const count = endPage - safeStart + 1;
+    if (count <= 0)
+        return [];
+    // Preallocate array for speed
+    return Array.from({ length: count }, (_, i) => safeStart + i);
+}
+/**
+ * Close a PDF document opened with unpdf, so pdf.js frees what it holds for it
+ * @param pdfDocument The document, closed through its loading task: unpdf 1.8's
+ * document has no destroy() of its own (1.4's only calls loadingTask.destroy())
+ */
+export async function closePdfDocument(pdfDocument) {
+    try {
+        await pdfDocument.loadingTask.destroy();
+    }
+    catch (e) { /* Ignore cleanup errors */ }
+}

package/dist/vendor/desktop-commander/dist/tools/process.js

@@ -0,0 +1,90 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import { KillProcessArgsSchema } from './schemas.js';
+import { resolveProgramPath } from '../utils/shell.js';
+import { terminatePid } from '../utils/process-tree.js';
+const execFileAsync = promisify(execFile);
+/**
+ * Parse `tasklist /FO CSV /NH` output (#662). Fields per row, all quoted:
+ * [Image Name, PID, Session Name, Session#, Mem Usage]. CSV instead of the
+ * default table: image names can contain spaces and Mem Usage contains
+ * thousands separators, so positional whitespace splitting can't work.
+ * tasklist has no live per-process CPU%, so cpu is reported as n/a.
+ */
+export function parseWindowsTasklistCsv(stdout) {
+    return stdout.split(/\r?\n/)
+        .filter(Boolean)
+        .map(line => {
+        const fields = (line.match(/"([^"]*)"/g) || []).map(f => f.slice(1, -1));
+        return {
+            pid: parseInt(fields[1], 10),
+            command: fields[0] ?? '',
+            cpu: 'n/a',
+            memory: fields[4] ?? '',
+        };
+    })
+        .filter(p => !Number.isNaN(p.pid));
+}
+/**
+ * Parse `ps aux` output: 11 whitespace-separated columns, COMMAND from
+ * column 10 onward (it can contain spaces, so it must be rejoined, not
+ * taken as the last token).
+ */
+export function parsePsAux(stdout) {
+    return stdout.split(/\r?\n/)
+        .slice(1)
+        .filter(Boolean)
+        .map(line => {
+        const parts = line.trim().split(/\s+/);
+        return {
+            pid: parseInt(parts[1], 10),
+            command: parts.slice(10).join(' ') || parts[parts.length - 1],
+            cpu: parts[2],
+            memory: parts[3],
+        };
+    })
+        .filter(p => !Number.isNaN(p.pid));
+}
+export async function listProcesses() {
+    const isWindows = os.platform() === 'win32';
+    const [program, args] = isWindows ? ['tasklist', ['/FO', 'CSV', '/NH']] : ['ps', ['aux']];
+    try {
+        const { stdout } = await execFileAsync(resolveProgramPath(program), args);
+        const processes = isWindows ? parseWindowsTasklistCsv(stdout) : parsePsAux(stdout);
+        return {
+            content: [{
+                    type: "text",
+                    text: processes.map(p => `PID: ${p.pid}, Command: ${p.command}, CPU: ${p.cpu}, Memory: ${p.memory}`).join('\n')
+                }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: Failed to list processes: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+}
+export async function killProcess(args) {
+    const parsed = KillProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for kill_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        // Returns once the process is gone, so a success means it no longer runs
+        await terminatePid(parsed.data.pid);
+        return {
+            content: [{ type: "text", text: `Successfully terminated process ${parsed.data.pid}` }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: Failed to kill process: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+}