flutter-skill 0.7.4

package/dart/lib/src/cli/setup.dart

@@ -0,0 +1,76 @@
+import 'dart:io';
+
+Future<void> runSetup(String projectPath) async {
+  final pubspecFile = File('$projectPath/pubspec.yaml');
+  final mainFile = File('$projectPath/lib/main.dart');
+
+  if (!pubspecFile.existsSync()) {
+    print('Error: pubspec.yaml not found at $projectPath');
+    exit(1);
+  }
+
+  if (!mainFile.existsSync()) {
+    print('Error: lib/main.dart not found at $projectPath');
+    exit(1);
+  }
+
+  print('Checking dependencies in ${pubspecFile.path}...');
+  final pubspecContent = pubspecFile.readAsStringSync();
+
+  if (!pubspecContent.contains('flutter_skill:')) {
+    print('Adding flutter_skill dependency...');
+    final result = await Process.run(
+      'flutter',
+      ['pub', 'add', 'flutter_skill'],
+      workingDirectory: projectPath,
+    );
+    if (result.exitCode != 0) {
+      print('Failed to add dependency: ${result.stderr}');
+      exit(1);
+    }
+    print('Dependency added.');
+  } else {
+    print('Dependency flutter_skill already exists.');
+  }
+
+  print('Checking instrumentation in ${mainFile.path}...');
+  String mainContent = mainFile.readAsStringSync();
+
+  bool changed = false;
+
+  // 1. Check Import
+  if (!mainContent.contains('package:flutter_skill/flutter_skill.dart')) {
+    mainContent =
+        "import 'package:flutter_skill/flutter_skill.dart';\nimport 'package:flutter/foundation.dart'; // For kDebugMode\n" +
+            mainContent;
+    changed = true;
+    print('Added imports.');
+  }
+
+  // 2. Check Initialization
+  if (!mainContent.contains('FlutterSkillBinding.ensureInitialized()')) {
+    final mainRegex = RegExp(r'void\s+main\s*\(\s*\)\s*\{');
+    final match = mainRegex.firstMatch(mainContent);
+
+    if (match != null) {
+      final end = match.end;
+      const injection =
+          '\n  if (kDebugMode) {\n    FlutterSkillBinding.ensureInitialized();\n  }\n';
+      mainContent = mainContent.replaceRange(end, end, injection);
+      changed = true;
+      print('Added FlutterSkillBinding initialization.');
+    } else {
+      print(
+          'Warning: Could not find "void main() {" to inject code. Manual setup required.');
+    }
+  }
+
+  if (changed) {
+    mainFile.writeAsStringSync(mainContent);
+    print('Updated lib/main.dart.');
+  } else {
+    print('No changes needed for lib/main.dart.');
+  }
+
+  print('Setup complete.');
+}

package/dart/lib/src/flutter_skill_client.dart

