create-tether-app 0.1.0

package/template/src-tauri/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "tether-app"
+version = "0.1.0"
+description = "A Tether App"
+authors = ["you"]
+edition = "2021"
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+tauri-plugin-shell = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["sync"] }
+portpicker = "0.1"
+
+[features]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]
+# Enable devtools in development (adds ~20% to compile time)
+# Use: cargo build --features devtools
+devtools = ["tauri/devtools"]

package/template/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/template/src-tauri/capabilities/default.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://schemas.tauri.app/capability/schema.json",
+  "identifier": "default",
+  "description": "Default capabilities for the app",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    {
+      "identifier": "shell:allow-spawn",
+      "allow": [
+        {
+          "name": "binaries/api",
+          "sidecar": true,
+          "args": [
+            "--port",
+            {
+              "validator": "\\d+"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "identifier": "shell:allow-execute",
+      "allow": [
+        {
+          "name": "binaries/api",
+          "sidecar": true,
+          "args": [
+            "--port",
+            {
+              "validator": "\\d+"
+            }
+          ]
+        }
+      ]
+    },
+    "shell:allow-kill"
+  ]
+}

package/template/src-tauri/src/main.rs

@@ -0,0 +1,65 @@
+// Prevents additional console window on Windows in release
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+mod sidecar;
+
+use sidecar::SidecarManager;
+use std::sync::Arc;
+use tauri::Manager;
+use tokio::sync::Mutex;
+
+#[tauri::command]
+async fn get_api_port(state: tauri::State<'_, Arc<Mutex<SidecarManager>>>) -> Result<u16, String> {
+    let manager = state.lock().await;
+    Ok(manager.port())
+}
+
+#[tauri::command]
+async fn restart_backend(
+    state: tauri::State<'_, Arc<Mutex<SidecarManager>>>,
+) -> Result<String, String> {
+    let mut manager = state.lock().await;
+    manager.restart().await
+}
+
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
+        .setup(|app| {
+            let app_handle = app.handle().clone();
+
+            // Find an available port
+            let port = portpicker::pick_unused_port().expect("No available port");
+
+            // Create sidecar manager
+            let manager = Arc::new(Mutex::new(SidecarManager::new(port)));
+
+            // Store in app state
+            app.manage(manager.clone());
+
+            // Start the sidecar
+            tauri::async_runtime::spawn(async move {
+                let mut manager = manager.lock().await;
+                if let Err(e) = manager.start(&app_handle).await {
+                    eprintln!("Failed to start API server: {}", e);
+                }
+            });
+
+            Ok(())
+        })
+        .on_window_event(|window, event| {
+            if let tauri::WindowEvent::CloseRequested { .. } = event {
+                let app_handle = window.app_handle().clone();
+                tauri::async_runtime::block_on(async {
+                    let state = app_handle.state::<Arc<Mutex<SidecarManager>>>();
+                    let mut manager = state.lock().await;
+                    if let Err(e) = manager.stop() {
+                        eprintln!("Error stopping API server: {}", e);
+                    }
+                });
+            }
+        })
+        .invoke_handler(tauri::generate_handler![get_api_port, restart_backend])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}

package/template/src-tauri/src/sidecar.rs

@@ -0,0 +1,110 @@
+//! Python sidecar process management.
+
+use std::process::Command as StdCommand;
+use tauri::AppHandle;
+use tauri_plugin_shell::process::{CommandChild, CommandEvent};
+use tauri_plugin_shell::ShellExt;
+
+/// Manages the Python sidecar process.
+pub struct SidecarManager {
+    child: Option<CommandChild>,
+    port: u16,
+}
+
+impl SidecarManager {
+    /// Create a new sidecar manager with the specified port.
+    pub fn new(port: u16) -> Self {
+        Self { child: None, port }
+    }
+
+    /// Get the port the sidecar is running on.
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+
+    /// Start the sidecar process.
+    pub async fn start(&mut self, app: &AppHandle) -> Result<String, String> {
+        if self.child.is_some() {
+            return Ok("API server is already running".into());
+        }
+
+        println!("Starting API server on port {}...", self.port);
+
+        let shell = app.shell();
+        let (mut rx, child) = shell
+            .sidecar("api")
+            .map_err(|e| format!("Failed to create sidecar command: {}", e))?
+            .args(["--port", &self.port.to_string()])
+            .spawn()
+            .map_err(|e| format!("Failed to spawn API server: {}", e))?;
+
+        // Spawn a task to handle sidecar output
+        tauri::async_runtime::spawn(async move {
+            while let Some(event) = rx.recv().await {
+                match event {
+                    CommandEvent::Stdout(line) => println!("API: {}", String::from_utf8_lossy(&line)),
+                    CommandEvent::Stderr(line) => {
+                        eprintln!("API Error: {}", String::from_utf8_lossy(&line))
+                    }
+                    CommandEvent::Error(error) => eprintln!("API Process Error: {}", error),
+                    CommandEvent::Terminated(status) => {
+                        println!("API Process Terminated with status: {:?}", status)
+                    }
+                    _ => {}
+                }
+            }
+        });
+
+        self.child = Some(child);
+        println!("API server started successfully on port {}", self.port);
+        Ok(format!("API server started on port {}", self.port))
+    }
+
+    /// Stop the sidecar process.
+    pub fn stop(&mut self) -> Result<String, String> {
+        if let Some(child) = self.child.take() {
+            println!("Stopping API server...");
+
+            let pid = child.pid();
+
+            // Kill child processes first
+            #[cfg(unix)]
+            {
+                let _ = StdCommand::new("pkill")
+                    .args(["-P", &pid.to_string()])
+                    .output();
+            }
+
+            #[cfg(windows)]
+            {
+                let _ = StdCommand::new("taskkill")
+                    .args(["/F", "/T", "/PID", &pid.to_string()])
+                    .output();
+            }
+
+            // Kill the main process
+            child
+                .kill()
+                .map_err(|e| format!("Failed to stop API server: {}", e))?;
+
+            println!("API server stopped");
+            Ok("API server stopped".into())
+        } else {
+            Ok("API server is not running".into())
+        }
+    }
+
+    /// Restart the sidecar process.
+    pub async fn restart(&mut self) -> Result<String, String> {
+        // We can't restart without an app handle, so this is a placeholder
+        // In practice, you'd store the app handle or use a different approach
+        self.stop()?;
+        Err("Restart requires app handle - use Tauri commands".into())
+    }
+}
+
+impl Drop for SidecarManager {
+    fn drop(&mut self) {
+        let _ = self.stop();
+    }
+}

package/template/src-tauri/tauri.conf.json.template

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "identifier": "com.tether.{{PROJECT_NAME}}",
+  "build": {
+    "beforeDevCommand": "pnpm dev",
+    "devUrl": "http://localhost:1420",
+    "beforeBuildCommand": "pnpm build:all",
+    "frontendDist": "../dist"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "{{PROJECT_NAME}}",
+        "width": 1024,
+        "height": 768,
+        "resizable": true,
+        "fullscreen": false,
+        "dragDropEnabled": false
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "externalBin": ["binaries/api"]
+  },
+  "plugins": {
+    "shell": {
+      "open": true
+    }
+  }
+}

