YzPzCode：集成 26 款 AI 编码 CLI 的终端工作台

Note

YzPzCode is under active development. Some features may be experimental or evolve between releases. Feedback, bug reports, and pull requests are warmly welcomed!

⚡ Why YzPzCode?

Modern AI-assisted development often degrades into a chaotic shuffle between dozens of terminal tabs, scattered coding agents, disconnected browsers, IDEs, and ad-hoc CLI tools.

YzPzCode replaces the window juggling with a single, coherent command center.

📸 See It in Action

🤖 Supported AI Coding CLIs

YzPzCode detects, launches, and manages PTY sessions for 26 external AI coding agents. The core integrations include:

                     ┌─── Claude (Anthropic)
                     ├─── Antigravity (Google)
                     ├─── Codex (OpenAI)
                     ├─── OpenCode
  YzPzCode Host ─────┼─── Cursor
                     ├─── Kilo
                     ├─── Hermes
                     ├─── Pi (earendil-works)
                     └─── Command Code

Additional integrations include:

See the CLI integration reference for vendor install instructions, documentation, and platform notes.

Important

YzPzCode integrates with third-party CLIs via PTY bridges and is not affiliated with or endorsed by their respective vendors unless explicitly stated.

🛠️ SaaS & Developer Tool CLIs

YzPzCode automatically tracks installation status, executable paths, and authentication state for popular cloud & developer CLIs:

See the Tool CLIs reference guide for workflows, common commands, and authentication details.

🧩 Graphical Workspace Extensions

Run your favorite graphical coding assistants and visual extension webviews directly alongside shell and AI agent terminals inside the workspace grid.

Press Ctrl+Shift+X or click the Extensions icon in the header to open the curated catalog.

• 🎛️ Side-by-Side Grid Layouts: Extension panels mount right inside the terminal grid with drag-and-drop reordering, interactive resizing, focus presets (focus-left, focus-right), and split layouts.
• 📦 Zero-Config Managed Runtime: Automatically provisions a verified VSCodium reh-web runtime using pinned SHA-256 digests and Open VSX packages. No external VS Code or Node installation needed.
• 🛡️ Hardened Sandboxing: Each assistant runs in an isolated child webview on its own panel-<uuid>.localhost:<port> origin with persistent storage. Extension webviews are strictly restricted from calling Tauri host application commands.
• 🔒 Workspace Trust & State Persistence: Preserves workspace trust approvals (workspace-trust.json) and transactionally synchronizes IndexedDB workbench state (workbench-state.json) per workspace.

See the graphical workspace extensions documentation for architecture, runtime specifications, and validation details.

⚡ Application Run & Build System

Launch, build, and debug your applications with zero configuration. YzPzCode automatically discovers project manifests and runnable entry points across 15+ ecosystems directly inside terminal headers:

• ▶️ One-Click Run & Build: Trigger runs or isolated compilation steps directly from the terminal header with instant target switching.
• 💬 Interactive Stdin Console Pipe: Send input to running console applications (input(), scanf, Console.ReadLine()) directly from the terminal input bar.
• 🌐 Dev-Server Localhost Auto-Discovery: Automatically recognizes localhost URLs emitted by dev servers in terminal output and surfaces a 1-click preview button in the browser bar.
• ⚙️ Custom Run Configurations: Define and persist custom commands, environment variables, arguments, and working directories in Settings → Application runs (scoped globally or per workspace).

See the application runs guide for full configuration schemas, multi-target switching, and compiler details.

✨ Core Features

🖥️ 1. Multi-Agent Terminal Grid

• Real PTY Backend: Full xterm.js 6 frontend powered by Rust's portable-pty
• Managed Commands: Run non-interactive / background tasks with PID, exit code, and live output streaming
• Terminal Mouse Modes: Full xterm mouse reporting protocol (click, drag, any-event, application mouse tracking) for interactive TUIs and CLI tools
• Hardware-Accelerated Rendering: Canvas/WebGL rendering pipeline optimizations with dirty-rectangle updates for ultra-low latency throughput
• Workspace Scoping: Terminal sessions are isolated per project workspace
• Redesigned Spawn Dialog: Searchable modal categorized by shells, primary AI agents, additional agents, and SaaS tool CLIs with real-time status badges
• External Terminal Tiling: Spawn external native consoles (Windows Terminal, macOS Terminal, Linux) with auto-tiling

⚡ 2. Application Run & Build System