@@ -0,0 +1,294 @@
+import 'dart:io';
+import 'package:vm_service/vm_service.dart';
+import 'package:vm_service/vm_service_io.dart';
+
+class FlutterSkillClient {
+  final String wsUri;
+  VmService? _service;
+  String? _isolateId;
+
+  FlutterSkillClient(this.wsUri);
+
+  Future<void> connect() async {
+    print('DEBUG: Connecting to $wsUri');
+    _service = await vmServiceConnectUri(wsUri);
+    print('DEBUG: Connected to VM Service');
+
+    final vm = await _service!.getVM();
+    print('DEBUG: Got VM info');
+    final isolates = vm.isolates;
+    if (isolates == null || isolates.isEmpty) {
+      throw Exception('No isolates found');
+    }
+    _isolateId = isolates.first.id!;
+  }
+
+  Future<void> disconnect() async {
+    await _service?.dispose();
+    _service = null;
+    _isolateId = null;
+  }
+
+  Future<Map<String, dynamic>> _call(String method,
+      [Map<String, dynamic>? args]) async {
+    if (_service == null || _isolateId == null) {
+      throw Exception('Not connected');
+    }
+    final response = await _service!.callServiceExtension(
+      method,
+      isolateId: _isolateId!,
+      args: args,
+    );
+    return response.json ?? {};
+  }
+
+  // ==================== EXISTING METHODS ====================
+
+  Future<List<dynamic>> getInteractiveElements() async {
+    final result = await _call('ext.flutter.flutter_skill.interactive');
+    print('DEBUG: Interactive Result type: ${result.runtimeType}');
+    print('DEBUG: Interactive Result: $result');
+
+    if (result.containsKey('elements')) {
+      return result['elements'] as List<dynamic>;
+    }
+    return [];
+  }
+
+  Future<void> tap({String? key, String? text}) async {
+    if (key == null && text == null) {
+      throw ArgumentError('Must provide key or text for tap');
+    }
+    await _call('ext.flutter.flutter_skill.tap', {
+      if (key != null) 'key': key,
+      if (text != null) 'text': text,
+    });
+  }
+
+  Future<void> enterText(String key, String text) async {
+    await _call('ext.flutter.flutter_skill.enterText', {
+      'key': key,
+      'text': text,
+    });
+  }
+
+  Future<void> scrollTo({String? key, String? text}) async {
+    await _call('ext.flutter.flutter_skill.scroll', {
+      if (key != null) 'key': key,
+      if (text != null) 'text': text,
+    });
+  }
+
+  // ==================== UI INSPECTION ====================
+
+  Future<Map<String, dynamic>> getWidgetTree({int maxDepth = 10}) async {
+    final result = await _call('ext.flutter.flutter_skill.getWidgetTree', {
+      'maxDepth': maxDepth.toString(),
+    });
+    return result['tree'] ?? {};
+  }
+
+  Future<Map<String, dynamic>?> getWidgetProperties(String key) async {
+    final result =
+        await _call('ext.flutter.flutter_skill.getWidgetProperties', {
+      'key': key,
+    });
+    return result['properties'];
+  }
+
+  Future<List<dynamic>> getTextContent() async {
+    final result = await _call('ext.flutter.flutter_skill.getTextContent');
+    return result['texts'] ?? [];
+  }
+
+  Future<List<dynamic>> findByType(String type) async {
+    final result = await _call('ext.flutter.flutter_skill.findByType', {
+      'type': type,
+    });
+    return result['elements'] ?? [];
+  }
+
+  // ==================== MORE INTERACTIONS ====================
+
+  Future<bool> longPress(
+      {String? key, String? text, int duration = 500}) async {
+    final result = await _call('ext.flutter.flutter_skill.longPress', {
+      if (key != null) 'key': key,
+      if (text != null) 'text': text,
+      'duration': duration.toString(),
+    });
+    return result['success'] == true;
+  }
+
+  Future<bool> swipe(
+      {required String direction, double distance = 300, String? key}) async {
+    final result = await _call('ext.flutter.flutter_skill.swipe', {
+      'direction': direction,
+      'distance': distance.toString(),
+      if (key != null) 'key': key,
+    });
+    return result['success'] == true;
+  }
+
+  Future<bool> drag({required String fromKey, required String toKey}) async {
+    final result = await _call('ext.flutter.flutter_skill.drag', {
+      'fromKey': fromKey,
+      'toKey': toKey,
+    });
+    return result['success'] == true;
+  }
+
+  Future<bool> doubleTap({String? key, String? text}) async {
+    final result = await _call('ext.flutter.flutter_skill.doubleTap', {
+      if (key != null) 'key': key,
+      if (text != null) 'text': text,
+    });
+    return result['success'] == true;
+  }
+
+  // ==================== STATE & VALIDATION ====================
+
+  Future<String?> getTextValue(String key) async {
+    final result = await _call('ext.flutter.flutter_skill.getTextValue', {
+      'key': key,
+    });
+    return result['value'];
+  }
+
+  Future<bool?> getCheckboxState(String key) async {
+    final result = await _call('ext.flutter.flutter_skill.getCheckboxState', {
+      'key': key,
+    });
+    return result['checked'];
+  }
+
+  Future<double?> getSliderValue(String key) async {
+    final result = await _call('ext.flutter.flutter_skill.getSliderValue', {
+      'key': key,
+    });
+    return result['value']?.toDouble();
+  }
+
+  Future<bool> waitForElement(
+      {String? key, String? text, int timeout = 5000}) async {
+    final result = await _call('ext.flutter.flutter_skill.waitForElement', {
+      if (key != null) 'key': key,
+      if (text != null) 'text': text,
+      'timeout': timeout.toString(),
+    });
+    return result['found'] == true;
+  }
+
+  Future<bool> waitForGone(
+      {String? key, String? text, int timeout = 5000}) async {
+    final result = await _call('ext.flutter.flutter_skill.waitForGone', {
+      if (key != null) 'key': key,
+      if (text != null) 'text': text,
+      'timeout': timeout.toString(),
+    });
+    return result['gone'] == true;
+  }
+
+  // ==================== SCREENSHOT ====================
+
+  Future<String?> takeScreenshot() async {
+    final result = await _call('ext.flutter.flutter_skill.screenshot');
+    return result['image'];
+  }
+
+  Future<String?> takeElementScreenshot(String key) async {
+    final result = await _call('ext.flutter.flutter_skill.screenshotElement', {
+      'key': key,
+    });
+    return result['image'];
+  }
+
+  // ==================== NAVIGATION ====================
+
+  Future<String?> getCurrentRoute() async {
+    final result = await _call('ext.flutter.flutter_skill.getCurrentRoute');
+    return result['route'];
+  }
+
+  Future<bool> goBack() async {
+    final result = await _call('ext.flutter.flutter_skill.goBack');
+    return result['success'] == true;
+  }
+
+  Future<List<String>> getNavigationStack() async {
+    final result = await _call('ext.flutter.flutter_skill.getNavigationStack');
+    return (result['stack'] as List?)?.cast<String>() ?? [];
+  }
+
+  // ==================== DEBUG & LOGS ====================
+
+  Future<List<String>> getLogs() async {
+    final result = await _call('ext.flutter.flutter_skill.getLogs');
+    return (result['logs'] as List?)?.cast<String>() ?? [];
+  }
+
+  Future<List<dynamic>> getErrors() async {
+    final result = await _call('ext.flutter.flutter_skill.getErrors');
+    return result['errors'] ?? [];
+  }
+
+  Future<void> clearLogs() async {
+    await _call('ext.flutter.flutter_skill.clearLogs');
+  }
+
+  Future<Map<String, dynamic>> getPerformance() async {
+    return await _call('ext.flutter.flutter_skill.getPerformance');
+  }
+
+  // ==================== EXISTING HELPERS ====================
+
+  Future<void> hotReload() async {
+    if (_service == null || _isolateId == null) {
+      throw Exception('Not connected');
+    }
+    await _service!.reloadSources(_isolateId!);
+  }
+
+  Future<void> hotRestart() async {
+    if (_service == null || _isolateId == null) {
+      throw Exception('Not connected');
+    }
+    await _service!.reloadSources(_isolateId!);
+  }
+
+  Future<Map<String, dynamic>> getLayoutTree() async {
+    try {
+      final groupName =
+          'flutter_skill_${DateTime.now().millisecondsSinceEpoch}';
+      final result =
+          await _call('ext.flutter.inspector.getRootWidgetSummaryTree', {
+        'objectGroup': groupName,
+      });
+      return result;
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  bool get isConnected => _service != null && _isolateId != null;
+
+  static Future<String> resolveUri(List<String> args) async {
+    if (args.isNotEmpty) {
+      final arg = args[0];
+      if (arg.startsWith('ws://') || arg.startsWith('http://')) {
+        return arg;
+      }
+    }
+
+    final file = File('.flutter_skill_uri');
+    if (await file.exists()) {
+      final uri = (await file.readAsString()).trim();
+      if (uri.isNotEmpty) {
+        return uri;
+      }
+    }
+
+    throw ArgumentError(
+        'No URI provided and .flutter_skill_uri not found/empty. Run `flutter_skill launch` or provide URI as first argument.');
+  }
+}

package/dart/pubspec.yaml

@@ -0,0 +1,26 @@
+name: flutter_skill
+description: Give your AI Agent eyes and hands inside your Flutter app.
+version: 0.2.0
+homepage: https://github.com/ai-dashboad/flutter-skill
+repository: https://github.com/ai-dashboad/flutter-skill
+# publish_to: 'none' # Remove this when ready to publish to pub.dev
+
+executables:
+  flutter_skill: flutter_skill
+
+environment:
+  sdk: '>=3.0.0 <4.0.0'
+  flutter: ">=3.0.0"
+
+dependencies:
+  flutter:
+    sdk: flutter
+  vm_service: ^14.0.0
+  http: ^1.1.0
+  path: ^1.8.0
+  logging: ^1.2.0
+
+dev_dependencies:
+  flutter_test:
+    sdk: flutter
+  lints: ^3.0.0

package/index.js

@@ -0,0 +1,7 @@
+// flutter-skill
+// MCP Server for Flutter app automation
+
+module.exports = {
+  name: 'flutter-skill',
+  version: require('./package.json').version
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "flutter-skill",
+  "version": "0.7.4",
+  "description": "MCP Server for app automation - Give your AI Agent eyes and hands inside any app (Flutter, React, Web, Native)",
+  "main": "index.js",
+  "bin": {
+    "flutter-skill-mcp": "./bin/cli.js",
+    "flutter-skill": "./bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "flutter",
+    "react-native",
+    "web",
+    "mcp",
+    "ai",
+    "automation",
+    "testing",
+    "claude",
+    "cursor",
+    "windsurf"
+  ],
+  "author": "ai-dashboad",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai-dashboad/flutter-skill.git"
+  },
+  "homepage": "https://github.com/ai-dashboad/flutter-skill",
+  "bugs": {
+    "url": "https://github.com/ai-dashboad/flutter-skill/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "dart/",
+    "web/",
+    "README.md"
+  ]
+}

package/scripts/build.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '..', '..');
+const npmDir = path.join(__dirname, '..');
+const dartDir = path.join(npmDir, 'dart');
+
+// Files to copy
+const filesToCopy = [
+  'pubspec.yaml',
+  'lib/flutter_skill.dart',
+  'lib/src/flutter_skill_client.dart',
+  'lib/src/cli/server.dart',
+  'lib/src/cli/setup.dart',
+  'lib/src/cli/launch.dart',
+  'lib/src/cli/inspect.dart',
+  'lib/src/cli/act.dart',
+  'bin/server.dart',
+];
+
+// Create directories
+function mkdirp(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// Copy file
+function copyFile(src, dest) {
+  mkdirp(path.dirname(dest));
+  fs.copyFileSync(src, dest);
+  console.log(`Copied: ${path.relative(rootDir, src)} -> ${path.relative(npmDir, dest)}`);
+}
+
+// Main
+console.log('Building npm package...\n');
+
+// Clean dart directory
+if (fs.existsSync(dartDir)) {
+  fs.rmSync(dartDir, { recursive: true });
+}
+mkdirp(dartDir);
+
+// Copy files
+for (const file of filesToCopy) {
+  const src = path.join(rootDir, file);
+  const dest = path.join(dartDir, file);
+  if (fs.existsSync(src)) {
+    copyFile(src, dest);
+  } else {
+    console.warn(`Warning: ${file} not found`);
+  }
+}
+
+// Update version in package.json from pubspec.yaml
+const pubspec = fs.readFileSync(path.join(rootDir, 'pubspec.yaml'), 'utf8');
+const versionMatch = pubspec.match(/version:\s*(\S+)/);
+if (versionMatch) {
+  const packageJson = JSON.parse(fs.readFileSync(path.join(npmDir, 'package.json'), 'utf8'));
+  packageJson.version = versionMatch[1];
+  fs.writeFileSync(path.join(npmDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+  console.log(`\nUpdated package.json version to ${versionMatch[1]}`);
+}
+
+console.log('\nBuild complete!');

package/scripts/check-dart.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+
+function checkCommand(cmd) {
+  try {
+    execSync(`${cmd} --version`, { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+const hasDart = checkCommand('dart');
+const hasFlutter = checkCommand('flutter');
+
+if (!hasDart && !hasFlutter) {
+  console.log('\n' + '='.repeat(60));
+  console.log('flutter-skill requires Dart SDK');
+  console.log('='.repeat(60));
+  console.log('\nPlease install Flutter (includes Dart):');
+  console.log('  https://docs.flutter.dev/get-started/install\n');
+  console.log('Or install Dart standalone:');
+  console.log('  https://dart.dev/get-dart\n');
+} else if (hasDart && !hasFlutter) {
+  console.log('\nNote: Flutter SDK not found. Some features may be limited.');
+  console.log('Install Flutter for full functionality:');
+  console.log('  https://docs.flutter.dev/get-started/install\n');
+} else {
+  console.log('\nflutter-skill installed successfully!');
+  console.log('\nMCP Config:');
+  console.log(JSON.stringify({
+    "flutter-skill": {
+      "command": "npx",
+      "args": ["flutter-skill"]
+    }
+  }, null, 2));
+  console.log('\n');
+}

package/scripts/postinstall.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const packageJson = require('../package.json');
+const VERSION = packageJson.version;
+
+const cacheDir = path.join(os.homedir(), '.flutter-skill');
+const binDir = path.join(cacheDir, 'bin');
+
+function getBinaryName() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  if (platform === 'darwin') {
+    return arch === 'arm64' ? 'flutter-skill-macos-arm64' : 'flutter-skill-macos-x64';
+  } else if (platform === 'linux') {
+    return 'flutter-skill-linux-x64';
+  } else if (platform === 'win32') {
+    return 'flutter-skill-windows-x64.exe';
+  }
+  return null;
+}
+
+function downloadBinary(url, destPath) {
+  return new Promise((resolve, reject) => {
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+    const file = fs.createWriteStream(destPath);
+
+    const request = (url) => {
+      https.get(url, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          request(response.headers.location);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`HTTP ${response.statusCode}`));
+          return;
+        }
+
+        const totalBytes = parseInt(response.headers['content-length'], 10);
+        let downloadedBytes = 0;
+
+        response.on('data', (chunk) => {
+          downloadedBytes += chunk.length;
+          if (totalBytes) {
+            const percent = Math.round((downloadedBytes / totalBytes) * 100);
+            process.stdout.write(`\r[flutter-skill] Downloading native binary... ${percent}%`);
+          }
+        });
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          fs.chmodSync(destPath, 0o755);
+          console.log('\n[flutter-skill] Native binary installed successfully!');
+          resolve(destPath);
+        });
+      }).on('error', reject);
+    };
+
+    request(url);
+  });
+}
+
+async function main() {
+  const binaryName = getBinaryName();
+  if (!binaryName) {
+    console.log('[flutter-skill] No native binary available for this platform, using Dart runtime');
+    return;
+  }
+
+  const localPath = path.join(binDir, `${binaryName}-v${VERSION}`);
+
+  if (fs.existsSync(localPath)) {
+    console.log('[flutter-skill] Native binary already installed');
+    return;
+  }
+
+  const downloadUrl = `https://github.com/ai-dashboad/flutter-skill/releases/download/v${VERSION}/${binaryName}`;
+
+  console.log(`[flutter-skill] Installing native binary for faster startup...`);
+
+  try {
+    await downloadBinary(downloadUrl, localPath);
+  } catch (error) {
+    console.log(`[flutter-skill] Could not download native binary (${error.message}), will use Dart runtime`);
+    console.log('[flutter-skill] This is normal for new releases, Dart fallback works fine');
+  }
+}
+
+// Install tool priority rules for Claude Code
+function installToolPriorityRules() {
+  const homeDir = os.homedir();
+  const promptsDir = path.join(homeDir, '.claude', 'prompts');
+  const targetFile = path.join(promptsDir, 'flutter-tool-priority.md');
+
+  if (fs.existsSync(targetFile)) {
+    return Promise.resolve(); // Already installed
+  }
+
+  // Download from GitHub
+  const url = 'https://raw.githubusercontent.com/ai-dashboad/flutter-skill/main/docs/prompts/tool-priority.md';
+
+  return new Promise((resolve) => {
+    fs.mkdirSync(promptsDir, { recursive: true });
+    const file = fs.createWriteStream(targetFile);
+
+    const request = (reqUrl) => {
+      https.get(reqUrl, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          request(response.headers.location);
+          return;
+        }
+        if (response.statusCode !== 200) {
+          resolve(); // Silent fail
+          return;
+        }
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          console.log('[flutter-skill] Tool priority rules installed for Claude Code');
+          resolve();
+        });
+      }).on('error', () => resolve());
+    };
+
+    request(url);
+  });
+}
+
+main()
+  .then(() => installToolPriorityRules())
+  .catch(() => {
+    // Silent fail - Dart fallback will work
+    installToolPriorityRules().catch(() => {});
+  });