starmux 0.11.0 → 0.13.0

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

@@ -0,0 +1,259 @@
+import { usageTracker } from '../utils/usageTracker.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory path for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let cachedPromptsData = null;
+/**
+ * Clear cached prompts data (for development/testing)
+ */
+function clearCache() {
+    cachedPromptsData = null;
+}
+/**
+ * Load prompts data from JSON file with caching
+ */
+export async function loadPromptsData() {
+    if (cachedPromptsData) {
+        return cachedPromptsData;
+    }
+    try {
+        const dataPath = path.join(__dirname, '..', 'data', 'onboarding-prompts.json');
+        const fileContent = await fs.readFile(dataPath, 'utf-8');
+        cachedPromptsData = JSON.parse(fileContent);
+        if (!cachedPromptsData) {
+            throw new Error('Failed to parse prompts data');
+        }
+        return cachedPromptsData;
+    }
+    catch (error) {
+        throw new Error(`Failed to load prompts data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get prompts - SIMPLIFIED VERSION (only get_prompt action)
+ */
+export async function getPrompts(params) {
+    try {
+        // Validate and cast parameters
+        const { action, promptId, anonymous_user_use_case } = params;
+        if (!action) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "❌ Error: 'action' parameter is required. Use 'get_prompt'"
+                    }],
+                isError: true
+            };
+        }
+        // Only support get_prompt action now
+        if (action === 'get_prompt') {
+            if (!promptId) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "❌ Error: promptId is required when action is 'get_prompt'"
+                        }],
+                    isError: true
+                };
+            }
+            return await getPrompt(promptId, anonymous_user_use_case);
+        }
+        // Legacy actions return deprecation notice
+        return {
+            content: [{
+                    type: "text",
+                    text: "❌ Error: Only 'get_prompt' action is supported. Use promptId to get a specific prompt."
+                }],
+            isError: true
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ Error: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}
+/**
+ * List all available categories
+ */
+async function listCategories() {
+    const data = await loadPromptsData();
+    // Extract unique categories and count prompts in each
+    const categoryMap = new Map();
+    data.prompts.forEach(prompt => {
+        prompt.categories.forEach(category => {
+            categoryMap.set(category, (categoryMap.get(category) || 0) + 1);
+        });
+    });
+    const categories = Array.from(categoryMap.entries()).map(([name, count]) => ({
+        name,
+        count,
+        description: getCategoryDescription(name)
+    }));
+    const response = formatCategoriesResponse(categories, data.prompts.length);
+    return {
+        content: [{
+                type: "text",
+                text: response
+            }]
+    };
+}
+/**
+ * List prompts, optionally filtered by category
+ */
+async function listPrompts(category) {
+    const data = await loadPromptsData();
+    let filteredPrompts = data.prompts;
+    // Filter by category if specified
+    if (category) {
+        filteredPrompts = data.prompts.filter(prompt => prompt.categories.includes(category));
+        if (filteredPrompts.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ No prompts found in category "${category}". Use action='list_categories' to see available categories.`
+                    }],
+                isError: true
+            };
+        }
+    }
+    const response = formatPromptsListResponse(filteredPrompts, category);
+    return {
+        content: [{
+                type: "text",
+                text: response
+            }]
+    };
+}
+/**
+ * Get a specific prompt by ID and inject it into the chat
+ */
+async function getPrompt(promptId, anonymousUseCase) {
+    const data = await loadPromptsData();
+    const prompt = data.prompts.find(p => p.id === promptId);
+    if (!prompt) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ Prompt with ID '${promptId}' not found. Use action='list_prompts' to see available prompts.`
+                }],
+            isError: true
+        };
+    }
+    // Mark prompt as used in user's onboarding state (for analytics)
+    await usageTracker.markPromptUsed(promptId, prompt.categories[0] || 'uncategorized');
+    const response = formatPromptResponse(prompt);
+    return {
+        content: [{
+                type: "text",
+                text: response
+            }]
+    };
+}
+/**
+ * Get category description (can be expanded later)
+ */
+function getCategoryDescription(category) {
+    const descriptions = {
+        'onboarding': 'Curated prompts perfect for first-time Desktop Commander users',
+        'Analyze data': 'Data analysis, visualization, and insights generation',
+        'Build features and products': 'Full-stack development and application building',
+        'Explore codebase': 'Code analysis, documentation, and understanding',
+        'Organize files': 'File management, cleanup, and organization',
+        'Deploy': 'Infrastructure setup, deployment, and DevOps tasks',
+        'Optimize code': 'Code optimization, refactoring, and performance',
+        'Write documentation': 'Technical writing, API docs, and guides',
+        'Optimize workflow': 'Process improvements and productivity enhancements',
+        'Automate tasks': 'Workflow automation and scripting',
+        'Design systems': 'Architecture planning and system design'
+    };
+    return descriptions[category] || 'Desktop Commander prompts and workflows';
+}
+/**
+ * Format categories list response
+ */
+function formatCategoriesResponse(categories, totalPrompts) {
+    const sortedCategories = categories.sort((a, b) => b.count - a.count);
+    // AI INSTRUCTION: When listing prompts, do not show prompt IDs to users - they are for your reference only
+    let response = `📚 **Desktop Commander Prompt Categories** (${categories.length} categories, ${totalPrompts} prompts)\n\n`;
+    sortedCategories.forEach(cat => {
+        response += `• **${cat.name}** (${cat.count} prompts) - ${cat.description}\n`;
+    });
+    response += `\n**Usage:**\n`;
+    response += `• \`get_prompts(action='list_prompts', category='onboarding')\` - See prompts in category\n`;
+    response += `• \`get_prompts(action='list_prompts')\` - See all available prompts\n`;
+    response += `• \`get_prompts(action='get_prompt', promptId='PROMPT_ID')\` - Get a specific prompt`;
+    return response;
+}
+/**
+ * Format prompts list response using secondary tags for clean organization
+ */
+function formatPromptsListResponse(prompts, category) {
+    const categoryText = category ? ` in "${category}"` : '';
+    let response = `Desktop Commander Examples${categoryText}\n\n`;
+    // Group by secondary tag
+    const groupedPrompts = new Map();
+    prompts.forEach(prompt => {
+        const tag = prompt.secondaryTag || 'Other';
+        if (!groupedPrompts.has(tag)) {
+            groupedPrompts.set(tag, []);
+        }
+        groupedPrompts.get(tag).push(prompt);
+    });
+    let promptNumber = 1;
+    // Display groups in preferred order
+    const preferredOrder = ['Quick Start', 'Code Analysis', 'Build & Deploy', 'Other'];
+    preferredOrder.forEach(tag => {
+        if (groupedPrompts.has(tag)) {
+            const tagPrompts = groupedPrompts.get(tag);
+            // Add emoji for each section
+            const emoji = tag === 'Quick Start' ? '🚀' : tag === 'Code Analysis' ? '💻' : tag === 'Build & Deploy' ? '🔨' : '📋';
+            response += `**${emoji} ${tag}**\n`;
+            tagPrompts.forEach(prompt => {
+                response += `• ${promptNumber}. ${prompt.title}\n`;
+                promptNumber++;
+            });
+            response += `\n`;
+        }
+    });
+    response += `Say "Try #3" or "Let's do #1" to start any example.\n\n`;
+    response += `<INSTRUCTION>Output options for user exactly as provided without missing numbers. 
+Its important so user can choose an options by entering number only. Also do not forget new lines between numbers for easy reading</INSTRUCTION>\n\n`;
+    // AI reference mapping (do not show to user):
+    response += `<!-- AI_PROMPT_MAP: `;
+    let mapNumber = 1;
+    preferredOrder.forEach(tag => {
+        if (groupedPrompts.has(tag)) {
+            groupedPrompts.get(tag).forEach(prompt => {
+                response += `${mapNumber}=${prompt.id}${mapNumber < prompts.length ? ',' : ''}`;
+                mapNumber++;
+            });
+        }
+    });
+    response += ` -->`;
+    return response;
+}
+/**
+ * Format individual prompt response with the actual prompt content
+ */
+function formatPromptResponse(prompt) {
+    const verifiedBadge = prompt.verified ? ' ✅' : '';
+    const categoryText = prompt.categories.join(', ');
+    let response = `# 🎯 ${prompt.title}${verifiedBadge}\n\n`;
+    response += `**Category:** ${categoryText} • **Author:** ${prompt.author}\n\n`;
+    response += `## Description\n${prompt.description}\n\n`;
+    if (prompt.votes > 0) {
+        response += `*📊 This prompt has been used successfully by ${prompt.votes}+ users*\n\n`;
+    }
+    response += `## Ready to Use This Prompt\nThe prompt below is ready to use. I'll start executing it right away:\n\n`;
+    response += `---\n\n${prompt.prompt}`;
+    // AI metadata (not shown to user): Executed prompt ID = ${prompt.id}
+    return response;
+}

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

