@hypothesi/tauri-mcp-server 0.1.1

package/dist/manager/cli.js

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import { execa } from 'execa';
+import fs from 'fs/promises';
+import path from 'path';
+export const RunCommandSchema = z.object({
+    command: z.string().describe('Any Tauri CLI command (e.g., "init", "dev", "build", "android dev", "migrate", "plugin add", etc.)'),
+    args: z.array(z.string()).optional().describe('Additional arguments to pass to the command'),
+    cwd: z.string().describe('The project directory'),
+    timeout: z.number().optional().describe('Command timeout in milliseconds (default: 180000)'),
+});
+/**
+ * Get available Tauri commands by running 'tauri --help'
+ */
+export async function listTauriCommands(cwd) {
+    try {
+        const packageJsonPath = path.join(cwd, 'package.json');
+        const hasTauriScript = await fs
+            .readFile(packageJsonPath, 'utf8')
+            .then((content) => {
+            try {
+                const pkg = JSON.parse(content);
+                return Boolean(pkg.scripts && pkg.scripts.tauri);
+            }
+            catch {
+                return false;
+            }
+        })
+            .catch(() => { return false; });
+        let result;
+        if (hasTauriScript) {
+            result = await execa('npm', ['run', 'tauri', '--', '--help'], {
+                cwd,
+                timeout: 10000,
+            });
+        }
+        else {
+            result = await execa('tauri', ['--help'], {
+                cwd,
+                timeout: 10000,
+            });
+        }
+        return result.stdout;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to get Tauri commands: ${message}`);
+    }
+}
+export async function runTauriCommand(command, cwd, args = [], timeout = 180000) {
+    try {
+        // Split command if it contains spaces (e.g., "android dev" or "plugin add")
+        const commandParts = command.split(' ');
+        const allArgs = [...commandParts, ...args];
+        const packageJsonPath = path.join(cwd, 'package.json');
+        const hasTauriScript = await fs
+            .readFile(packageJsonPath, 'utf8')
+            .then((content) => {
+            try {
+                const pkg = JSON.parse(content);
+                return Boolean(pkg.scripts && pkg.scripts.tauri);
+            }
+            catch {
+                return false;
+            }
+        })
+            .catch(() => { return false; });
+        const isDevLikeCommand = commandParts[0] === 'dev' ||
+            command.startsWith('android dev') ||
+            command.startsWith('ios dev');
+        const spawnTauri = () => {
+            if (hasTauriScript) {
+                return execa('npm', ['run', 'tauri', '--', ...allArgs], {
+                    cwd,
+                    timeout: isDevLikeCommand ? undefined : timeout,
+                });
+            }
+            return execa('tauri', allArgs, {
+                cwd,
+                timeout: isDevLikeCommand ? undefined : timeout,
+            });
+        };
+        const child = spawnTauri();
+        if (isDevLikeCommand) {
+            // For long-running dev commands, start the process and return once the
+            // command appears healthy
+            child.catch(() => { return; });
+            await new Promise((resolve) => {
+                setTimeout(resolve, 3000);
+            });
+            if (child.exitCode !== null) {
+                if (child.exitCode === 0) {
+                    return 'Tauri dev command completed successfully.';
+                }
+                throw new Error('Tauri dev command exited unexpectedly. Check your project configuration and logs for details.');
+            }
+            const text = [
+                'Tauri dev command started. It may still be initializing; check your terminal',
+                'or devtools logs for live output. Use Ctrl+C in the appropriate terminal to',
+                'stop it.',
+            ];
+            return text.join(' ');
+        }
+        const result = await child;
+        if (Array.isArray(result.stdout)) {
+            return result.stdout.join('\n');
+        }
+        if (result.stdout instanceof Uint8Array) {
+            return new TextDecoder().decode(result.stdout);
+        }
+        return result.stdout || 'Command completed successfully';
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error), stderr = error && typeof error === 'object' && 'stderr' in error ? String(error.stderr) : '';
+        // Provide more helpful error messages
+        if (message.includes('Unknown command')) {
+            throw new Error(`Unknown Tauri command: "${command}". Run 'tauri --help' to see available commands.\n${stderr}`);
+        }
+        if (message.includes('spawn tauri ENOENT')) {
+            const msgParts = [
+                'Failed to run the Tauri CLI. Either add a "tauri" script to your',
+                'package.json (e.g., "tauri": "tauri") or install the global Tauri CLI',
+                'as described in the documentation, then try again.',
+            ];
+            throw new Error(msgParts.join(' '));
+        }
+        throw new Error(`Tauri command failed: ${message}${stderr ? `\n${stderr}` : ''}`);
+    }
+}

package/dist/manager/config.js

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+// Tauri supports multiple configuration files
+const TAURI_CONFIG_FILES = [
+    'tauri.conf.json',
+    'tauri.conf.json5',
+    'Tauri.toml',
+    // Platform-specific configs
+    'tauri.windows.conf.json',
+    'tauri.linux.conf.json',
+    'tauri.macos.conf.json',
+    'tauri.android.conf.json',
+    'tauri.ios.conf.json',
+    // Build-specific configs
+    'tauri.conf.dev.json',
+    'tauri.conf.prod.json',
+    // Project files
+    'Cargo.toml',
+    'package.json',
+    // Mobile-specific files
+    'Info.plist',
+    'AndroidManifest.xml',
+];
+export const ReadConfigSchema = z.object({
+    projectPath: z.string(),
+    file: z.enum(TAURI_CONFIG_FILES).describe('Tauri configuration file to read'),
+});
+export const WriteConfigSchema = z.object({
+    projectPath: z.string(),
+    file: z.enum(TAURI_CONFIG_FILES).describe('Tauri configuration file to write'),
+    content: z.string().describe('The new content of the file'),
+});
+export async function readConfig(projectPath, file) {
+    const filePath = path.join(projectPath, getRelativePath(file));
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return content;
+    }
+    catch (error) {
+        throw new Error(`Failed to read ${file}: ${error}`);
+    }
+}
+/**
+ * List all available Tauri configuration files in the project
+ */
+export async function listConfigFiles(projectPath) {
+    const availableFiles = [];
+    for (const file of TAURI_CONFIG_FILES) {
+        const filePath = path.join(projectPath, getRelativePath(file));
+        try {
+            await fs.access(filePath);
+            availableFiles.push(file);
+        }
+        catch (e) {
+            // File doesn't exist, skip it
+        }
+    }
+    return availableFiles;
+}
+export async function writeConfig(projectPath, file, content) {
+    const filePath = path.join(projectPath, getRelativePath(file));
+    // Validate JSON files
+    if (file.endsWith('.json')) {
+        try {
+            JSON.parse(content);
+        }
+        catch (e) {
+            throw new Error(`Invalid JSON content for ${file}`);
+        }
+    }
+    // Validate JSON5 files
+    if (file.endsWith('.json5')) {
+        // JSON5 is a superset of JSON, basic validation
+        // In production, you'd want to use a json5 parser
+        try {
+            // At minimum, check for basic syntax
+            if (!content.trim()) {
+                throw new Error(`Empty content for ${file}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`Invalid content for ${file}`);
+        }
+    }
+    // Validate TOML files
+    if (file.endsWith('.toml')) {
+        // Basic TOML validation - in production use a TOML parser
+        if (!content.trim()) {
+            throw new Error(`Empty content for ${file}`);
+        }
+    }
+    // Validate XML files
+    if (file.endsWith('.xml')) {
+        // Basic XML validation
+        if (!content.includes('<') || !content.includes('>')) {
+            throw new Error(`Invalid XML content for ${file}`);
+        }
+    }
+    // Validate plist files
+    if (file.endsWith('.plist')) {
+        // plist files are XML-based
+        if (!content.includes('<?xml') || !content.includes('<plist')) {
+            throw new Error(`Invalid plist content for ${file}`);
+        }
+    }
+    try {
+        await fs.writeFile(filePath, content, 'utf-8');
+        return `Successfully wrote to ${file}`;
+    }
+    catch (error) {
+        throw new Error(`Failed to write ${file}: ${error}`);
+    }
+}
+function getRelativePath(file) {
+    // Main Tauri config files
+    if (file === 'tauri.conf.json' || file === 'tauri.conf.json5' || file === 'Tauri.toml') {
+        return `src-tauri/${file}`;
+    }
+    // Platform-specific Tauri configs
+    if (file.startsWith('tauri.') && (file.endsWith('.conf.json') || file.endsWith('.conf.json5'))) {
+        return `src-tauri/${file}`;
+    }
+    // Cargo.toml
+    if (file === 'Cargo.toml') {
+        return 'src-tauri/Cargo.toml';
+    }
+    // iOS Info.plist
+    if (file === 'Info.plist') {
+        return 'src-tauri/gen/apple/Runner/Info.plist';
+    }
+    // Android manifest
+    if (file === 'AndroidManifest.xml') {
+        return 'src-tauri/gen/android/app/src/main/AndroidManifest.xml';
+    }
+    // Package.json is at root
+    if (file === 'package.json') {
+        return 'package.json';
+    }
+    // Default: assume it's relative to project root
+    return file;
+}

