starmux 0.12.0 → 0.13.0

package/dist/vendor/desktop-commander/dist/ui/resources.js

@@ -0,0 +1,93 @@
+/**
+ * Server-side UI resource loading helpers for MCP responses. It resolves packaged UI assets, reads files safely, and exposes structured resource payloads to clients.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { buildUiContentSecurityPolicy, CONFIG_EDITOR_RESOURCE_URI, FILE_PREVIEW_RESOURCE_URI, UI_FONT_ORIGINS, UI_RESOURCE_CSP } from './contracts.js';
+const UI_RESOURCE_MIME_TYPE = 'text/html;profile=mcp-app';
+export const FILE_PREVIEW_RESOURCE = {
+    uri: FILE_PREVIEW_RESOURCE_URI,
+    name: 'Desktop Commander File Preview',
+    description: 'Markdown-first preview surface for read_file structured content.',
+    mimeType: UI_RESOURCE_MIME_TYPE
+};
+export const CONFIG_EDITOR_RESOURCE = {
+    uri: CONFIG_EDITOR_RESOURCE_URI,
+    name: 'Desktop Commander Config Editor',
+    description: 'Interactive editor for Desktop Commander configuration values.',
+    mimeType: UI_RESOURCE_MIME_TYPE
+};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DIST_FILE_PREVIEW_DIR = path.resolve(__dirname, 'file-preview');
+const DIST_CONFIG_EDITOR_DIR = path.resolve(__dirname, 'config-editor');
+function replaceOrThrow(source, pattern, replacement, context) {
+    if (!pattern.test(source)) {
+        throw new Error(`UI template is missing expected ${context}`);
+    }
+    return source.replace(pattern, () => replacement);
+}
+function inlineTemplateAssets(templateHtml, css, runtime) {
+    const safeCss = css.replace(/<\/style/gi, '<\\/style');
+    const safeRuntime = runtime.replace(/<\/script/gi, '<\\/script');
+    // First in <head>, so it covers everything the page loads, previews included
+    const policyAdded = replaceOrThrow(templateHtml, /<head>/i, `<head><meta http-equiv="Content-Security-Policy" content="${buildUiContentSecurityPolicy(UI_RESOURCE_CSP, UI_FONT_ORIGINS)}">`, '<head> tag');
+    const cssInlined = replaceOrThrow(policyAdded, /<link[^>]*href=["']\.\/styles\.css["'][^>]*>/i, `<style>${safeCss}</style>`, 'styles.css link tag');
+    const runtimeInlined = replaceOrThrow(cssInlined, /<script[^>]*src=["']\.\/[^"']+["'][^>]*>\s*<\/script>/i, `<script>${safeRuntime}</script>`, 'runtime script tag');
+    if (/href=["']\.\/styles\.css["']/i.test(runtimeInlined) ||
+        /<script[^>]*src=["']\.\/[^"']+["']/i.test(runtimeInlined)) {
+        throw new Error('UI template still contains external static asset references after inlining');
+    }
+    return runtimeInlined;
+}
+async function readInlinedResourceHtml(distDir, runtimeFileName) {
+    const [templateHtml, css, runtime] = await Promise.all([
+        fs.readFile(path.join(distDir, 'index.html'), 'utf8'),
+        fs.readFile(path.join(distDir, 'styles.css'), 'utf8'),
+        fs.readFile(path.join(distDir, runtimeFileName), 'utf8')
+    ]);
+    return inlineTemplateAssets(templateHtml, css, runtime);
+}
+export async function getFilePreviewResourceText() {
+    return readInlinedResourceHtml(DIST_FILE_PREVIEW_DIR, 'preview-runtime.js');
+}
+export async function getConfigEditorResourceText() {
+    return readInlinedResourceHtml(DIST_CONFIG_EDITOR_DIR, 'config-editor-runtime.js');
+}
+function getUiResourceMeta() {
+    return { ui: { csp: UI_RESOURCE_CSP } };
+}
+const READABLE_UI_RESOURCES = {
+    [FILE_PREVIEW_RESOURCE_URI]: {
+        mimeType: FILE_PREVIEW_RESOURCE.mimeType,
+        getText: getFilePreviewResourceText,
+        getMeta: getUiResourceMeta
+    },
+    [CONFIG_EDITOR_RESOURCE_URI]: {
+        mimeType: CONFIG_EDITOR_RESOURCE.mimeType,
+        getText: getConfigEditorResourceText,
+        getMeta: getUiResourceMeta
+    }
+};
+export function listUiResources() {
+    return [FILE_PREVIEW_RESOURCE, CONFIG_EDITOR_RESOURCE];
+}
+export async function readUiResource(uri) {
+    const resource = READABLE_UI_RESOURCES[uri];
+    if (!resource) {
+        return null;
+    }
+    const resourceText = await resource.getText();
+    const resourceMeta = resource.getMeta?.();
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: resource.mimeType,
+                text: resourceText,
+                ...(resourceMeta ? { _meta: resourceMeta } : {})
+            }
+        ]
+    };
+}

package/dist/vendor/desktop-commander/dist/utils/ab-test.js

@@ -0,0 +1,122 @@
+import { configManager } from '../config-manager.js';
+import { featureFlagManager } from './feature-flags.js';
+// Cache for variant assignments (loaded once per session). This map and the
+// experiments map are keyed by experiment names from remote JSON, so they have
+// no prototype: a name like __proto__ or constructor is an entry like any other.
+const variantCache = Object.create(null);
+/**
+ * Get experiments config from feature flags.
+ * The config is remote JSON, so it is validated here once: every experiment
+ * comes back as { variants: WeightedVariant[] }, keeping only variants with a
+ * string name (an invalid or negative weight counts as 0). One malformed entry
+ * must not break the lookups for all the others.
+ */
+function getExperiments() {
+    const raw = featureFlagManager.get('experiments', {});
+    const experiments = Object.create(null);
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return experiments;
+    for (const [name, experiment] of Object.entries(raw)) {
+        const rawVariants = Array.isArray(experiment?.variants) ? experiment.variants : [];
+        const variants = [];
+        for (const v of rawVariants) {
+            if (typeof v?.name !== 'string' || !v.name)
+                continue;
+            const weight = typeof v.weight === 'number' && Number.isFinite(v.weight) && v.weight > 0 ? v.weight : 0;
+            variants.push({ name: v.name, weight });
+        }
+        experiments[name] = { variants };
+    }
+    return experiments;
+}
+/**
+ * Get user's variant for an experiment (cached, deterministic)
+ * Supports weighted variants for unequal splits
+ */
+async function getVariant(experimentName) {
+    const experiments = getExperiments();
+    const experiment = experiments[experimentName];
+    if (!experiment?.variants.length)
+        return null;
+    // Check cache
+    if (variantCache[experimentName]) {
+        return variantCache[experimentName];
+    }
+    // Check persisted assignment
+    const configKey = `abTest_${experimentName}`;
+    const existing = await configManager.getValue(configKey);
+    // Validate existing assignment is still a valid variant
+    const variantNames = experiment.variants.map(v => v.name);
+    if (existing && variantNames.includes(existing)) {
+        variantCache[experimentName] = existing;
+        return existing;
+    }
+    // New assignment based on clientId with weighted selection
+    const clientId = await configManager.getOrCreateClientId();
+    const hash = hashCode(clientId + experimentName);
+    // Calculate total weight and select variant
+    const totalWeight = experiment.variants.reduce((sum, v) => sum + v.weight, 0);
+    let variant;
+    if (totalWeight > 0) {
+        const roll = hash % totalWeight;
+        let cumulative = 0;
+        variant = experiment.variants[0].name; // fallback
+        for (const v of experiment.variants) {
+            cumulative += v.weight;
+            if (roll < cumulative) {
+                variant = v.name;
+                break;
+            }
+        }
+    }
+    else {
+        // Fallback to equal split when weights are misconfigured (all zero)
+        const index = hash % experiment.variants.length;
+        variant = experiment.variants[index].name;
+    }
+    await configManager.setValue(configKey, variant);
+    variantCache[experimentName] = variant;
+    return variant;
+}
+/**
+ * Get the exact assigned variant for a named experiment.
+ */
+export async function getABTestVariant(experimentName) {
+    return getVariant(experimentName);
+}
+/**
+ * Check if a feature (variant name) is enabled for current user
+ */
+export async function hasFeature(featureName) {
+    const experiments = getExperiments();
+    for (const [expName, experiment] of Object.entries(experiments)) {
+        if (experiment.variants.some(v => v.name === featureName)) {
+            const variant = await getVariant(expName);
+            return variant === featureName;
+        }
+    }
+    return false;
+}
+/**
+ * Get all A/B test assignments for analytics (reads from config)
+ */
+export async function getABTestAssignments() {
+    const experiments = getExperiments();
+    const assignments = {};
+    for (const expName of Object.keys(experiments)) {
+        const configKey = `abTest_${expName}`;
+        const variant = await configManager.getValue(configKey);
+        if (variant) {
+            assignments[`ab_${expName}`] = variant;
+        }
+    }
+    return assignments;
+}
+function hashCode(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) - hash) + str.charCodeAt(i);
+        hash |= 0;
+    }
+    return Math.abs(hash);
+}

