neoagent 2.4.1-beta.11 → 2.4.1-beta.12

package/flutter_app/lib/main_devices.dart

@@ -706,8 +706,8 @@ class _DevicesPanelState extends State<DevicesPanel> {
                         onAction: _runQuickAction,
                       ),
                       if (kIsWeb) ...<Widget>[
-                        const SizedBox(height: 14),
-                        AndroidApkDropZone(
+                        const SizedBox(height: 12),
+                        _AndroidActionsBox(
                           enabled: _androidOnline,
                           busy: _isCurrentSurfaceBusy,
                           onInstall: ({required filename, required bytes}) {
@@ -1264,6 +1264,77 @@ class _AndroidNavDock extends StatelessWidget {
   }
 }
 
+/// Tiny pill shown in the top-right corner of the preview to indicate no audio.
+class _MutedBadge extends StatelessWidget {
+  const _MutedBadge();
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 5, vertical: 4),
+      decoration: BoxDecoration(
+        color: Colors.black54,
+        borderRadius: BorderRadius.circular(8),
+      ),
+      child: const Icon(Icons.volume_off_rounded, size: 11, color: Colors.white),
+    );
+  }
+}
+
+/// Compact expandable actions box shown beneath the Android nav dock.
+/// Starts with APK install; more actions can be added as tiles.
+class _AndroidActionsBox extends StatelessWidget {
+  const _AndroidActionsBox({
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final AndroidApkInstallCallback onInstall;
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
+      decoration: BoxDecoration(
+        color: _bgSecondary,
+        borderRadius: BorderRadius.circular(18),
+        border: Border.all(color: _borderLight),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+          Text(
+            'ACTIONS',
+            style: TextStyle(
+              fontSize: 10,
+              fontWeight: FontWeight.w700,
+              letterSpacing: 0.8,
+              color: _textSecondary,
+            ),
+          ),
+          const SizedBox(height: 8),
+          Wrap(
+            spacing: 8,
+            runSpacing: 8,
+            children: <Widget>[
+              AndroidApkTile(
+                enabled: enabled,
+                busy: busy,
+                onInstall: onInstall,
+              ),
+            ],
+          ),
+        ],
+      ),
+    );
+  }
+}
+
 class _SurfaceSwitcher extends StatelessWidget {
   const _SurfaceSwitcher({required this.surface, required this.onSelect});
 
@@ -1636,6 +1707,14 @@ class _InteractiveSurfacePreviewState
                                 ? null
                                 : (x, y) => widget.onHover?.call(Offset(x, y)),
                           ),
+                          const Positioned(
+                            top: 8,
+                            right: 8,
+                            child: Opacity(
+                              opacity: 0.45,
+                              child: _MutedBadge(),
+                            ),
+                          ),
                           Positioned(
                             left: 12,
                             right: 12,
@@ -1743,6 +1822,14 @@ class _InteractiveSurfacePreviewState
                               fit: BoxFit.contain,
                               gaplessPlayback: true,
                             ),
+                            const Positioned(
+                              top: 8,
+                              right: 8,
+                              child: Opacity(
+                                opacity: 0.45,
+                                child: _MutedBadge(),
+                              ),
+                            ),
                             Positioned(
                               left: 12,
                               right: 12,

package/flutter_app/lib/src/android_apk_drop_zone.dart

@@ -30,3 +30,27 @@ class AndroidApkDropZone extends StatelessWidget {
     );
   }
 }