• Zero-Config Detection: Automatic target and manifest discovery across 15+ programming languages and frameworks
• Terminal Header Controls: Instant Run and Build triggers with multi-target selection dropdowns
• Interactive Stdin Streaming: Direct input piping into running console programs (input(), scanf, etc.)
• Dev-Server Auto-Preview: Automatic detection of localhost URLs in terminal logs linking directly to the in-app browser
• Saved Configurations: Scoped run configurations customizable in Settings with custom arguments and environment variables

🧩 3. Graphical Workspace Extensions

• Curated Open VSX Catalog: 1-click install for leading visual coding extensions (Google Antigravity, Kilo Code, Cline, Codex, Claude Code, Continue, Amazon Q, Tabby, Windsurf, Mistral Vibe, Roo Code, Qoder CN, Augment, Nexrall Code)
• Grid Layout Integration: Open AI assistant panels in a dedicated Extensions view with independent layouts
• Strict Security Boundaries: Isolated child webviews with connection tokens, local origins, and app command rejection
• Durable Profile Persistence: Workspace-scoped profiles, persistent authentication, and synchronized trust gates

📝 4. Monaco-Based Code Editor & Source Control

• Multi-Tab Workspace: Split views, tab management (close others / right / saved)
• Syntax Highlighting & Minimap: Rich language support via Monaco + CodeMirror engines
• Rich File Previews: Markdown, PDF, CSV, Excel (.xlsx), Word (.docx), and Draw.io diagrams
• Transactional File Sync: High-speed recursive filesystem watcher (notify) with debounced synchronization keeping open editor tabs in sync with external IDEs and agents
• Integrated Git Source Control: Branch switching, diff statistics, staging/unstaging individual files or hunk diffs, discard changes, commit workflow, and remote sync

🌐 5. In-App Browser & Visual Inspector

• Device Presets: Emulate iPhone, iPad, responsive desktop; toggle portrait/landscape
• Deep Element Inspector: Inspect computed CSS, pseudo-elements, box model, and DOM hierarchy
• Style Picker & Generator: Capture styles directly to clipboard, generate atomic CSS classes, and apply with full undo stack
• Dev-Server Integration: Instant 1-click browser preview when development servers emit local URLs

🎨 6. AI Designer & Layered Image Editor

• Prompt-to-UI Generator: Produce responsive HTML/CSS/JS interfaces directly from natural language prompts
• Full Layered Canvas: Raster, vector, text, and shape layers powered by Konva
• 16 Blend Modes: Full layer opacity, rotation, masking, marquee/lasso selections, and history
• Multi-Format Export: PNG, JPG, WebP, SVG, GIF, BMP, AVIF, TIFF

🏗️ Architecture

flowchart TB
    subgraph Frontend["React 19 + TypeScript Frontend (Vite 6)"]
        direction LR
        UI_Term["Terminal Grid\n(xterm.js 6)"]
        UI_Ext["Workspace\nExtensions"]
        UI_Editor["Code Editor\n(Monaco)"]
        UI_Browser["Browser &\nInspector"]
        UI_Image["Image Editor\n(Konva)"]
    end

    subgraph TauriHost["Tauri v2 + Rust Core Host"]
        IPC["Tauri IPC Command Router"]
        PTY["PTY & Run Engine\n(portable-pty)"]
        ExtHost["Extension Host\nManager"]
        FS["File & Git Watcher\n(notify)"]
        DevEnv["IDE / CLI Detector"]
    end

    subgraph External["External Runtime"]
        ExtRuntime["VSCodium reh-web\n(Open VSX Host)"]
        CLIs["External AI & Tool CLIs\n(Claude, Antigravity, gh, etc.)"]
        IDEs["External IDEs\n(VS Code, Cursor, Zed)"]
    end

    Frontend <==>|"Tauri IPC (Async Invokes + Events)"| IPC
    IPC --> PTY
    IPC --> ExtHost
    IPC --> FS
    IPC --> DevEnv

    PTY <==>|"Raw PTY Stream"| CLIs
    ExtHost <==>|"Loopback HTTP / Child Webview"| ExtRuntime
    DevEnv -.->|"Process Launch"| IDEs

Loading

Technology Matrix

📂 Project Structure

