starmux 0.12.0 → 0.13.0

package/dist/vendor/desktop-commander/dist/utils/terminal-timestamps.js

@@ -0,0 +1,18 @@
+import { formatWithOptions } from 'node:util';
+/** Prefix human-readable console output only; stdout also carries MCP JSON-RPC. */
+export function startTerminalTimestamps() {
+    const methods = ['log', 'info', 'warn', 'error', 'debug'];
+    const originals = methods.map((method) => [method, console[method]]);
+    for (const [method, original] of originals) {
+        console[method] = (...args) => {
+            const time = new Date().toTimeString().slice(0, 8);
+            const stream = method === 'warn' || method === 'error' ? process.stderr : process.stdout;
+            const message = formatWithOptions({ colors: stream.isTTY === true }, ...args);
+            original.call(console, message.split('\n').map((line) => line ? `[${time}] ${line}` : line).join('\n'));
+        };
+    }
+    return () => {
+        for (const [method, original] of originals)
+            console[method] = original;
+    };
+}

package/dist/vendor/desktop-commander/dist/utils/toolHistory.js

@@ -0,0 +1,309 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Format timestamp in local timezone for display
+function formatLocalTimestamp(isoTimestamp) {
+    const date = new Date(isoTimestamp);
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false
+    });
+}
+class ToolHistory {
+    constructor() {
+        this.history = [];
+        this.MAX_ENTRIES = 1000;
+        /**
+         * Cap on the output kept per entry. Entries hold the FULL ServerResult, and
+         * get_recent_tool_calls serialises them straight back out, so without a cap
+         * the history is unbounded in two compounding ways:
+         *
+         *   - a single large output (a big read_file, a wide list_directory) makes
+         *     every later history dump that includes it large too, and
+         *   - any tool whose output happens to CONTAIN a history dump — e.g.
+         *     `cat`-ing a file a previous dump was written to — nests the whole
+         *     history inside itself, and each nesting level roughly doubles the JSON
+         *     escaping. Observed 2026-07-27: 83KB of arguments on disk produced a
+         *     1.89MB in-memory dump this way.
+         *
+         * Excluding more tool names cannot fix that, because the nesting arrives
+         * through ordinary tools. Capping the stored output does, and a preview is
+         * all this history is for — it is a "what happened recently" aid, not a
+         * result cache.
+         */
+        this.MAX_STORED_OUTPUT_BYTES = 4 * 1024;
+        this.MAX_HISTORY_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+        // When the file exceeds the cap we trim it down to this target instead of
+        // all the way to zero, so a single overflow doesn't cause every subsequent
+        // flush to re-trim.
+        this.HISTORY_FILE_TRIM_TARGET_BYTES = 4 * 1024 * 1024;
+        this.writeQueue = [];
+        this.isWriting = false;
+        // Store history in same directory as config to keep everything together
+        const historyDir = path.join(os.homedir(), '.claude-server-commander');
+        // Ensure directory exists
+        if (!fs.existsSync(historyDir)) {
+            fs.mkdirSync(historyDir, { recursive: true });
+        }
+        // Use append-only JSONL format (JSON Lines)
+        this.historyFile = path.join(historyDir, 'tool-history.jsonl');
+        // Load existing history on startup
+        this.loadFromDisk();
+        // Start async write processor
+        this.startWriteProcessor();
+    }
+    /**
+     * Load history from disk (all instances share the same file)
+     */
+    loadFromDisk() {
+        try {
+            if (!fs.existsSync(this.historyFile)) {
+                return;
+            }
+            // If the file is over the cap, trim it down before reading so we
+            // load a bounded amount.
+            this.trimHistoryFileIfTooLarge();
+            const content = fs.readFileSync(this.historyFile, 'utf-8');
+            const lines = content.trim().split('\n').filter(line => line.trim());
+            // Parse each line as JSON
+            const records = [];
+            for (const line of lines) {
+                try {
+                    records.push(JSON.parse(line));
+                }
+                catch (e) {
+                    // Silently skip invalid lines
+                }
+            }
+            // Keep only last 1000 entries, and cap on the way IN as well as on the
+            // way out. Entries written before the cap existed are still on disk and
+            // are well under the whole-file trim threshold, so without this the cap
+            // does nothing for anyone upgrading with an existing history file — i.e.
+            // for everyone it was written for.
+            this.history = records
+                .slice(-this.MAX_ENTRIES)
+                .map(record => ({ ...record, output: this.capOutput(record.output) }));
+            // If file is getting too large, trim it
+            if (lines.length > this.MAX_ENTRIES * 2) {
+                this.trimHistoryFile();
+            }
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+    /**
+     * Trim the on-disk history file to stay under the size cap by dropping the
+     * oldest entries (lines) until the kept tail fits within the trim target.
+     * Returns true only when the file was actually rewritten with a smaller
+     * tail, so callers can fall through to their normal path on failure or
+     * no-op rather than mutating in-memory state.
+     *
+     * Always keeps at least the most recent entry, even if a single record
+     * exceeds the trim target — there is no useful state below that.
+     */
+    trimHistoryFileIfTooLarge() {
+        let stats;
+        try {
+            if (!fs.existsSync(this.historyFile)) {
+                return false;
+            }
+            stats = fs.statSync(this.historyFile);
+            if (stats.size <= this.MAX_HISTORY_FILE_SIZE_BYTES) {
+                return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+        try {
+            const content = fs.readFileSync(this.historyFile, 'utf-8');
+            const lines = content.split('\n').filter(line => line.length > 0);
+            if (lines.length === 0) {
+                return false;
+            }
+            // Walk lines from newest to oldest, accumulating bytes (line + '\n'),
+            // and keep as many as fit within the trim target. Always keep at
+            // least the last line.
+            const kept = [];
+            let bytes = 0;
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const lineBytes = Buffer.byteLength(lines[i], 'utf-8') + 1; // +1 for '\n'
+                if (kept.length > 0 && bytes + lineBytes > this.HISTORY_FILE_TRIM_TARGET_BYTES) {
+                    break;
+                }
+                kept.push(lines[i]);
+                bytes += lineBytes;
+            }
+            kept.reverse();
+            fs.writeFileSync(this.historyFile, kept.join('\n') + '\n', 'utf-8');
+            return true;
+        }
+        catch (error) {
+            // Trim failed; do not claim the file was changed.
+            return false;
+        }
+    }
+    /**
+     * Trim history file to prevent it from growing indefinitely
+     */
+    trimHistoryFile() {
+        try {
+            // Keep last 1000 entries in memory
+            const keepEntries = this.history.slice(-this.MAX_ENTRIES);
+            // Write them back
+            const lines = keepEntries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+            fs.writeFileSync(this.historyFile, lines, 'utf-8');
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+    /**
+     * Async write processor - batches writes to avoid blocking
+     */
+    startWriteProcessor() {
+        this.writeInterval = setInterval(() => {
+            if (this.writeQueue.length > 0 && !this.isWriting) {
+                this.flushToDisk();
+            }
+        }, 1000); // Flush every second
+        // Prevent interval from keeping process alive during shutdown/tests
+        this.writeInterval.unref();
+    }
+    /**
+     * Flush queued writes to disk
+     */
+    async flushToDisk() {
+        if (this.isWriting || this.writeQueue.length === 0)
+            return;
+        this.isWriting = true;
+        const toWrite = [...this.writeQueue];
+        this.writeQueue = [];
+        try {
+            // If the on-disk file has grown past the cap, trim it down to the
+            // target size (keeping the most recent entries) before appending.
+            // The in-memory cache is unaffected — it is already bounded by
+            // MAX_ENTRIES via addCall.
+            this.trimHistoryFileIfTooLarge();
+            // Append to file (atomic append operation)
+            const lines = toWrite.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+            fs.appendFileSync(this.historyFile, lines, 'utf-8');
+        }
+        catch (error) {
+            // Put back in queue on failure
+            this.writeQueue.unshift(...toWrite);
+        }
+        finally {
+            this.isWriting = false;
+        }
+    }
+    /**
+     * Add a tool call to history
+     */
+    /**
+     * Replace an oversized output with a short marker. Keeps the record shape
+     * ({ content: [...] }) so readers and formatters need no special case.
+     */
+    capOutput(output) {
+        let size;
+        try {
+            size = JSON.stringify(output)?.length ?? 0;
+        }
+        catch {
+            // Circular or otherwise unserialisable — it could never be returned to a
+            // client anyway, so don't retain it.
+            size = Number.POSITIVE_INFINITY;
+        }
+        if (size <= this.MAX_STORED_OUTPUT_BYTES)
+            return output;
+        const shown = Number.isFinite(size) ? `${size} bytes` : 'unserialisable';
+        return {
+            ...output,
+            content: [
+                {
+                    type: 'text',
+                    text: `[output omitted from history: ${shown}, over the ${this.MAX_STORED_OUTPUT_BYTES}-byte cap]`,
+                },
+            ],
+        };
+    }
+    addCall(toolName, args, output, duration) {
+        const record = {
+            timestamp: new Date().toISOString(),
+            toolName,
+            arguments: args,
+            output: this.capOutput(output),
+            duration
+        };
+        this.history.push(record);
+        // Keep only last 1000 in memory
+        if (this.history.length > this.MAX_ENTRIES) {
+            this.history.shift();
+        }
+        // Queue for async write
+        this.writeQueue.push(record);
+    }
+    /**
+     * Get recent tool calls with filters
+     */
+    getRecentCalls(options) {
+        let results = [...this.history];
+        // Filter by tool name
+        if (options.toolName) {
+            results = results.filter(r => r.toolName === options.toolName);
+        }
+        // Filter by timestamp
+        if (options.since) {
+            const sinceDate = new Date(options.since);
+            results = results.filter(r => new Date(r.timestamp) >= sinceDate);
+        }
+        // Limit results (default 50, max 1000)
+        const limit = Math.min(options.maxResults || 50, 1000);
+        return results.slice(-limit);
+    }
+    /**
+     * Get recent calls formatted with local timezone
+     */
+    getRecentCallsFormatted(options) {
+        const calls = this.getRecentCalls(options);
+        // Format timestamps to local timezone
+        return calls.map(call => ({
+            ...call,
+            timestamp: formatLocalTimestamp(call.timestamp)
+        }));
+    }
+    /**
+     * Get current stats
+     */
+    getStats() {
+        return {
+            totalEntries: this.history.length,
+            oldestEntry: this.history[0]?.timestamp,
+            newestEntry: this.history[this.history.length - 1]?.timestamp,
+            historyFile: this.historyFile,
+            queuedWrites: this.writeQueue.length
+        };
+    }
+    /**
+     * Cleanup method - clears interval and flushes pending writes
+     * Call this during shutdown or in tests
+     */
+    async cleanup() {
+        // Clear the interval
+        if (this.writeInterval) {
+            clearInterval(this.writeInterval);
+            this.writeInterval = undefined;
+        }
+        // Flush any remaining writes
+        if (this.writeQueue.length > 0) {
+            await this.flushToDisk();
+        }
+    }
+}
+export const toolHistory = new ToolHistory();

package/dist/vendor/desktop-commander/dist/utils/trackTools.js

@@ -0,0 +1,55 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { TOOL_CALL_FILE, TOOL_CALL_FILE_MAX_SIZE } from '../config.js';
+import { renameWithRetry } from './rename.js';
+// Ensure the directory for the log file exists
+const logDir = path.dirname(TOOL_CALL_FILE);
+await fs.promises.mkdir(logDir, { recursive: true });
+/**
+ * Track tool calls and save them to a log file
+ * @param toolName Name of the tool being called
+ * @param args Arguments passed to the tool (optional)
+ */
+export async function trackToolCall(toolName, args) {
+    try {
+        // Get current timestamp
+        const timestamp = new Date().toISOString();
+        // Format the log entry
+        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${args ? `\t| Arguments: ${JSON.stringify(args)}` : ''}\n`;
+        // Check if file exists and get its size
+        let fileSize = 0;
+        try {
+            const stats = await fs.promises.stat(TOOL_CALL_FILE);
+            fileSize = stats.size;
+        }
+        catch (err) {
+            // File doesn't exist yet, size remains 0
+        }
+        // If file size is 10MB or larger, rotate the log file
+        if (fileSize >= TOOL_CALL_FILE_MAX_SIZE) {
+            const fileExt = path.extname(TOOL_CALL_FILE);
+            const fileBase = path.basename(TOOL_CALL_FILE, fileExt);
+            const dirName = path.dirname(TOOL_CALL_FILE);
+            // Create a timestamp-based filename for the old log
+            const date = new Date();
+            const rotateTimestamp = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}_${String(date.getHours()).padStart(2, '0')}-${String(date.getMinutes()).padStart(2, '0')}-${String(date.getSeconds()).padStart(2, '0')}`;
+            const newFileName = path.join(dirName, `${fileBase}_${rotateTimestamp}${fileExt}`);
+            // Rename the current file
+            await renameWithRetry(TOOL_CALL_FILE, newFileName);
+        }
+        // Append to log file (if file was renamed, this will create a new file)
+        await fs.promises.appendFile(TOOL_CALL_FILE, logEntry, 'utf8');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const { capture } = await import('./capture.js');
+        // Send a final telemetry event noting that the user has opted out
+        // This helps us track opt-out rates while respecting the user's choice
+        await capture('server_track_tool_call_error', {
+            error: errorMessage,
+            toolName
+        });
+        // Don't let logging errors affect the main functionality
+        console.error(`Error logging tool call: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/vendor/desktop-commander/dist/utils/unsupportedParams.js

@@ -0,0 +1,66 @@
+/**
+ * Utility for detecting parameters a caller sent that a tool's Zod schema does
+ * not accept.
+ *
+ * Zod's default `z.object()` silently strips unknown keys, so a model that
+ * invents a parameter (e.g. `view_range`) gets a normal-looking response with no
+ * signal that its input was ignored. These helpers let the dispatcher surface a
+ * corrective warning instead.
+ *
+ * Detection is top-level only. That is sufficient here because none of the tool
+ * arg schemas use a top-level `.passthrough()`/catchall — free-form fields
+ * (`options`, `params`, `pdfOptions`) are named keys whose contents are
+ * intentionally unvalidated.
+ */
+/**
+ * Resolve a Zod schema down to the field map of its underlying object schema,
+ * unwrapping wrappers (effects/optional/default/nullable/branded) defensively.
+ * Returns null when the schema is not (and does not wrap) a plain object schema,
+ * in which case we cannot determine the supported parameters and must not warn.
+ */
+function getObjectShape(schema) {
+    let current = schema;
+    for (let i = 0; current && current._def && i < 10; i++) {
+        const typeName = current._def.typeName;
+        if (typeName === 'ZodObject') {
+            const shape = typeof current.shape === 'function' ? current.shape() : current.shape;
+            return shape ?? null;
+        }
+        if (typeName === 'ZodEffects')
+            current = current._def.schema;
+        else if (typeName === 'ZodOptional' || typeName === 'ZodNullable' || typeName === 'ZodDefault') {
+            current = typeof current._def.innerType === 'function' ? current._def.innerType() : current._def.innerType;
+        }
+        else if (typeName === 'ZodBranded')
+            current = current._def.type;
+        else
+            return null;
+    }
+    return null;
+}
+/** List the parameter names a tool schema accepts (empty array if it takes none). */
+export function getSupportedParams(schema) {
+    const shape = getObjectShape(schema);
+    return shape ? Object.keys(shape) : [];
+}
+/**
+ * Return the names of top-level keys in `args` that the schema does not accept.
+ * Returns [] when args is not a plain object or the schema's params can't be
+ * determined (so we never warn on something we can't reason about).
+ */
+export function detectUnsupportedParams(args, schema) {
+    if (!args || typeof args !== 'object' || Array.isArray(args))
+        return [];
+    const shape = getObjectShape(schema);
+    if (shape === null)
+        return [];
+    const supported = new Set(Object.keys(shape));
+    return Object.keys(args).filter((k) => !supported.has(k));
+}
+/** Build the corrective warning string shown to the model. */
+export function buildUnsupportedParamsWarning(toolName, unsupported, supported) {
+    const ignored = unsupported.join(', ');
+    const supportedList = supported.length > 0 ? supported.join(', ') : '(none)';
+    return `You sent parameters not supported by this tool, which were ignored: ${ignored}. `
+        + `Supported parameters for ${toolName}: ${supportedList}.`;
+}

package/dist/vendor/desktop-commander/dist/utils/usageTracker.js

@@ -0,0 +1,225 @@
+import { configManager } from '../config-manager.js';
+const TURN_OFF_FEEDBACK_INSTRUCTION = "*This request disappears after you give feedback or set feedbackGiven=true*";
+// Tool categories mapping
+const TOOL_CATEGORIES = {
+    filesystem: ['read_file', 'read_multiple_files', 'write_file', 'create_directory', 'list_directory', 'move_file', 'get_file_info'],
+    terminal: ['execute_command', 'read_output', 'force_terminate', 'list_sessions'],
+    edit: ['edit_block'],
+    search: ['start_search', 'get_more_search_results', 'stop_search', 'list_searches'],
+    config: ['get_config', 'set_config_value'],
+    process: ['list_processes', 'kill_process']
+};
+// Session timeout (30 minutes of inactivity = new session)
+const SESSION_TIMEOUT = 30 * 60 * 1000;
+class UsageTracker {
+    constructor() {
+        this.currentSession = null;
+    }
+    /**
+     * Get default usage stats
+     */
+    getDefaultStats() {
+        return {
+            filesystemOperations: 0,
+            terminalOperations: 0,
+            editOperations: 0,
+            searchOperations: 0,
+            configOperations: 0,
+            processOperations: 0,
+            totalToolCalls: 0,
+            successfulCalls: 0,
+            failedCalls: 0,
+            toolCounts: {},
+            firstUsed: Date.now(),
+            lastUsed: Date.now(),
+            totalSessions: 0, // Start at 0, incremented on first command
+            lastFeedbackPrompt: 0
+        };
+    }
+    /**
+     * Get current usage stats from config
+     */
+    async getStats() {
+        // Migrate old nested feedbackGiven to top-level if needed
+        const stats = await configManager.getValue('usageStats');
+        return stats || this.getDefaultStats();
+    }
+    /**
+     * Determine which category a tool belongs to
+     */
+    getToolCategory(toolName) {
+        for (const [category, tools] of Object.entries(TOOL_CATEGORIES)) {
+            if (tools.includes(toolName)) {
+                switch (category) {
+                    case 'filesystem': return 'filesystemOperations';
+                    case 'terminal': return 'terminalOperations';
+                    case 'edit': return 'editOperations';
+                    case 'search': return 'searchOperations';
+                    case 'config': return 'configOperations';
+                    case 'process': return 'processOperations';
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if we're in a new session
+     */
+    isNewSession() {
+        if (!this.currentSession)
+            return true;
+        const now = Date.now();
+        const timeSinceLastActivity = now - this.currentSession.lastActivity;
+        return timeSinceLastActivity > SESSION_TIMEOUT;
+    }
+    /**
+     * Update session tracking
+     */
+    updateSession() {
+        const now = Date.now();
+        if (this.isNewSession()) {
+            this.currentSession = {
+                sessionStart: now,
+                lastActivity: now,
+                commandsInSession: 1,
+                promptedThisSession: false // Reset for new session
+            };
+        }
+        else {
+            this.currentSession.lastActivity = now;
+            this.currentSession.commandsInSession++;
+        }
+    }
+    /**
+     * Track a successful tool call
+     */
+    async trackSuccess(toolName) {
+        this.updateSession();
+        const now = Date.now();
+        const category = this.getToolCategory(toolName);
+        const newSession = this.currentSession?.commandsInSession === 1;
+        return await configManager.updateValueNonBlocking('usageStats', (stored) => {
+            const defaults = { ...this.getDefaultStats(), firstUsed: now, lastUsed: now };
+            const stats = {
+                ...defaults,
+                ...(stored || {}),
+                toolCounts: { ...(stored?.toolCounts || {}) },
+            };
+            stats.totalToolCalls++;
+            stats.successfulCalls++;
+            stats.lastUsed = Math.max(stats.lastUsed || 0, now);
+            stats.toolCounts[toolName] = (stats.toolCounts[toolName] || 0) + 1;
+            if (category)
+                stats[category]++;
+            if (newSession)
+                stats.totalSessions++;
+            return stats;
+        });
+    }
+    /**
+     * Track a failed tool call
+     */
+    async trackFailure(toolName) {
+        this.updateSession();
+        const now = Date.now();
+        const category = this.getToolCategory(toolName);
+        const newSession = this.currentSession?.commandsInSession === 1;
+        return await configManager.updateValueNonBlocking('usageStats', (stored) => {
+            const defaults = { ...this.getDefaultStats(), firstUsed: now, lastUsed: now };
+            const stats = {
+                ...defaults,
+                ...(stored || {}),
+                toolCounts: { ...(stored?.toolCounts || {}) },
+            };
+            stats.totalToolCalls++;
+            stats.failedCalls++;
+            stats.lastUsed = Math.max(stats.lastUsed || 0, now);
+            stats.toolCounts[toolName] = (stats.toolCounts[toolName] || 0) + 1;
+            if (category)
+                stats[category]++;
+            if (newSession)
+                stats.totalSessions++;
+            return stats;
+        });
+    }
+    /**
+     * Check if user should be prompted for feedback based on usage patterns
+     */
+    async shouldPromptForFeedback() { return false; }
+    /**
+     * Get a random feedback prompt message with strong CTAs and clear actions
+     * NEW 2025 Survey - 3 variants for fresh analytics tracking
+     */
+    async getFeedbackPromptMessage() { return { variant: 'disabled', message: '' }; }
+    /**
+     * Check if user should be prompted for error feedback
+     */
+    async shouldPromptForErrorFeedback() { return false; }
+    /**
+     * Mark that user was prompted for feedback
+     */
+    async markFeedbackPrompted() {
+        const now = Date.now();
+        const today = new Date(now).toISOString().split('T')[0];
+        if (this.currentSession) {
+            this.currentSession.promptedThisSession = true;
+        }
+        await configManager.updateValueNonBlocking('usageStats', (stored) => {
+            const defaults = { ...this.getDefaultStats(), firstUsed: now, lastUsed: now };
+            const stats = {
+                ...defaults,
+                ...(stored || {}),
+                toolCounts: { ...(stored?.toolCounts || {}) },
+            };
+            stats.lastFeedbackPrompt = Math.max(stats.lastFeedbackPrompt || 0, now);
+            stats.lastFeedbackPromptDate = today;
+            stats.feedbackAttempts = (stats.feedbackAttempts || 0) + 1;
+            return stats;
+        });
+    }
+    /**
+     * Mark that user has given feedback
+     */
+    async markFeedbackGiven() {
+        // Set top-level config flag
+        await configManager.setValue('feedbackGiven', true);
+    }
+    /**
+     * Get usage summary for debugging/admin purposes
+     */
+    async getUsageSummary() {
+        const stats = await this.getStats();
+        const now = Date.now();
+        const daysSinceFirst = Math.round((now - stats.firstUsed) / (1000 * 60 * 60 * 24));
+        const uniqueTools = Object.keys(stats.toolCounts).length;
+        const successRate = stats.totalToolCalls > 0 ?
+            Math.round((stats.successfulCalls / stats.totalToolCalls) * 100) : 0;
+        const topTools = Object.entries(stats.toolCounts)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 5)
+            .map(([tool, count]) => `${tool}: ${count}`)
+            .join(', ');
+        return `📊 **Usage Summary**
+• Total calls: ${stats.totalToolCalls} (${stats.successfulCalls} successful, ${stats.failedCalls} failed)
+• Success rate: ${successRate}%
+• Days using: ${daysSinceFirst}
+• Sessions: ${stats.totalSessions}
+• Unique tools: ${uniqueTools}
+• Most used: ${topTools || 'None'}
+• Feedback given: ${(await configManager.getValue('feedbackGiven')) ? 'Yes' : 'No'}
+
+**By Category:**
+• Filesystem: ${stats.filesystemOperations}
+• Terminal: ${stats.terminalOperations}
+• Editing: ${stats.editOperations}
+• Search: ${stats.searchOperations}
+• Config: ${stats.configOperations}
+• Process: ${stats.processOperations}`;
+    }
+    // Retained for the dormant prompt implementation, which is no longer exposed as an MCP tool.
+    async markPromptUsed(promptId, category) {
+        console.log(`[PROMPT USAGE] User retrieved prompt: ${promptId} (category: ${category})`);
+    }
+}
+// Export singleton instance
+export const usageTracker = new UsageTracker();

package/dist/vendor/desktop-commander/dist/utils/welcome-onboarding.js

@@ -0,0 +1,2 @@
+export async function skipWelcomePageOnboarding() {}
+export async function handleWelcomePageOnboarding() {}