+
+/// Compact tile variant — fits inside an actions row.
+class AndroidApkTile extends StatelessWidget {
+  const AndroidApkTile({
+    super.key,
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final AndroidApkInstallCallback onInstall;
+
+  @override
+  Widget build(BuildContext context) {
+    return buildAndroidApkTile(
+      context,
+      enabled: enabled,
+      busy: busy,
+      onInstall: onInstall,
+    );
+  }
+}

package/flutter_app/lib/src/android_apk_drop_zone_stub.dart

@@ -14,3 +14,16 @@ Widget buildAndroidApkDropZone(
 }) {
   return const SizedBox.shrink();
 }
+
+Widget buildAndroidApkTile(
+  BuildContext context, {
+  required bool enabled,
+  required bool busy,
+  required Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall,
+}) {
+  return const SizedBox.shrink();
+}

package/flutter_app/lib/src/android_apk_drop_zone_web.dart

@@ -346,3 +346,220 @@ bool _isSupportedInstallFile(String filename) {
   final normalized = filename.toLowerCase();
   return _supportedAndroidInstallExtensions.any(normalized.endsWith);
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Compact tile variant — used inside the Android actions box.
+// Same file-picker / drag-and-drop logic but rendered as a small square tile
+// that fits neatly alongside other action tiles.
+// ─────────────────────────────────────────────────────────────────────────────
+
+int _androidApkTileViewId = 0;
+
+Widget buildAndroidApkTile(
+  BuildContext context, {
+  required bool enabled,
+  required bool busy,
+  required Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall,
+}) {
+  return _AndroidApkTileWeb(enabled: enabled, busy: busy, onInstall: onInstall);
+}
+
+class _AndroidApkTileWeb extends StatefulWidget {
+  const _AndroidApkTileWeb({
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final Future<void> Function({required String filename, required Uint8List bytes}) onInstall;
+
+  @override
+  State<_AndroidApkTileWeb> createState() => _AndroidApkTileWebState();
+}
+
+class _AndroidApkTileWebState extends State<_AndroidApkTileWeb> {
+  late final String _viewType;
+  late final html.DivElement _dropElement;
+  late final html.FileUploadInputElement _fileInput;
+  final List<StreamSubscription<dynamic>> _subs = [];
+  bool _dragActive = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _viewType = 'neoagent-android-apk-tile-${_androidApkTileViewId++}';
+    _dropElement = html.DivElement()
+      ..setAttribute('role', 'button')
+      ..setAttribute('aria-label', 'Install APK — click or drop a .apk file')
+      ..tabIndex = 0
+      ..style.width = '100%'
+      ..style.height = '100%'
+      ..style.display = 'block'
+      ..style.background = 'rgba(0,0,0,0.001)'
+      ..style.cursor = 'pointer';
+    _fileInput = html.FileUploadInputElement()
+      ..accept = '.apk,.apks'
+      ..multiple = false
+      ..style.display = 'none';
+    _dropElement.append(_fileInput);
+
+    _subs.addAll([
+      _dropElement.onClick.listen((_) => _openPicker()),
+      _dropElement.onKeyDown.listen((e) {
+        if (e.key == 'Enter' || e.key == ' ') {
+          e.preventDefault();
+          _openPicker();
+        }
+      }),
+      _dropElement.onDragEnter.listen((e) {
+        e.preventDefault();
+        if (!_dragActive && mounted) setState(() => _dragActive = true);
+      }),
+      _dropElement.onDragOver.listen((e) {
+        e.preventDefault();
+        e.dataTransfer.dropEffect = 'copy';
+        if (!_dragActive && mounted) setState(() => _dragActive = true);
+      }),
+      _dropElement.onDragLeave.listen((e) {
+        e.preventDefault();
+        if (_dragActive && mounted) setState(() => _dragActive = false);
+      }),
+      _dropElement.onDrop.listen((e) {
+        e.preventDefault();
+        if (_dragActive && mounted) setState(() => _dragActive = false);
+        final files = e.dataTransfer.files;
+        if (files != null && files.isNotEmpty) unawaited(_handleFile(files.first));
+      }),
+      _fileInput.onChange.listen((_) {
+        final files = _fileInput.files;
+        if (files != null && files.isNotEmpty) unawaited(_handleFile(files.first));
+      }),
+    ]);
+
+    ui_web.platformViewRegistry.registerViewFactory(_viewType, (int _) => _dropElement);
+  }
+
+  @override
+  void dispose() {
+    for (final s in _subs) s.cancel();
+    _dropElement.remove();
+    super.dispose();
+  }
+
+  void _openPicker() {
+    if (!widget.enabled || widget.busy) return;
+    _fileInput.value = '';
+    _fileInput.click();
+  }
+
+  Future<void> _handleFile(html.File file) async {
+    if (!widget.enabled || widget.busy) return;
+    if (!_isSupportedInstallFile(file.name)) {
+      _showError('Only .apk or .apks files can be installed.');
+      return;
+    }
+    try {
+      final bytes = await _readFileBytes(file);
+      if (mounted) await widget.onInstall(filename: file.name, bytes: bytes);
+    } catch (e) {
+      _showError(e.toString().replaceFirst('Exception: ', ''));
+    }
+  }
+
+  Future<Uint8List> _readFileBytes(html.File file) {
+    final completer = Completer<Uint8List>();
+    final reader = html.FileReader();
+    reader.onLoad.listen((_) {
+      final result = reader.result;
+      if (result is ByteBuffer) { completer.complete(Uint8List.view(result)); return; }
+      if (result is Uint8List) { completer.complete(result); return; }
+      if (!completer.isCompleted) completer.completeError(StateError('Could not read the APK.'));
+    });
+    reader.onError.listen((_) {
+      if (!completer.isCompleted) completer.completeError(reader.error ?? StateError('Read error'));
+    });
+    reader.readAsArrayBuffer(file);
+    return completer.future;
+  }
+
+  void _showError(String msg) {
+    if (!mounted) return;
+    ScaffoldMessenger.maybeOf(context)?.showSnackBar(SnackBar(content: Text(msg)));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final cs = Theme.of(context).colorScheme;
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+    final borderColor = _dragActive ? cs.primary : cs.outlineVariant;
+    final bgColor = _dragActive
+        ? cs.primary.withValues(alpha: isDark ? 0.16 : 0.10)
+        : widget.enabled
+            ? cs.surfaceContainerHighest.withValues(alpha: isDark ? 0.50 : 0.70)
+            : cs.surfaceContainerHighest.withValues(alpha: isDark ? 0.28 : 0.44);
+    final iconColor = _dragActive
+        ? cs.primary
+        : widget.enabled
+            ? cs.onSurface
+            : cs.onSurface.withValues(alpha: 0.38);
+    final labelColor = _dragActive ? cs.primary : cs.onSurfaceVariant;
+
+    return SizedBox(
+      width: 80,
+      height: 72,
+      child: Stack(
+        children: [
+          // Visual tile
+          Positioned.fill(
+            child: AnimatedContainer(
+              duration: const Duration(milliseconds: 150),
+              decoration: BoxDecoration(
+                color: bgColor,
+                borderRadius: BorderRadius.circular(12),
+                border: Border.all(color: borderColor),
+              ),
+              child: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  Icon(
+                    widget.busy
+                        ? Icons.hourglass_top_rounded
+                        : Icons.install_mobile_outlined,
+                    size: 20,
+                    color: iconColor,
+                  ),
+                  const SizedBox(height: 5),
+                  Text(
+                    widget.busy ? 'Installing…' : 'Install APK',
+                    style: TextStyle(
+                      fontSize: 10,
+                      height: 1.2,
+                      fontWeight: FontWeight.w600,
+                      color: labelColor,
+                    ),
+                    textAlign: TextAlign.center,
+                    maxLines: 2,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                ],
+              ),
+            ),
+          ),
+          // Transparent HTML element captures all drag / click events
+          Positioned.fill(
+            child: ClipRRect(
+              borderRadius: BorderRadius.circular(12),
+              child: HtmlElementView(viewType: _viewType),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

package/lib/manager.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { CLAUDE_CODE_SCOPES } = require('../server/services/ai/providers/claudeCode');
+const { GROK_OAUTH_SCOPES, GROK_OAUTH_CLIENT_ID } = require('../server/services/ai/providers/grokOauth');
 const {
   buildBundledWebClientIfPossible: buildWebClient,
   commandExists: sharedCommandExists,
@@ -945,10 +946,135 @@ async function cmdLoginClaudeCode() {
   cmdRestart();
 }
 
+async function cmdLoginGrokOAuth() {
+  heading('Grok (xAI OAuth) Login');
+
+  const http = require('http');
+  const { URL: NodeURL } = require('url');
+
+  const clientId = GROK_OAUTH_CLIENT_ID;
+  const SCOPES = GROK_OAUTH_SCOPES;
+  const redirectPort = 56121;
+  const redirectUri = `http://127.0.0.1:${redirectPort}/callback`;
+
+  const codeVerifier = crypto.randomBytes(48).toString('base64url');
+  const codeChallenge = crypto
+    .createHash('sha256')
+    .update(codeVerifier)
+    .digest('base64url');
+  const state = crypto.randomBytes(16).toString('hex');
+
+  const authUrl = new URL('https://auth.x.ai/oauth2/authorize');
+  authUrl.searchParams.set('response_type', 'code');
+  authUrl.searchParams.set('client_id', clientId);
+  authUrl.searchParams.set('redirect_uri', redirectUri);
+  authUrl.searchParams.set('scope', SCOPES);
+  authUrl.searchParams.set('code_challenge', codeChallenge);
+  authUrl.searchParams.set('code_challenge_method', 'S256');
+  authUrl.searchParams.set('state', state);
+
+  console.log(`\n  ${COLORS.cyan}Opening browser for Grok (xAI) authorization...${COLORS.reset}`);
+  console.log(`  ${COLORS.dim}If the browser doesn't open, visit:${COLORS.reset}`);
+  console.log(`  ${authUrl.toString()}\n`);
+
+  const openCmd = process.platform === 'darwin' ? 'open'
+    : process.platform === 'win32' ? 'start'
+    : 'xdg-open';
+  spawnSync(openCmd, [authUrl.toString()], { stdio: 'ignore' });
+
+  const authCode = await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error('Grok OAuth authorization timed out after 5 minutes.'));
+    }, 5 * 60 * 1000);
+
+    const server = http.createServer((req, res) => {
+      try {
+        const reqUrl = new NodeURL(req.url, redirectUri);
+        const code = reqUrl.searchParams.get('code');
+        const returnedState = reqUrl.searchParams.get('state');
+        const error = reqUrl.searchParams.get('error');
+
+        if (error) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Authorization failed.</h2><p>You can close this tab.</p></body></html>');
+          clearTimeout(timeout);
+          server.close();
+          reject(new Error(`OAuth error: ${error}`));
+          return;
+        }
+
+        if (returnedState && returnedState !== state) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Authorization failed.</h2><p>State mismatch. You can close this tab.</p></body></html>');
+          clearTimeout(timeout);
+          server.close();
+          reject(new Error('OAuth state mismatch — possible CSRF attempt.'));
+          return;
+        }
+
+        if (code) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h2>Authorization successful!</h2><p>You can close this tab and return to the terminal.</p></body></html>');
+          clearTimeout(timeout);
+          server.close();
+          resolve(code);
+        }
+      } catch (err) {
+        res.writeHead(500);
+        res.end('Internal error');
+      }
+    });
+
+    server.listen(redirectPort, '127.0.0.1', () => {
+      logInfo(`Waiting for OAuth callback on ${redirectUri} ...`);
+    });
+    server.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Could not start OAuth callback server on port ${redirectPort}: ${err.message}`));
+    });
+  });
+
+  logInfo('Exchanging authorization code for access token...');
+  const tokenRes = await fetch('https://auth.x.ai/oauth2/token', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Accept': 'application/json',
+    },
+    body: new URLSearchParams({
+      grant_type: 'authorization_code',
+      code: authCode,
+      redirect_uri: redirectUri,
+      client_id: clientId,
+      code_verifier: codeVerifier,
+    }),
+  });
+
+  if (!tokenRes.ok) {
+    const text = await tokenRes.text().catch(() => 'Unknown error');
+    throw new Error(`Token exchange failed: HTTP ${tokenRes.status} — ${text}`);
+  }
+
+  const tokenData = await tokenRes.json();
+  const accessToken = tokenData.access_token;
+  if (!accessToken) {
+    throw new Error('Token exchange succeeded but no access_token was returned.');
+  }
+
+  upsertEnvValue('GROK_OAUTH_ACCESS_TOKEN', accessToken);
+  if (tokenData.refresh_token) {
+    upsertEnvValue('GROK_OAUTH_REFRESH_TOKEN', tokenData.refresh_token);
+  }
+  logOk('Saved Grok OAuth tokens to .env');
+  logInfo('Restarting NeoAgent to apply credentials...');
+  cmdRestart();
+}
+
 async function cmdLogin(args = []) {
   const provider = args[0];
-  if (provider !== 'github-copilot' && provider !== 'openai-codex' && provider !== 'claude-code') {
-    throw new Error(`Unsupported login provider: ${provider || 'none'}. Available: github-copilot, openai-codex, claude-code`);
+  if (provider !== 'github-copilot' && provider !== 'openai-codex' && provider !== 'claude-code' && provider !== 'grok-oauth') {
+    throw new Error(`Unsupported login provider: ${provider || 'none'}. Available: github-copilot, openai-codex, claude-code, grok-oauth`);
   }
 
   if (provider === 'github-copilot') {
@@ -1054,6 +1180,8 @@ async function cmdLogin(args = []) {
     cmdRestart();
   } else if (provider === 'claude-code') {
     await cmdLoginClaudeCode();
+  } else if (provider === 'grok-oauth') {
+    await cmdLoginGrokOAuth();
   }
 }
 
@@ -1633,6 +1761,7 @@ function printHelp() {
   row('login github-copilot','Authenticate GitHub Copilot');
   row('login openai-codex',  'Authenticate OpenAI Codex');
   row('login claude-code',   'Authenticate Claude Code');
+  row('login grok-oauth',    'Authenticate Grok (xAI OAuth)');
   console.log('');
 
   console.log(`${c.bold}Maintenance${c.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.4.1-beta.11",
+  "version": "2.4.1-beta.12",
   "description": "Proactive personal AI agent with no limits",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-178383462d4c7125ce032b3783b45564
+2d79bb1c88e94d9acee7e3021ec0b119

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"4c525dac5ebe5971c5708ef73558ed8edcf4a3
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "559469558" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "4015974692" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });