PacketADE

A local-first desktop ADE (Agent Development Environment) for orchestrating AI software work.

PacketADE is a Tauri v2 desktop app that brings AI coding agents, planning, issue tracking, memory, deployment tooling, and workspace management into a single native environment. It is built for running real development workflows across multiple agent CLIs without leaving the app.

What It Does

• Run multiple agent sessions side-by-side in PTY-backed panes inside a Workspace (your terminal-CLI command center)
• Plan and supervise larger units of work from the Flight Deck — a single-screen master-detail mission control
• Track issues on a kanban board and send them directly to workspace sessions
• Connect to remote servers via SSH and run agent sessions over the wire
• Keep project context close with auto-learning memory, history, and GitHub integration
• Manage MCP servers, inspect crashes, and run deploy workflows from the same UI

Looking for a terminal-native orchestration experience? See FlightDeck — the TUI-first sibling project, split out of this repo and evolving independently.

Supported Agents

PacketADE runs two kinds of agents side-by-side.

PTY-backed CLI sessions — launched in a workspace pane and driven by the CLI's own UI:

• Claude Code
• OpenAI Codex CLI
• Gemini CLI
• OpenCode

API agents in the Agents pane — structured conversations with streaming, tool calls, and permission gating, picked from a grouped dropdown:

Row	Internal id	Auth
Anthropic (Subscription)	api-claude-oauth	Claude Code OAuth (claude login) — uses your Pro/Max subscription
Anthropic (API)	api-claude	ANTHROPIC_API_KEY in OS keyring
OpenAI (ChatGPT Plus/Pro)	api-openai-codex	Codex CLI OAuth (codex login) — uses your ChatGPT subscription
OpenAI (API)	api-openai	OPENAI_API_KEY in OS keyring
OpenRouter	api-openrouter	API key in OS keyring
MiniMax	api-minimax	API key in OS keyring
Ollama	api-ollama	none — local daemon at localhost:11434

Auth status is probed live and shown as a badge next to each row (ready / login_required / missing_key / service_down). An fs watcher flips the badge automatically after a claude login / codex login completes, and expired-but-refreshable tokens stay ready (the SDK / CLI refreshes them transparently). API-key providers run in-process in Rust; subscription providers run in a Node sidecar that hosts the Anthropic Claude Agent SDK and wraps codex exec. Each session can be launched with agent-specific arguments and model selections exposed through the UI.

Main Features

Workspaces — Terminal CLI Command Center

• Multi-pane terminal workflow built on xterm.js and portable-pty with a draggable mosaic tiling layout
• Live status bars for supported agent CLIs
• Per-pane model and effort overrides, bypass-permissions toggles
• Agent profile system for reusable agent configurations
• Pane layout presets (1×1, 1×2, 2×1, 2×2, 2×3, 3×2) live in the main toolbar when a workspace is active

Flight Deck — Mission Control

• Single-screen master-detail layout: a status-grouped flight list on the left, the selected flight's mission control on the right
• Attention group automatically surfaces paused, failed, and approval-needed flights
• Live tiles for the selected flight: stat strip (cost, tokens, tasks, approvals, sessions, last update), milestones, live agents, approvals queue, and timeline
• Inline edit of title and objective; status and priority dropdowns; pause/resume/cancel lifecycle controls
• Kanban issue tracking with priorities, labels, acceptance criteria, and flight linkage
• Standalone Review Queue view for triaging approvals across all flights

SSH Remote Workspaces

• Add and manage remote servers with SSH agent, key, or password authentication
• Auto-detect and install agent CLIs on remote servers (Claude Code, OpenCode)
• Create workspaces that run agent sessions over SSH on remote machines
• Password authentication via in-app prompt (never saved to disk)

Issues — Work on This Issue

• Kanban board with drag-and-drop columns (To Do, In Progress, QA, Done, Blocked, Needs Human)
• Click "Work on this issue" to send the issue prompt to an existing workspace session
• Or create a new workspace named after the project with the issue pre-loaded
• Acceptance criteria, dependency graphs, flight assignment, labels, and priorities

