tauri-plugin-debug-tools 0.1.0

package/skills/debug-tauri/scripts/analyze_logs.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# Analyze Tauri console logs for errors and patterns
+# Usage: ./analyze_logs.sh [log-file] [bundle-id]
+#
+# Examples:
+#   ./analyze_logs.sh                              # Auto-detect from TAURI_BUNDLE_ID
+#   ./analyze_logs.sh /path/to/debug.log           # Custom path
+#   ./analyze_logs.sh "" com.example.myapp         # Specify bundle ID
+
+# Auto-detect log file path based on platform and bundle ID
+detect_log_path() {
+  local bundle_id="${1:-${TAURI_BUNDLE_ID}}"
+
+  if [ -z "$bundle_id" ]; then
+    echo "⚠️  Bundle ID not provided. Set TAURI_BUNDLE_ID or pass as argument."
+    return 1
+  fi
+
+  case "$(uname -s)" in
+    Darwin)  # macOS
+      echo "$HOME/Library/Logs/$bundle_id/debug.log"
+      ;;
+    Linux)
+      echo "$HOME/.local/share/$bundle_id/logs/debug.log"
+      ;;
+    MINGW*|MSYS*|CYGWIN*)  # Windows
+      echo "$LOCALAPPDATA/$bundle_id/logs/debug.log"
+      ;;
+    *)
+      echo "⚠️  Unsupported platform: $(uname -s)"
+      return 1
+      ;;
+  esac
+}
+
+# Determine log file
+if [ -n "$1" ]; then
+  LOG_FILE="$1"
+else
+  LOG_FILE=$(detect_log_path "${2}")
+  if [ $? -ne 0 ] || [ -z "$LOG_FILE" ]; then
+    echo "❌ Could not determine log file path"
+    echo "💡 Usage: $0 [log-file] [bundle-id]"
+    echo "   Example: $0 \"\" com.example.myapp"
+    echo "   Or set: export TAURI_BUNDLE_ID=com.example.myapp"
+    exit 1
+  fi
+fi
+
+if [ ! -f "$LOG_FILE" ]; then
+  echo "❌ Log file not found: $LOG_FILE"
+  echo "💡 Ensure tauri-plugin-log is initialized and app has been run"
+  echo "💡 Expected locations:"
+  echo "   macOS:   ~/Library/Logs/{bundle_id}/debug.log"
+  echo "   Linux:   ~/.local/share/{bundle_id}/logs/debug.log"
+  echo "   Windows: %LOCALAPPDATA%\\{bundle_id}\\logs\\debug.log"
+  exit 1
+fi
+
+echo "🔍 Analyzing logs from: $LOG_FILE"
+echo "=========================================="
+echo ""
+
+# Count log levels (tauri-plugin-log format: YYYY-MM-DDTHH:MM:SS.sssZ LEVEL app: message)
+echo "📊 Log Statistics:"
+total_lines=$(wc -l < "$LOG_FILE" | tr -d ' ')
+error_count=$(grep -c " ERROR " "$LOG_FILE" 2>/dev/null || echo "0")
+warn_count=$(grep -c " WARN " "$LOG_FILE" 2>/dev/null || echo "0")
+info_count=$(grep -c " INFO " "$LOG_FILE" 2>/dev/null || echo "0")
+debug_count=$(grep -c " DEBUG " "$LOG_FILE" 2>/dev/null || echo "0")
+trace_count=$(grep -c " TRACE " "$LOG_FILE" 2>/dev/null || echo "0")
+
+echo "  Total lines: $total_lines"
+echo "  ERROR: $error_count"
+echo "  WARN:  $warn_count"
+echo "  INFO:  $info_count"
+echo "  DEBUG: $debug_count"
+echo "  TRACE: $trace_count"
+
+echo ""
+echo "❌ Recent Errors (last 5):"
+if [ "$error_count" -eq 0 ]; then
+  echo "  ✅ No errors found"
+else
+  grep " ERROR " "$LOG_FILE" | tail -5
+fi
+
+echo ""
+echo "⚠️  Recent Warnings (last 5):"
+if [ "$warn_count" -eq 0 ]; then
+  echo "  ✅ No warnings found"
+else
+  grep " WARN " "$LOG_FILE" | tail -5
+fi
+
+echo ""
+echo "📈 Pattern Analysis:"
+
+# Common error patterns
+echo "  Searching for common issues..."
+
+# Network errors
+net_errors=$(grep -i "network\|fetch\|xhr\|cors" "$LOG_FILE" 2>/dev/null | wc -l | tr -d ' ')
+if [ "$net_errors" -gt 0 ]; then
+  echo "    🌐 Network-related issues: $net_errors"
+fi
+
+# Type errors
+type_errors=$(grep -i "typeerror\|undefined\|null" "$LOG_FILE" 2>/dev/null | wc -l | tr -d ' ')
+if [ "$type_errors" -gt 0 ]; then
+  echo "    🔤 Type/undefined errors: $type_errors"
+fi
+
+# WebGPU errors
+gpu_errors=$(grep -i "webgpu\|gpu\|shader" "$LOG_FILE" 2>/dev/null | wc -l | tr -d ' ')
+if [ "$gpu_errors" -gt 0 ]; then
+  echo "    🎮 WebGPU-related issues: $gpu_errors"
+fi
+
+echo ""
+echo "✅ Analysis complete"
+echo ""
+echo "💡 For full log review:"
+echo "   cat $LOG_FILE"
+echo ""
+echo "💡 Monitor logs in real-time:"
+echo "   tail -f $LOG_FILE"