package/dist/manager/docs.js

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+import { execa } from 'execa';
+export const GetDocsSchema = z.object({
+    projectPath: z.string().describe('Path to the Tauri project'),
+});
+export async function getDocs(projectPath) {
+    try {
+        const version = await getTauriVersion(projectPath), isV2 = version.startsWith('2'), docs = await fetchDocs(version, isV2);
+        return docs;
+    }
+    catch (error) {
+        return `Error getting docs: ${error}`;
+    }
+}
+async function getTauriVersion(projectPath) {
+    try {
+        // 1. Try 'cargo tree' to get the exact resolved version of the tauri crate
+        try {
+            const { stdout } = await execa('cargo', ['tree', '-p', 'tauri', '--depth', '0'], { cwd: path.join(projectPath, 'src-tauri') }), match = stdout.match(/tauri v([\d.]+)/);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+        // 2. Try 'npm list' for the CLI version
+        try {
+            const { stdout } = await execa('npm', ['list', '@tauri-apps/cli', '--depth=0', '--json'], { cwd: projectPath }), pkg = JSON.parse(stdout);
+            if (pkg.dependencies?.['@tauri-apps/cli']?.version) {
+                return pkg.dependencies['@tauri-apps/cli'].version;
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+        // 3. Fallback: Read Cargo.toml manually
+        const cargoPath = path.join(projectPath, 'src-tauri', 'Cargo.toml'), cargoContent = await fs.readFile(cargoPath, 'utf-8'), match = cargoContent.match(/tauri\s*=\s*{?[^}]*version\s*=\s*"([^"]+)"/);
+        if (match && match[1]) {
+            return match[1];
+        }
+        // 4. Fallback: Read package.json
+        const pkgPath = path.join(projectPath, 'package.json'), pkgContent = await fs.readFile(pkgPath, 'utf-8'), pkgJson = JSON.parse(pkgContent), cliVersion = pkgJson.devDependencies?.['@tauri-apps/cli'] || pkgJson.dependencies?.['@tauri-apps/cli'];
+        if (cliVersion) {
+            return cliVersion.replace('^', '').replace('~', '');
+        }
+        return 'unknown';
+    }
+    catch (e) {
+        return 'unknown';
+    }
+}
+// Exported for testing
+export async function fetchDocs(version, isV2) {
+    const branch = isV2 ? 'v2' : 'v1', treeUrl = `https://api.github.com/repos/tauri-apps/tauri-docs/git/trees/${branch}?recursive=1`, rawBaseUrl = `https://raw.githubusercontent.com/tauri-apps/tauri-docs/${branch}`;
+    try {
+        // Fetching file tree from ${treeUrl}...
+        const treeResponse = await fetch(treeUrl, {
+            headers: {
+                'User-Agent': 'mcp-server-tauri', // GitHub API requires User-Agent
+            },
+        });
+        if (!treeResponse.ok) {
+            throw new Error(`Failed to fetch file tree: ${treeResponse.status} ${treeResponse.statusText}`);
+        }
+        const treeData = (await treeResponse.json()), relevantFiles = filterRelevantFiles(treeData.tree, isV2);
+        // Found ${relevantFiles.length} relevant documentation files.
+        let combinedDocs = `# Tauri ${isV2 ? 'v2' : 'v1'} Documentation (Dynamically Fetched)\n\n`;
+        combinedDocs += `Version Detected: ${version}\n`;
+        combinedDocs += `Source: ${rawBaseUrl}\n\n`;
+        // Fetch content in batches to be polite and avoid timeouts
+        const batchSize = 5;
+        for (let i = 0; i < relevantFiles.length; i += batchSize) {
+            const batch = relevantFiles.slice(i, i + batchSize), results = await Promise.all(batch.map((file) => { return fetchContent(rawBaseUrl, file); }));
+            combinedDocs += results.join('\n\n');
+        }
+        return combinedDocs;
+    }
+    catch (e) {
+        // Error fetching dynamic docs: ${e}
+        return `Error fetching dynamic docs: ${e}\n\n` + getStaticFallback(version, isV2);
+    }
+}
+function isExcludedPath(filePath) {
+    // Check for common exclusions
+    if (filePath.includes('/blog/') || filePath.includes('/_') || filePath.includes('/translations/')) {
+        return true;
+    }
+    // Check file extensions
+    if (!filePath.endsWith('.md') && !filePath.endsWith('.mdx')) {
+        return true;
+    }
+    // Check for hidden or node_modules
+    if (filePath.startsWith('.') || filePath.includes('/node_modules/')) {
+        return true;
+    }
+    // Check for blog posts
+    if (filePath.startsWith('blog/') || filePath.includes('/blog/')) {
+        return true;
+    }
+    return false;
+}
+function isTranslationPath(filePath) {
+    const langCodes = ['fr', 'es', 'it', 'ja', 'ko', 'zh-cn', 'zh-tw', 'pt-br', 'ru', 'de'];
+    for (const lang of langCodes) {
+        const hasLang = filePath.includes(`/${lang}/`) || filePath.includes(`/_${lang}/`) ||
+            filePath.startsWith(`${lang}/`) || filePath.startsWith(`_${lang}/`);
+        if (hasLang) {
+            return true;
+        }
+    }
+    return false;
+}
+function filterRelevantFiles(tree, isV2) {
+    return tree.filter((item) => {
+        if (item.type !== 'blob') {
+            return false;
+        }
+        const file = item;
+        if (isExcludedPath(file.path) || isTranslationPath(file.path)) {
+            return false;
+        }
+        if (isV2) {
+            // v2 docs are in src/content/docs
+            if (!file.path.startsWith('src/content/docs/')) {
+                return false;
+            }
+            // Exclude fragments and templates
+            if (file.path.includes('/_fragments/') || file.path.includes('/.templates/')) {
+                return false;
+            }
+        }
+        else {
+            // v1 docs are in docs/
+            if (!file.path.startsWith('docs/')) {
+                return false;
+            }
+            // Exclude templates
+            if (file.path.includes('/.templates/')) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+async function fetchContent(baseUrl, file) {
+    try {
+        const url = `${baseUrl}/${file.path}`, response = await fetch(url);
+        if (!response.ok) {
+            return `## ${file.path}\n\n(Failed to fetch: ${response.status})\n`;
+        }
+        const text = await response.text();
+        // Remove frontmatter
+        const cleanText = text.replace(/^---[\s\S]*?---\n/, '');
+        return `## ${file.path}\n\n${cleanText}\n\n---\n`;
+    }
+    catch (e) {
+        return `## ${file.path}\n\n(Error fetching content: ${e})\n`;
+    }
+}
+function getStaticFallback(version, isV2) {
+    if (isV2) {
+        return `# Tauri v2 Static Fallback
+(Dynamic fetching failed. This is a minimal fallback.)
+
+## Core Concepts
+- **Frontend**: Web technologies (HTML/CSS/JS).
+- **Backend**: Rust.
+- **IPC**: Use \`invoke\` to call Rust commands.
+
+## Security
+- Enable capabilities in \`src-tauri/capabilities\`.
+- Configure permissions in \`tauri.conf.json\`.
+`;
+    }
+    return `# Tauri v1 LLM Cheat Sheet
+Version Detected: ${version}
+Documentation: https://tauri.app/v1/api/
+
+## Core Concepts
+- **Frontend**: Web technologies.
+- **Backend**: Rust.
+- **IPC**: \`invoke\` and \`#[tauri::command]\`.
+
+## Key APIs (Frontend)
+\`\`\`typescript
+import { invoke } from '@tauri-apps/api/tauri';
+
+// Call Rust command
+await invoke('my_command', { arg: 'value' });
+\`\`\`
+
+## Key APIs (Rust)
+\`\`\`rust
+#[tauri::command]
+fn my_command(arg: String) -> String {
+    format!("Hello {}", arg)
+}
+
+fn main() {
+    tauri::Builder::default()
+        .invoke_handler(tauri::generate_handler![my_command])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+\`\`\`
+
+## Configuration
+- **tauri.conf.json**: Uses \`allowlist\` to enable features.
+`;
+}

package/dist/manager/mobile.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { execa } from 'execa';
+export const ListDevicesSchema = z.object({});
+async function getAndroidDevices() {
+    try {
+        const { stdout } = await execa('adb', ['devices', '-l']);
+        return stdout
+            .split('\n')
+            .slice(1)
+            .filter((line) => { return line.trim().length > 0; })
+            .map((line) => { return line.trim(); });
+    }
+    catch (_) {
+        // Android SDK not available or adb command failed
+        return [];
+    }
+}
+async function getIOSSimulators() {
+    if (process.platform !== 'darwin') {
+        return [];
+    }
+    try {
+        const { stdout } = await execa('xcrun', ['simctl', 'list', 'devices', 'booted']);
+        return stdout
+            .split('\n')
+            .filter((line) => { return line.trim().length > 0 && !line.includes('== Devices =='); });
+    }
+    catch (_) {
+        // Xcode not installed or xcrun command failed
+        return [];
+    }
+}
+export async function listDevices() {
+    const [android, ios] = await Promise.all([
+        getAndroidDevices(),
+        getIOSSimulators(),
+    ]);
+    return { android, ios };
+}
+export const LaunchEmulatorSchema = z.object({
+    platform: z.enum(['android', 'ios']),
+    name: z.string().describe('Name of the AVD or Simulator'),
+});
+export async function launchEmulator(platform, name) {
+    if (platform === 'android') {
+        try {
+            // Launch Android Emulator - Try to spawn, but immediately await to catch ENOENT
+            await execa('emulator', ['-avd', name], {
+                detached: true,
+                stdio: 'ignore',
+                timeout: 1000, // Just check if it spawns
+            });
+            return `Launching Android AVD: ${name}`;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to launch Android emulator: ${message}`);
+        }
+    }
+    else if (platform === 'ios') {
+        // Check if we're on macOS first
+        if (process.platform !== 'darwin') {
+            throw new Error('iOS simulators are only available on macOS');
+        }
+        try {
+            // Launch iOS Simulator
+            await execa('xcrun', ['simctl', 'boot', name]);
+            await execa('open', ['-a', 'Simulator']);
+            return `Booted iOS Simulator: ${name}`;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Provide more helpful error messages
+            if (message.includes('xcrun: error')) {
+                throw new Error('Xcode is not installed. Please install Xcode from the App Store to use iOS simulators.');
+            }
+            throw new Error(`Failed to launch iOS simulator: ${message}`);
+        }
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}. Use 'android' or 'ios'.`);
+    }
+}

package/dist/monitor/logs.js

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { execa } from 'execa';
+export const ReadLogsSchema = z.object({
+    source: z.enum(['android', 'ios', 'system']),
+    lines: z.number().default(50),
+    filter: z.string().optional().describe('Regex or keyword to filter logs'),
+    since: z.string().optional().describe('ISO timestamp to filter logs since (e.g. 2023-10-27T10:00:00Z)'),
+});
+export async function readLogs(source, lines, filter, since) {
+    try {
+        let output = '';
+        if (source === 'android') {
+            const args = ['logcat', '-d'];
+            if (since) {
+                // adb logcat -T expects "MM-DD HH:MM:SS.mmm"
+                const date = new Date(since);
+                const month = (date.getMonth() + 1).toString().padStart(2, '0');
+                const day = date.getDate().toString().padStart(2, '0');
+                const hours = date.getHours().toString().padStart(2, '0');
+                const minutes = date.getMinutes().toString().padStart(2, '0');
+                const seconds = date.getSeconds().toString().padStart(2, '0');
+                const ms = date.getMilliseconds().toString().padStart(3, '0');
+                const adbTime = `${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+                args.push('-T', adbTime);
+            }
+            else {
+                args.push('-t', lines.toString());
+            }
+            const { stdout } = await execa('logcat', ['-d', '-t', lines.toString()], { timeout: 5000 });
+            output = stdout;
+        }
+        else if (source === 'ios') {
+            // iOS / macOS
+            const args = ['log', 'show', '--style', 'syslog'];
+            if (source === 'ios') {
+                args.unshift('xcrun', 'simctl', 'spawn', 'booted');
+            }
+            if (since) {
+                // log show --start "YYYY-MM-DD HH:MM:SS"
+                // It accepts ISO-like formats too usually, but let's be safe with
+                // local time format if possible
+                // Actually 'log show' on macOS is picky. ISO 8601 works in recent versions.
+                args.push('--start', since);
+            }
+            else {
+                // Default to last 1m if no since provided, as 'lines' isn't
+                // directly supported by log show time window
+                args.push('--last', '1m');
+            }
+            try {
+                const { stdout } = await execa(args[0], args.slice(1));
+                // We still apply line limit manually if we didn't use -t (adb)
+                let outLines = stdout.split('\n');
+                if (!since) {
+                    outLines = outLines.slice(-lines);
+                }
+                output = outLines.join('\n');
+            }
+            catch (e) {
+                return `Error reading logs: ${e}`;
+            }
+        }
+        else {
+            // System (same as iOS essentially but local)
+            const args = ['log', 'show', '--style', 'syslog'];
+            if (since) {
+                args.push('--start', since);
+            }
+            else {
+                args.push('--last', '1m');
+            }
+            try {
+                const { stdout } = await execa('log', args.slice(1)); // 'log' is the command
+                let outLines = stdout.split('\n');
+                if (!since) {
+                    outLines = outLines.slice(-lines);
+                }
+                output = outLines.join('\n');
+            }
+            catch (e) {
+                return `Error reading system logs: ${e}`;
+            }
+        }
+        if (filter) {
+            try {
+                const regex = new RegExp(filter, 'i');
+                return output.split('\n').filter((line) => { return regex.test(line); }).join('\n');
+            }
+            catch (e) {
+                return `Invalid filter regex: ${e}`;
+            }
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error reading logs: ${error}`;
+    }
+}