Memory — Auto-Learning System

• Automatically learns from completed sessions: reads PTY transcripts, summarizes via Claude, extracts reusable patterns
• Learned patterns with confidence scores and categories (architecture, convention, preference, pitfall)
• Live context injection into workspace sessions (patterns + lessons + recent summaries)
• Per-project scoping with bounded context to avoid token overflow

Ideation Scanner

• AI-powered codebase analysis that generates improvement ideas across categories (code quality, security, performance, documentation, UI/UX)
• Per-workspace scoping — each workspace gets its own scan results
• Convert ideas directly to issues on the kanban board

GitHub Integration

• GitHub PAT authentication stored in OS keyring
• Repository listing and selection
• Issue browsing with search, labels, and import-to-board
• Pull request browsing with diff viewer
• AI investigation of issues via Claude

Project Operations

• MCP server management (global and project scope) in the Tools page
• Deploy configuration and terminal-backed deploy runs
• Local crash report browsing and cleanup
• Agent profile management and AI routing configuration
• Prompt template library

Tech Stack

Layer	Technology
Desktop	Tauri v2
Frontend	React 19 + TypeScript + Vite
State	Zustand
Styling	Tailwind CSS
Terminal	xterm.js + portable-pty
Backend	Rust
Markdown	react-markdown + remark-gfm
Icons	lucide-react
Testing	Vitest + Playwright

Getting Started

Prerequisites

• Node.js 18+
• pnpm
• Rust stable toolchain
• One or more supported agent CLIs installed and available on PATH

Examples:

• Claude Code for Claude sessions
• Codex CLI for Codex sessions
• Gemini CLI for Gemini sessions
• OpenCode for OpenCode sessions

Install

git clone git@github.com:packetloss404/PacketADE.git
cd PacketADE
pnpm install

Agent Sidecar

PacketADE ships with a Node.js sidecar that powers the Anthropic (Subscription) and OpenAI (ChatGPT Plus/Pro) providers.

• pnpm install at the repo root also installs the sidecar's dependencies automatically via a postinstall hook (idempotent; adds a few seconds to the first install).

• Before using the Anthropic (Subscription) or OpenAI (ChatGPT Plus/Pro) providers for the first time, compile the sidecar once:

  pnpm sidecar:build

• For a full-fidelity local build that compiles both the sidecar and the Vite app in order, use:

  pnpm build:all

• To point the app at a custom sidecar entry point (e.g. when running from a different working copy), set PACKETADE_SIDECAR_PATH to the absolute path of the compiled entry file before launching PacketADE.

pnpm build:all still works for a full local build. For production bundling, pnpm tauri build now auto-runs the prebundle chain (fetch-node → sidecar:install → sidecar:build → sidecar:prune) via Tauri's beforeBuildCommand, so no manual sidecar or Node setup is needed. A pinned Node 20.17.0 runtime is fetched as a Tauri externalBin, and the sidecar ships with a pruned production node_modules. Reference sizes from a Windows build: NSIS installer ~74 MB, MSI installer ~114 MB (both are produced because bundle.targets is "all"), standalone packetade.exe ~30 MB. The prune step removes the sidecar's devDependencies; run pnpm sidecar:install afterward to restore them for further sidecar development.

Sidecar v2 status

The v2 sidecar work is complete across four tiers:

• Tier 1 — Bundling: pinned Node 20.17.0 runtime fetched as a Tauri externalBin, sidecar resources bundled with pruned production node_modules, prebundle chain wired into tauri build.
• Tier 2 — Lifecycle & auth: sidecar version handshake on startup, toolbar status chip reflecting live sidecar state, credential expiry parsing for Anthropic Subscription / OpenAI ChatGPT tokens, and a filesystem watcher that re-reads auth when cred files change on disk.
• Tier 3 — Protocol & UX: pending_edit diff preview for Anthropic Subscription turns, command forwarding (set_permission_mode, set_model, retry) through a versioned protocol. Codex MCP remains intentionally deferred — the upstream Codex SDK does not yet expose MCP hooks.
• Tier 4 — Observability & updates: sidecar lifetime stats (uptime, restart count, last-exit reason), per-provider launch counters surfaced to the UI, and a documented Tauri auto-updater setup.
• Refresh-token aware expiry: provider_auth now treats expired access tokens as ready when a refresh token is present, avoiding spurious "please log in" prompts for subscription users whose SDK / CLI would have refreshed on next use anyway.
• See agent-sidecar/README.md for sidecar internals and docs/updater-setup.md for signing / release channel configuration.

Multi-platform builds

PacketADE is developed on Windows but is designed to ship on macOS and Linux as well. For per-platform prerequisites, supported target triples, and cross-compilation notes, see docs/multi-platform-build.md. A manual-trigger GitHub Actions skeleton that builds on all three OSes via tauri-apps/tauri-action lives at .github/workflows/build.yml — it is disabled by default so it does not burn CI minutes.

Run The Desktop App

pnpm tauri dev

Build

pnpm tauri build

Build artifacts are written under src-tauri/target/release/bundle/.

Quality Checks

pnpm lint
pnpm test
pnpm build
pnpm e2e

Rust Checks

cargo check --manifest-path src-tauri/Cargo.toml

Windows Note

If Tauri builds cannot find the Rust toolchain, ensure the Rust binary path is on PATH.

Example:

set PATH=C:\Users\ianwalmsley\.rustup\toolchains\stable-x86_64-pc-windows-msvc\bin;%PATH%

Project Layout

PacketADE/
  src/
    App.tsx                    # Root app shell and view routing
    components/
      layout/                  # Title bar, toolbar, mosaic tiling, status bar
      session/                 # Terminal panes, session modals, status bars, inspect UI
      issues/                  # Kanban issue board and issue detail UI
      flights/                 # Flight Deck tiles (FlightList, FlightDetail, FlightHeaderTile, etc.)
      views/                   # First-class application views (FlightDeckView, WorkspaceView, …)
      workspace/               # Workspace creation, sidebar, and pane container UI
      servers/                 # SSH server form modal
      common/                  # Shared presentation components
      ui/                      # Shared UI primitives
    stores/                    # Zustand stores for app, layout, flights, issues, workspaces, etc.
    modules/                   # Module registration and module metadata
    lib/                       # Tauri bindings, shared utilities, model lists, event helpers
    generated/                 # Generated TypeScript types (Rust ↔ TS DTO contract)
    hooks/                     # UI and agent interaction hooks
    types/                     # Shared TypeScript types

  src-tauri/
    src/
      lib.rs                   # Tauri app bootstrap and command registration
      commands/                # Tauri commands exposed to the frontend
      api/                     # DTO layer that decouples internal Rust types from the TS contract
      core/                    # Orchestration engine, storage, workspace, PTY core
      claude/                  # Claude CLI integration helpers

  scripts/                     # Build and schema-check scripts
  e2e/                         # Playwright tests
  docs/                        # Documentation site assets
  public/                      # Static frontend assets

Contributor Notes

• Core views are declared in src/stores/appStore.ts
• Tauri commands live in src-tauri/src/commands/ and are bound in src/lib/tauri.ts
• App modules are registered through src/modules/registry.ts
• Session management is PTY-based rather than JSONL-session based
• Backend orchestration concepts (Flights, PTY sessions, agent configs) are mirrored by FlightDeck, PacketADE's sibling TUI project in a separate repo
• GitHub PAT is stored in the OS keyring via the keyring crate
• SSH passwords are prompted at connect time and held in memory only

License

PacketADE is licensed under the Apache License, Version 2.0. See LICENSE and NOTICE.