starmux 0.12.0 → 0.13.0

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

@@ -0,0 +1,172 @@
+import { SHOWN_TEXT_CHARS, MAX_OUTPUT_LINE_CHARS } from '../search-manager.js';
+/**
+ * The words of the search answers (start_search, get_more_search_results), in
+ * one place (#768). Each answer ends saying how the search ended: its outcome
+ * (SearchOutcome in search-manager.ts).
+ */
+export const SEARCH_WORDS = {
+    /** "Total results: …", the same in both answers */
+    total: (matches, rows) => `${matches === 1 ? '1 match' : `${matches} matches`}${rows > matches ? ` (${rows} rows with context)` : ''}`,
+    matchRow: (file, line, text) => `📄 ${file}:${line} - ${text}`,
+    contextRow: (file, line, text) => `   ${file}:${line} · ${text}`,
+    fileRow: (file) => `📁 ${file}`,
+    /** A page with no results */
+    noMatches: 'No matches found.',
+    noneAtOffset: (offset, rows) => `No results at offset ${offset} (${rows} in total).`,
+    noneYet: (offset, rows) => `Still running: ${rows === 1 ? '1 result' : `${rows} results`} so far${offset >= 0 ? `, none at offset ${offset} yet` : ''}.`,
+    /** After a page's results: whether there are more */
+    moreResults: (nextOffset) => `📖 More results available. Use get_more_search_results with offset: ${nextOffset}`,
+    moreMayCome: 'Still running: more may come.',
+    inProgress: '🔄 Search in progress. Use get_more_search_results to get more results.',
+    /** How the search ended, by outcome */
+    completed: '✅ Search completed.',
+    timedOut: (ms) => `⏱️ Stopped after ${ms} ms: results may be incomplete.`,
+    stopped: '⏹️ Stopped on request: results may be incomplete.',
+    maxResults: (n) => `Stopped at maxResults (${n}): there may be more.`,
+    /** Partial, when the only files it couldn't search were ones it may not read: as it always said */
+    permissionsOnly: '✅ Search completed.\n⚠️  Warning: Some files were inaccessible due to permissions. Results may be incomplete.',
+    partial: (reasons) => `⚠️ Completed, but some files couldn't be searched: ${reasons.join('; ')}.`,
+    unsearched: {
+        permissions: () => 'some files were inaccessible due to permissions',
+        ripgrep_error: (u) => `ripgrep: ${u.example}${andMore(u)}`,
+        ripgrep_ended: (u) => `ripgrep stopped unexpectedly (${u.example})`,
+        excel_search: (u) => `the Excel search failed (${u.example})`,
+        docx_search: (u) => `the DOCX search failed (${u.example})`,
+        excel_file: (u) => `${counted(u, 'an Excel file', 'Excel files')} couldn't be read (${u.example}${andMore(u)})`,
+        docx_file: (u) => `${counted(u, 'a DOCX file', 'DOCX files')} couldn't be read (${u.example}${andMore(u)})`,
+        excel_folder: (u) => `${counted(u, 'a folder', 'folders')} couldn't be listed for the Excel search (${u.example}${andMore(u)})`,
+        docx_folder: (u) => `${counted(u, 'a folder', 'folders')} couldn't be listed for the DOCX search (${u.example}${andMore(u)})`,
+    },
+    /** A failed search's whole answer */
+    failedWithError: (sessionId, error) => `Search session ${sessionId} encountered an error: ${error}`,
+    failedRipgrepEnded: (sessionId, how) => `Search session ${sessionId} failed: ripgrep stopped unexpectedly (${how}).`,
+};
+const andMore = (u) => (u.count > 1 ? ` and ${u.count - 1} more` : '');
+const counted = (u, one, many) => (u.count === 1 ? one : `${u.count} ${many}`);
+/**
+ * Which lines a search skipped as too long: how many, in which files. Part of a
+ * successful answer, worded so that nobody retries: the same search skips them again.
+ */
+function describeSkippedLines(skipped) {
+    const lines = skipped.reduce((sum, { count }) => sum + count, 0);
+    const files = skipped.slice(0, 5).map(({ file }) => file || 'a file whose name is not valid UTF-8').join(', ');
+    const more = skipped.length > 5 ? ` and ${skipped.length - 5} more files` : '';
+    const exclude = skipped.length === 1 ? "that file (filePattern) if it isn't" : "those files (filePattern) if they aren't";
+    return `Skipped ${lines === 1 ? 'a line' : `${lines} lines`} over ${Math.round(MAX_OUTPUT_LINE_CHARS / 1024 / 1024)} MB in ${files}${more}: too long to search. ` +
+        `Searching again gives the same result; exclude ${exclude} needed.`;
+}
+/** A result as answers list it: a match, a line around one, or a file */
+function resultRow(result) {
+    if (result.type !== 'content')
+        return SEARCH_WORDS.fileRow(result.file);
+    const text = `${result.match?.substring(0, SHOWN_TEXT_CHARS)}${result.match && result.match.length > SHOWN_TEXT_CHARS ? '...' : ''}`;
+    return (result.context ? SEARCH_WORDS.contextRow : SEARCH_WORDS.matchRow)(result.file, result.line, text);
+}
+/** How a complete search ended, as its answer's last line(s); undefined while it runs */
+function endedText(state) {
+    switch (state.outcome) {
+        case 'completed': return SEARCH_WORDS.completed;
+        case 'timed_out': return SEARCH_WORDS.timedOut(state.timeLimitMs);
+        case 'stopped': return SEARCH_WORDS.stopped;
+        case 'max_results': return SEARCH_WORDS.maxResults(state.maxResults);
+        case 'partial':
+            return state.unsearched.every(u => u.kind === 'permissions')
+                ? SEARCH_WORDS.permissionsOnly
+                : SEARCH_WORDS.partial(state.unsearched.map(u => SEARCH_WORDS.unsearched[u.kind](u)));
+        default: return undefined;
+    }
+}
+/** The answer to a search that failed, whichever tool reads it */
+function failedAnswer(state) {
+    const failure = state.failure;
+    const text = 'error' in failure
+        ? SEARCH_WORDS.failedWithError(state.sessionId, failure.error)
+        : SEARCH_WORDS.failedRipgrepEnded(state.sessionId, failure.ripgrepEnded);
+    return {
+        content: [{ type: 'text', text }],
+        isError: true,
+        structuredContent: { sessionId: state.sessionId, isComplete: state.isComplete, outcome: state.outcome },
+    };
+}
+/** start_search's answer: the search as it is once it started, with its first results */
+export function startSearchAnswer(search, args) {
+    if (search.outcome === 'failed')
+        return failedAnswer(search);
+    let text = `Started ${args.searchType === 'content' ? 'content search' : 'file search'} session: ${search.sessionId}\n`;
+    text += `Pattern: "${args.pattern}"\n`;
+    text += `Path: ${args.path}\n`;
+    text += `Status: ${search.isComplete ? 'COMPLETED' : 'RUNNING'}\n`;
+    text += `Runtime: ${Math.round(search.runtime)}ms\n`;
+    text += `Total results: ${SEARCH_WORDS.total(search.totalMatches, search.totalResults)}\n\n`;
+    if (search.results.length > 0) {
+        text += 'Initial results:\n';
+        for (const result of search.results.slice(0, 10)) {
+            text += `${resultRow(result)}\n`;
+        }
+        if (search.results.length > 10) {
+            text += `... and ${search.results.length - 10} more results\n`;
+        }
+    }
+    text += `\n${endedText(search) ?? SEARCH_WORDS.inProgress}`;
+    return {
+        content: [{ type: 'text', text }],
+        structuredContent: {
+            sessionId: search.sessionId,
+            isComplete: search.isComplete,
+            outcome: search.outcome,
+            totalResults: search.totalMatches,
+        },
+    };
+}
+/** get_more_search_results' answer: one page of a search's results (a negative offset: its last results) */
+export function searchResultsAnswer(page, offset) {
+    if (page.outcome === 'failed')
+        return failedAnswer(page);
+    let text = `Search session: ${page.sessionId}\n`;
+    text += `Status: ${page.isComplete ? 'COMPLETED' : 'IN PROGRESS'}\n`;
+    text += `Runtime: ${Math.round(page.runtime / 1000)}s\n`;
+    text += `Total results: ${SEARCH_WORDS.total(page.totalMatches, page.totalResults)}\n`;
+    if (page.returnedCount > 0) {
+        text += offset < 0
+            ? `Showing last ${page.returnedCount} results\n`
+            : `Showing results ${offset}-${offset + page.returnedCount - 1}\n`;
+    }
+    text += '\n';
+    const nextOffset = offset + page.returnedCount;
+    if (page.returnedCount === 0) {
+        if (!page.isComplete)
+            text += SEARCH_WORDS.noneYet(offset, page.totalResults);
+        else
+            text += page.totalResults === 0 ? SEARCH_WORDS.noMatches : SEARCH_WORDS.noneAtOffset(offset, page.totalResults);
+    }
+    else {
+        text += 'Results:\n';
+        for (const result of page.results) {
+            text += `${resultRow(result)}\n`;
+        }
+        if (offset >= 0 && nextOffset < page.totalResults) {
+            text += `\n${SEARCH_WORDS.moreResults(nextOffset)}`;
+        }
+        else if (!page.isComplete) {
+            text += `\n${SEARCH_WORDS.moreMayCome}`;
+        }
+    }
+    if (page.skippedLines.length > 0) {
+        text += `\n${describeSkippedLines(page.skippedLines)}`;
+    }
+    const ended = endedText(page);
+    if (ended)
+        text += `\n${ended}`;
+    return {
+        content: [{ type: 'text', text }],
+        structuredContent: {
+            sessionId: page.sessionId,
+            isComplete: page.isComplete,
+            outcome: page.outcome,
+            totalResults: page.totalResults,
+            totalMatches: page.totalMatches,
+            returnedCount: page.returnedCount,
+            hasMoreResults: page.hasMoreResults,
+        },
+    };
+}

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

