flutterbridge 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Flutter Bridge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,510 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, cpSync, rmSync } from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+const program = new Command();
+// Configuração da CLI
+program
+    .name('flutterbridge')
+    .description('CLI para transformar SPAs em apps mobile usando Flutter')
+    .version('1.0.0');
+// Comando: init
+program
+    .command('init')
+    .description('Inicializa um novo projeto FlutterBridge')
+    .argument('[project-name]', 'Nome do projeto')
+    .action(async (projectName) => {
+    try {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Nome do projeto:',
+                default: projectName || 'my-app',
+                validate: (input) => input.length > 0 || 'Nome é obrigatório'
+            },
+            {
+                type: 'input',
+                name: 'appId',
+                message: 'App ID (ex: com.example.app):',
+                default: 'com.example.app',
+                validate: (input) => /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/.test(input) || 'App ID inválido'
+            },
+            {
+                type: 'input',
+                name: 'appName',
+                message: 'Nome do app (exibido no dispositivo):',
+                default: (answers) => answers.name
+            },
+            {
+                type: 'list',
+                name: 'webDir',
+                message: 'Diretório de build do seu projeto web:',
+                choices: ['dist', 'build', 'public', 'www', 'outro'],
+            },
+            {
+                type: 'input',
+                name: 'customWebDir',
+                message: 'Digite o diretório customizado:',
+                when: (answers) => answers.webDir === 'outro'
+            }
+        ]);
+        const webDir = answers.customWebDir || answers.webDir;
+        await initProject(answers.name, answers.appId, answers.appName, webDir);
+    }
+    catch (error) {
+        console.error(chalk.red('Erro ao inicializar projeto:'), error);
+    }
+});
+// Comando: add
+program
+    .command('add')
+    .description('Adiciona uma plataforma (android/ios)')
+    .argument('<platform>', 'Plataforma: android ou ios')
+    .action(async (platform) => {
+    await addPlatform(platform);
+});
+// Comando: sync
+program
+    .command('sync')
+    .description('Sincroniza o projeto web com o Flutter')
+    .action(async () => {
+    await syncProject();
+});
+// Comando: run
+program
+    .command('run')
+    .description('Executa o app em um dispositivo/emulador')
+    .argument('<platform>', 'Plataforma: android ou ios')
+    .option('-d, --device <device>', 'ID do dispositivo específico')
+    .action(async (platform, options) => {
+    await runApp(platform, options.device);
+});
+// Comando: build
+program
+    .command('build')
+    .description('Faz build do app')
+    .argument('<platform>', 'Plataforma: android ou ios')
+    .option('--release', 'Build de produção')
+    .action(async (platform, options) => {
+    await buildApp(platform, options.release);
+});
+// Comando: plugin
+program
+    .command('plugin')
+    .description('Gerencia plugins nativos')
+    .argument('<action>', 'add ou list')
+    .argument('[plugin]', 'Nome do plugin (para add)')
+    .action(async (action, plugin) => {
+    if (action === 'add' && plugin) {
+        await addPlugin(plugin);
+    }
+    else if (action === 'list') {
+        await listPlugins();
+    }
+});
+// Funções auxiliares
+async function initProject(name, appId, appName, webDir) {
+    const spinner = ora('Criando projeto FlutterBridge...').start();
+    try {
+        // Verifica se Flutter está instalado
+        try {
+            execSync('flutter --version', { stdio: 'ignore' });
+        }
+        catch {
+            spinner.fail('Flutter não encontrado. Instale o Flutter primeiro.');
+            return;
+        }
+        const projectPath = path.join(process.cwd(), name);
+        // Cria estrutura de diretórios
+        mkdirSync(projectPath, { recursive: true });
+        mkdirSync(path.join(projectPath, 'flutter_app'), { recursive: true });
+        // Cria flutterbridge.config.json
+        const config = {
+            appId,
+            appName,
+            webDir,
+            flutter: {
+                version: '3.0.0',
+                projectPath: 'flutter_app'
+            },
+            plugins: []
+        };
+        writeFileSync(path.join(projectPath, 'flutterbridge.config.json'), JSON.stringify(config, null, 2));
+        // Cria projeto Flutter
+        spinner.text = 'Criando projeto Flutter...';
+        execSync(`flutter create --org ${appId.split('.').slice(0, -1).join('.')} --project-name ${name.replace(/-/g, '_')} flutter_app`, {
+            cwd: projectPath,
+            stdio: 'pipe'
+        });
+        // Atualiza pubspec.yaml
+        const pubspecPath = path.join(projectPath, 'flutter_app', 'pubspec.yaml');
+        let pubspec = readFileSync(pubspecPath, 'utf-8');
+        // Adiciona dependências
+        // Encontra onde está "dependencies:" e adiciona depois
+        pubspec = pubspec.replace('dependencies:', `dependencies:
+  webview_flutter: ^4.4.2
+  path_provider: ^2.1.1
+  flutter_inappwebview: ^6.0.0`);
+        writeFileSync(pubspecPath, pubspec);
+        // Cria main.dart customizado
+        const mainDart = generateMainDart(appName);
+        writeFileSync(path.join(projectPath, 'flutter_app', 'lib', 'main.dart'), mainDart);
+        // Cria diretório para assets web
+        mkdirSync(path.join(projectPath, 'flutter_app', 'assets', 'web'), { recursive: true });
+        // Atualiza pubspec.yaml para incluir assets
+        pubspec += `
+  assets:
+    - assets/web/
+`;
+        writeFileSync(pubspecPath, pubspec);
+        // Cria README
+        const readme = generateReadme(name, webDir);
+        writeFileSync(path.join(projectPath, 'README.md'), readme);
+        spinner.succeed(chalk.green(`Projeto ${name} criado com sucesso!`));
+        console.log(chalk.cyan('\nPróximos passos:'));
+        console.log(chalk.white(`  cd ${name}`));
+        console.log(chalk.white(`  # Faça o build do seu projeto web para ./${webDir}`));
+        console.log(chalk.white(`  flutterbridge sync`));
+        console.log(chalk.white(`  flutterbridge run android`));
+    }
+    catch (error) {
+        spinner.fail('Erro ao criar projeto');
+        throw error;
+    }
+}
+async function addPlatform(platform) {
+    if (!['android', 'ios'].includes(platform)) {
+        console.error(chalk.red('Plataforma deve ser android ou ios'));
+        return;
+    }
+    const spinner = ora(`Adicionando plataforma ${platform}...`).start();
+    try {
+        const config = await loadConfig();
+        const flutterPath = path.join(process.cwd(), config.flutter.projectPath);
+        // Flutter já cria android e ios por padrão, mas podemos recriar se necessário
+        console.log(chalk.green(`Plataforma ${platform} já está disponível no projeto Flutter`));
+        spinner.succeed();
+    }
+    catch (error) {
+        spinner.fail('Erro ao adicionar plataforma');
+        throw error;
+    }
+}
+async function syncProject() {
+    const spinner = ora('Sincronizando projeto...').start();
+    try {
+        const config = await loadConfig();
+        const webDirPath = path.join(process.cwd(), config.webDir);
+        const assetsPath = path.join(process.cwd(), config.flutter.projectPath, 'assets', 'web');
+        // Verifica se diretório web existe
+        if (!existsSync(webDirPath)) {
+            spinner.fail(`Diretório ${config.webDir} não encontrado. Execute o build do seu projeto web primeiro.`);
+            return;
+        }
+        // Copia arquivos web para assets do Flutter
+        // limpa e copia (síncrono)
+        rmSync(assetsPath, { recursive: true, force: true });
+        mkdirSync(assetsPath, { recursive: true });
+        cpSync(webDirPath, assetsPath, { recursive: true });
+        // Executa flutter pub get
+        spinner.text = 'Instalando dependências Flutter...';
+        execSync('flutter pub get', {
+            cwd: path.join(process.cwd(), config.flutter.projectPath),
+            stdio: 'pipe'
+        });
+        spinner.succeed(chalk.green('Projeto sincronizado com sucesso!'));
+    }
+    catch (error) {
+        spinner.fail('Erro ao sincronizar projeto');
+        throw error;
+    }
+}
+async function runApp(platform, device) {
+    const spinner = ora(`Executando app em ${platform}...`).start();
+    try {
+        await syncProject();
+        const config = await loadConfig();
+        const flutterPath = path.join(process.cwd(), config.flutter.projectPath);
+        const deviceFlag = device ? `-d ${device}` : '';
+        const cmd = `flutter run ${deviceFlag}`;
+        spinner.stop();
+        console.log(chalk.cyan(`Executando: ${cmd}`));
+        execSync(cmd, {
+            cwd: flutterPath,
+            stdio: 'inherit'
+        });
+    }
+    catch (error) {
+        spinner.fail('Erro ao executar app');
+        throw error;
+    }
+}
+async function buildApp(platform, release = false) {
+    const spinner = ora(`Fazendo build para ${platform}...`).start();
+    try {
+        await syncProject();
+        const config = await loadConfig();
+        const flutterPath = path.join(process.cwd(), config.flutter.projectPath);
+        const buildMode = release ? '--release' : '--debug';
+        const cmd = `flutter build ${platform === 'ios' ? 'ios' : 'apk'} ${buildMode}`;
+        spinner.text = `Executando: ${cmd}`;
+        execSync(cmd, {
+            cwd: flutterPath,
+            stdio: 'inherit'
+        });
+        spinner.succeed(chalk.green(`Build concluído!`));
+        if (platform === 'android') {
+            const apkPath = path.join(flutterPath, 'build', 'app', 'outputs', 'flutter-apk', release ? 'app-release.apk' : 'app-debug.apk');
+            console.log(chalk.cyan(`APK disponível em: ${apkPath}`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Erro ao fazer build');
+        throw error;
+    }
+}
+async function addPlugin(plugin) {
+    const spinner = ora(`Adicionando plugin ${plugin}...`).start();
+    try {
+        const config = await loadConfig();
+        const flutterPath = path.join(process.cwd(), config.flutter.projectPath);
+        execSync(`flutter pub add ${plugin}`, {
+            cwd: flutterPath,
+            stdio: 'pipe'
+        });
+        // Atualiza config
+        config.plugins.push(plugin);
+        writeFileSync(path.join(process.cwd(), 'flutterbridge.config.json'), JSON.stringify(config, null, 2));
+        spinner.succeed(chalk.green(`Plugin ${plugin} adicionado!`));
+    }
+    catch (error) {
+        spinner.fail('Erro ao adicionar plugin');
+        throw error;
+    }
+}
+async function listPlugins() {
+    try {
+        const config = await loadConfig();
+        if (config.plugins.length === 0) {
+            console.log(chalk.yellow('Nenhum plugin instalado'));
+            return;
+        }
+        console.log(chalk.cyan('Plugins instalados:'));
+        config.plugins.forEach((plugin) => {
+            console.log(chalk.white(`  - ${plugin}`));
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Erro ao listar plugins'));
+    }
+}
+async function loadConfig() {
+    const configPath = path.join(process.cwd(), 'flutterbridge.config.json');
+    if (!existsSync(configPath)) {
+        throw new Error('Arquivo flutterbridge.config.json não encontrado. Execute "flutterbridge init" primeiro.');
+    }
+    return JSON.parse(readFileSync(configPath, 'utf-8'));
+}
+function generateMainDart(appName) {
+    return `import 'package:flutter/material.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_inappwebview/flutter_inappwebview.dart';
+
+void main() {
+  runApp(MyApp());
+}
+
+class MyApp extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: '${appName}',
+      theme: ThemeData(primarySwatch: Colors.blue),
+      home: WebViewPage(),
+    );
+  }
+}
+
+class WebViewPage extends StatefulWidget {
+  @override
+  _WebViewPageState createState() => _WebViewPageState();
+}
+
+class _WebViewPageState extends State<WebViewPage> {
+  InAppWebViewController? webViewController;
+  double progress = 0;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: SafeArea(
+        child: Column(
+          children: [
+            progress < 1.0
+                ? LinearProgressIndicator(value: progress)
+                : Container(),
+            Expanded(
+              child: InAppWebView(
+                initialSettings: InAppWebViewSettings(
+                  javaScriptEnabled: true,
+                  allowFileAccessFromFileURLs: true,
+                  allowUniversalAccessFromFileURLs: true,
+                  mediaPlaybackRequiresUserGesture: false,
+                  useOnLoadResource: true,
+                ),
+                initialFile: 'assets/web/index.html',
+                onWebViewCreated: (controller) {
+                  webViewController = controller;
+                  
+                  if (!kIsWeb) {
+                    controller.addJavaScriptHandler(
+                      handlerName: 'FlutterBridge',
+                      callback: (args) {
+                        print('Mensagem do JS: \$args');
+                        return {'response': 'Recebido pelo Flutter', 'data': args};
+                      },
+                    );
+                  }
+                },
+                onProgressChanged: (controller, progress) {
+                  setState(() {
+                    this.progress = progress / 100;
+                  });
+                },
+                onLoadStop: (controller, url) {
+                  setState(() {
+                    progress = 1.0;
+                  });
+                },
+                onLoadResource: (controller, resource) {
+                  print('Carregando: \${resource.url}');
+                },
+                onLoadResourceWithCustomScheme: (controller, request) async {
+                  // Intercepta requests personalizados
+                  var url = request.url.toString();
+                  print('Custom scheme: \$url');
+                  
+                  return null;
+                },
+                shouldOverrideUrlLoading: (controller, navigationAction) async {
+                  var uri = navigationAction.request.url!;
+                  var url = uri.toString();
+                  
+                  print('Navegando para: \$url');
+                  
+                  // Se for navegação interna (mesma origem), permite
+                  if (url.startsWith('file://') || 
+                      url.startsWith('about:') ||
+                      url.contains('assets/web/')) {
+                    return NavigationActionPolicy.ALLOW;
+                  }
+                  
+                  // Se for link externo (http/https), abre no navegador
+                  if (url.startsWith('http://') || url.startsWith('https://')) {
+                    // Aqui você pode usar url_launcher se quiser abrir no browser
+                    print('Link externo detectado: \$url');
+                    return NavigationActionPolicy.ALLOW;
+                  }
+                  
+                  return NavigationActionPolicy.ALLOW;
+                },
+                onConsoleMessage: (controller, consoleMessage) {
+                  print('Console [\${consoleMessage.messageLevel}]: \${consoleMessage.message}');
+                },
+                onLoadError: (controller, url, code, message) {
+                  print('Erro ao carregar \$url: \$message (código: \$code)');
+                },
+                onLoadHttpError: (controller, url, statusCode, description) {
+                  print('Erro HTTP ao carregar \$url: \$statusCode - \$description');
+                },
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+`;
+}
+function generateReadme(name, webDir) {
+    return `# ${name}
+
+Projeto criado com FlutterBridge CLI
+
+## Estrutura do Projeto
+
+\`\`\`
+${name}/
+├── flutterbridge.config.json    # Configuração do FlutterBridge
+├── flutter_app/                 # Projeto Flutter
+│   ├── lib/
+│   │   └── main.dart           # App Flutter principal
+│   ├── assets/
+│   │   └── web/                # Arquivos web copiados aqui
+│   └── pubspec.yaml
+└── ${webDir}/                   # Build do seu projeto web (React/Vue/Angular)
+\`\`\`
+
+## Comandos Disponíveis
+
+### Sincronizar projeto web com Flutter
+\`\`\`bash
+flutterbridge sync
+\`\`\`
+
+### Executar em emulador/dispositivo
+\`\`\`bash
+flutterbridge run android
+flutterbridge run ios
+\`\`\`
+
+### Build de produção
+\`\`\`bash
+flutterbridge build android --release
+flutterbridge build ios --release
+\`\`\`
+
+### Adicionar plugins Flutter
+\`\`\`bash
+flutterbridge plugin add camera
+flutterbridge plugin add geolocator
+flutterbridge plugin list
+\`\`\`
+
+## Comunicação JavaScript <-> Flutter
+
+No seu código JavaScript, você pode se comunicar com o Flutter:
+
+\`\`\`javascript
+// Enviar mensagem para Flutter
+window.flutter_inappwebview.callHandler('FlutterBridge', { 
+  action: 'getData' 
+}).then(function(result) {
+  console.log('Resposta do Flutter:', result);
+});
+\`\`\`
+
+## Workflow de Desenvolvimento
+
+1. Desenvolva seu app web normalmente (React/Vue/Angular)
+2. Faça o build: \`npm run build\`
+3. Sincronize: \`flutterbridge sync\`
+4. Execute: \`flutterbridge run android\`
+
+## Requisitos
+
+- Flutter SDK instalado
+- Node.js 16+
+- Android Studio (para Android)
+- Xcode (para iOS, apenas macOS)
+`;
+}
+// Executa o programa
+program.parse();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "flutterbridge",
+  "version": "1.0.1",
+  "description": "CLI para fazer apps Android via WebView do Flutter",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "flutter",
+    "cli",
+    "mobile",
+    "capacitor",
+    "webview"
+  ],
+  "bin": {
+    "flutterbridge": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/index.ts",
+    "test": "node dist/index.js --help"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "fs-extra": "^10.1.0",
+    "inquirer": "^9.2.12",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}