package/skills/debug-tauri/scripts/capture.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+# Tauri app screenshot helper script (DEPRECATED)
+# Usage: ./capture.sh
+#
+# ⚠️  DEPRECATED: This script is legacy and macOS-only.
+#
+# 💡 Migrate to official plugin API:
+#    import { captureMainWindow } from "tauri-plugin-debug-tools/screenshotHelper";
+#    const screenshot = await captureMainWindow();
+#
+# Benefits of plugin API:
+#   - Cross-platform (macOS/Windows/Linux)
+#   - No screen recording permissions required
+#   - Programmatic access from TypeScript
+#   - Base64 PNG data returned directly
+
+APP_NAME="${TAURI_APP_NAME:-tauri-app}"
+OUTPUT_DIR="/tmp"
+
+# Show deprecation warning
+echo "⚠️  WARNING: This script is deprecated"
+echo "═══════════════════════════════════════"
+echo ""
+echo "This legacy script only works on macOS and requires Screen Recording permissions."
+echo ""
+echo "💡 Recommended: Use the official tauri-plugin-screenshots API instead:"
+echo ""
+echo "   import { captureMainWindow } from 'tauri-plugin-debug-tools/screenshotHelper';"
+echo "   const screenshot = await captureMainWindow();"
+echo ""
+echo "Benefits:"
+echo "  ✅ Cross-platform (macOS/Windows/Linux)"
+echo "  ✅ No special permissions required"
+echo "  ✅ Programmatic access from TypeScript"
+echo ""
+echo "Press Enter to continue with legacy script, or Ctrl+C to cancel..."
+read -r
+echo ""
+
+function check_app_running() {
+  if ! pgrep -x "$APP_NAME" > /dev/null; then
+    echo "❌ Error: $APP_NAME is not running"
+    echo "💡 Start the app with your dev command (e.g., tauri dev)"
+    exit 1
+  fi
+  echo "✅ $APP_NAME is running"
+}
+
+function capture_screenshot() {
+  local timestamp=$(date +%s)
+  local output_path="$OUTPUT_DIR/tauri_debug_$timestamp.png"
+
+  echo "📸 Capturing screenshot..."
+
+  if ! screencapture -x -T 0 "$output_path" 2>/dev/null; then
+    echo "❌ Failed to capture screenshot"
+    echo "💡 Check System Preferences > Security & Privacy > Screen Recording"
+    exit 1
+  fi
+
+  if [ ! -f "$output_path" ]; then
+    echo "❌ Screenshot file not created"
+    exit 1
+  fi
+
+  echo "✅ Screenshot saved: $output_path"
+  echo "$output_path"
+}
+
+function get_process_info() {
+  echo "🔍 Process information:"
+  ps aux | grep "$APP_NAME" | grep -v grep | head -1
+}
+
+function main() {
+  echo "🚀 Tauri Debug Helper"
+  echo "===================="
+  echo ""
+
+  check_app_running
+  echo ""
+
+  get_process_info
+  echo ""
+
+  capture_screenshot
+}
+
+main

