myitscloud-org/shiroscout

1. Overall shape

- ShiroScout is a Tauri desktop application: a React + TypeScript frontend runs in the WebView, while a Rust backend handles Windows/system operations and privileged work.

- The app is oriented around local or remote Windows support workflows for L1/L2 technicians.

2. Frontend shell and navigation

- src/app contains the application shell: router, layout, navbar, sidenav, terminal panel, and top-level routes.

- The routes are mostly thin page entry points; they delegate real work to feature modules instead of embedding logic in the route layer.

3. Feature-based UI modules

- src/features/* is the main UI domain boundary. Each folder represents a technician task area such as:

- device/process/software inventory

- event logs and security logs

- disk, network, services, startup, scheduled tasks

- remote tools, registry browser, SCCM, AD users, Windows Update

- AI diagnostics, quick fixes, fix history, tickets, integrations

- This is where the product’s functional surface area lives, and it maps closely to the pages in the router.

4. Shared UI and cross-cutting client code

- src/components contains reusable UI primitives and common wrappers such as error boundaries, confirm dialogs, toast notifications, loading/empty states, and styled helpers.

- src/hooks, src/lib, src/config, and src/types provide shared client-side behavior: keyboard shortcuts, idle timeout, Tauri command helpers, environment configuration, export utilities, and typed bridges to backend commands.

5. Terminal and command-oriented UX

- The app includes a terminal/console experience (src/features/terminal*, terminal-panel.tsx, terminal-context.tsx) for operational workflows.

- This is a distinct UX path from the normal form-based pages and is likely used for command execution, live output, or session tracking.

6. Rust backend as the system boundary

- src-tauri/src is the execution and integration layer. It exposes commands and services that the frontend calls through Tauri IPC.

- Key backend modules suggest a clear command boundary:

- commands.rs, cmd_catalog.rs, cmdlet_reference.rs for the public command surface

- error.rs, config.rs, environment.rs for backend wiring and failure handling

- rate_limiter.rs for throttling sensitive operations, especially around AI or remote actions

7. Windows/endpoint management subsystems

- Several Rust modules are dedicated to Windows support tasks:

- ps.rs and ps_audit.rs for PowerShell execution and auditing

- system.rs, health_snapshot.rs, screenshot.rs, attestation.rs

- ad.rs, gp.rs, sccm.rs, dpapi.rs, history.rs

- audit.rs, triage.rs, rca.rs, network-oriented and event-fix related logic

- These modules are the core of the product: they gather machine state, run diagnostics, and support remediation.

8. PowerShell and scripted operations

- The backend invokes repository scripts under src-tauri/scripts and top-level scripts/ for tasks like health checks, remote-state capture, VM detection, teardown, backups, and maintenance.

- This scripting layer is a major architectural boundary: the Rust app orchestrates Windows-native PowerShell behavior rather than reimplementing everything in Rust.

9. AI-assisted diagnostics and external integrations

- AI support is first-class in the architecture: src/features/ai-diagnostics, src-tauri/src/llm.rs, and src/features/settings/llm-providers.tsx indicate pluggable LLM providers.

- custom-webhooks, tickets, and integrations suggest outbound integration points for reporting, automation, or workflow handoff.

- The backend’s rate limiting and audit-related modules indicate these external calls are treated as controlled, observable operations.

10. Data, history, and reporting

- The app keeps operational context such as fix history, health snapshots, event-fix mappings, and audit artifacts.

- UI modules like fix-history, desktop-health, and the report-oriented docs/files imply the product is not just for one-off actions; it also supports reviewability and post-incident traceability.

11. Permissions and Tauri security model

- src-tauri/capabilities and generated schemas show the app uses Tauri’s capability system to constrain what the frontend can ask the backend to do.

- That separation matters architecturally: the UI is not directly privileged; backend commands and allowed capabilities define the security boundary.

12. Build, test, and delivery pipeline

- The frontend uses Vite, TypeScript, Biome, and tests in src/components and src/lib.

- The backend uses Rust/Cargo, with Tauri configuration in src-tauri/tauri.conf.json.

- GitHub Actions CI is present, and the repo also includes many operational docs/scripts for release, auditing, and maintenance.