starmux 0.12.0 → 0.13.0

package/dist/vendor/desktop-commander/dist/config-recovery.js

@@ -0,0 +1,81 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+/**
+ * The settings still readable in a corrupt config.json: the longest beginning
+ * of it that is a JSON object once closed, so every complete top-level setting
+ * before the first error. {} when there is none.
+ */
+export function salvageSettings(text) {
+    const body = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    // A readable beginning can end at each comma between top-level settings, or at
+    // the brace that closes the object (anything after it is ignored)
+    const ends = [];
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < body.length; i++) {
+        const char = body[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+        }
+        else if (char === '"') {
+            inString = true;
+        }
+        else if (char === '{' || char === '[') {
+            depth++;
+        }
+        else if (char === '}' || char === ']') {
+            if (--depth === 0) {
+                ends.push(i);
+                break;
+            }
+        }
+        else if (char === ',' && depth === 1) {
+            ends.push(i);
+        }
+    }
+    for (const end of ends.reverse()) {
+        try {
+            return JSON.parse(body.slice(0, end) + '}');
+        }
+        catch {
+            // Not valid JSON up to here either, so try a shorter beginning
+        }
+    }
+    return {};
+}
+/**
+ * What a corrupt config.json is recovered as: the defaults, then the settings
+ * last read (while running), then the settings salvaged from it. The welcome
+ * page stays off, as for any existing install.
+ */
+export function buildRecoveredConfig(defaults, lastRead, text) {
+    const { version: _version, ...settings } = lastRead ?? {};
+    return { ...defaults, ...settings, ...salvageSettings(text), welcomeOnboardingEligible: false, pendingWelcomeOnboarding: false };
+}
+/**
+ * Backs up a corrupt config.json as config.json.corrupt.<ms>.<pid>, unless the
+ * newest backup already holds `bytes` (a recovery tried again after its write
+ * failed). Returns the backup's name, or null when there is no config.json.
+ */
+export async function backupCorruptConfig(configPath, bytes) {
+    if (!existsSync(configPath))
+        return null;
+    const folder = path.dirname(configPath);
+    const prefix = `${path.basename(configPath)}.corrupt.`;
+    const newest = (await fs.readdir(folder).catch(() => []))
+        .filter((name) => name.startsWith(prefix))
+        .sort((a, b) => parseInt(a.slice(prefix.length), 10) - parseInt(b.slice(prefix.length), 10))
+        .pop();
+    if (newest && (await fs.readFile(path.join(folder, newest)).catch(() => null))?.equals(bytes))
+        return newest;
+    const name = `${prefix}${Date.now()}.${process.pid}`;
+    await fs.copyFile(configPath, path.join(folder, name));
+    return name;
+}

package/dist/vendor/desktop-commander/dist/config.js

@@ -0,0 +1,19 @@
+import path from 'path';
+import os from 'os';
+// Use user's home directory for configuration files
+export const USER_HOME = os.homedir();
+const CONFIG_DIR = path.join(USER_HOME, '.claude-server-commander');
+// Paths relative to the config directory
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export const TOOL_CALL_FILE = path.join(CONFIG_DIR, 'claude_tool_call.log');
+export const TOOL_CALL_FILE_MAX_SIZE = 1024 * 1024 * 10; // 10 MB
+export const DEFAULT_COMMAND_TIMEOUT = 1000; // milliseconds
+// Longest one process call (start_process, interact_with_process,
+// read_process_output) blocks, whatever timeout_ms asks for; the process keeps
+// running and the caller reads the rest with read_process_output. It stays well
+// under 60 s: that is the MCP SDK's default request timeout
+// (DEFAULT_REQUEST_TIMEOUT_MSEC), which Claude Desktop and the remote device's
+// own client use, and an answer capped at 60 s arrived just after the client had
+// given up (-32001 "Request timed out", #447). The margin leaves time to build
+// and deliver the answer.
+export const MAX_PROCESS_WAIT_MS = 50000;

package/dist/vendor/desktop-commander/dist/custom-stdio.js