package/skills/debug-tauri/scripts/validate_setup.sh

@@ -0,0 +1,181 @@
+#!/bin/bash
+# Validate debug tools setup with official plugins
+# Usage: ./validate_setup.sh [bundle-id]
+#
+# Examples:
+#   TAURI_BUNDLE_ID=com.example.myapp ./validate_setup.sh
+#   ./validate_setup.sh com.example.myapp
+
+APP_NAME="${TAURI_APP_NAME:-tauri-app}"
+BUNDLE_ID="${1:-${TAURI_BUNDLE_ID}}"
+
+# Detect log file path based on platform
+detect_log_path() {
+  local bundle_id="$1"
+
+  if [ -z "$bundle_id" ]; then
+    return 1
+  fi
+
+  case "$(uname -s)" in
+    Darwin)
+      echo "$HOME/Library/Logs/$bundle_id/debug.log"
+      ;;
+    Linux)
+      echo "$HOME/.local/share/$bundle_id/logs/debug.log"
+      ;;
+    MINGW*|MSYS*|CYGWIN*)
+      echo "$LOCALAPPDATA/$bundle_id/logs/debug.log"
+      ;;
+    *)
+      return 1
+      ;;
+  esac
+}
+
+echo "🔍 Validating debug setup..."
+echo "============================"
+echo ""
+
+# Check if app is running
+echo "📱 App Process:"
+if pgrep -x "$APP_NAME" > /dev/null; then
+  pid=$(pgrep -x "$APP_NAME")
+  echo "  ✅ App is running (PID: $pid)"
+
+  # Get process details
+  if command -v ps &> /dev/null; then
+    ps -p "$pid" -o pid,rss,%cpu,%mem,command 2>/dev/null | tail -1
+  fi
+else
+  echo "  ⚠️  App not running"
+  echo "  💡 Start with: tauri dev"
+fi
+
+echo ""
+
+# Check screen recording permission (macOS only)
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  echo "📸 Screen Recording Permission:"
+
+  test_file="/tmp/screen_test_$$.png"
+  if screencapture -x -T 0 "$test_file" 2>/dev/null; then
+    rm -f "$test_file"
+    echo "  ✅ Screen recording permission granted"
+  else
+    echo "  ❌ Screen recording permission denied"
+    echo "  💡 Grant in: System Preferences > Security & Privacy > Screen Recording"
+  fi
+
+  echo ""
+fi
+
+# Check for official plugin log file
+echo "📝 Official Plugin Logs (tauri-plugin-log):"
+if [ -n "$BUNDLE_ID" ]; then
+  PLUGIN_LOG=$(detect_log_path "$BUNDLE_ID")
+
+  if [ -n "$PLUGIN_LOG" ] && [ -f "$PLUGIN_LOG" ]; then
+    log_size=$(wc -l < "$PLUGIN_LOG" | tr -d ' ')
+    echo "  ✅ Plugin log file exists ($log_size lines)"
+    echo "     Location: $PLUGIN_LOG"
+
+    if [ "$log_size" -eq 0 ]; then
+      echo "  ⚠️  Log file is empty - logger may not be initialized"
+      echo "  💡 Call logger.initialize() in frontend"
+    fi
+  else
+    echo "  ⚠️  Plugin log file not found"
+    echo "  💡 Expected: $PLUGIN_LOG"
+    echo "  💡 Ensure tauri-plugin-log is initialized and app has been run"
+  fi
+else
+  echo "  ℹ️  Bundle ID not provided"
+  echo "  💡 Set TAURI_BUNDLE_ID or pass as argument to check plugin logs"
+  echo "  💡 Example: TAURI_BUNDLE_ID=com.example.myapp ./validate_setup.sh"
+fi
+
+# Check for legacy log file
+echo ""
+echo "📝 Legacy Logs (consoleLogger):"
+if [ -f "/tmp/tauri_console_logs.jsonl" ]; then
+  log_size=$(wc -l < /tmp/tauri_console_logs.jsonl | tr -d ' ')
+  echo "  ⚠️  Legacy log file exists ($log_size lines)"
+  echo "  💡 Migrate to tauri-plugin-log for better persistence"
+else
+  echo "  ✅ No legacy logs (good - using official plugin)"
+fi
+
+# Check for screenshots
+echo ""
+echo "📸 Screenshots:"
+screenshot_count=$(find /tmp -name "tauri_debug_*.png" -mtime -1 2>/dev/null | wc -l | tr -d ' ')
+if [ "$screenshot_count" -gt 0 ]; then
+  echo "  ℹ️  Found $screenshot_count legacy screenshot(s) in /tmp"
+  echo "     $(ls -t /tmp/tauri_debug_*.png 2>/dev/null | head -1)"
+  echo "  💡 Use captureMainWindow() from screenshotHelper for plugin API"
+else
+  echo "  ℹ️  No legacy screenshots found"
+fi
+
+echo ""
+
+# Check for required tools
+echo "🛠️  Tools:"
+
+check_tool() {
+  local tool=$1
+  local status=$2
+  local install_hint=$3
+
+  if command -v "$tool" &> /dev/null; then
+    echo "  ✅ $tool ($status)"
+  else
+    echo "  ⚠️  $tool not found ($status)"
+    if [ -n "$install_hint" ]; then
+      echo "     Install: $install_hint"
+    fi
+  fi
+}
+
+# Optional tools
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  check_tool "screencapture" "legacy, optional" ""
+fi
+
+echo ""
+
+# Check project structure (if run from project root)
+echo "📁 Project Structure:"
+
+if [ -f "tauri.conf.json" ] || [ -f "src-tauri/tauri.conf.json" ]; then
+  echo "  ✅ Tauri project detected"
+
+  # Check for debug capabilities
+  if [ -f "src-tauri/capabilities/default.json" ]; then
+    echo "  ✅ Capabilities file exists"
+
+    if grep -q "debug-tools" src-tauri/capabilities/default.json 2>/dev/null; then
+      echo "  ✅ Debug tools permissions found"
+    else
+      echo "  ⚠️  Debug tools permissions may not be configured"
+    fi
+  else
+    echo "  ℹ️  No capabilities file found"
+  fi
+else
+  echo "  ℹ️  Not in a Tauri project directory (or run from skill directory)"
+fi
+
+echo ""
+echo "=========================================="
+echo "✅ Validation complete"
+echo ""
+
+# Summary
+if pgrep -x "$APP_NAME" > /dev/null && [[ "$OSTYPE" == "darwin"* ]] && screencapture -x -T 0 /tmp/test_$$.png 2>/dev/null; then
+  rm -f /tmp/test_$$.png
+  echo "🎉 Ready to debug!"
+else
+  echo "⚠️  Some issues found. Review output above."
+fi