package/template/tailwind.config.js.template

@@ -0,0 +1,19 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./frontend/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        surface: 'var(--color-surface)',
+        'surface-hover': 'var(--color-surface-hover)',
+        border: 'var(--color-border)',
+        primary: 'var(--color-primary)',
+        'primary-hover': 'var(--color-primary-hover)',
+      },
+    },
+  },
+  plugins: [],
+}

package/template/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["frontend"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/template/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

package/template/vite.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  // Prevent vite from obscuring rust errors
+  clearScreen: false,
+  server: {
+    port: 1420,
+    strictPort: true,
+    watch: {
+      // Ignore the src-tauri and backend directories
+      ignored: ["**/src-tauri/**", "**/backend/**"],
+    },
+  },
+  // Env variables starting with TAURI_ are exposed to the frontend
+  envPrefix: ["VITE_", "TAURI_"],
+  build: {
+    // Tauri uses Chromium on Windows and WebKit on macOS and Linux
+    target: process.env.TAURI_PLATFORM === "windows" ? "chrome105" : "safari13",
+    // Don't minify for debug builds
+    minify: !process.env.TAURI_DEBUG ? "esbuild" : false,
+    // Produce sourcemaps for debug builds
+    sourcemap: !!process.env.TAURI_DEBUG,
+  },
+});