@@ -0,0 +1,358 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import process from "node:process";
+/**
+ * Enhanced StdioServerTransport that wraps console output in valid JSON-RPC structures
+ * instead of filtering them out. This prevents crashes while maintaining debug visibility.
+ */
+export class FilteredStdioServerTransport extends StdioServerTransport {
+    constructor() {
+        super();
+        this.isInitialized = false;
+        this.messageBuffer = [];
+        this.clientName = 'unknown';
+        this.disableNotifications = false;
+        // Store original methods
+        this.originalConsole = {
+            log: console.log,
+            warn: console.warn,
+            error: console.error,
+            debug: console.debug,
+            info: console.info,
+        };
+        this.originalStdoutWrite = process.stdout.write;
+        // Setup console redirection
+        this.setupConsoleRedirection();
+        // Setup stdout filtering for any other output
+        this.setupStdoutFiltering();
+        // Note: We defer the initialization notification until enableNotifications() is called
+        // to ensure MCP protocol compliance - notifications must not be sent before initialization
+    }
+    /**
+     * Call this method after MCP initialization is complete to enable JSON-RPC notifications
+     */
+    enableNotifications() {
+        this.isInitialized = true;
+        // Check if notifications should be disabled based on client
+        if (this.disableNotifications) {
+            // Clear buffer without sending - just log to stderr instead
+            if (this.messageBuffer.length > 0) {
+                process.stderr.write(`[INFO] ${this.messageBuffer.length} buffered messages suppressed for ${this.clientName}\n`);
+            }
+            this.messageBuffer = [];
+            return;
+        }
+        // Send the deferred initialization notification first
+        this.sendLogNotification('info', ['Enhanced FilteredStdioServerTransport initialized']);
+        // Replay all buffered messages in chronological order
+        if (this.messageBuffer.length > 0) {
+            this.sendLogNotification('info', [`Replaying ${this.messageBuffer.length} buffered initialization messages`]);
+            this.messageBuffer
+                .sort((a, b) => a.timestamp - b.timestamp)
+                .forEach(msg => {
+                this.sendLogNotification(msg.level, msg.args);
+            });
+            // Clear the buffer
+            this.messageBuffer = [];
+        }
+        this.sendLogNotification('info', ['JSON-RPC notifications enabled']);
+    }
+    /**
+     * Configure client-specific behavior
+     * Call this BEFORE enableNotifications()
+     */
+    configureForClient(clientName) {
+        this.clientName = clientName.toLowerCase();
+        // Detect Cline and disable notifications
+        if (this.clientName.includes('cline') ||
+            this.clientName.includes('vscode') ||
+            this.clientName === 'claude-dev') {
+            this.disableNotifications = true;
+            process.stderr.write(`[INFO] Desktop Commander: Notifications disabled for ${clientName}\n`);
+        }
+    }
+    /**
+     * Check if notifications are enabled
+     */
+    get isNotificationsEnabled() {
+        return this.isInitialized;
+    }
+    /**
+     * Get the current count of buffered messages
+     */
+    get bufferedMessageCount() {
+        return this.messageBuffer.length;
+    }
+    setupConsoleRedirection() {
+        console.log = (...args) => {
+            if (this.isInitialized) {
+                this.sendLogNotification("info", args);
+            }
+            else {
+                // Buffer for later replay to client
+                this.messageBuffer.push({
+                    level: "info",
+                    args,
+                    timestamp: Date.now()
+                });
+            }
+        };
+        console.info = (...args) => {
+            if (this.isInitialized) {
+                this.sendLogNotification("info", args);
+            }
+            else {
+                this.messageBuffer.push({
+                    level: "info",
+                    args,
+                    timestamp: Date.now()
+                });
+            }
+        };
+        console.warn = (...args) => {
+            if (this.isInitialized) {
+                this.sendLogNotification("warning", args);
+            }
+            else {
+                this.messageBuffer.push({
+                    level: "warning",
+                    args,
+                    timestamp: Date.now()
+                });
+            }
+        };
+        console.error = (...args) => {
+            if (this.isInitialized) {
+                this.sendLogNotification("error", args);
+            }
+            else {
+                this.messageBuffer.push({
+                    level: "error",
+                    args,
+                    timestamp: Date.now()
+                });
+            }
+        };
+        console.debug = (...args) => {
+            if (this.isInitialized) {
+                this.sendLogNotification("debug", args);
+            }
+            else {
+                this.messageBuffer.push({
+                    level: "debug",
+                    args,
+                    timestamp: Date.now()
+                });
+            }
+        };
+    }
+    setupStdoutFiltering() {
+        process.stdout.write = (buffer, encoding, callback) => {
+            // Handle different call signatures
+            if (typeof buffer === 'string') {
+                const trimmed = buffer.trim();
+                // Check if this looks like a valid JSON-RPC message
+                if (trimmed.startsWith('{') && (trimmed.includes('"jsonrpc"') ||
+                    trimmed.includes('"method"') ||
+                    trimmed.includes('"id"'))) {
+                    // This looks like a valid JSON-RPC message, allow it
+                    return this.originalStdoutWrite.call(process.stdout, buffer, encoding, callback);
+                }
+                else if (trimmed.length > 0) {
+                    // Non-JSON-RPC output, wrap it in a log notification
+                    if (this.isInitialized) {
+                        this.sendLogNotification("info", [buffer.replace(/\n$/, '')]);
+                    }
+                    else {
+                        // Buffer for later replay to client
+                        this.messageBuffer.push({
+                            level: "info",
+                            args: [buffer.replace(/\n$/, '')],
+                            timestamp: Date.now()
+                        });
+                    }
+                    if (callback)
+                        callback();
+                    return true;
+                }
+            }
+            // For non-string buffers or empty strings, let them through
+            return this.originalStdoutWrite.call(process.stdout, buffer, encoding, callback);
+        };
+    }
+    sendLogNotification(level, args) {
+        // Skip if notifications are disabled (e.g., for Cline)
+        if (this.disableNotifications) {
+            return;
+        }
+        try {
+            // For data, we can send structured data or string according to MCP spec
+            let data;
+            if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+                // Single object - send as structured data
+                data = args[0];
+            }
+            else {
+                // Multiple args or primitives - convert to string
+                data = args.map(arg => {
+                    if (typeof arg === 'object') {
+                        try {
+                            return JSON.stringify(arg, null, 2);
+                        }
+                        catch {
+                            return String(arg);
+                        }
+                    }
+                    return String(arg);
+                }).join(' ');
+            }
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: level,
+                    logger: "desktop-commander",
+                    data: data
+                }
+            };
+            // Send as valid JSON-RPC notification
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            // Fallback to a simple JSON-RPC error notification if JSON serialization fails
+            const fallbackNotification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: "error",
+                    logger: "desktop-commander",
+                    data: `Log serialization failed: ${args.join(' ')}`
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(fallbackNotification) + '\n');
+        }
+    }
+    /**
+     * Public method to send log notifications from anywhere in the application
+     * Now properly buffers messages before MCP initialization to avoid breaking stdio protocol
+     */
+    sendLog(level, message, data) {
+        // Skip if notifications are disabled (e.g., for Cline)
+        if (this.disableNotifications) {
+            return;
+        }
+        // Buffer messages before initialization to avoid breaking MCP protocol
+        // MCP requires client to send first message - server cannot write to stdout before that
+        if (!this.isInitialized) {
+            this.messageBuffer.push({
+                level,
+                args: [data ? { message, ...data } : message],
+                timestamp: Date.now()
+            });
+            return;
+        }
+        try {
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: level,
+                    logger: "desktop-commander",
+                    data: data ? { message, ...data } : message
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            // Fallback to basic JSON-RPC notification
+            const fallbackNotification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: "error",
+                    logger: "desktop-commander",
+                    data: `sendLog failed: ${message}`
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(fallbackNotification) + '\n');
+        }
+    }
+    /**
+     * Send a progress notification (useful for long-running operations)
+     */
+    sendProgress(token, value, total) {
+        // Don't send progress before initialization - would break MCP protocol
+        if (!this.isInitialized) {
+            return;
+        }
+        try {
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/progress",
+                params: {
+                    progressToken: token,
+                    value: value,
+                    ...(total && { total })
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            // Fallback to basic JSON-RPC notification for progress
+            const fallbackNotification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: "info",
+                    logger: "desktop-commander",
+                    data: `Progress ${token}: ${value}${total ? `/${total}` : ''}`
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(fallbackNotification) + '\n');
+        }
+    }
+    /**
+     * Send a custom notification with any method name
+     */
+    sendCustomNotification(method, params) {
+        // Don't send custom notifications before initialization - would break MCP protocol
+        if (!this.isInitialized) {
+            return;
+        }
+        try {
+            const notification = {
+                jsonrpc: "2.0",
+                method: method,
+                params: params
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            // Fallback to basic JSON-RPC notification for custom notifications
+            const fallbackNotification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: "error",
+                    logger: "desktop-commander",
+                    data: `Custom notification failed: ${method}: ${JSON.stringify(params)}`
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(fallbackNotification) + '\n');
+        }
+    }
+    /**
+     * Cleanup method to restore original console methods if needed
+     */
+    cleanup() {
+        if (this.originalConsole) {
+            console.log = this.originalConsole.log;
+            console.warn = this.originalConsole.warn;
+            console.error = this.originalConsole.error;
+            console.debug = this.originalConsole.debug;
+            console.info = this.originalConsole.info;
+        }
+        if (this.originalStdoutWrite) {
+            process.stdout.write = this.originalStdoutWrite;
+        }
+    }
+}

package/dist/vendor/desktop-commander/dist/error-handlers.js

@@ -0,0 +1,15 @@
+import { capture } from "./utils/capture.js";
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export function createErrorResponse(message) {
+    capture('server_request_error', {
+        error: message
+    });
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}

package/dist/vendor/desktop-commander/dist/handlers/edit-search-handlers.js

@@ -0,0 +1,6 @@
+import { handleEditBlock } from '../tools/edit.js';
+/**
+ * Handle edit_block command
+ * Uses the enhanced implementation with multiple occurrence support and fuzzy matching
+ */
+export { handleEditBlock };