package/src/commands.rs

@@ -0,0 +1,147 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use tauri::{AppHandle, Emitter, Manager, Runtime};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WebViewState {
+    pub url: String,
+    pub title: String,
+    pub user_agent: String,
+    pub viewport: ViewportInfo,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ViewportInfo {
+    pub width: u32,
+    pub height: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ConsoleMessage {
+    pub level: String,
+    pub message: String,
+    pub timestamp: i64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ConsoleLogEntryPayload {
+    pub timestamp: i64,
+    pub level: String,
+    pub message: String,
+    pub args: serde_json::Value,
+    pub stack_trace: Option<String>,
+}
+
+fn console_log_path() -> PathBuf {
+    // Use platform temp directory to avoid hardcoded /tmp paths.
+    std::env::temp_dir().join("tauri_console_logs.jsonl")
+}
+
+/// Get WebView state.
+#[tauri::command]
+pub async fn capture_webview_state<R: Runtime>(app: AppHandle<R>) -> Result<WebViewState, String> {
+    let window = app
+        .get_webview_window("main")
+        .ok_or("Main window not found")?;
+
+    let url = window.url().map_err(|e| e.to_string())?;
+    let title = window.title().map_err(|e| e.to_string())?;
+
+    // Fetch viewport information.
+    let size = window
+        .inner_size()
+        .map_err(|e| format!("Failed to get window size: {}", e))?;
+
+    Ok(WebViewState {
+        url: url.to_string(),
+        title,
+        user_agent: "TauriWebView/2.0".to_string(), // TODO: Fetch the real User-Agent.
+        viewport: ViewportInfo {
+            width: size.width,
+            height: size.height,
+        },
+    })
+}
+
+/// Get console logs.
+/// NOTE: Prefer fetching logs directly on the frontend instead of buffering in Rust.
+/// Use debugBridge.getConsoleLogs() to inspect logs without Safari DevTools.
+#[tauri::command]
+pub async fn get_console_logs<R: Runtime>(
+    _app: AppHandle<R>,
+) -> Result<Vec<ConsoleMessage>, String> {
+    // Placeholder for backward compatibility.
+    // Actual log collection happens in the frontend consoleLogger.
+    Ok(vec![])
+}
+
+/// Send a message to the WebView for frontend handling.
+/// Use event-based communication instead of eval().
+#[tauri::command]
+pub async fn send_debug_command<R: Runtime>(
+    app: AppHandle<R>,
+    command: String,
+    payload: serde_json::Value,
+) -> Result<String, String> {
+    let window = app
+        .get_webview_window("main")
+        .ok_or("Main window not found")?;
+
+    // Emit event to the frontend.
+    window
+        .emit("debug-command", (command, payload))
+        .map_err(|e| format!("Failed to send debug command: {}", e))?;
+
+    Ok("Command sent to frontend".to_string())
+}
+
+/// Append console logs to /tmp.
+#[tauri::command]
+pub async fn append_debug_logs(logs: Vec<ConsoleLogEntryPayload>) -> Result<String, String> {
+    if logs.is_empty() {
+        return Ok("no logs".to_string());
+    }
+
+    let path = console_log_path();
+    let mut file = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| format!("Failed to open log file: {}", e))?;
+
+    for entry in logs {
+        let line = serde_json::to_string(&entry)
+            .map_err(|e| format!("Failed to serialize log entry: {}", e))?;
+        use std::io::Write;
+        writeln!(file, "{}", line).map_err(|e| format!("Failed to write log: {}", e))?;
+    }
+
+    Ok(path.to_string_lossy().into_owned())
+}
+
+/// Reset the console log file.
+#[tauri::command]
+pub async fn reset_debug_logs() -> Result<String, String> {
+    let path = console_log_path();
+    std::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(&path)
+        .map_err(|e| format!("Failed to reset log file: {}", e))?;
+    Ok(path.to_string_lossy().into_owned())
+}
+
+/// Save a debug snapshot to /tmp.
+#[tauri::command]
+pub async fn write_debug_snapshot(payload: serde_json::Value) -> Result<String, String> {
+    let ts = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|e| format!("Failed to get timestamp: {}", e))?
+        .as_secs();
+    let path = std::env::temp_dir().join(format!("tauri_debug_snapshot_{}.json", ts));
+    let json = serde_json::to_string_pretty(&payload)
+        .map_err(|e| format!("Failed to serialize payload: {}", e))?;
+    std::fs::write(&path, json).map_err(|e| format!("Failed to write file: {}", e))?;
+    Ok(path.to_string_lossy().into_owned())
+}

package/src/lib.rs

@@ -0,0 +1,41 @@
+use tauri::{
+    plugin::{Builder, TauriPlugin},
+    Manager, Runtime,
+};
+use tauri_plugin_log::{Target, TargetKind};
+
+mod commands;
+
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("debug-tools")
+        .setup(|app, _api| {
+            let log_plugin = tauri_plugin_log::Builder::new()
+                .targets([
+                    Target::new(TargetKind::Stdout),
+                    Target::new(TargetKind::LogDir {
+                        file_name: Some("debug.log".to_string()),
+                    }),
+                    Target::new(TargetKind::Webview),
+                ])
+                .max_file_size(50_000) // 50KB auto-rotation
+                .build();
+            let screenshots_plugin = tauri_plugin_screenshots::init();
+
+            let handle = app.app_handle().clone();
+            std::thread::spawn(move || {
+                let _ = handle.plugin(log_plugin);
+                let _ = handle.plugin(screenshots_plugin);
+            });
+
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            commands::capture_webview_state,
+            commands::get_console_logs,
+            commands::send_debug_command,
+            commands::append_debug_logs,
+            commands::reset_debug_logs,
+            commands::write_debug_snapshot,
+        ])
+        .build()
+}