@@ -0,0 +1,136 @@
+import { searchManager } from '../search-manager.js';
+import { StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema } from '../tools/schemas.js';
+import { capture } from '../utils/capture.js';
+import { startSearchAnswer, searchResultsAnswer } from './search-answers.js';
+/**
+ * Handle start_search command
+ */
+export async function handleStartSearch(args) {
+    const parsed = StartSearchArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for start_search: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await searchManager.startSearch({
+            rootPath: parsed.data.path,
+            pattern: parsed.data.pattern,
+            searchType: parsed.data.searchType,
+            filePattern: parsed.data.filePattern,
+            ignoreCase: parsed.data.ignoreCase,
+            maxResults: parsed.data.maxResults,
+            includeHidden: parsed.data.includeHidden,
+            contextLines: parsed.data.contextLines,
+            timeout: parsed.data.timeout_ms,
+            earlyTermination: parsed.data.earlyTermination,
+            literalSearch: parsed.data.literalSearch,
+        });
+        return startSearchAnswer(result, parsed.data);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('search_session_start_error', { error: errorMessage });
+        return {
+            content: [{ type: "text", text: `Error starting search session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_more_search_results command
+ */
+export async function handleGetMoreSearchResults(args) {
+    const parsed = GetMoreSearchResultsArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for get_more_search_results: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const page = searchManager.readSearchResults(parsed.data.sessionId, parsed.data.offset, parsed.data.length);
+        return searchResultsAnswer(page, parsed.data.offset);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error reading search results: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle stop_search command
+ */
+export async function handleStopSearch(args) {
+    const parsed = StopSearchArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for stop_search: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const success = searchManager.terminateSearch(parsed.data.sessionId);
+        if (success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} terminated successfully.`
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} not found or already completed.`
+                    }],
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error terminating search session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle list_searches command
+ */
+export async function handleListSearches() {
+    try {
+        const sessions = searchManager.listSearchSessions();
+        if (sessions.length === 0) {
+            return {
+                content: [{ type: "text", text: "No active searches." }],
+            };
+        }
+        let output = `Active Searches (${sessions.length}):\n\n`;
+        for (const session of sessions) {
+            const status = session.isComplete
+                ? (session.isError ? '❌ ERROR' : '✅ COMPLETED')
+                : '🔄 RUNNING';
+            output += `Session: ${session.id}\n`;
+            output += `  Type: ${session.searchType}\n`;
+            output += `  Pattern: "${session.pattern}"\n`;
+            output += `  Status: ${status}\n`;
+            output += `  Runtime: ${Math.round(session.runtime / 1000)}s\n`;
+            output += `  Results: ${session.totalResults}\n\n`;
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error listing search sessions: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,35 @@
+import { startProcess, readProcessOutput, interactWithProcess, forceTerminate, listSessions } from '../tools/improved-process-tools.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle start_process command (improved execute_command)
+ */
+export async function handleStartProcess(args) {
+    const parsed = StartProcessArgsSchema.parse(args);
+    return startProcess(parsed);
+}
+/**
+ * Handle read_process_output command (improved read_output)
+ */
+export async function handleReadProcessOutput(args) {
+    const parsed = ReadProcessOutputArgsSchema.parse(args);
+    return readProcessOutput(parsed);
+}
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export async function handleInteractWithProcess(args) {
+    return interactWithProcess(args);
+}
+/**
+ * Handle force_terminate command
+ */
+export async function handleForceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.parse(args);
+    return forceTerminate(parsed);
+}
+/**
+ * Handle list_sessions command
+ */
+export async function handleListSessions() {
+    return listSessions();
+}

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

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import './bootstrap.js';
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+import { server, flushDeferredMessages } from './server.js';
+import { configManager } from './config-manager.js';
+import { logToStderr, logger } from './utils/logger.js';
+import { exitProcess } from './utils/exit-process.js';
+import { preloadFileSupport } from './utils/files/index.js';
+
+const deferredMessages = [];
+function deferLog(level, message) {
+  deferredMessages.push({ level, message });
+}
+
+async function runServer() {
+  try {
+    global.disableOnboarding = true;
+    const transport = new FilteredStdioServerTransport();
+    global.mcpTransport = transport;
+    try {
+      deferLog('info', 'Loading configuration...');
+      await configManager.loadConfig();
+      deferLog('info', 'Configuration loaded successfully');
+    } catch (configError) {
+      deferLog('error', `Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+      deferLog('warning', 'Continuing with in-memory configuration only');
+    }
+
+    process.on('uncaughtException', async (error) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+        logger.error(`JSON parsing error: ${errorMessage}`);
+        return;
+      }
+      logger.error(`Uncaught exception: ${errorMessage}`);
+      exitProcess(1);
+    });
+
+    process.on('unhandledRejection', async (reason) => {
+      const errorMessage = reason instanceof Error ? reason.message : String(reason);
+      if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+        logger.error(`JSON parsing rejection: ${errorMessage}`);
+        return;
+      }
+      logger.error(`Unhandled rejection: ${errorMessage}`);
+    });
+
+    deferLog('info', 'Connecting server...');
+    server.oninitialized = () => {
+      transport.enableNotifications();
+      while (deferredMessages.length > 0) {
+        const msg = deferredMessages.shift();
+        transport.sendLog('info', msg.message);
+      }
+      flushDeferredMessages();
+      transport.sendLog('info', 'Server connected successfully');
+      transport.sendLog('info', 'MCP fully initialized, all startup messages sent');
+      preloadFileSupport();
+    };
+    await server.connect(transport);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`FATAL ERROR: ${errorMessage}`);
+    const errorNotification = {
+      jsonrpc: '2.0',
+      method: 'notifications/message',
+      params: {
+        level: 'error',
+        logger: 'desktop-commander',
+        data: `Failed to start server: ${errorMessage} (${new Date().toISOString()})`,
+      },
+    };
+    process.stdout.write(JSON.stringify(errorNotification) + '\n');
+    exitProcess(1);
+  }
+}
+
+runServer().catch(async (error) => {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  process.stderr.write(
+    JSON.stringify({
+      type: 'error',
+      timestamp: new Date().toISOString(),
+      message: `Fatal error running server: ${errorMessage}`,
+    }) + '\n'
+  );
+  exitProcess(1);
+});