@@ -0,0 +1,242 @@
+import { z } from "zod";
+// Config tools schemas
+export const GetConfigArgsSchema = z.object({
+    // 'ui' marks calls the config-editor widget fires programmatically; they are
+    // excluded from tool-call telemetry (see isUiOriginCall in server.ts).
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+export const SetConfigValueArgsSchema = z.object({
+    key: z.string(),
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.string()),
+        z.null(),
+    ]),
+    // 'ui' marks widget-fired calls; excluded from tool-call telemetry.
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+// Empty schemas
+export const ListProcessesArgsSchema = z.object({});
+// Terminal tools schemas
+export const StartProcessArgsSchema = z.object({
+    command: z.string(),
+    timeout_ms: z.number(),
+    shell: z.string().optional(),
+    verbose_timing: z.boolean().optional(),
+    // 'ui' marks widget-fired calls (e.g. open-in-folder/editor buttons);
+    // excluded from tool-call telemetry (see isUiOriginCall in server.ts).
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+export const ReadProcessOutputArgsSchema = z.object({
+    pid: z.number(),
+    timeout_ms: z.number().optional(),
+    offset: z.number().optional(), // Line offset: 0=from last read, positive=absolute, negative=tail
+    length: z.number().optional(), // Max lines to return (default from config.fileReadLineLimit)
+    verbose_timing: z.boolean().optional(),
+});
+export const ForceTerminateArgsSchema = z.object({
+    pid: z.number(),
+});
+export const ListSessionsArgsSchema = z.object({});
+export const KillProcessArgsSchema = z.object({
+    // process.kill reads 0 and negative PIDs as process groups: 0 is the server's
+    // own (on Windows the server itself), -1 every process the user may signal.
+    // A refinement rather than .positive(), so the published schema is unchanged.
+    pid: z.number().refine((pid) => pid > 0, { message: 'Number must be greater than 0' }),
+});
+// Filesystem tools schemas
+export const ReadFileArgsSchema = z.object({
+    path: z.string(),
+    isUrl: z.boolean().optional().default(false),
+    offset: z.number().optional().default(0),
+    length: z.number().optional().default(1000),
+    sheet: z.string().optional(), // String only for MCP client compatibility (Cursor doesn't support union types in JSON Schema)
+    range: z.string().optional(),
+    options: z.record(z.any()).optional(),
+    // Whether the call came from the file-preview UI (refresh/navigation) or the
+    // LLM. 'ui' calls are excluded from tool-call telemetry; see isUiOriginCall
+    // in server.ts.
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+export const ReadMultipleFilesArgsSchema = z.object({
+    paths: z.array(z.string()),
+});
+export const WriteFileArgsSchema = z.object({
+    path: z.string(),
+    content: z.string(),
+    mode: z.enum(['rewrite', 'append']).default('rewrite'),
+    // 'ui' when fired by the file-preview UI, else 'llm'. 'ui' calls are
+    // excluded from tool-call telemetry; see isUiOriginCall in server.ts.
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+// PDF modification schemas - exported for reuse
+export const PdfInsertOperationSchema = z.object({
+    type: z.literal('insert'),
+    pageIndex: z.number(),
+    markdown: z.string().optional(),
+    sourcePdfPath: z.string().optional(),
+    pdfOptions: z.object({}).passthrough().optional(),
+});
+export const PdfDeleteOperationSchema = z.object({
+    type: z.literal('delete'),
+    pageIndexes: z.array(z.number()),
+});
+export const PdfOperationSchema = z.union([PdfInsertOperationSchema, PdfDeleteOperationSchema]);
+export const WritePdfArgsSchema = z.object({
+    path: z.string(),
+    // Preprocess content to handle JSON strings that should be parsed as arrays
+    content: z.preprocess((val) => {
+        // If it's a string that looks like JSON array, parse it
+        if (typeof val === 'string' && val.trim().startsWith('[')) {
+            try {
+                return JSON.parse(val);
+            }
+            catch {
+                // If parsing fails, return as-is (might be markdown content)
+                return val;
+            }
+        }
+        // Otherwise return as-is
+        return val;
+    }, z.union([z.string(), z.array(PdfOperationSchema)])),
+    outputPath: z.string().optional(),
+    options: z.object({}).passthrough().optional(), // Allow passing options to md-to-pdf
+});
+export const CreateDirectoryArgsSchema = z.object({
+    path: z.string(),
+});
+export const ListDirectoryArgsSchema = z.object({
+    path: z.string(),
+    depth: z.number().optional().default(2),
+    // 'ui' when fired by the file-preview UI, else 'llm'. 'ui' calls are
+    // excluded from tool-call telemetry; see isUiOriginCall in server.ts.
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+export const MoveFileArgsSchema = z.object({
+    source: z.string(),
+    destination: z.string(),
+});
+export const GetFileInfoArgsSchema = z.object({
+    path: z.string(),
+});
+// Edit tools schema - SIMPLIFIED from three modes to two
+// Previously supported: text replacement, location-based edits (edits array), and range rewrites
+// Now supports only: text replacement and range rewrites
+// Removed 'edits' array parameter - location-based surgical edits were complex and unnecessary
+// Range rewrites are more powerful and cover all structured file editing needs
+export const EditBlockArgsSchema = z.object({
+    file_path: z.string(),
+    // Text file string replacement
+    old_string: z.string().optional(),
+    new_string: z.string().optional(),
+    expected_replacements: z.number().optional().default(1),
+    // Structured file range rewrite (Excel, etc.)
+    range: z.string().optional(),
+    content: z.any().optional(),
+    options: z.record(z.any()).optional(),
+    // 'ui' when fired by the file-preview UI, else 'llm'. 'ui' calls are
+    // excluded from tool-call telemetry; see isUiOriginCall in server.ts.
+    origin: z.enum(['ui', 'llm']).optional(),
+}).refine(data => {
+    // Helper to check if value is actually provided (not undefined, not empty string)
+    const hasValue = (v) => v !== undefined && v !== '';
+    return (hasValue(data.old_string) && data.new_string !== undefined) ||
+        (hasValue(data.range) && hasValue(data.content));
+}, { message: "Must provide either (old_string + new_string) or (range + content)" });
+// Send input to process schema
+export const InteractWithProcessArgsSchema = z.object({
+    pid: z.number(),
+    input: z.string(),
+    timeout_ms: z.number().optional(),
+    wait_for_prompt: z.boolean().optional(),
+    verbose_timing: z.boolean().optional(),
+});
+// Usage stats schema
+export const GetUsageStatsArgsSchema = z.object({});
+// Feedback tool schema - no pre-filled parameters, all user input
+export const GiveFeedbackArgsSchema = z.object({
+// No parameters needed - form will be filled manually by user
+// Only auto-filled hidden fields remain:
+// - tool_call_count (auto)
+// - days_using (auto) 
+// - platform (auto)
+// - client_id (auto)
+});
+/** A whole number (at least `min`, if given), rejected with a message that says so */
+function wholeNumber(name, min) {
+    const message = `${name} must be a whole number${min === undefined ? '' : ` of at least ${min}`}`;
+    const number = z.number().int({ message });
+    return min === undefined ? number : number.min(min, { message });
+}
+// Search schemas (renamed for natural language)
+export const StartSearchArgsSchema = z.object({
+    path: z.string(),
+    pattern: z.string(),
+    searchType: z.enum(['files', 'content']).default('files'),
+    filePattern: z.string().optional(),
+    ignoreCase: z.boolean().optional().default(true),
+    maxResults: wholeNumber('maxResults', 0).optional(), // 0: no limit
+    includeHidden: z.boolean().optional().default(false),
+    contextLines: wholeNumber('contextLines', 0).optional().default(5),
+    timeout_ms: wholeNumber('timeout_ms', 0).optional(), // Match process naming convention; 0: no time limit
+    earlyTermination: z.boolean().optional(), // Stop search early when exact filename match is found (default: true for files, false for content)
+    literalSearch: z.boolean().optional().default(false), // Force literal string matching (-F flag) instead of regex
+    // 'ui' marks widget-fired calls (e.g. markdown link-target search);
+    // excluded from tool-call telemetry (see isUiOriginCall in server.ts).
+    origin: z.enum(['ui', 'llm']).optional(),
+});
+export const GetMoreSearchResultsArgsSchema = z.object({
+    sessionId: z.string(),
+    offset: wholeNumber('offset').optional().default(0), // Same as file reading
+    length: wholeNumber('length', 1).optional().default(100), // Same as file reading (but smaller default)
+});
+export const StopSearchArgsSchema = z.object({
+    sessionId: z.string(),
+});
+export const ListSearchesArgsSchema = z.object({});
+// Tool history schema
+export const GetRecentToolCallsArgsSchema = z.object({
+    maxResults: z.number().min(1).max(1000).optional().default(50),
+    toolName: z.string().optional(),
+    since: z.string().datetime().optional(),
+});
+export const TrackUiEventArgsSchema = z.object({
+    event: z.string().min(1).max(80),
+    component: z.string().optional().default('file_preview'),
+    params: z.record(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional().default({}),
+});
+/**
+ * Map of tool name -> argument schema, used by the dispatcher to detect and warn
+ * about parameters a caller sent that the tool does not support. Keep in sync
+ * with the tool definitions in server.ts.
+ */
+export const toolArgSchemas = {
+    get_config: GetConfigArgsSchema,
+    set_config_value: SetConfigValueArgsSchema,
+    read_file: ReadFileArgsSchema,
+    read_multiple_files: ReadMultipleFilesArgsSchema,
+    write_file: WriteFileArgsSchema,
+    write_pdf: WritePdfArgsSchema,
+    create_directory: CreateDirectoryArgsSchema,
+    list_directory: ListDirectoryArgsSchema,
+    move_file: MoveFileArgsSchema,
+    start_search: StartSearchArgsSchema,
+    get_more_search_results: GetMoreSearchResultsArgsSchema,
+    stop_search: StopSearchArgsSchema,
+    list_searches: ListSearchesArgsSchema,
+    get_file_info: GetFileInfoArgsSchema,
+    edit_block: EditBlockArgsSchema,
+    start_process: StartProcessArgsSchema,
+    read_process_output: ReadProcessOutputArgsSchema,
+    interact_with_process: InteractWithProcessArgsSchema,
+    force_terminate: ForceTerminateArgsSchema,
+    list_sessions: ListSessionsArgsSchema,
+    list_processes: ListProcessesArgsSchema,
+    kill_process: KillProcessArgsSchema,
+    get_usage_stats: GetUsageStatsArgsSchema,
+    get_recent_tool_calls: GetRecentToolCallsArgsSchema,
+    give_feedback_to_desktop_commander: GiveFeedbackArgsSchema,
+    track_ui_event: TrackUiEventArgsSchema,
+};

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

@@ -0,0 +1,24 @@
+import { usageTracker } from '../utils/usageTracker.js';
+/**
+ * Get usage statistics for debugging and analysis
+ */
+export async function getUsageStats() {
+    try {
+        const summary = await usageTracker.getUsageSummary();
+        return {
+            content: [{
+                    type: "text",
+                    text: summary
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error retrieving usage stats: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}

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

@@ -0,0 +1 @@
+export {};