package/dist/vendor/desktop-commander/dist/utils/atomic-write.js

@@ -0,0 +1,80 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { renameWithRetry } from './rename.js';
+import { logger } from './logger.js';
+/**
+ * Single place for crash-safe file writes. Data goes to a temp file next to
+ * the target and a rename swaps it in, so readers only ever see the previous
+ * or the new complete file — never a truncated one.
+ *
+ * - The temp file's data is flushed to disk before the rename: otherwise the
+ *   new name can reach the disk before the data, and a crash or power loss
+ *   leaves the file empty or zero-filled (#697, #692). On macOS/Linux the
+ *   folder is flushed after the rename, so the rename itself survives.
+ * - Writes to the same file from this process run one after another, so the
+ *   per-process temp name (`<file>.<pid>.tmp`) can't collide; the pid keeps
+ *   separate processes off each other's temp file.
+ * - The swap goes through renameWithRetry, which rides out Windows' brief
+ *   locks on files other processes have open.
+ */
+const pendingWrites = new Map();
+async function writeThroughTempFile(filePath, data, options) {
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    try {
+        const handle = await fs.open(tempPath, 'w', options.mode);
+        try {
+            await handle.writeFile(data, { encoding: options.encoding ?? 'utf8' });
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await options.beforeCommit?.();
+        await renameWithRetry(tempPath, filePath);
+    }
+    finally {
+        // After a successful rename the temp file is gone (ENOENT); after a failed
+        // write, removing it is best effort and the write's own error is what's reported
+        await fs.unlink(tempPath).catch(() => { });
+    }
+    await syncFolder(path.dirname(filePath));
+}
+/**
+ * macOS/Linux: flushes the folder, so a rename in it reaches the disk. Windows
+ * can't open a folder for flushing, and NTFS journals the rename itself. The
+ * new content is already committed when this runs, so a failure is logged,
+ * not reported as a failed write.
+ */
+async function syncFolder(folder) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        const handle = await fs.open(folder, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        logger.error(`Could not flush ${folder} after replacing a file in it: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Atomically replaces `filePath` with `data`. Resolves once the new content is
+ * committed; rejects (leaving the previous file intact) if it can't be.
+ */
+export function writeFileAtomic(filePath, data, options = {}) {
+    const key = path.resolve(filePath);
+    const previous = pendingWrites.get(key) ?? Promise.resolve();
+    // The previous write's failure was already reported to its own caller; this one runs regardless
+    const write = previous.catch(() => { }).then(() => writeThroughTempFile(key, data, options));
+    pendingWrites.set(key, write);
+    // Bookkeeping only: the caller gets `write` itself, with its rejection
+    write.finally(() => {
+        if (pendingWrites.get(key) === write)
+            pendingWrites.delete(key);
+    }).catch(() => { });
+    return write;
+}

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

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+const uiOriginCallContext = new AsyncLocalStorage();
+export function runInUiOriginCallContext(fn) {
+  return uiOriginCallContext.run(true, fn);
+}
+export function isInsideUiOriginCall() {
+  return uiOriginCallContext.getStore() === true;
+}
+
+const toolCallPaths = new AsyncLocalStorage();
+export function runWithToolCallPaths(fn) {
+  return toolCallPaths.run(new Set(), fn);
+}
+export function addToolCallPaths() {}
+
+export function isTelemetryDisabledByEnv() {
+  return true;
+}
+
+export function sanitizeError(error) {
+  if (error instanceof Error) {
+    return {
+      message: `${error.name}: ${error.message}`,
+      code: 'code' in error ? error.code : undefined,
+    };
+  }
+  return {
+    message: typeof error === 'string' ? error : 'Unknown error',
+    code: undefined,
+  };
+}
+
+export const captureBase = async () => {};
+export const buildEventProperties = async () => ({});
+export const capture = async () => {};
+export const captureTransport = async () => {};
+export const capture_call_tool = async () => {};
+export const capture_ui_event = async () => {};
+export const captureRemote = async () => {};

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

@@ -0,0 +1,9 @@
+export async function shouldPromptForDockerInfo() {
+  return false;
+}
+export function getDockerInfoMessage() {
+  return '';
+}
+export async function processDockerPrompt(result) {
+  return result;
+}

package/dist/vendor/desktop-commander/dist/utils/exit-process.js

@@ -0,0 +1,31 @@
+/**
+ * Single place for ending the process on purpose. Use this instead of process.exit().
+ *
+ * process.exit() tears Node down at once, without waiting for work V8 still
+ * runs on background threads. On Windows that aborts the process with
+ * "Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\win\async.c"
+ * and exit code 0xC0000409 instead of the one asked for, whenever V8 is still
+ * compiling WebAssembly, e.g. the HTTP parser fetch() compiles right after a
+ * download (nodejs/node#56645). An exit that happens because nothing is left
+ * to do waits for that work.
+ *
+ * So exitProcess() sets the exit code and lets Node exit on its own. If
+ * something keeps the process alive (stdin, a socket, a timer), process.exit()
+ * ends it after EXIT_GRACE_MS, by which time that background work is done.
+ * Either way 'exit' listeners run and pending stdout/stderr writes get the
+ * grace period to flush.
+ *
+ * Unlike process.exit() this returns, and the process keeps running for up to
+ * EXIT_GRACE_MS: callers return right after calling it. Only the first call
+ * counts; later calls (a second Ctrl+C, a timeout firing) keep its exit code.
+ */
+/** Longest the process keeps running after exitProcess() */
+export const EXIT_GRACE_MS = 1000;
+let exitCode;
+export function exitProcess(code) {
+    if (exitCode !== undefined)
+        return;
+    exitCode = code;
+    process.exitCode = code;
+    setTimeout(() => process.exit(code), EXIT_GRACE_MS).unref();
+}

package/dist/vendor/desktop-commander/dist/utils/feature-flags.js

@@ -0,0 +1,18 @@
+class FeatureFlagManager {
+  async initialize() {}
+  get(_flagName, defaultValue = false) {
+    return defaultValue;
+  }
+  getAll() {
+    return {};
+  }
+  async refresh() {
+    return false;
+  }
+  wasLoadedFromCache() {
+    return true;
+  }
+  async waitForFreshFlags() {}
+  destroy() {}
+}
+export const featureFlagManager = new FeatureFlagManager();

package/dist/vendor/desktop-commander/dist/utils/files/base.js

@@ -0,0 +1,5 @@
+/**
+ * Base interfaces and types for file handling system
+ * All file handlers implement the FileHandler interface
+ */
+export {};

package/dist/vendor/desktop-commander/dist/utils/files/binary.js

@@ -0,0 +1,65 @@
+/**
+ * Binary file handler
+ * Handles binary files that aren't supported by other handlers (Excel, Image)
+ * Uses isBinaryFile for content-based detection
+ * Returns instructions to use start_process with appropriate tools
+ */
+import fs from "fs/promises";
+import path from "path";
+import { isBinaryFile } from 'isbinaryfile';
+/**
+ * Binary file handler implementation
+ * Uses content-based detection via isBinaryFile
+ */
+export class BinaryFileHandler {
+    async canHandle(filePath) {
+        // Content-based binary detection using isBinaryFile
+        try {
+            return await isBinaryFile(filePath);
+        }
+        catch (error) {
+            // If we can't check (file doesn't exist, etc.), don't handle it
+            return false;
+        }
+    }
+    async read(filePath, options) {
+        const instructions = this.getBinaryInstructions(filePath);
+        return {
+            content: instructions,
+            mimeType: 'text/plain',
+            metadata: {
+                isBinary: true
+            }
+        };
+    }
+    async write(path, content) {
+        throw new Error('Cannot write binary files directly. Use start_process with appropriate tools (Python, Node.js libraries, command-line utilities).');
+    }
+    async getInfo(path) {
+        const stats = await fs.stat(path);
+        return {
+            size: stats.size,
+            created: stats.birthtime,
+            modified: stats.mtime,
+            accessed: stats.atime,
+            isDirectory: stats.isDirectory(),
+            isFile: stats.isFile(),
+            permissions: stats.mode.toString(8).slice(-3),
+            fileType: 'binary',
+            metadata: {
+                isBinary: true
+            }
+        };
+    }
+    /**
+     * Generate instructions for handling binary files
+     */
+    getBinaryInstructions(filePath) {
+        const fileName = path.basename(filePath);
+        return `Cannot read binary file as text: ${fileName}
+
+Use start_process + interact_with_process to analyze binary files with appropriate tools (Node.js or Python libraries, command-line utilities, etc.).
+
+The read_file tool only handles text files, images, and Excel files.`;
+    }
+}