yzpzcode/
├── .github/workflows/          # CI/CD Release workflows (multi-platform builds)
├── docs/                       # Guides (application runs, extensions, ToolCLIs), screenshots
└── app/
    ├── src-tauri/              # Rust backend
    │   └── src/
    │       ├── agent/          # Autonomous agent task orchestration & retry logic
    │       ├── agent_cli/      # AI & Tool CLI detection, installation & auth
    │       ├── browser/        # Webview management & visual inspector bridge
    │       ├── commands/       # Tauri IPC commands (~100+ endpoints)
    │       ├── extension_host/ # Embedded VSCodium web runtime manager, Open VSX & VSIX sandboxing
    │       ├── terminal/       # PTY sessions, application run engine & managed commands
    │       ├── filesystem/     # Recursive watcher, transactional file sync, Git ops & diffs
    │       ├── ide/            # External IDE launcher (VS Code, Cursor, Zed, etc.)
    │       └── discord_presence/ # Discord Rich Presence integration
    │
    ├── src/                    # React 19 frontend
    │   ├── components/         # Modular UI components
    │   │   ├── workspace/      # Terminal grid, extension panels, aurora background, browser, view switchers
    │   │   ├── editor/         # Monaco editor tabs & rich file previews
    │   │   ├── explorer/       # Virtualized file tree & Git panels
    │   │   ├── designer/       # AI design generation studio
    │   │   ├── image/          # Layered canvas image editor
    │   │   ├── settings/       # 11-section preferences panel (runs, aurora, agents, etc.)
    │   │   └── setup/          # Interactive onboarding wizard
    │   ├── hooks/              # Custom React hooks (useTerminal, useBrowser, useFileWatcher, etc.)
    │   ├── stores/             # Zustand global state stores (appStore, runConfigStore, extensionStore)
    │   └── types/              # TypeScript mirror interfaces of Rust structs

🚀 Download & Installation

Option 1: Pre-Built Binaries (Recommended)

Grab the latest installer for your operating system from the Releases Page:

Tip

macOS Note: If running an unsigned build, open with Right Click → Open, or allow it under System Settings → Privacy & Security → Open Anyway.

Option 2: Build From Source

Prerequisites

• Node.js: 22.x or higher
• Rust: Latest stable toolchain (rustup update stable)
• C++ Build Tools: Visual Studio Build Tools (Windows) / Xcode CLI Tools (macOS) / build-essential (Linux)

1. Clone the repository

git clone https://github.com/wolfenazz/YzPzCode.git
cd YzPzCode/app

2. Install dependencies

# Install frontend dependencies
npm install

3. Run in development mode

npm run tauri dev

4. Build production installer

npm run tauri build

The compiled binaries will be output to app/src-tauri/target/release/bundle/.

🎨 UI Customization

Tailor YzPzCode to your aesthetic and workflow preferences:

• 🌗 Dark / Light Modes: Full dynamic theming across the entire UI
• 🎨 8 Accent Color Schemes: Default, Blue, Purple, Green, Orange, Red, Pink, Cyan
• 🌌 Animated Workspace Aurora: GPU-accelerated ambient aurora background for workspaces with customizable color presets (gemini, sage, accent, custom), intensity, speed, blur, and opacity controls (Settings → Appearance → Workspace Aurora)
• 💎 Modernized App Chrome: Sleek view switcher tabs, interactive status indicators, and real-time process monitoring in the footer chrome
• 📐 3 Density Presets: Compact, Comfortable, Spacious
• ⌨️ Terminal Styling: Configurable font families, ligatures, cursor styles, mouse tracking modes, and opacity
• ✨ Accessibility: Animation disable toggle (reduced-motion compliance), custom cursor toggle

🔒 Security & Privacy

YzPzCode was built with a local-first security philosophy:

• 🛡️ Your Code Stays Local: No project files or source code are ever uploaded to third-party servers by YzPzCode itself.
• 🔑 Locally Stored Secrets: API keys and tokens are stored exclusively on your local machine.
• 📡 Direct Provider Connections: When you configure API keys for Anthropic, OpenAI, or other LLMs, requests are dispatched directly to their official endpoints.

🤝 Contributing

Contributions make open source incredible! Any bugs found, improvements, or new features are appreciated.

Quality Checklist before Submitting PRs

# 1. Typecheck the frontend
cd app && npx tsc --noEmit

# 2. Check Rust formatting & lints
cd src-tauri
cargo fmt --check
cargo clippy -- -D warnings

# 3. Run unit & integration tests
cargo test

Please check open issues or start a discussion before proposing major architectural changes.

👥 Contributors

A huge thank you to everyone building and refining YzPzCode:

📄 License

YzPzCode is open-source software licensed under the Apache License 2.0.