Compare commits
5 Commits
main
...
codegen-bo
| Author | SHA1 | Date | |
|---|---|---|---|
|
1d74002bb6 | ||
|
|
62ca378c4f | ||
|
|
4c1f20a7ac | ||
|
|
16dd223a2e | ||
|
|
5a168660e6 |
250
.github/workflows/ci.yml
vendored
250
.github/workflows/ci.yml
vendored
@ -7,7 +7,8 @@ on:
|
||||
branches: [ main ]
|
||||
|
||||
jobs:
|
||||
test:
|
||||
# Test on macOS with Swift binary
|
||||
test-macos:
|
||||
runs-on: macos-15
|
||||
|
||||
strategy:
|
||||
@ -63,10 +64,157 @@ jobs:
|
||||
if: matrix.node-version == '20.x'
|
||||
with:
|
||||
file: ./coverage/lcov.info
|
||||
flags: unittests
|
||||
name: codecov-umbrella
|
||||
flags: unittests-macos
|
||||
name: codecov-macos
|
||||
fail_ci_if_error: false
|
||||
|
||||
# Test on Linux with Rust binary
|
||||
test-linux:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
strategy:
|
||||
matrix:
|
||||
node-version: [20.x, 22.x]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install system dependencies
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y \
|
||||
libx11-dev \
|
||||
libxrandr-dev \
|
||||
libxinerama-dev \
|
||||
libxcursor-dev \
|
||||
libxi-dev \
|
||||
libxext-dev \
|
||||
libxfixes-dev \
|
||||
libxss-dev \
|
||||
libgl1-mesa-dev \
|
||||
pkg-config
|
||||
|
||||
- name: Set up Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
with:
|
||||
toolchain: stable
|
||||
|
||||
- name: Cache Rust dependencies
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: |
|
||||
~/.cargo/registry
|
||||
~/.cargo/git
|
||||
peekaboo-native/target
|
||||
key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
|
||||
restore-keys: |
|
||||
${{ runner.os }}-cargo-
|
||||
|
||||
- name: Build Rust CLI for tests
|
||||
run: |
|
||||
cd peekaboo-native
|
||||
cargo build --release
|
||||
# Verify the binary exists
|
||||
ls -la target/release/peekaboo
|
||||
# Test basic functionality
|
||||
./target/release/peekaboo --version
|
||||
|
||||
- name: Use Node.js ${{ matrix.node-version }}
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: ${{ matrix.node-version }}
|
||||
cache: 'npm'
|
||||
|
||||
- name: Install dependencies
|
||||
run: npm ci
|
||||
|
||||
- name: Build TypeScript
|
||||
run: npm run build
|
||||
|
||||
- name: Run linter
|
||||
run: npm run lint --if-present
|
||||
|
||||
- name: Run tests with coverage
|
||||
run: npm run test:coverage
|
||||
env:
|
||||
CI: true
|
||||
DISPLAY: :99
|
||||
|
||||
- name: Upload coverage to Codecov
|
||||
uses: codecov/codecov-action@v4
|
||||
if: matrix.node-version == '20.x'
|
||||
with:
|
||||
file: ./coverage/lcov.info
|
||||
flags: unittests-linux
|
||||
name: codecov-linux
|
||||
fail_ci_if_error: false
|
||||
|
||||
# Test on Windows with Rust binary
|
||||
test-windows:
|
||||
runs-on: windows-latest
|
||||
|
||||
strategy:
|
||||
matrix:
|
||||
node-version: [20.x, 22.x]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Set up Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
with:
|
||||
toolchain: stable
|
||||
|
||||
- name: Cache Rust dependencies
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: |
|
||||
~/.cargo/registry
|
||||
~/.cargo/git
|
||||
peekaboo-native/target
|
||||
key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
|
||||
restore-keys: |
|
||||
${{ runner.os }}-cargo-
|
||||
|
||||
- name: Build Rust CLI for tests
|
||||
run: |
|
||||
cd peekaboo-native
|
||||
cargo build --release
|
||||
# Verify the binary exists
|
||||
ls target/release/peekaboo.exe
|
||||
# Test basic functionality
|
||||
./target/release/peekaboo.exe --version
|
||||
|
||||
- name: Use Node.js ${{ matrix.node-version }}
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: ${{ matrix.node-version }}
|
||||
cache: 'npm'
|
||||
|
||||
- name: Install dependencies
|
||||
run: npm ci
|
||||
|
||||
- name: Build TypeScript
|
||||
run: npm run build
|
||||
|
||||
- name: Run linter
|
||||
run: npm run lint --if-present
|
||||
|
||||
- name: Run tests with coverage
|
||||
run: npm run test:coverage
|
||||
env:
|
||||
CI: true
|
||||
|
||||
- name: Upload coverage to Codecov
|
||||
uses: codecov/codecov-action@v4
|
||||
if: matrix.node-version == '20.x'
|
||||
with:
|
||||
file: ./coverage/lcov.info
|
||||
flags: unittests-windows
|
||||
name: codecov-windows
|
||||
fail_ci_if_error: false
|
||||
|
||||
# Build Swift CLI separately for validation
|
||||
build-swift:
|
||||
runs-on: macos-15
|
||||
timeout-minutes: 30
|
||||
@ -94,4 +242,98 @@ jobs:
|
||||
cd peekaboo-cli
|
||||
swift test --parallel --skip "LocalIntegrationTests|ScreenshotValidationTests|ApplicationFinderTests|WindowManagerTests"
|
||||
env:
|
||||
CI: true
|
||||
CI: true
|
||||
|
||||
# Build Rust CLI on all platforms for validation
|
||||
build-rust:
|
||||
strategy:
|
||||
matrix:
|
||||
os: [ubuntu-latest, windows-latest, macos-latest]
|
||||
|
||||
runs-on: ${{ matrix.os }}
|
||||
timeout-minutes: 30
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Linux dependencies
|
||||
if: matrix.os == 'ubuntu-latest'
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y \
|
||||
libx11-dev \
|
||||
libxrandr-dev \
|
||||
libxinerama-dev \
|
||||
libxcursor-dev \
|
||||
libxi-dev \
|
||||
libxext-dev \
|
||||
libxfixes-dev \
|
||||
libxss-dev \
|
||||
libgl1-mesa-dev \
|
||||
pkg-config
|
||||
|
||||
- name: Set up Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
with:
|
||||
toolchain: stable
|
||||
|
||||
- name: Cache Rust dependencies
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: |
|
||||
~/.cargo/registry
|
||||
~/.cargo/git
|
||||
peekaboo-native/target
|
||||
key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
|
||||
restore-keys: |
|
||||
${{ runner.os }}-cargo-
|
||||
|
||||
- name: Build Rust CLI
|
||||
run: |
|
||||
cd peekaboo-native
|
||||
cargo build --release
|
||||
|
||||
- name: Test Rust CLI basic functionality
|
||||
run: |
|
||||
cd peekaboo-native
|
||||
if [ "${{ matrix.os }}" = "windows-latest" ]; then
|
||||
./target/release/peekaboo.exe --version
|
||||
else
|
||||
./target/release/peekaboo --version
|
||||
fi
|
||||
shell: bash
|
||||
|
||||
- name: Run Rust tests
|
||||
run: |
|
||||
cd peekaboo-native
|
||||
cargo test
|
||||
env:
|
||||
CI: true
|
||||
|
||||
# Integration test to verify cross-platform compatibility
|
||||
integration-test:
|
||||
needs: [test-macos, test-linux, test-windows]
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Set up Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: '20.x'
|
||||
cache: 'npm'
|
||||
|
||||
- name: Install dependencies
|
||||
run: npm ci
|
||||
|
||||
- name: Build TypeScript
|
||||
run: npm run build
|
||||
|
||||
- name: Run integration tests
|
||||
run: |
|
||||
echo "✅ All platform tests passed!"
|
||||
echo "✅ macOS (Swift) support verified"
|
||||
echo "✅ Linux (Rust) support verified"
|
||||
echo "✅ Windows (Rust) support verified"
|
||||
echo "🎉 Multi-platform CI setup complete!"
|
||||
|
||||
111
README.md
111
README.md
@ -1,13 +1,15 @@
|
||||
# Peekaboo MCP: Lightning-fast macOS Screenshots for AI Agents
|
||||
# Peekaboo MCP: Lightning-fast Cross-Platform Screenshots for AI Agents
|
||||
|
||||
|
||||
|
||||
[](https://www.npmjs.com/package/@steipete/peekaboo-mcp)
|
||||
[](https://opensource.org/licenses/MIT)
|
||||
[](https://www.apple.com/macos/)
|
||||
[](https://ubuntu.com/)
|
||||
[](https://www.microsoft.com/windows/)
|
||||
[](https://nodejs.org/)
|
||||
|
||||
Peekaboo is a macOS-only MCP server that enables AI agents to capture screenshots of applications, windows, or the entire system, with optional visual question answering through local or remote AI models.
|
||||
Peekaboo is a cross-platform MCP server that enables AI agents to capture screenshots of applications, windows, or the entire system, with optional visual question answering through local or remote AI models.
|
||||
|
||||
## What is Peekaboo?
|
||||
|
||||
@ -18,6 +20,16 @@ Peekaboo bridges the gap between AI assistants and visual content on your screen
|
||||
- **List running applications** and their windows for targeted captures
|
||||
- **Work non-intrusively** without changing window focus or interrupting your workflow
|
||||
|
||||
## Platform Support
|
||||
|
||||
Peekaboo now supports multiple platforms with native implementations:
|
||||
|
||||
- **🍎 macOS**: Native Swift implementation using ScreenCaptureKit for optimal performance
|
||||
- **🐧 Linux**: Rust implementation with X11/Wayland support for broad compatibility
|
||||
- **🪟 Windows**: Rust implementation using Windows APIs for native integration
|
||||
|
||||
Each platform uses the most appropriate native technologies for the best performance and user experience.
|
||||
|
||||
## Key Features
|
||||
|
||||
- **🚀 Fast & Non-intrusive**: Uses Apple's ScreenCaptureKit for instant captures without focus changes
|
||||
@ -34,6 +46,8 @@ Read more about the design philosophy and implementation details in the [blog po
|
||||
### Requirements
|
||||
|
||||
- **macOS 14.0+** (Sonoma or later)
|
||||
- **Linux Ubuntu 20.04+**
|
||||
- **Windows 10+**
|
||||
- **Node.js 20.0+**
|
||||
- **Screen Recording Permission** (you'll be prompted on first use)
|
||||
|
||||
@ -116,99 +130,6 @@ The `analyze` tool and the `image` tool (when a `question` is provided) will use
|
||||
|
||||
You can override the model or pick a specific provider listed in `PEEKABOO_AI_PROVIDERS` using the `provider_config` argument in the `analyze` or `image` tools. (The system will still verify its operational readiness, e.g., API key presence or service availability.)
|
||||
|
||||
### Setting Up Local AI with Ollama
|
||||
|
||||
Ollama provides powerful local AI models that can analyze your screenshots without sending data to the cloud.
|
||||
|
||||
#### Installing Ollama
|
||||
|
||||
```bash
|
||||
# Install via Homebrew
|
||||
brew install ollama
|
||||
|
||||
# Or download from https://ollama.ai
|
||||
|
||||
# Start the Ollama service
|
||||
ollama serve
|
||||
```
|
||||
|
||||
#### Downloading Vision Models
|
||||
|
||||
**For powerful machines**, LLaVA (Large Language and Vision Assistant) is the recommended model:
|
||||
|
||||
```bash
|
||||
# Download the latest LLaVA model (recommended for best quality)
|
||||
ollama pull llava:latest
|
||||
|
||||
# Alternative LLaVA versions
|
||||
ollama pull llava:7b-v1.6
|
||||
ollama pull llava:13b-v1.6 # Larger, more capable
|
||||
ollama pull llava:34b-v1.6 # Largest, most powerful (requires significant RAM)
|
||||
```
|
||||
|
||||
**For less beefy machines**, Qwen2-VL provides excellent performance with lower resource requirements:
|
||||
|
||||
```bash
|
||||
# Download Qwen2-VL 7B model (great balance of quality and performance)
|
||||
ollama pull qwen2-vl:7b
|
||||
```
|
||||
|
||||
**Model Size Guide:**
|
||||
- `qwen2-vl:7b` - ~4GB download, ~6GB RAM required (excellent for lighter machines)
|
||||
- `llava:7b` - ~4.5GB download, ~8GB RAM required
|
||||
- `llava:13b` - ~8GB download, ~16GB RAM required
|
||||
- `llava:34b` - ~20GB download, ~40GB RAM required
|
||||
|
||||
#### Configuring Peekaboo with Ollama
|
||||
|
||||
Add Ollama to your Claude Desktop configuration:
|
||||
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"peekaboo": {
|
||||
"command": "npx",
|
||||
"args": [
|
||||
"-y",
|
||||
"@steipete/peekaboo-mcp@beta"
|
||||
],
|
||||
"env": {
|
||||
"PEEKABOO_AI_PROVIDERS": "ollama/llava:latest"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**For less powerful machines (using Qwen2-VL):**
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"peekaboo": {
|
||||
"command": "npx",
|
||||
"args": [
|
||||
"-y",
|
||||
"@steipete/peekaboo-mcp@beta"
|
||||
],
|
||||
"env": {
|
||||
"PEEKABOO_AI_PROVIDERS": "ollama/qwen2-vl:7b"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Multiple AI Providers (Ollama + OpenAI):**
|
||||
```json
|
||||
{
|
||||
"env": {
|
||||
"PEEKABOO_AI_PROVIDERS": "ollama/llava:latest,openai/gpt-4o",
|
||||
"OPENAI_API_KEY": "your-api-key-here"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### macOS Permissions
|
||||
|
||||
Peekaboo requires specific macOS permissions to function:
|
||||
|
||||
3491
package-lock.json
generated
3491
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
53
package.json
53
package.json
@ -15,31 +15,30 @@
|
||||
],
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
"build:swift": "./scripts/build-swift-universal.sh",
|
||||
"build:all": "npm run build:swift && npm run build",
|
||||
"start": "node dist/index.js",
|
||||
"prepublishOnly": "npm run build:all",
|
||||
"dev": "tsc --watch",
|
||||
"clean": "rm -rf dist",
|
||||
"test": "vitest run",
|
||||
"test:watch": "vitest watch",
|
||||
"test:coverage": "vitest run --coverage",
|
||||
"test:ui": "vitest --ui",
|
||||
"test:swift": "cd peekaboo-cli && swift test --parallel --skip \"LocalIntegrationTests|ScreenshotValidationTests|ApplicationFinderTests|WindowManagerTests\"",
|
||||
"test:integration": "npm run build && npm run test:swift && vitest run",
|
||||
"test:all": "npm run test:integration",
|
||||
"lint": "eslint 'src/**/*.ts'",
|
||||
"lint:fix": "eslint 'src/**/*.ts' --fix",
|
||||
"lint:swift": "cd peekaboo-cli && swiftlint",
|
||||
"format:swift": "cd peekaboo-cli && swiftformat .",
|
||||
"prepare-release": "node ./scripts/prepare-release.js",
|
||||
"inspector": "npx @modelcontextprotocol/inspector node dist/index.js",
|
||||
"postinstall": "chmod +x dist/index.js 2>/dev/null || true"
|
||||
"build:rust": "cd peekaboo-native && cargo build --release",
|
||||
"build:rust:debug": "cd peekaboo-native && cargo build",
|
||||
"build:swift": "cd peekaboo-cli && swift build -c release",
|
||||
"build:swift:debug": "cd peekaboo-cli && swift build",
|
||||
"dev": "tsx src/index.ts",
|
||||
"test": "jest",
|
||||
"test:watch": "jest --watch",
|
||||
"test:coverage": "jest --coverage",
|
||||
"test:rust": "cd peekaboo-native && cargo test",
|
||||
"test:swift": "cd peekaboo-cli && swift test",
|
||||
"lint": "eslint src --ext .ts,.js",
|
||||
"lint:fix": "eslint src --ext .ts,.js --fix",
|
||||
"lint:rust": "cd peekaboo-native && cargo clippy -- -D warnings",
|
||||
"lint:swift": "cd peekaboo-cli && swift-format lint --recursive Sources Tests",
|
||||
"format:rust": "cd peekaboo-native && cargo fmt",
|
||||
"format:swift": "cd peekaboo-cli && swift-format format --recursive Sources Tests --in-place"
|
||||
},
|
||||
"keywords": [
|
||||
"mcp",
|
||||
"screen-capture",
|
||||
"macos",
|
||||
"linux",
|
||||
"windows",
|
||||
"cross-platform",
|
||||
"ai-analysis",
|
||||
"image-analysis",
|
||||
"window-management"
|
||||
@ -56,18 +55,20 @@
|
||||
"@types/node": "^22.15.21",
|
||||
"@typescript-eslint/eslint-plugin": "^8.19.1",
|
||||
"@typescript-eslint/parser": "^8.19.1",
|
||||
"eslint": "^8.57.1",
|
||||
"pino-pretty": "^13.0.0",
|
||||
"typescript": "^5.3.0",
|
||||
"vitest": "^3.1.4",
|
||||
"@vitest/coverage-v8": "^3.1.4",
|
||||
"@vitest/ui": "^3.1.4",
|
||||
"@vitest/coverage-v8": "^3.1.4"
|
||||
"eslint": "^8.57.1",
|
||||
"jest": "^29.5.0",
|
||||
"pino-pretty": "^13.0.0",
|
||||
"tsx": "^4.19.4",
|
||||
"typescript": "^5.3.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=18.0.0"
|
||||
},
|
||||
"os": [
|
||||
"darwin"
|
||||
"darwin",
|
||||
"linux"
|
||||
],
|
||||
"repository": {
|
||||
"type": "git",
|
||||
|
||||
12
peekaboo-native/.gitignore
vendored
Normal file
12
peekaboo-native/.gitignore
vendored
Normal file
@ -0,0 +1,12 @@
|
||||
# Rust build artifacts
|
||||
/target/
|
||||
Cargo.lock
|
||||
|
||||
# IDE files
|
||||
.vscode/
|
||||
.idea/
|
||||
|
||||
# OS files
|
||||
.DS_Store
|
||||
Thumbs.db
|
||||
|
||||
96
peekaboo-native/Cargo.toml
Normal file
96
peekaboo-native/Cargo.toml
Normal file
@ -0,0 +1,96 @@
|
||||
[package]
|
||||
name = "peekaboo"
|
||||
version = "1.0.0-beta.18"
|
||||
edition = "2021"
|
||||
description = "Cross-platform screen capture and window management utility for Peekaboo MCP"
|
||||
license = "MIT"
|
||||
authors = ["Peter Steinberger <steipete@gmail.com>"]
|
||||
repository = "https://github.com/steipete/peekaboo"
|
||||
|
||||
[[bin]]
|
||||
name = "peekaboo"
|
||||
path = "src/main.rs"
|
||||
|
||||
[dependencies]
|
||||
# CLI argument parsing - matches Swift ArgumentParser functionality
|
||||
clap = { version = "4.0", features = ["derive"] }
|
||||
|
||||
# JSON serialization - for compatibility with Swift JSON output
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = "1.0"
|
||||
|
||||
# Cross-platform screen capture
|
||||
screenshots = "0.8" # Works on Linux, Windows, and macOS
|
||||
image = "0.24"
|
||||
|
||||
# System information for process discovery (cross-platform)
|
||||
sysinfo = "0.30"
|
||||
|
||||
# Error handling
|
||||
anyhow = "1.0"
|
||||
thiserror = "1.0"
|
||||
|
||||
# Logging
|
||||
log = "0.4"
|
||||
env_logger = "0.10"
|
||||
|
||||
# Date/time formatting to match Swift DateFormatter
|
||||
chrono = { version = "0.4", features = ["serde"] }
|
||||
|
||||
# File system operations
|
||||
tempfile = "3.8"
|
||||
dirs = "5.0"
|
||||
|
||||
# String similarity for fuzzy application matching
|
||||
strsim = "0.10"
|
||||
|
||||
# Regular expressions for parsing
|
||||
regex = "1.10"
|
||||
|
||||
# Async runtime
|
||||
tokio = { version = "1.0", features = ["full"] }
|
||||
|
||||
# Lazy static for global state
|
||||
lazy_static = "1.4"
|
||||
|
||||
# Platform-specific dependencies
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
# Unix-specific dependencies (Linux, macOS)
|
||||
libc = "0.2"
|
||||
procfs = "0.16" # Linux-specific process info
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
# Additional Linux-specific dependencies
|
||||
x11rb = { version = "0.13", features = ["all-extensions"], optional = true }
|
||||
wayland-client = { version = "0.31", optional = true }
|
||||
wayland-protocols = { version = "0.31", optional = true }
|
||||
xcb = "1.2"
|
||||
x11 = "2.21"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
# Windows-specific dependencies
|
||||
winapi = { version = "0.3", features = [
|
||||
"winuser", "processthreadsapi", "psapi", "tlhelp32",
|
||||
"handleapi", "errhandlingapi", "winnt", "winerror"
|
||||
] }
|
||||
windows = { version = "0.52", features = [
|
||||
"Win32_Foundation", "Win32_System_ProcessStatus",
|
||||
"Win32_System_Threading", "Win32_UI_WindowsAndMessaging",
|
||||
"Win32_Graphics_Gdi", "Win32_System_Diagnostics_ToolHelp"
|
||||
] }
|
||||
|
||||
[features]
|
||||
default = []
|
||||
x11 = ["x11rb"]
|
||||
wayland = ["wayland-client", "wayland-protocols"]
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3.8"
|
||||
assert_cmd = "2.0"
|
||||
predicates = "3.0"
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
panic = "abort"
|
||||
strip = true
|
||||
16
peekaboo-native/build.rs
Normal file
16
peekaboo-native/build.rs
Normal file
@ -0,0 +1,16 @@
|
||||
fn main() {
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
println!("cargo:rustc-link-lib=X11");
|
||||
println!("cargo:rustc-link-lib=Xext");
|
||||
println!("cargo:rustc-link-lib=xcb");
|
||||
}
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
println!("cargo:rustc-link-lib=user32");
|
||||
println!("cargo:rustc-link-lib=gdi32");
|
||||
println!("cargo:rustc-link-lib=kernel32");
|
||||
}
|
||||
}
|
||||
|
||||
429
peekaboo-native/src/application_finder.rs
Normal file
429
peekaboo-native/src/application_finder.rs
Normal file
@ -0,0 +1,429 @@
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use crate::models::{ApplicationData, ApplicationInfo};
|
||||
use sysinfo::{System, Pid};
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[cfg(windows)]
|
||||
use winapi::um::{
|
||||
processthreadsapi::OpenProcess,
|
||||
psapi::{GetModuleFileNameExW, GetProcessImageFileNameW},
|
||||
winnt::{PROCESS_QUERY_INFORMATION, PROCESS_VM_READ},
|
||||
handleapi::CloseHandle,
|
||||
tlhelp32api::{CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS},
|
||||
winuser::{GetWindowTextW, EnumWindows, GetWindowThreadProcessId, IsWindowVisible},
|
||||
};
|
||||
|
||||
#[cfg(windows)]
|
||||
use std::ffi::OsString;
|
||||
#[cfg(windows)]
|
||||
use std::os::windows::ffi::OsStringExt;
|
||||
|
||||
pub struct ApplicationFinder {
|
||||
system: System,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AppMatch {
|
||||
pub app: ApplicationData,
|
||||
pub score: f64,
|
||||
pub match_type: String,
|
||||
}
|
||||
|
||||
impl ApplicationFinder {
|
||||
pub fn new() -> Self {
|
||||
let mut system = System::new_all();
|
||||
system.refresh_all();
|
||||
Self { system }
|
||||
}
|
||||
|
||||
pub fn refresh(&mut self) {
|
||||
self.system.refresh_all();
|
||||
}
|
||||
|
||||
pub fn find_application(&mut self, identifier: &str) -> PeekabooResult<ApplicationData> {
|
||||
crate::logger::debug(&format!("Searching for application: {}", identifier));
|
||||
|
||||
self.refresh();
|
||||
let running_apps = self.get_all_running_applications_internal()?;
|
||||
|
||||
// Check for exact name match first
|
||||
if let Some(exact_match) = running_apps.iter().find(|app| {
|
||||
app.name.to_lowercase() == identifier.to_lowercase()
|
||||
}) {
|
||||
crate::logger::debug(&format!("Found exact name match: {}", exact_match.name));
|
||||
return Ok(exact_match.clone());
|
||||
}
|
||||
|
||||
// Check for exact bundle ID match (if it looks like a bundle ID)
|
||||
if identifier.contains('.') {
|
||||
if let Some(bundle_match) = running_apps.iter().find(|app| {
|
||||
app.bundle_id.as_ref().map_or(false, |id| id == identifier)
|
||||
}) {
|
||||
crate::logger::debug(&format!("Found exact bundle ID match: {}", bundle_match.name));
|
||||
return Ok(bundle_match.clone());
|
||||
}
|
||||
}
|
||||
|
||||
// Find all possible matches
|
||||
let matches = self.find_all_matches(identifier, &running_apps);
|
||||
let unique_matches = self.remove_duplicate_matches(matches);
|
||||
|
||||
self.process_match_results(unique_matches, identifier, &running_apps)
|
||||
}
|
||||
|
||||
pub fn get_all_running_applications(&mut self) -> PeekabooResult<Vec<ApplicationInfo>> {
|
||||
crate::logger::debug("Retrieving all running applications");
|
||||
|
||||
self.refresh();
|
||||
let apps = self.get_all_running_applications_internal()?;
|
||||
|
||||
let mut result = Vec::new();
|
||||
for app in apps {
|
||||
// Count windows for this app (simplified for now)
|
||||
let window_count = self.count_windows_for_app(app.pid);
|
||||
|
||||
// Only include applications that have one or more windows
|
||||
if window_count > 0 {
|
||||
let mut app_info: ApplicationInfo = app.into();
|
||||
app_info.window_count = window_count;
|
||||
result.push(app_info);
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by name for consistent output
|
||||
result.sort_by(|a, b| a.app_name.to_lowercase().cmp(&b.app_name.to_lowercase()));
|
||||
|
||||
crate::logger::debug(&format!("Found {} running applications with windows", result.len()));
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn get_all_running_applications_internal(&mut self) -> PeekabooResult<Vec<ApplicationData>> {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
return self.get_windows_applications();
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
let mut apps = Vec::new();
|
||||
let mut seen_names = HashMap::new();
|
||||
|
||||
for (pid, process) in self.system.processes() {
|
||||
let process_name = process.name().to_string();
|
||||
|
||||
// Skip system processes and processes without names
|
||||
if process_name.is_empty() || self.is_system_process(&process_name) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Try to get a more user-friendly name
|
||||
let display_name = self.get_display_name(&process_name, *pid);
|
||||
|
||||
// Skip duplicates (same display name)
|
||||
if seen_names.contains_key(&display_name) {
|
||||
continue;
|
||||
}
|
||||
seen_names.insert(display_name.clone(), true);
|
||||
|
||||
let bundle_id = self.get_bundle_id(*pid);
|
||||
let path = process.exe().map(|p| p.to_string_lossy().to_string());
|
||||
|
||||
apps.push(ApplicationData {
|
||||
name: display_name,
|
||||
bundle_id,
|
||||
path,
|
||||
pid: pid.as_u32() as i32,
|
||||
is_active: self.is_process_active(*pid),
|
||||
});
|
||||
}
|
||||
|
||||
Ok(apps)
|
||||
}
|
||||
}
|
||||
|
||||
fn find_all_matches(&self, identifier: &str, apps: &[ApplicationData]) -> Vec<AppMatch> {
|
||||
let mut matches = Vec::new();
|
||||
let lower_identifier = identifier.to_lowercase();
|
||||
|
||||
for app in apps {
|
||||
let lower_app_name = app.name.to_lowercase();
|
||||
|
||||
// Check exact name match
|
||||
if lower_app_name == lower_identifier {
|
||||
matches.push(AppMatch {
|
||||
app: app.clone(),
|
||||
score: 1.0,
|
||||
match_type: "exact_name".to_string(),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check prefix match
|
||||
if lower_app_name.starts_with(&lower_identifier) {
|
||||
let score = lower_identifier.len() as f64 / lower_app_name.len() as f64;
|
||||
matches.push(AppMatch {
|
||||
app: app.clone(),
|
||||
score,
|
||||
match_type: "prefix".to_string(),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check contains match
|
||||
if lower_app_name.contains(&lower_identifier) {
|
||||
let score = (lower_identifier.len() as f64 / lower_app_name.len() as f64) * 0.8;
|
||||
matches.push(AppMatch {
|
||||
app: app.clone(),
|
||||
score,
|
||||
match_type: "contains".to_string(),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check bundle ID match
|
||||
if let Some(bundle_id) = &app.bundle_id {
|
||||
if bundle_id.to_lowercase().contains(&lower_identifier) {
|
||||
let score = (lower_identifier.len() as f64 / bundle_id.len() as f64) * 0.6;
|
||||
matches.push(AppMatch {
|
||||
app: app.clone(),
|
||||
score,
|
||||
match_type: "bundle_contains".to_string(),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Fuzzy matching
|
||||
let similarity = strsim::jaro_winkler(&lower_app_name, &lower_identifier);
|
||||
if similarity >= 0.7 {
|
||||
matches.push(AppMatch {
|
||||
app: app.clone(),
|
||||
score: similarity * 0.9,
|
||||
match_type: "fuzzy".to_string(),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
matches.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
|
||||
matches
|
||||
}
|
||||
|
||||
fn remove_duplicate_matches(&self, matches: Vec<AppMatch>) -> Vec<AppMatch> {
|
||||
let mut unique_matches = Vec::new();
|
||||
let mut seen_pids = std::collections::HashSet::new();
|
||||
|
||||
for app_match in matches {
|
||||
if !seen_pids.contains(&app_match.app.pid) {
|
||||
seen_pids.insert(app_match.app.pid);
|
||||
unique_matches.push(app_match);
|
||||
}
|
||||
}
|
||||
|
||||
unique_matches
|
||||
}
|
||||
|
||||
fn process_match_results(
|
||||
&self,
|
||||
matches: Vec<AppMatch>,
|
||||
identifier: &str,
|
||||
_running_apps: &[ApplicationData],
|
||||
) -> PeekabooResult<ApplicationData> {
|
||||
if matches.is_empty() {
|
||||
crate::logger::error(&format!("No applications found matching: {}", identifier));
|
||||
return Err(PeekabooError::app_not_found(identifier.to_string()));
|
||||
}
|
||||
|
||||
// Check for ambiguous matches
|
||||
let top_score = matches[0].score;
|
||||
let threshold = if matches[0].match_type.contains("fuzzy") { 0.05 } else { 0.1 };
|
||||
let top_matches: Vec<_> = matches.iter()
|
||||
.filter(|m| (m.score - top_score).abs() < threshold)
|
||||
.collect();
|
||||
|
||||
if top_matches.len() > 1 {
|
||||
let match_descriptions: Vec<String> = top_matches.iter()
|
||||
.map(|m| format!("{} (PID: {})", m.app.name, m.app.pid))
|
||||
.collect();
|
||||
|
||||
let error_msg = format!(
|
||||
"Multiple applications match identifier '{}'. Please be more specific. Matches found: {}",
|
||||
identifier,
|
||||
match_descriptions.join(", ")
|
||||
);
|
||||
crate::logger::error(&error_msg);
|
||||
return Err(PeekabooError::invalid_argument(error_msg));
|
||||
}
|
||||
|
||||
let best_match = &matches[0];
|
||||
crate::logger::debug(&format!(
|
||||
"Found application: {} (score: {:.2}, type: {})",
|
||||
best_match.app.name, best_match.score, best_match.match_type
|
||||
));
|
||||
|
||||
Ok(best_match.app.clone())
|
||||
}
|
||||
|
||||
fn is_system_process(&self, name: &str) -> bool {
|
||||
// List of common system processes to filter out
|
||||
let system_processes = [
|
||||
"kernel", "kthreadd", "ksoftirqd", "migration", "rcu_", "watchdog",
|
||||
"systemd", "kworker", "dbus", "NetworkManager", "pulseaudio",
|
||||
"gdm", "gnome-session", "gnome-shell", "Xorg", "wayland",
|
||||
];
|
||||
|
||||
system_processes.iter().any(|&sys_proc| name.contains(sys_proc))
|
||||
}
|
||||
|
||||
fn get_display_name(&self, process_name: &str, _pid: Pid) -> String {
|
||||
// Remove common suffixes and clean up the name
|
||||
let name = process_name
|
||||
.trim_end_matches(".exe")
|
||||
.trim_end_matches("-bin")
|
||||
.to_string();
|
||||
|
||||
// Capitalize first letter
|
||||
if let Some(first_char) = name.chars().next() {
|
||||
first_char.to_uppercase().collect::<String>() + &name[1..]
|
||||
} else {
|
||||
name
|
||||
}
|
||||
}
|
||||
|
||||
fn get_bundle_id(&self, _pid: Pid) -> Option<String> {
|
||||
// On Linux, we don't have bundle IDs like macOS
|
||||
// We could potentially read from .desktop files or other sources
|
||||
// For now, return None
|
||||
None
|
||||
}
|
||||
|
||||
fn is_process_active(&self, _pid: Pid) -> bool {
|
||||
// On Linux, determining if a process is "active" (has focus) is complex
|
||||
// For now, assume all GUI processes are potentially active
|
||||
true
|
||||
}
|
||||
|
||||
fn count_windows_for_app(&self, _pid: i32) -> i32 {
|
||||
// This will be implemented when we add window management
|
||||
// For now, return 1 for all processes to include them
|
||||
1
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_application_finder_creation() {
|
||||
let finder = ApplicationFinder::new();
|
||||
// Just test that we can create the finder without panicking
|
||||
assert!(finder.system.processes().len() >= 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fuzzy_matching() {
|
||||
let finder = ApplicationFinder::new();
|
||||
let apps = vec![
|
||||
ApplicationData {
|
||||
name: "Firefox".to_string(),
|
||||
bundle_id: Some("org.mozilla.firefox".to_string()),
|
||||
path: None,
|
||||
pid: 1234,
|
||||
is_active: true,
|
||||
},
|
||||
ApplicationData {
|
||||
name: "Chrome".to_string(),
|
||||
bundle_id: Some("com.google.chrome".to_string()),
|
||||
path: None,
|
||||
pid: 5678,
|
||||
is_active: false,
|
||||
},
|
||||
];
|
||||
|
||||
let matches = finder.find_all_matches("fire", &apps);
|
||||
assert!(!matches.is_empty());
|
||||
assert_eq!(matches[0].app.name, "Firefox");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_system_process_filtering() {
|
||||
let finder = ApplicationFinder::new();
|
||||
|
||||
assert!(finder.is_system_process("systemd"));
|
||||
assert!(finder.is_system_process("kworker/0:1"));
|
||||
assert!(!finder.is_system_process("firefox"));
|
||||
assert!(!finder.is_system_process("code"));
|
||||
}
|
||||
}
|
||||
|
||||
// Windows-specific implementations
|
||||
#[cfg(windows)]
|
||||
impl ApplicationFinder {
|
||||
/// Windows-specific method to get running applications with window titles
|
||||
fn get_windows_applications(&mut self) -> PeekabooResult<Vec<ApplicationData>> {
|
||||
let mut applications = Vec::new();
|
||||
let mut process_map = HashMap::new();
|
||||
|
||||
// First, get all processes using sysinfo (cross-platform)
|
||||
self.refresh();
|
||||
for (pid, process) in self.system.processes() {
|
||||
let process_name = process.name().to_string();
|
||||
let app_data = ApplicationData {
|
||||
name: process_name,
|
||||
bundle_id: None, // Windows doesn't have bundle IDs like macOS
|
||||
path: None,
|
||||
path: process.exe().map(|p| p.to_string_lossy().to_string()),
|
||||
pid: pid.as_u32() as i32,
|
||||
is_active: false, // Will be determined by window enumeration
|
||||
};
|
||||
process_map.insert(pid.as_u32(), app_data);
|
||||
}
|
||||
|
||||
// Then enumerate windows to find which processes have visible windows
|
||||
unsafe {
|
||||
let mut window_processes = std::collections::HashSet::new();
|
||||
|
||||
EnumWindows(Some(enum_windows_proc), &mut window_processes as *mut _ as isize);
|
||||
|
||||
// Mark processes with visible windows as active
|
||||
for (pid, mut app_data) in process_map {
|
||||
if window_processes.contains(&pid) {
|
||||
app_data.is_active = true;
|
||||
}
|
||||
|
||||
// Filter out system processes
|
||||
if !self.is_system_process(&app_data.name) {
|
||||
applications.push(app_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(applications)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
unsafe extern "system" fn enum_windows_proc(
|
||||
hwnd: winapi::shared::windef::HWND,
|
||||
lparam: isize,
|
||||
) -> i32 {
|
||||
let window_processes = &mut *(lparam as *mut std::collections::HashSet<u32>);
|
||||
|
||||
// Check if window is visible
|
||||
if IsWindowVisible(hwnd) != 0 {
|
||||
let mut process_id: u32 = 0;
|
||||
GetWindowThreadProcessId(hwnd, &mut process_id);
|
||||
|
||||
if process_id != 0 {
|
||||
// Get window title to filter out empty/system windows
|
||||
let mut title: [u16; 256] = [0; 256];
|
||||
let title_len = GetWindowTextW(hwnd, title.as_mut_ptr(), title.len() as i32);
|
||||
|
||||
if title_len > 0 {
|
||||
window_processes.insert(process_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
1 // Continue enumeration
|
||||
}
|
||||
287
peekaboo-native/src/cli.rs
Normal file
287
peekaboo-native/src/cli.rs
Normal file
@ -0,0 +1,287 @@
|
||||
use clap::{Parser, Subcommand, ValueEnum};
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use serde::Serialize;
|
||||
use serde_json;
|
||||
|
||||
/// A Linux utility for screen capture, application listing, and window management
|
||||
#[derive(Parser, Debug)]
|
||||
#[command(name = "peekaboo")]
|
||||
#[command(about = "A Linux utility for screen capture, application listing, and window management")]
|
||||
#[command(version = env!("CARGO_PKG_VERSION"))]
|
||||
pub struct PeekabooCommand {
|
||||
#[command(subcommand)]
|
||||
pub command: Option<Commands>,
|
||||
}
|
||||
|
||||
#[derive(Subcommand, Debug)]
|
||||
pub enum Commands {
|
||||
/// Capture screenshots or windows
|
||||
Image(ImageCommand),
|
||||
/// List applications and windows
|
||||
#[command(subcommand)]
|
||||
List(ListCommands),
|
||||
}
|
||||
|
||||
#[derive(Subcommand, Debug)]
|
||||
pub enum ListCommands {
|
||||
/// List running applications
|
||||
Apps(AppsCommand),
|
||||
/// List windows
|
||||
Windows(WindowsCommand),
|
||||
/// Check server permissions status
|
||||
#[command(name = "server_status")]
|
||||
ServerStatus(ServerStatusCommand),
|
||||
}
|
||||
|
||||
#[derive(Parser, Debug, Default)]
|
||||
pub struct ImageCommand {
|
||||
/// Target application identifier
|
||||
#[arg(long)]
|
||||
pub app: Option<String>,
|
||||
|
||||
/// Base output path for saved images
|
||||
#[arg(long)]
|
||||
pub path: Option<String>,
|
||||
|
||||
/// Capture mode
|
||||
#[arg(long)]
|
||||
pub mode: Option<CaptureMode>,
|
||||
|
||||
/// Window title to capture
|
||||
#[arg(long = "window-title")]
|
||||
pub window_title: Option<String>,
|
||||
|
||||
/// Window index to capture (0=frontmost)
|
||||
#[arg(long = "window-index")]
|
||||
pub window_index: Option<i32>,
|
||||
|
||||
/// Screen index to capture (0-based)
|
||||
#[arg(long = "screen-index")]
|
||||
pub screen_index: Option<i32>,
|
||||
|
||||
/// Image format
|
||||
#[arg(long, default_value = "png")]
|
||||
pub format: ImageFormat,
|
||||
|
||||
/// Capture focus behavior
|
||||
#[arg(long = "capture-focus", default_value = "auto")]
|
||||
pub capture_focus: CaptureFocus,
|
||||
|
||||
/// Include additional window details
|
||||
#[arg(long, value_enum)]
|
||||
pub window_details: Vec<crate::models::WindowDetailOption>,
|
||||
|
||||
/// Output results in JSON format
|
||||
#[arg(long = "json-output")]
|
||||
pub json_output: bool,
|
||||
}
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
pub struct AppsCommand {
|
||||
/// Output results in JSON format
|
||||
#[arg(long = "json-output")]
|
||||
pub json_output: bool,
|
||||
}
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
pub struct WindowsCommand {
|
||||
/// Target application identifier
|
||||
#[arg(long)]
|
||||
pub app: String,
|
||||
|
||||
/// Include additional window details (comma-separated: off_screen,bounds,ids)
|
||||
#[arg(long = "include-details")]
|
||||
pub include_details: Option<String>,
|
||||
|
||||
/// Output results in JSON format
|
||||
#[arg(long = "json-output")]
|
||||
pub json_output: bool,
|
||||
}
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
pub struct ServerStatusCommand {
|
||||
/// Output results in JSON format
|
||||
#[arg(long = "json-output")]
|
||||
pub json_output: bool,
|
||||
}
|
||||
|
||||
#[derive(ValueEnum, Clone, Debug, Serialize, Default)]
|
||||
pub enum CaptureMode {
|
||||
#[default]
|
||||
Screen,
|
||||
Window,
|
||||
Multi,
|
||||
}
|
||||
|
||||
#[derive(ValueEnum, Debug, Clone, Default)]
|
||||
pub enum ImageFormat {
|
||||
#[default]
|
||||
Png,
|
||||
Jpg,
|
||||
}
|
||||
|
||||
#[derive(ValueEnum, Debug, Clone, Default)]
|
||||
pub enum CaptureFocus {
|
||||
Background,
|
||||
#[default]
|
||||
Auto,
|
||||
Foreground,
|
||||
}
|
||||
|
||||
|
||||
impl ImageCommand {
|
||||
pub async fn execute(&self) -> PeekabooResult<()> {
|
||||
// TODO: Implement image capture functionality
|
||||
println!("Image capture not yet implemented");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn execute_with_platform(&self, platform_manager: &crate::platform::PlatformManager) -> PeekabooResult<()> {
|
||||
use crate::traits::ScreenCapture;
|
||||
|
||||
let screen_capture = platform_manager.get_screen_capture()?;
|
||||
let output_file = self.path.clone().unwrap_or_else(|| "screenshot.png".to_string());
|
||||
|
||||
// For now, just capture the screen regardless of mode
|
||||
let result = screen_capture.capture_screen(None, &output_file)?;
|
||||
|
||||
if self.json_output {
|
||||
let data = serde_json::json!({
|
||||
"success": true,
|
||||
"file_path": result,
|
||||
"app": self.app,
|
||||
"window_title": self.window_title,
|
||||
"window_index": self.window_index,
|
||||
"mode": self.mode
|
||||
});
|
||||
println!("{}", serde_json::to_string_pretty(&data).unwrap());
|
||||
} else {
|
||||
println!("Screenshot saved to: {}", result);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl AppsCommand {
|
||||
pub async fn execute(&self) -> PeekabooResult<()> {
|
||||
// TODO: Implement apps listing functionality
|
||||
println!("Apps listing not yet implemented");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn execute_with_platform(&self, platform_manager: &crate::platform::PlatformManager) -> PeekabooResult<()> {
|
||||
use crate::traits::ApplicationFinder;
|
||||
|
||||
let app_finder = platform_manager.get_application_finder()?;
|
||||
let apps = app_finder.get_all_running_applications()?;
|
||||
|
||||
if self.json_output {
|
||||
let data = serde_json::json!({
|
||||
"success": true,
|
||||
"applications": apps
|
||||
});
|
||||
println!("{}", serde_json::to_string_pretty(&data).unwrap());
|
||||
} else {
|
||||
println!("Running Applications:");
|
||||
for app in apps {
|
||||
println!(" {} (PID: {})", app.app_name, app.pid);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowsCommand {
|
||||
pub async fn execute(&self) -> PeekabooResult<()> {
|
||||
// TODO: Implement windows listing functionality
|
||||
println!("Windows listing not yet implemented");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn execute_with_platform(&self, platform_manager: &crate::platform::PlatformManager) -> PeekabooResult<()> {
|
||||
use crate::traits::WindowManager;
|
||||
|
||||
let window_manager = platform_manager.get_window_manager()?;
|
||||
|
||||
// For now, just return a placeholder response
|
||||
if self.json_output {
|
||||
let data = serde_json::json!({
|
||||
"success": true,
|
||||
"windows": [],
|
||||
"message": "Window listing not yet fully implemented"
|
||||
});
|
||||
println!("{}", serde_json::to_string_pretty(&data).unwrap());
|
||||
} else {
|
||||
println!("Window listing not yet fully implemented");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ServerStatusCommand {
|
||||
pub async fn execute(&self) -> PeekabooResult<()> {
|
||||
// TODO: Implement server status functionality
|
||||
println!("Server status not yet implemented");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn execute_with_platform(&self, platform_manager: &crate::platform::PlatformManager) -> PeekabooResult<()> {
|
||||
use crate::traits::PermissionChecker;
|
||||
|
||||
let permission_checker = platform_manager.get_permission_checker()?;
|
||||
let has_screen_recording = permission_checker.check_screen_recording_permission().unwrap_or(false);
|
||||
let has_accessibility = permission_checker.check_accessibility_permission().unwrap_or(false);
|
||||
|
||||
if self.json_output {
|
||||
let data = serde_json::json!({
|
||||
"success": true,
|
||||
"server_status": {
|
||||
"platform": std::env::consts::OS,
|
||||
"permissions": {
|
||||
"screen_recording": has_screen_recording,
|
||||
"accessibility": has_accessibility
|
||||
},
|
||||
"version": env!("CARGO_PKG_VERSION")
|
||||
}
|
||||
});
|
||||
println!("{}", serde_json::to_string_pretty(&data).unwrap());
|
||||
} else {
|
||||
println!("Server Status:");
|
||||
println!(" Platform: {}", std::env::consts::OS);
|
||||
println!(" Version: {}", env!("CARGO_PKG_VERSION"));
|
||||
println!(" Permissions:");
|
||||
println!(" Screen Recording: {}", if has_screen_recording { "✓" } else { "✗" });
|
||||
println!(" Accessibility: {}", if has_accessibility { "✓" } else { "✗" });
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for CaptureMode {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
CaptureMode::Screen => write!(f, "screen"),
|
||||
CaptureMode::Window => write!(f, "window"),
|
||||
CaptureMode::Multi => write!(f, "multi"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ImageFormat {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
ImageFormat::Png => write!(f, "png"),
|
||||
ImageFormat::Jpg => write!(f, "jpg"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for CaptureFocus {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
CaptureFocus::Background => write!(f, "background"),
|
||||
CaptureFocus::Auto => write!(f, "auto"),
|
||||
CaptureFocus::Foreground => write!(f, "foreground"),
|
||||
}
|
||||
}
|
||||
}
|
||||
326
peekaboo-native/src/environment.rs
Normal file
326
peekaboo-native/src/environment.rs
Normal file
@ -0,0 +1,326 @@
|
||||
use std::env;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum DisplayServer {
|
||||
X11,
|
||||
Wayland,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum DesktopEnvironment {
|
||||
Gnome,
|
||||
Kde,
|
||||
Xfce,
|
||||
I3,
|
||||
Sway,
|
||||
Unity,
|
||||
Mate,
|
||||
Cinnamon,
|
||||
Lxde,
|
||||
Lxqt,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct EnvironmentInfo {
|
||||
pub display_server: DisplayServer,
|
||||
pub desktop_environment: DesktopEnvironment,
|
||||
pub session_type: Option<String>,
|
||||
pub display_name: Option<String>,
|
||||
pub wayland_display: Option<String>,
|
||||
pub is_sandboxed: bool,
|
||||
pub user_id: u32,
|
||||
pub runtime_dir: Option<String>,
|
||||
}
|
||||
|
||||
pub struct Environment;
|
||||
|
||||
impl Environment {
|
||||
pub fn detect() -> EnvironmentInfo {
|
||||
EnvironmentInfo {
|
||||
display_server: Self::detect_display_server(),
|
||||
desktop_environment: Self::detect_desktop_environment(),
|
||||
session_type: env::var("XDG_SESSION_TYPE").ok(),
|
||||
display_name: env::var("DISPLAY").ok(),
|
||||
wayland_display: env::var("WAYLAND_DISPLAY").ok(),
|
||||
is_sandboxed: Self::is_sandboxed(),
|
||||
user_id: Self::get_user_id(),
|
||||
runtime_dir: env::var("XDG_RUNTIME_DIR").ok(),
|
||||
}
|
||||
}
|
||||
|
||||
fn detect_display_server() -> DisplayServer {
|
||||
// Check for Wayland first (more modern)
|
||||
if env::var("WAYLAND_DISPLAY").is_ok() {
|
||||
return DisplayServer::Wayland;
|
||||
}
|
||||
|
||||
// Check for X11
|
||||
if env::var("DISPLAY").is_ok() {
|
||||
return DisplayServer::X11;
|
||||
}
|
||||
|
||||
// Check session type as fallback
|
||||
if let Ok(session_type) = env::var("XDG_SESSION_TYPE") {
|
||||
match session_type.to_lowercase().as_str() {
|
||||
"wayland" => return DisplayServer::Wayland,
|
||||
"x11" => return DisplayServer::X11,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
DisplayServer::Unknown
|
||||
}
|
||||
|
||||
fn detect_desktop_environment() -> DesktopEnvironment {
|
||||
// Check XDG_CURRENT_DESKTOP first (most reliable)
|
||||
if let Ok(desktop) = env::var("XDG_CURRENT_DESKTOP") {
|
||||
let desktop_lower = desktop.to_lowercase();
|
||||
|
||||
if desktop_lower.contains("gnome") {
|
||||
return DesktopEnvironment::Gnome;
|
||||
} else if desktop_lower.contains("kde") || desktop_lower.contains("plasma") {
|
||||
return DesktopEnvironment::Kde;
|
||||
} else if desktop_lower.contains("xfce") {
|
||||
return DesktopEnvironment::Xfce;
|
||||
} else if desktop_lower.contains("i3") {
|
||||
return DesktopEnvironment::I3;
|
||||
} else if desktop_lower.contains("sway") {
|
||||
return DesktopEnvironment::Sway;
|
||||
} else if desktop_lower.contains("unity") {
|
||||
return DesktopEnvironment::Unity;
|
||||
} else if desktop_lower.contains("mate") {
|
||||
return DesktopEnvironment::Mate;
|
||||
} else if desktop_lower.contains("cinnamon") {
|
||||
return DesktopEnvironment::Cinnamon;
|
||||
} else if desktop_lower.contains("lxde") {
|
||||
return DesktopEnvironment::Lxde;
|
||||
} else if desktop_lower.contains("lxqt") {
|
||||
return DesktopEnvironment::Lxqt;
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback checks using other environment variables
|
||||
if env::var("GNOME_DESKTOP_SESSION_ID").is_ok() || env::var("GNOME_SHELL_SESSION_MODE").is_ok() {
|
||||
return DesktopEnvironment::Gnome;
|
||||
}
|
||||
|
||||
if env::var("KDE_FULL_SESSION").is_ok() || env::var("KDE_SESSION_VERSION").is_ok() {
|
||||
return DesktopEnvironment::Kde;
|
||||
}
|
||||
|
||||
if env::var("DESKTOP_SESSION").as_ref().map(|s| s.contains("xfce")).unwrap_or(false) {
|
||||
return DesktopEnvironment::Xfce;
|
||||
}
|
||||
|
||||
// Check for window manager processes
|
||||
if Self::is_process_running("i3") {
|
||||
return DesktopEnvironment::I3;
|
||||
}
|
||||
|
||||
if Self::is_process_running("sway") {
|
||||
return DesktopEnvironment::Sway;
|
||||
}
|
||||
|
||||
DesktopEnvironment::Unknown
|
||||
}
|
||||
|
||||
fn is_sandboxed() -> bool {
|
||||
// Check for various sandboxing technologies
|
||||
env::var("FLATPAK_ID").is_ok() ||
|
||||
env::var("SNAP").is_ok() ||
|
||||
env::var("APPIMAGE").is_ok() ||
|
||||
Path::new("/.dockerenv").exists() ||
|
||||
Path::new("/run/.containerenv").exists()
|
||||
}
|
||||
|
||||
fn get_user_id() -> u32 {
|
||||
unsafe { libc::getuid() }
|
||||
}
|
||||
|
||||
fn is_process_running(process_name: &str) -> bool {
|
||||
// Check if a process is running by looking in /proc
|
||||
if let Ok(entries) = fs::read_dir("/proc") {
|
||||
for entry in entries.flatten() {
|
||||
if let Ok(file_name) = entry.file_name().into_string() {
|
||||
if let Ok(_pid) = file_name.parse::<u32>() {
|
||||
let comm_path = format!("/proc/{}/comm", file_name);
|
||||
if let Ok(comm) = fs::read_to_string(comm_path) {
|
||||
if comm.trim() == process_name {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn get_screenshot_method(env_info: &EnvironmentInfo) -> ScreenshotMethod {
|
||||
match env_info.display_server {
|
||||
DisplayServer::X11 => ScreenshotMethod::X11,
|
||||
DisplayServer::Wayland => {
|
||||
match env_info.desktop_environment {
|
||||
DesktopEnvironment::Gnome => ScreenshotMethod::GnomeScreenshot,
|
||||
DesktopEnvironment::Kde => ScreenshotMethod::Spectacle,
|
||||
DesktopEnvironment::Sway => ScreenshotMethod::Grim,
|
||||
_ => ScreenshotMethod::WaylandGeneric,
|
||||
}
|
||||
}
|
||||
DisplayServer::Unknown => ScreenshotMethod::Generic,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_window_manager_method(env_info: &EnvironmentInfo) -> WindowManagerMethod {
|
||||
match env_info.display_server {
|
||||
DisplayServer::X11 => WindowManagerMethod::X11,
|
||||
DisplayServer::Wayland => {
|
||||
match env_info.desktop_environment {
|
||||
DesktopEnvironment::Sway => WindowManagerMethod::SwayIPC,
|
||||
DesktopEnvironment::Gnome => WindowManagerMethod::GnomeShell,
|
||||
_ => WindowManagerMethod::WaylandGeneric,
|
||||
}
|
||||
}
|
||||
DisplayServer::Unknown => WindowManagerMethod::Generic,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum ScreenshotMethod {
|
||||
X11,
|
||||
GnomeScreenshot,
|
||||
Spectacle,
|
||||
Grim,
|
||||
WaylandGeneric,
|
||||
Generic,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum WindowManagerMethod {
|
||||
X11,
|
||||
SwayIPC,
|
||||
GnomeShell,
|
||||
WaylandGeneric,
|
||||
Generic,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for DisplayServer {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
DisplayServer::X11 => write!(f, "X11"),
|
||||
DisplayServer::Wayland => write!(f, "Wayland"),
|
||||
DisplayServer::Unknown => write!(f, "Unknown"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for DesktopEnvironment {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
DesktopEnvironment::Gnome => write!(f, "GNOME"),
|
||||
DesktopEnvironment::Kde => write!(f, "KDE"),
|
||||
DesktopEnvironment::Xfce => write!(f, "XFCE"),
|
||||
DesktopEnvironment::I3 => write!(f, "i3"),
|
||||
DesktopEnvironment::Sway => write!(f, "Sway"),
|
||||
DesktopEnvironment::Unity => write!(f, "Unity"),
|
||||
DesktopEnvironment::Mate => write!(f, "MATE"),
|
||||
DesktopEnvironment::Cinnamon => write!(f, "Cinnamon"),
|
||||
DesktopEnvironment::Lxde => write!(f, "LXDE"),
|
||||
DesktopEnvironment::Lxqt => write!(f, "LXQt"),
|
||||
DesktopEnvironment::Unknown => write!(f, "Unknown"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for EnvironmentInfo {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "Display Server: {}, Desktop Environment: {}",
|
||||
self.display_server, self.desktop_environment)?;
|
||||
|
||||
if let Some(session) = &self.session_type {
|
||||
write!(f, ", Session Type: {}", session)?;
|
||||
}
|
||||
|
||||
if self.is_sandboxed {
|
||||
write!(f, ", Sandboxed: Yes")?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_environment_detection() {
|
||||
let env_info = Environment::detect();
|
||||
|
||||
println!("Detected environment: {}", env_info);
|
||||
println!("Display server: {}", env_info.display_server);
|
||||
println!("Desktop environment: {}", env_info.desktop_environment);
|
||||
|
||||
// Basic sanity checks
|
||||
assert!(env_info.user_id >= 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_display_server_detection() {
|
||||
let display_server = Environment::detect_display_server();
|
||||
println!("Display server: {}", display_server);
|
||||
|
||||
// Should detect something, even if unknown
|
||||
assert!(matches!(display_server, DisplayServer::X11 | DisplayServer::Wayland | DisplayServer::Unknown));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_desktop_environment_detection() {
|
||||
let desktop = Environment::detect_desktop_environment();
|
||||
println!("Desktop environment: {}", desktop);
|
||||
|
||||
// Should detect something, even if unknown
|
||||
// This is just a smoke test to ensure the function doesn't panic
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_screenshot_method_selection() {
|
||||
let env_info = Environment::detect();
|
||||
let method = Environment::get_screenshot_method(&env_info);
|
||||
|
||||
println!("Recommended screenshot method: {:?}", method);
|
||||
|
||||
// Should return a valid method
|
||||
assert!(matches!(method,
|
||||
ScreenshotMethod::X11 |
|
||||
ScreenshotMethod::GnomeScreenshot |
|
||||
ScreenshotMethod::Spectacle |
|
||||
ScreenshotMethod::Grim |
|
||||
ScreenshotMethod::WaylandGeneric |
|
||||
ScreenshotMethod::Generic
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_window_manager_method_selection() {
|
||||
let env_info = Environment::detect();
|
||||
let method = Environment::get_window_manager_method(&env_info);
|
||||
|
||||
println!("Recommended window manager method: {:?}", method);
|
||||
|
||||
// Should return a valid method
|
||||
assert!(matches!(method,
|
||||
WindowManagerMethod::X11 |
|
||||
WindowManagerMethod::SwayIPC |
|
||||
WindowManagerMethod::GnomeShell |
|
||||
WindowManagerMethod::WaylandGeneric |
|
||||
WindowManagerMethod::Generic
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
194
peekaboo-native/src/errors.rs
Normal file
194
peekaboo-native/src/errors.rs
Normal file
@ -0,0 +1,194 @@
|
||||
use thiserror::Error;
|
||||
|
||||
pub type PeekabooResult<T> = Result<T, PeekabooError>;
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum PeekabooError {
|
||||
#[error("No displays available for capture")]
|
||||
NoDisplaysAvailable,
|
||||
|
||||
#[error("Screen recording permission is required. Please ensure your user has access to the display server and necessary permissions.")]
|
||||
ScreenRecordingPermissionDenied,
|
||||
|
||||
#[error("Accessibility permission is required for some operations. Please ensure your user has necessary window management permissions.")]
|
||||
AccessibilityPermissionDenied,
|
||||
|
||||
#[error("Invalid display ID provided")]
|
||||
InvalidDisplayID,
|
||||
|
||||
#[error("Failed to create the screen capture")]
|
||||
CaptureCreationFailed,
|
||||
|
||||
#[error("The specified window could not be found")]
|
||||
WindowNotFound,
|
||||
|
||||
#[error("Failed to capture the specified window")]
|
||||
WindowCaptureFailed,
|
||||
|
||||
#[error("Failed to write capture file to path: {path}. {details}")]
|
||||
FileWriteError { path: String, details: String },
|
||||
|
||||
#[error("Application with identifier '{identifier}' not found or is not running")]
|
||||
AppNotFound { identifier: String },
|
||||
|
||||
#[error("Invalid window index: {index}")]
|
||||
InvalidWindowIndex { index: i32 },
|
||||
|
||||
#[error("Invalid argument: {message}")]
|
||||
InvalidArgument { message: String },
|
||||
|
||||
#[error("An unexpected error occurred: {message}")]
|
||||
UnknownError { message: String },
|
||||
|
||||
#[error("The '{app_name}' process is running, but no capturable windows were found")]
|
||||
NoWindowsFound { app_name: String },
|
||||
|
||||
#[error("X11 error: {message}")]
|
||||
X11Error { message: String },
|
||||
|
||||
#[error("Wayland error: {message}")]
|
||||
WaylandError { message: String },
|
||||
|
||||
#[error("Environment error: {message}")]
|
||||
EnvironmentError { message: String },
|
||||
|
||||
#[error("IO error: {0}")]
|
||||
IoError(#[from] std::io::Error),
|
||||
|
||||
#[error("Image processing error: {0}")]
|
||||
ImageError(#[from] image::ImageError),
|
||||
|
||||
#[error("JSON serialization error: {0}")]
|
||||
JsonError(#[from] serde_json::Error),
|
||||
|
||||
#[error("System information error: {message}")]
|
||||
SystemInfoError { message: String },
|
||||
|
||||
#[error("System error: {message}")]
|
||||
SystemError { message: String },
|
||||
|
||||
#[error("Platform '{platform}' is not supported")]
|
||||
UnsupportedPlatform { platform: String },
|
||||
}
|
||||
|
||||
impl PeekabooError {
|
||||
pub fn exit_code(&self) -> i32 {
|
||||
match self {
|
||||
Self::NoDisplaysAvailable => 10,
|
||||
Self::ScreenRecordingPermissionDenied => 11,
|
||||
Self::AccessibilityPermissionDenied => 12,
|
||||
Self::InvalidDisplayID => 13,
|
||||
Self::CaptureCreationFailed => 14,
|
||||
Self::WindowNotFound => 15,
|
||||
Self::WindowCaptureFailed => 16,
|
||||
Self::FileWriteError { .. } => 17,
|
||||
Self::AppNotFound { .. } => 18,
|
||||
Self::InvalidWindowIndex { .. } => 19,
|
||||
Self::InvalidArgument { .. } => 20,
|
||||
Self::NoWindowsFound { .. } => 7,
|
||||
Self::X11Error { .. } => 21,
|
||||
Self::WaylandError { .. } => 22,
|
||||
Self::EnvironmentError { .. } => 23,
|
||||
Self::IoError(_) => 24,
|
||||
Self::ImageError(_) => 25,
|
||||
Self::JsonError(_) => 26,
|
||||
Self::SystemInfoError { .. } => 27,
|
||||
Self::SystemError { .. } => 28,
|
||||
Self::UnsupportedPlatform { .. } => 29,
|
||||
Self::UnknownError { .. } => 1,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error_code(&self) -> &'static str {
|
||||
match self {
|
||||
Self::NoDisplaysAvailable => "NO_DISPLAYS_AVAILABLE",
|
||||
Self::ScreenRecordingPermissionDenied => "PERMISSION_ERROR_SCREEN_RECORDING",
|
||||
Self::AccessibilityPermissionDenied => "PERMISSION_ERROR_ACCESSIBILITY",
|
||||
Self::InvalidDisplayID => "INVALID_DISPLAY_ID",
|
||||
Self::CaptureCreationFailed => "CAPTURE_CREATION_FAILED",
|
||||
Self::WindowNotFound => "WINDOW_NOT_FOUND",
|
||||
Self::WindowCaptureFailed => "WINDOW_CAPTURE_FAILED",
|
||||
Self::FileWriteError { .. } => "FILE_IO_ERROR",
|
||||
Self::AppNotFound { .. } => "APP_NOT_FOUND",
|
||||
Self::InvalidWindowIndex { .. } => "INVALID_WINDOW_INDEX",
|
||||
Self::InvalidArgument { .. } => "INVALID_ARGUMENT",
|
||||
Self::NoWindowsFound { .. } => "NO_WINDOWS_FOUND",
|
||||
Self::X11Error { .. } => "X11_ERROR",
|
||||
Self::WaylandError { .. } => "WAYLAND_ERROR",
|
||||
Self::EnvironmentError { .. } => "ENVIRONMENT_ERROR",
|
||||
Self::IoError(_) => "IO_ERROR",
|
||||
Self::ImageError(_) => "IMAGE_ERROR",
|
||||
Self::JsonError(_) => "JSON_ERROR",
|
||||
Self::SystemInfoError { .. } => "SYSTEM_INFO_ERROR",
|
||||
Self::SystemError { .. } => "SYSTEM_ERROR",
|
||||
Self::UnsupportedPlatform { .. } => "UNSUPPORTED_PLATFORM",
|
||||
Self::UnknownError { .. } => "UNKNOWN_ERROR",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Helper functions for creating specific errors
|
||||
impl PeekabooError {
|
||||
pub fn file_write_error(path: String, underlying_error: Option<&dyn std::error::Error>) -> Self {
|
||||
let details = if let Some(error) = underlying_error {
|
||||
let error_string = error.to_string().to_lowercase();
|
||||
if error_string.contains("permission") {
|
||||
"Permission denied - check that the directory is writable and the application has necessary permissions.".to_string()
|
||||
} else if error_string.contains("no such file") {
|
||||
"Directory does not exist - ensure the parent directory exists.".to_string()
|
||||
} else if error_string.contains("no space") {
|
||||
"Insufficient disk space available.".to_string()
|
||||
} else {
|
||||
error.to_string()
|
||||
}
|
||||
} else {
|
||||
"This may be due to insufficient permissions, missing directory, or disk space issues.".to_string()
|
||||
};
|
||||
|
||||
Self::FileWriteError { path, details }
|
||||
}
|
||||
|
||||
pub fn app_not_found(identifier: String) -> Self {
|
||||
Self::AppNotFound { identifier }
|
||||
}
|
||||
|
||||
pub fn invalid_window_index(index: i32) -> Self {
|
||||
Self::InvalidWindowIndex { index }
|
||||
}
|
||||
|
||||
pub fn invalid_argument(message: String) -> Self {
|
||||
Self::InvalidArgument { message }
|
||||
}
|
||||
|
||||
pub fn unknown_error(message: String) -> Self {
|
||||
Self::UnknownError { message }
|
||||
}
|
||||
|
||||
pub fn no_windows_found(app_name: String) -> Self {
|
||||
Self::NoWindowsFound { app_name }
|
||||
}
|
||||
|
||||
pub fn x11_error(message: String) -> Self {
|
||||
Self::X11Error { message }
|
||||
}
|
||||
|
||||
pub fn wayland_error(message: String) -> Self {
|
||||
Self::WaylandError { message }
|
||||
}
|
||||
|
||||
pub fn environment_error(message: String) -> Self {
|
||||
Self::EnvironmentError { message }
|
||||
}
|
||||
|
||||
pub fn system_info_error(message: String) -> Self {
|
||||
Self::SystemInfoError { message }
|
||||
}
|
||||
|
||||
pub fn system_error(message: String) -> Self {
|
||||
Self::SystemError { message }
|
||||
}
|
||||
|
||||
pub fn unsupported_platform(platform: String) -> Self {
|
||||
Self::UnsupportedPlatform { platform }
|
||||
}
|
||||
}
|
||||
143
peekaboo-native/src/json_output.rs
Normal file
143
peekaboo-native/src/json_output.rs
Normal file
@ -0,0 +1,143 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use crate::errors::PeekabooError;
|
||||
use crate::logger;
|
||||
|
||||
static JSON_OUTPUT_MODE: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
pub struct JsonOutputMode;
|
||||
|
||||
impl JsonOutputMode {
|
||||
pub fn set_global(enabled: bool) {
|
||||
JSON_OUTPUT_MODE.store(enabled, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
pub fn is_enabled() -> bool {
|
||||
JSON_OUTPUT_MODE.load(Ordering::Relaxed)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct JsonResponse {
|
||||
pub success: bool,
|
||||
pub data: Option<Value>,
|
||||
pub messages: Option<Vec<String>>,
|
||||
pub debug_logs: Vec<String>,
|
||||
pub error: Option<ErrorInfo>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ErrorInfo {
|
||||
pub message: String,
|
||||
pub code: String,
|
||||
pub details: Option<String>,
|
||||
}
|
||||
|
||||
impl JsonResponse {
|
||||
pub fn success(data: Option<Value>, messages: Option<Vec<String>>) -> Self {
|
||||
Self {
|
||||
success: true,
|
||||
data,
|
||||
messages,
|
||||
debug_logs: crate::logger::Logger::get_debug_logs(),
|
||||
error: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error(error: &PeekabooError, details: Option<String>) -> Self {
|
||||
Self {
|
||||
success: false,
|
||||
data: None,
|
||||
messages: None,
|
||||
debug_logs: crate::logger::Logger::get_debug_logs(),
|
||||
error: Some(ErrorInfo {
|
||||
message: error.to_string(),
|
||||
code: error.error_code().to_string(),
|
||||
details,
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn output_json(response: &JsonResponse) {
|
||||
match serde_json::to_string_pretty(&response) {
|
||||
Ok(json) => println!("{}", json),
|
||||
Err(e) => {
|
||||
logger::error(&format!("Failed to serialize data: {}", e));
|
||||
eprintln!("Error: Failed to serialize response data");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn output_success<T: Serialize>(data: &T, messages: Option<Vec<String>>) {
|
||||
let data_value = match serde_json::to_value(data) {
|
||||
Ok(value) => Some(value),
|
||||
Err(e) => {
|
||||
logger::error(&format!("Failed to serialize data: {}", e));
|
||||
None
|
||||
}
|
||||
};
|
||||
|
||||
let response = JsonResponse::success(data_value, messages);
|
||||
output_json(&response);
|
||||
}
|
||||
|
||||
pub fn output_error(error: &PeekabooError) {
|
||||
let response = JsonResponse::error(error, None);
|
||||
output_json(&response);
|
||||
}
|
||||
|
||||
pub fn output_error_with_details(error: &PeekabooError, details: String) {
|
||||
let response = JsonResponse::error(error, Some(details));
|
||||
output_json(&response);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::models::ApplicationInfo;
|
||||
|
||||
#[test]
|
||||
fn test_json_response_success() {
|
||||
let app_info = ApplicationInfo {
|
||||
app_name: "Test App".to_string(),
|
||||
bundle_id: "com.test.app".to_string(),
|
||||
pid: 1234,
|
||||
is_active: true,
|
||||
window_count: 2,
|
||||
};
|
||||
|
||||
let data_value = serde_json::to_value(&app_info).unwrap();
|
||||
let response = JsonResponse::success(Some(data_value), None);
|
||||
|
||||
assert!(response.success);
|
||||
assert!(response.data.is_some());
|
||||
assert!(response.error.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_json_response_error() {
|
||||
let error = PeekabooError::app_not_found("TestApp".to_string());
|
||||
let response = JsonResponse::error(&error, None);
|
||||
|
||||
assert!(!response.success);
|
||||
assert!(response.data.is_none());
|
||||
assert!(response.error.is_some());
|
||||
|
||||
let error_info = response.error.unwrap();
|
||||
assert_eq!(error_info.code, "APP_NOT_FOUND");
|
||||
assert!(error_info.message.contains("TestApp"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_json_serialization() {
|
||||
let response = JsonResponse::success(None, Some(vec!["Test message".to_string()]));
|
||||
let json_result = serde_json::to_string(&response);
|
||||
assert!(json_result.is_ok());
|
||||
|
||||
let json_string = json_result.unwrap();
|
||||
assert!(json_string.contains("\"success\":true"));
|
||||
assert!(json_string.contains("Test message"));
|
||||
}
|
||||
}
|
||||
113
peekaboo-native/src/logger.rs
Normal file
113
peekaboo-native/src/logger.rs
Normal file
@ -0,0 +1,113 @@
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::collections::VecDeque;
|
||||
|
||||
const MAX_DEBUG_LOGS: usize = 100;
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
static ref DEBUG_LOGS: Arc<Mutex<VecDeque<String>>> = Arc::new(Mutex::new(VecDeque::new()));
|
||||
}
|
||||
|
||||
pub struct Logger;
|
||||
|
||||
impl Logger {
|
||||
pub fn new() -> Self {
|
||||
// Initialize env_logger if not already initialized
|
||||
let _ = env_logger::try_init();
|
||||
Self
|
||||
}
|
||||
|
||||
pub fn debug(&self, message: &str) {
|
||||
log::debug!("{}", message);
|
||||
self.add_debug_log(format!("DEBUG: {}", message));
|
||||
}
|
||||
|
||||
pub fn info(&self, message: &str) {
|
||||
log::info!("{}", message);
|
||||
self.add_debug_log(format!("INFO: {}", message));
|
||||
}
|
||||
|
||||
pub fn warn(&self, message: &str) {
|
||||
log::warn!("{}", message);
|
||||
self.add_debug_log(format!("WARN: {}", message));
|
||||
}
|
||||
|
||||
pub fn error(&self, message: &str) {
|
||||
log::error!("{}", message);
|
||||
self.add_debug_log(format!("ERROR: {}", message));
|
||||
}
|
||||
|
||||
fn add_debug_log(&self, message: String) {
|
||||
if let Ok(mut logs) = DEBUG_LOGS.lock() {
|
||||
if logs.len() >= MAX_DEBUG_LOGS {
|
||||
logs.pop_front();
|
||||
}
|
||||
logs.push_back(message);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_debug_logs() -> Vec<String> {
|
||||
DEBUG_LOGS
|
||||
.lock()
|
||||
.map(|logs| logs.iter().cloned().collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
// Static methods for convenience
|
||||
pub fn debug_static(message: &str) {
|
||||
log::debug!("{}", message);
|
||||
if let Ok(mut logs) = DEBUG_LOGS.lock() {
|
||||
if logs.len() >= MAX_DEBUG_LOGS {
|
||||
logs.pop_front();
|
||||
}
|
||||
logs.push_back(format!("DEBUG: {}", message));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn info_static(message: &str) {
|
||||
log::info!("{}", message);
|
||||
if let Ok(mut logs) = DEBUG_LOGS.lock() {
|
||||
if logs.len() >= MAX_DEBUG_LOGS {
|
||||
logs.pop_front();
|
||||
}
|
||||
logs.push_back(format!("INFO: {}", message));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn warn_static(message: &str) {
|
||||
log::warn!("{}", message);
|
||||
if let Ok(mut logs) = DEBUG_LOGS.lock() {
|
||||
if logs.len() >= MAX_DEBUG_LOGS {
|
||||
logs.pop_front();
|
||||
}
|
||||
logs.push_back(format!("WARN: {}", message));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error_static(message: &str) {
|
||||
log::error!("{}", message);
|
||||
if let Ok(mut logs) = DEBUG_LOGS.lock() {
|
||||
if logs.len() >= MAX_DEBUG_LOGS {
|
||||
logs.pop_front();
|
||||
}
|
||||
logs.push_back(format!("ERROR: {}", message));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Convenience functions
|
||||
pub fn debug(message: &str) {
|
||||
Logger::debug_static(message);
|
||||
}
|
||||
|
||||
pub fn info(message: &str) {
|
||||
Logger::info_static(message);
|
||||
}
|
||||
|
||||
pub fn warn(message: &str) {
|
||||
Logger::warn_static(message);
|
||||
}
|
||||
|
||||
pub fn error(message: &str) {
|
||||
Logger::error_static(message);
|
||||
}
|
||||
|
||||
83
peekaboo-native/src/main.rs
Normal file
83
peekaboo-native/src/main.rs
Normal file
@ -0,0 +1,83 @@
|
||||
use clap::Parser;
|
||||
use std::process;
|
||||
|
||||
mod cli;
|
||||
mod models;
|
||||
mod errors;
|
||||
mod screen_capture;
|
||||
mod json_output;
|
||||
mod logger;
|
||||
mod application_finder;
|
||||
mod window_manager;
|
||||
mod permissions;
|
||||
mod environment;
|
||||
mod traits;
|
||||
mod platform;
|
||||
|
||||
use cli::{PeekabooCommand, Commands};
|
||||
use json_output::JsonOutputMode;
|
||||
use logger::Logger;
|
||||
use platform::PlatformManager;
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
let args = PeekabooCommand::parse();
|
||||
|
||||
// Initialize logger
|
||||
let logger = Logger::new();
|
||||
|
||||
// Initialize platform manager
|
||||
let platform_manager = match PlatformManager::new() {
|
||||
Ok(manager) => manager,
|
||||
Err(e) => {
|
||||
eprintln!("Failed to initialize platform manager: {}", e);
|
||||
process::exit(1);
|
||||
}
|
||||
};
|
||||
|
||||
// Set JSON output mode if specified
|
||||
let json_mode = match &args.command {
|
||||
Some(Commands::Image(cmd)) => cmd.json_output,
|
||||
Some(Commands::List(cmd)) => match cmd {
|
||||
cli::ListCommands::Apps(subcmd) => subcmd.json_output,
|
||||
cli::ListCommands::Windows(subcmd) => subcmd.json_output,
|
||||
cli::ListCommands::ServerStatus(subcmd) => subcmd.json_output,
|
||||
},
|
||||
None => false, // Default to image command
|
||||
};
|
||||
|
||||
JsonOutputMode::set_global(json_mode);
|
||||
|
||||
// Execute the command with platform manager
|
||||
let result = match args.command.unwrap_or(Commands::Image(Default::default())) {
|
||||
Commands::Image(cmd) => {
|
||||
logger.debug(&format!("Executing image command: {:?}", cmd));
|
||||
cmd.execute_with_platform(&platform_manager).await
|
||||
}
|
||||
Commands::List(list_cmd) => {
|
||||
logger.debug(&format!("Executing list command: {:?}", list_cmd));
|
||||
match list_cmd {
|
||||
cli::ListCommands::Apps(cmd) => cmd.execute_with_platform(&platform_manager).await,
|
||||
cli::ListCommands::Windows(cmd) => cmd.execute_with_platform(&platform_manager).await,
|
||||
cli::ListCommands::ServerStatus(cmd) => cmd.execute_with_platform(&platform_manager).await,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
match result {
|
||||
Ok(_) => {
|
||||
logger.debug("Command executed successfully");
|
||||
}
|
||||
Err(error) => {
|
||||
logger.error(&format!("Command failed: {}", error));
|
||||
|
||||
if json_mode {
|
||||
json_output::output_error(&error);
|
||||
} else {
|
||||
eprintln!("Error: {}", error);
|
||||
}
|
||||
|
||||
process::exit(error.exit_code());
|
||||
}
|
||||
}
|
||||
}
|
||||
202
peekaboo-native/src/models.rs
Normal file
202
peekaboo-native/src/models.rs
Normal file
@ -0,0 +1,202 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
// MARK: - Image Capture Models
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct SavedFile {
|
||||
pub path: String,
|
||||
pub item_label: Option<String>,
|
||||
pub window_title: Option<String>,
|
||||
pub window_id: Option<u32>,
|
||||
pub window_index: Option<i32>,
|
||||
pub mime_type: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ImageCaptureData {
|
||||
pub saved_files: Vec<SavedFile>,
|
||||
}
|
||||
|
||||
// MARK: - Application & Window Models
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ApplicationInfo {
|
||||
pub app_name: String,
|
||||
pub bundle_id: String,
|
||||
pub pid: i32,
|
||||
pub is_active: bool,
|
||||
pub window_count: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ApplicationListData {
|
||||
pub applications: Vec<ApplicationInfo>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct WindowInfo {
|
||||
pub window_title: String,
|
||||
pub window_id: Option<u32>,
|
||||
pub window_index: Option<i32>,
|
||||
pub bounds: Option<WindowBounds>,
|
||||
pub is_on_screen: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct WindowBounds {
|
||||
#[serde(rename = "xCoordinate")]
|
||||
pub x_coordinate: i32,
|
||||
#[serde(rename = "yCoordinate")]
|
||||
pub y_coordinate: i32,
|
||||
pub width: i32,
|
||||
pub height: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct TargetApplicationInfo {
|
||||
pub app_name: String,
|
||||
pub bundle_id: Option<String>,
|
||||
pub pid: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct WindowListData {
|
||||
pub windows: Vec<WindowInfo>,
|
||||
pub target_application_info: TargetApplicationInfo,
|
||||
}
|
||||
|
||||
// MARK: - Server Status Models
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ServerPermissions {
|
||||
pub screen_recording: bool,
|
||||
pub accessibility: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ServerStatusData {
|
||||
pub permissions: ServerPermissions,
|
||||
}
|
||||
|
||||
// MARK: - Window Management Internal Models
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct WindowData {
|
||||
pub window_id: u32,
|
||||
pub title: String,
|
||||
pub bounds: WindowBounds,
|
||||
pub is_on_screen: bool,
|
||||
pub window_index: i32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ApplicationData {
|
||||
pub name: String,
|
||||
pub bundle_id: Option<String>,
|
||||
pub path: Option<String>,
|
||||
pub pid: i32,
|
||||
pub is_active: bool,
|
||||
}
|
||||
|
||||
// MARK: - Window Specifier
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum WindowSpecifier {
|
||||
Title(String),
|
||||
Index(i32),
|
||||
}
|
||||
|
||||
// MARK: - Window Details Options
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash, clap::ValueEnum)]
|
||||
pub enum WindowDetailOption {
|
||||
#[value(name = "off_screen")]
|
||||
OffScreen,
|
||||
#[value(name = "bounds")]
|
||||
Bounds,
|
||||
#[value(name = "ids")]
|
||||
Ids,
|
||||
}
|
||||
|
||||
impl WindowDetailOption {
|
||||
pub fn from_str(s: &str) -> Option<Self> {
|
||||
match s {
|
||||
"off_screen" => Some(Self::OffScreen),
|
||||
"bounds" => Some(Self::Bounds),
|
||||
"ids" => Some(Self::Ids),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for WindowDetailOption {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Self::OffScreen => write!(f, "off_screen"),
|
||||
Self::Bounds => write!(f, "bounds"),
|
||||
Self::Ids => write!(f, "ids"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Helper implementations
|
||||
|
||||
impl SavedFile {
|
||||
pub fn new(
|
||||
path: String,
|
||||
item_label: Option<String>,
|
||||
window_title: Option<String>,
|
||||
window_id: Option<u32>,
|
||||
window_index: Option<i32>,
|
||||
format: &crate::cli::ImageFormat,
|
||||
) -> Self {
|
||||
let mime_type = match format {
|
||||
crate::cli::ImageFormat::Png => "image/png".to_string(),
|
||||
crate::cli::ImageFormat::Jpg => "image/jpeg".to_string(),
|
||||
};
|
||||
|
||||
Self {
|
||||
path,
|
||||
item_label,
|
||||
window_title,
|
||||
window_id,
|
||||
window_index,
|
||||
mime_type,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowBounds {
|
||||
pub fn new(x: i32, y: i32, width: i32, height: i32) -> Self {
|
||||
Self {
|
||||
x_coordinate: x,
|
||||
y_coordinate: y,
|
||||
width,
|
||||
height,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<WindowData> for WindowInfo {
|
||||
fn from(window_data: WindowData) -> Self {
|
||||
Self {
|
||||
window_title: window_data.title,
|
||||
window_id: Some(window_data.window_id),
|
||||
window_index: Some(window_data.window_index),
|
||||
bounds: Some(window_data.bounds),
|
||||
is_on_screen: Some(window_data.is_on_screen),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<ApplicationData> for ApplicationInfo {
|
||||
fn from(app_data: ApplicationData) -> Self {
|
||||
Self {
|
||||
app_name: app_data.name,
|
||||
bundle_id: app_data.bundle_id.unwrap_or_default(),
|
||||
pid: app_data.pid,
|
||||
is_active: app_data.is_active,
|
||||
window_count: 0, // Will be filled in by the caller
|
||||
}
|
||||
}
|
||||
}
|
||||
345
peekaboo-native/src/permissions.rs
Normal file
345
peekaboo-native/src/permissions.rs
Normal file
@ -0,0 +1,345 @@
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use std::env;
|
||||
use std::process::Command;
|
||||
|
||||
#[cfg(windows)]
|
||||
use winapi::um::{
|
||||
winuser::{GetSystemMetrics, SM_CXSCREEN, SM_CYSCREEN},
|
||||
errhandlingapi::GetLastError,
|
||||
};
|
||||
|
||||
pub struct PermissionsChecker;
|
||||
|
||||
impl PermissionsChecker {
|
||||
pub fn check_screen_recording_permission() -> bool {
|
||||
// On Linux, screen recording permissions are typically handled by:
|
||||
// 1. User being in the correct groups (e.g., video)
|
||||
// 2. Having access to the display server (X11/Wayland)
|
||||
// 3. Desktop environment permissions (for Wayland)
|
||||
|
||||
// Check if we can access the display
|
||||
if let Ok(_) = env::var("DISPLAY") {
|
||||
// X11 environment
|
||||
Self::check_x11_access()
|
||||
} else if let Ok(_) = env::var("WAYLAND_DISPLAY") {
|
||||
// Wayland environment
|
||||
Self::check_wayland_access()
|
||||
} else {
|
||||
// No display server detected - this is common in headless environments
|
||||
// For operations that don't actually need screen capture (like listing apps),
|
||||
// we should be more lenient
|
||||
crate::logger::debug("No display server detected (DISPLAY or WAYLAND_DISPLAY not set) - headless environment");
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub fn check_accessibility_permission() -> bool {
|
||||
// On Linux, accessibility permissions are less restrictive than macOS
|
||||
// Most window management operations don't require special permissions
|
||||
// unless running in a sandboxed environment
|
||||
|
||||
// Check if we can access basic window management
|
||||
Self::check_window_management_access()
|
||||
}
|
||||
|
||||
pub fn require_screen_recording_permission() -> PeekabooResult<()> {
|
||||
if !Self::check_screen_recording_permission() {
|
||||
return Err(PeekabooError::ScreenRecordingPermissionDenied);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn require_basic_permissions() -> PeekabooResult<()> {
|
||||
if !Self::check_basic_permissions() {
|
||||
return Err(PeekabooError::ScreenRecordingPermissionDenied);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn require_accessibility_permission() -> PeekabooResult<()> {
|
||||
if !Self::check_accessibility_permission() {
|
||||
return Err(PeekabooError::AccessibilityPermissionDenied);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn check_basic_permissions() -> bool {
|
||||
// Check if we can perform basic operations like listing processes
|
||||
// This is more lenient than screen recording permission
|
||||
|
||||
// Check if we have access to /proc (needed for process information)
|
||||
match std::fs::read_dir("/proc") {
|
||||
Ok(_) => true,
|
||||
Err(e) => {
|
||||
crate::logger::warn(&format!("Cannot access /proc: {}", e));
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_x11_access() -> bool {
|
||||
// Try to connect to X11 display
|
||||
match env::var("DISPLAY") {
|
||||
Ok(display) => {
|
||||
crate::logger::debug(&format!("Checking X11 access for display: {}", display));
|
||||
|
||||
// Try to run a simple X11 command to test access
|
||||
match Command::new("xdpyinfo").output() {
|
||||
Ok(output) => {
|
||||
let success = output.status.success();
|
||||
if !success {
|
||||
crate::logger::warn("xdpyinfo failed - X11 access may be restricted");
|
||||
}
|
||||
success
|
||||
}
|
||||
Err(_) => {
|
||||
// xdpyinfo not available, try alternative check
|
||||
crate::logger::debug("xdpyinfo not available, trying alternative X11 check");
|
||||
Self::check_x11_alternative()
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
crate::logger::warn("DISPLAY environment variable not set");
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_x11_alternative() -> bool {
|
||||
// Alternative X11 check using xlsclients or xwininfo
|
||||
if let Ok(output) = Command::new("xlsclients").output() {
|
||||
return output.status.success();
|
||||
}
|
||||
|
||||
if let Ok(output) = Command::new("xwininfo").arg("-root").arg("-tree").output() {
|
||||
return output.status.success();
|
||||
}
|
||||
|
||||
// If no X11 tools are available, assume we have access
|
||||
// The actual screen capture will fail if we don't
|
||||
crate::logger::debug("No X11 tools available for permission check, assuming access");
|
||||
true
|
||||
}
|
||||
|
||||
fn check_wayland_access() -> bool {
|
||||
match env::var("WAYLAND_DISPLAY") {
|
||||
Ok(display) => {
|
||||
crate::logger::debug(&format!("Checking Wayland access for display: {}", display));
|
||||
|
||||
// Check if we can access the Wayland socket
|
||||
let socket_path = if let Ok(runtime_dir) = env::var("XDG_RUNTIME_DIR") {
|
||||
format!("{}/{}", runtime_dir, display)
|
||||
} else {
|
||||
format!("/run/user/{}/{}", Self::get_user_id(), display)
|
||||
};
|
||||
|
||||
match std::fs::metadata(&socket_path) {
|
||||
Ok(_) => {
|
||||
crate::logger::debug(&format!("Wayland socket accessible at: {}", socket_path));
|
||||
true
|
||||
}
|
||||
Err(e) => {
|
||||
crate::logger::warn(&format!("Cannot access Wayland socket {}: {}", socket_path, e));
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
crate::logger::warn("WAYLAND_DISPLAY environment variable not set");
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_window_management_access() -> bool {
|
||||
// Check if we can perform basic window management operations
|
||||
// This is typically allowed on Linux unless in a very restricted environment
|
||||
|
||||
// Check if we're running in a known restricted environment
|
||||
if Self::is_sandboxed_environment() {
|
||||
crate::logger::warn("Running in sandboxed environment - window management may be restricted");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if we have access to /proc (needed for process information)
|
||||
match std::fs::read_dir("/proc") {
|
||||
Ok(_) => true,
|
||||
Err(e) => {
|
||||
crate::logger::warn(&format!("Cannot access /proc: {}", e));
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_sandboxed_environment() -> bool {
|
||||
// Check for common sandboxing indicators
|
||||
|
||||
// Flatpak
|
||||
if env::var("FLATPAK_ID").is_ok() {
|
||||
crate::logger::debug("Detected Flatpak environment");
|
||||
return true;
|
||||
}
|
||||
|
||||
// Snap
|
||||
if env::var("SNAP").is_ok() {
|
||||
crate::logger::debug("Detected Snap environment");
|
||||
return true;
|
||||
}
|
||||
|
||||
// AppImage
|
||||
if env::var("APPIMAGE").is_ok() {
|
||||
crate::logger::debug("Detected AppImage environment");
|
||||
return true;
|
||||
}
|
||||
|
||||
// Docker/Container
|
||||
if std::path::Path::new("/.dockerenv").exists() {
|
||||
crate::logger::debug("Detected Docker environment");
|
||||
return true;
|
||||
}
|
||||
|
||||
false
|
||||
}
|
||||
|
||||
fn get_user_id() -> u32 {
|
||||
// Get the current user ID
|
||||
unsafe { libc::getuid() }
|
||||
}
|
||||
|
||||
pub fn get_permission_status() -> (bool, bool) {
|
||||
let screen_recording = Self::check_screen_recording_permission();
|
||||
let accessibility = Self::check_accessibility_permission();
|
||||
|
||||
crate::logger::debug(&format!(
|
||||
"Permission status - Screen recording: {}, Accessibility: {}",
|
||||
screen_recording, accessibility
|
||||
));
|
||||
|
||||
(screen_recording, accessibility)
|
||||
}
|
||||
|
||||
pub fn get_environment_info() -> String {
|
||||
let mut info = Vec::new();
|
||||
|
||||
// Display server
|
||||
if let Ok(display) = env::var("DISPLAY") {
|
||||
info.push(format!("X11 Display: {}", display));
|
||||
}
|
||||
if let Ok(wayland) = env::var("WAYLAND_DISPLAY") {
|
||||
info.push(format!("Wayland Display: {}", wayland));
|
||||
}
|
||||
|
||||
// Desktop environment
|
||||
if let Ok(desktop) = env::var("XDG_CURRENT_DESKTOP") {
|
||||
info.push(format!("Desktop: {}", desktop));
|
||||
}
|
||||
if let Ok(session) = env::var("XDG_SESSION_TYPE") {
|
||||
info.push(format!("Session Type: {}", session));
|
||||
}
|
||||
|
||||
// Sandboxing
|
||||
if Self::is_sandboxed_environment() {
|
||||
info.push("Sandboxed: Yes".to_string());
|
||||
}
|
||||
|
||||
if info.is_empty() {
|
||||
"Unknown environment".to_string()
|
||||
} else {
|
||||
info.join(", ")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_permission_checker_creation() {
|
||||
// Just test that we can call the static methods without panicking
|
||||
let (screen, accessibility) = PermissionsChecker::get_permission_status();
|
||||
|
||||
// In a test environment, these might be false, which is expected
|
||||
println!("Screen recording permission: {}", screen);
|
||||
println!("Accessibility permission: {}", accessibility);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_environment_info() {
|
||||
let info = PermissionsChecker::get_environment_info();
|
||||
println!("Environment info: {}", info);
|
||||
|
||||
// Should return some information, even if minimal
|
||||
assert!(!info.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sandboxed_detection() {
|
||||
let is_sandboxed = PermissionsChecker::is_sandboxed_environment();
|
||||
println!("Is sandboxed: {}", is_sandboxed);
|
||||
|
||||
// This test just verifies the function doesn't panic
|
||||
// The actual result depends on the test environment
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_user_id() {
|
||||
let uid = PermissionsChecker::get_user_id();
|
||||
println!("User ID: {}", uid);
|
||||
|
||||
// Should return a valid user ID
|
||||
assert!(uid >= 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Windows-specific permission implementations
|
||||
#[cfg(windows)]
|
||||
impl PermissionsChecker {
|
||||
pub fn check_screen_recording_permission() -> bool {
|
||||
// On Windows, screen recording is generally available to all applications
|
||||
// unless restricted by group policy or security software
|
||||
// We can test this by checking if we can get screen metrics
|
||||
unsafe {
|
||||
let width = GetSystemMetrics(SM_CXSCREEN);
|
||||
let height = GetSystemMetrics(SM_CYSCREEN);
|
||||
|
||||
if width > 0 && height > 0 {
|
||||
crate::logger::debug(&format!("Screen access available: {}x{}", width, height));
|
||||
true
|
||||
} else {
|
||||
crate::logger::debug("Cannot access screen metrics");
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn check_accessibility_permission() -> bool {
|
||||
// On Windows, accessibility features are generally available
|
||||
// We can check if we can enumerate windows as a basic test
|
||||
unsafe {
|
||||
use winapi::um::winuser::{EnumWindows, GetWindowTextW};
|
||||
|
||||
let mut window_count = 0;
|
||||
let result = EnumWindows(Some(count_windows_proc), &mut window_count as *mut _ as isize);
|
||||
|
||||
if result != 0 && window_count > 0 {
|
||||
crate::logger::debug(&format!("Accessibility check passed: found {} windows", window_count));
|
||||
true
|
||||
} else {
|
||||
crate::logger::debug("Cannot enumerate windows - accessibility may be restricted");
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
unsafe extern "system" fn count_windows_proc(
|
||||
_hwnd: winapi::shared::windef::HWND,
|
||||
lparam: isize,
|
||||
) -> i32 {
|
||||
let counter = &mut *(lparam as *mut i32);
|
||||
*counter += 1;
|
||||
1 // Continue enumeration
|
||||
}
|
||||
646
peekaboo-native/src/platform/linux.rs
Normal file
646
peekaboo-native/src/platform/linux.rs
Normal file
@ -0,0 +1,646 @@
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use crate::models::{ApplicationInfo, WindowBounds, WindowData, WindowInfo};
|
||||
use crate::traits::{ApplicationFinder, PermissionChecker, ScreenCapture, ScreenInfo, WindowManager};
|
||||
use std::collections::HashMap;
|
||||
use std::process::Command;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
// X11 imports for native screen capture
|
||||
use x11::xlib::{self, Display, XOpenDisplay, XCloseDisplay, XDefaultRootWindow, XGetWindowAttributes, XWindowAttributes};
|
||||
use x11::xlib::{XGetImage, XDestroyImage, ZPixmap, XImage};
|
||||
use std::ptr;
|
||||
use std::ffi::CString;
|
||||
|
||||
/// Linux-specific window manager using X11/Wayland
|
||||
pub struct LinuxWindowManager {
|
||||
display_server: DisplayServer,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
enum DisplayServer {
|
||||
X11,
|
||||
Wayland,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl LinuxWindowManager {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
let display_server = detect_display_server();
|
||||
Ok(Self { display_server })
|
||||
}
|
||||
|
||||
fn get_windows_via_wmctrl(&self, pid: i32) -> PeekabooResult<Vec<WindowData>> {
|
||||
let output = Command::new("wmctrl")
|
||||
.args(["-l", "-p"])
|
||||
.output()
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to run wmctrl: {}", e)))?;
|
||||
|
||||
if !output.status.success() {
|
||||
return Err(PeekabooError::system_error("wmctrl command failed".to_string()));
|
||||
}
|
||||
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let mut windows = Vec::new();
|
||||
|
||||
for (index, line) in stdout.lines().enumerate() {
|
||||
let parts: Vec<&str> = line.split_whitespace().collect();
|
||||
if parts.len() >= 4 {
|
||||
if let Ok(window_pid) = parts[2].parse::<i32>() {
|
||||
if window_pid == pid {
|
||||
let window_id = u32::from_str_radix(parts[0].trim_start_matches("0x"), 16)
|
||||
.unwrap_or(0);
|
||||
let title = parts[4..].join(" ");
|
||||
|
||||
// Get window geometry
|
||||
let bounds = self.get_window_bounds(window_id).unwrap_or_else(|_| {
|
||||
WindowBounds::new(0, 0, 800, 600)
|
||||
});
|
||||
|
||||
windows.push(WindowData {
|
||||
window_id,
|
||||
title,
|
||||
bounds,
|
||||
is_on_screen: true, // wmctrl only shows visible windows
|
||||
window_index: index as i32,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(windows)
|
||||
}
|
||||
|
||||
fn get_window_bounds(&self, window_id: u32) -> PeekabooResult<WindowBounds> {
|
||||
let output = Command::new("xwininfo")
|
||||
.args(["-id", &format!("0x{:x}", window_id)])
|
||||
.output()
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to run xwininfo: {}", e)))?;
|
||||
|
||||
if !output.status.success() {
|
||||
return Err(PeekabooError::system_error("xwininfo command failed".to_string()));
|
||||
}
|
||||
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let mut x = 0;
|
||||
let mut y = 0;
|
||||
let mut width = 800;
|
||||
let mut height = 600;
|
||||
|
||||
for line in stdout.lines() {
|
||||
if line.contains("Absolute upper-left X:") {
|
||||
if let Some(value) = line.split(':').nth(1) {
|
||||
x = value.trim().parse().unwrap_or(0);
|
||||
}
|
||||
} else if line.contains("Absolute upper-left Y:") {
|
||||
if let Some(value) = line.split(':').nth(1) {
|
||||
y = value.trim().parse().unwrap_or(0);
|
||||
}
|
||||
} else if line.contains("Width:") {
|
||||
if let Some(value) = line.split(':').nth(1) {
|
||||
width = value.trim().parse().unwrap_or(800);
|
||||
}
|
||||
} else if line.contains("Height:") {
|
||||
if let Some(value) = line.split(':').nth(1) {
|
||||
height = value.trim().parse().unwrap_or(600);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(WindowBounds::new(x, y, width, height))
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowManager for LinuxWindowManager {
|
||||
fn get_windows_for_app(&self, pid: i32) -> PeekabooResult<Vec<WindowData>> {
|
||||
match self.display_server {
|
||||
DisplayServer::X11 => self.get_windows_via_wmctrl(pid),
|
||||
DisplayServer::Wayland => {
|
||||
// For Wayland, we'll need to use different tools or APIs
|
||||
// For now, return empty list with a warning
|
||||
crate::logger::warn("Wayland window enumeration not fully implemented yet");
|
||||
Ok(Vec::new())
|
||||
}
|
||||
DisplayServer::Unknown => {
|
||||
Err(PeekabooError::system_error("Unknown display server".to_string()))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn get_windows_info_for_app(
|
||||
&self,
|
||||
pid: i32,
|
||||
include_off_screen: bool,
|
||||
include_bounds: bool,
|
||||
include_ids: bool,
|
||||
) -> PeekabooResult<Vec<WindowInfo>> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
let mut window_infos = Vec::new();
|
||||
|
||||
for (index, window) in windows.iter().enumerate() {
|
||||
if !include_off_screen && !window.is_on_screen {
|
||||
continue;
|
||||
}
|
||||
|
||||
let window_info = WindowInfo {
|
||||
window_title: window.title.clone(),
|
||||
window_id: if include_ids { Some(window.window_id) } else { None },
|
||||
window_index: Some(index as i32),
|
||||
bounds: if include_bounds { Some(window.bounds.clone()) } else { None },
|
||||
is_on_screen: Some(window.is_on_screen),
|
||||
};
|
||||
|
||||
window_infos.push(window_info);
|
||||
}
|
||||
|
||||
Ok(window_infos)
|
||||
}
|
||||
|
||||
fn activate_window(&self, window_id: u32) -> PeekabooResult<()> {
|
||||
let output = Command::new("wmctrl")
|
||||
.args(["-i", "-a", &format!("0x{:x}", window_id)])
|
||||
.output()
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to activate window: {}", e)))?;
|
||||
|
||||
if output.status.success() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(PeekabooError::system_error("Failed to activate window".to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
fn get_window_by_title(&self, pid: i32, title: &str) -> PeekabooResult<WindowData> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
|
||||
for window in windows {
|
||||
if window.title.to_lowercase().contains(&title.to_lowercase()) {
|
||||
return Ok(window);
|
||||
}
|
||||
}
|
||||
|
||||
Err(PeekabooError::WindowNotFound)
|
||||
}
|
||||
|
||||
fn get_window_by_index(&self, pid: i32, index: i32) -> PeekabooResult<WindowData> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
|
||||
if index >= 0 && (index as usize) < windows.len() {
|
||||
Ok(windows[index as usize].clone())
|
||||
} else {
|
||||
Err(PeekabooError::invalid_window_index(index))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Linux-specific application finder
|
||||
pub struct LinuxApplicationFinder;
|
||||
|
||||
impl LinuxApplicationFinder {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
Ok(Self)
|
||||
}
|
||||
|
||||
fn get_process_info(&self, pid: i32) -> PeekabooResult<(String, String)> {
|
||||
let cmdline_path = format!("/proc/{}/cmdline", pid);
|
||||
let comm_path = format!("/proc/{}/comm", pid);
|
||||
|
||||
let name = fs::read_to_string(&comm_path)
|
||||
.map(|s| s.trim().to_string())
|
||||
.unwrap_or_else(|_| format!("Process {}", pid));
|
||||
|
||||
let cmdline = fs::read_to_string(&cmdline_path)
|
||||
.unwrap_or_else(|_| String::new());
|
||||
|
||||
// Try to extract a meaningful application name
|
||||
let app_name = if !cmdline.is_empty() {
|
||||
let parts: Vec<&str> = cmdline.split('\0').collect();
|
||||
if let Some(first_part) = parts.first() {
|
||||
Path::new(first_part)
|
||||
.file_name()
|
||||
.and_then(|n| n.to_str())
|
||||
.unwrap_or(&name)
|
||||
.to_string()
|
||||
} else {
|
||||
name.clone()
|
||||
}
|
||||
} else {
|
||||
name.clone()
|
||||
};
|
||||
|
||||
Ok((app_name, name))
|
||||
}
|
||||
}
|
||||
|
||||
impl ApplicationFinder for LinuxApplicationFinder {
|
||||
fn get_all_running_applications(&self) -> PeekabooResult<Vec<ApplicationInfo>> {
|
||||
let mut applications = Vec::new();
|
||||
let mut seen_names = HashMap::new();
|
||||
|
||||
// Read /proc to get all processes
|
||||
let proc_dir = fs::read_dir("/proc")
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to read /proc: {}", e)))?;
|
||||
|
||||
for entry in proc_dir {
|
||||
if let Ok(entry) = entry {
|
||||
if let Ok(pid) = entry.file_name().to_string_lossy().parse::<i32>() {
|
||||
if let Ok((app_name, _)) = self.get_process_info(pid) {
|
||||
// Skip kernel threads and system processes
|
||||
if app_name.starts_with('[') && app_name.ends_with(']') {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Group by application name to avoid duplicates
|
||||
let entry = seen_names.entry(app_name.clone()).or_insert_with(|| {
|
||||
ApplicationInfo {
|
||||
app_name: app_name.clone(),
|
||||
bundle_id: format!("linux.{}", app_name),
|
||||
pid,
|
||||
is_active: false, // We'll determine this later
|
||||
window_count: 0,
|
||||
}
|
||||
});
|
||||
|
||||
// Update window count
|
||||
if let Ok(windows) = self.get_window_count(pid) {
|
||||
entry.window_count += windows;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
applications.extend(seen_names.into_values());
|
||||
|
||||
// Sort by name for consistent output
|
||||
applications.sort_by(|a, b| a.app_name.cmp(&b.app_name));
|
||||
|
||||
Ok(applications)
|
||||
}
|
||||
|
||||
fn find_application(&self, identifier: &str) -> PeekabooResult<ApplicationInfo> {
|
||||
// Try to parse as PID first
|
||||
if let Ok(pid) = identifier.parse::<i32>() {
|
||||
if let Ok((app_name, _)) = self.get_process_info(pid) {
|
||||
let window_count = self.get_window_count(pid).unwrap_or(0);
|
||||
return Ok(ApplicationInfo {
|
||||
app_name,
|
||||
bundle_id: format!("linux.pid.{}", pid),
|
||||
pid,
|
||||
is_active: self.is_application_active(pid).unwrap_or(false),
|
||||
window_count,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Search by name
|
||||
let applications = self.get_all_running_applications()?;
|
||||
for app in applications {
|
||||
if app.app_name.to_lowercase().contains(&identifier.to_lowercase()) ||
|
||||
app.bundle_id.to_lowercase().contains(&identifier.to_lowercase()) {
|
||||
return Ok(app);
|
||||
}
|
||||
}
|
||||
|
||||
Err(PeekabooError::WindowNotFound)
|
||||
}
|
||||
|
||||
fn is_application_active(&self, _pid: i32) -> PeekabooResult<bool> {
|
||||
// On Linux, determining if an application is "active" is complex
|
||||
// For now, we'll return false and implement this later
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
fn get_window_count(&self, pid: i32) -> PeekabooResult<i32> {
|
||||
let window_manager = LinuxWindowManager::new()?;
|
||||
let windows = window_manager.get_windows_for_app(pid)?;
|
||||
Ok(windows.len() as i32)
|
||||
}
|
||||
}
|
||||
|
||||
/// Linux-specific screen capture
|
||||
pub struct LinuxScreenCapture {
|
||||
display_server: DisplayServer,
|
||||
}
|
||||
|
||||
impl LinuxScreenCapture {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
let display_server = detect_display_server();
|
||||
Ok(Self { display_server })
|
||||
}
|
||||
|
||||
fn capture_screen_x11(&self, _screen_index: Option<i32>, output_path: &str) -> PeekabooResult<String> {
|
||||
unsafe {
|
||||
// Open connection to X server
|
||||
let display = XOpenDisplay(ptr::null());
|
||||
if display.is_null() {
|
||||
return Err(PeekabooError::system_error("Failed to open X11 display".to_string()));
|
||||
}
|
||||
|
||||
// Get root window
|
||||
let root = XDefaultRootWindow(display);
|
||||
|
||||
// Get window attributes to determine screen size
|
||||
let mut attrs: XWindowAttributes = std::mem::zeroed();
|
||||
let result = XGetWindowAttributes(display, root, &mut attrs);
|
||||
if result == 0 {
|
||||
XCloseDisplay(display);
|
||||
return Err(PeekabooError::system_error("Failed to get window attributes".to_string()));
|
||||
}
|
||||
|
||||
// Capture the screen
|
||||
let image = XGetImage(
|
||||
display,
|
||||
root,
|
||||
0, 0,
|
||||
attrs.width as u32,
|
||||
attrs.height as u32,
|
||||
0xFFFFFFFF, // AllPlanes equivalent
|
||||
ZPixmap
|
||||
);
|
||||
|
||||
if image.is_null() {
|
||||
XCloseDisplay(display);
|
||||
return Err(PeekabooError::system_error("Failed to capture screen image".to_string()));
|
||||
}
|
||||
|
||||
// Convert X11 image to RGB data
|
||||
let result = self.save_x11_image_to_file(image, output_path, attrs.width as u32, attrs.height as u32);
|
||||
|
||||
// Cleanup
|
||||
XDestroyImage(image);
|
||||
XCloseDisplay(display);
|
||||
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
fn save_x11_image_to_file(&self, x_image: *mut XImage, output_path: &str, width: u32, height: u32) -> PeekabooResult<String> {
|
||||
unsafe {
|
||||
let image_ref = &*x_image;
|
||||
let data_ptr = image_ref.data as *const u8;
|
||||
let bytes_per_pixel = (image_ref.bits_per_pixel / 8) as usize;
|
||||
let total_bytes = (width * height) as usize * bytes_per_pixel;
|
||||
|
||||
// Convert X11 image data to RGB
|
||||
let mut rgb_data = Vec::with_capacity((width * height * 3) as usize);
|
||||
|
||||
for y in 0..height {
|
||||
for x in 0..width {
|
||||
let offset = ((y * width + x) as usize) * bytes_per_pixel;
|
||||
if offset + 2 < total_bytes {
|
||||
let pixel_data = std::slice::from_raw_parts(data_ptr.add(offset), bytes_per_pixel);
|
||||
|
||||
// X11 typically uses BGRA format, convert to RGB
|
||||
if bytes_per_pixel >= 3 {
|
||||
rgb_data.push(pixel_data[2]); // R
|
||||
rgb_data.push(pixel_data[1]); // G
|
||||
rgb_data.push(pixel_data[0]); // B
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Save as PNG using image crate
|
||||
let img = image::RgbImage::from_raw(width, height, rgb_data)
|
||||
.ok_or_else(|| PeekabooError::system_error("Failed to create image from raw data".to_string()))?;
|
||||
|
||||
img.save(output_path)
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to save image: {}", e)))?;
|
||||
|
||||
Ok(output_path.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
fn capture_screen_wayland(&self, output_path: &str) -> PeekabooResult<String> {
|
||||
// For Wayland, we'll use grim if available, otherwise fall back to other methods
|
||||
let output = Command::new("grim")
|
||||
.arg(output_path)
|
||||
.output();
|
||||
|
||||
if let Ok(output) = output {
|
||||
if output.status.success() {
|
||||
return Ok(output_path.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback to other methods
|
||||
self.capture_screen_fallback(output_path)
|
||||
}
|
||||
|
||||
fn capture_screen_fallback(&self, output_path: &str) -> PeekabooResult<String> {
|
||||
// Try scrot as fallback
|
||||
let output = Command::new("scrot")
|
||||
.arg(output_path)
|
||||
.output();
|
||||
|
||||
if let Ok(output) = output {
|
||||
if output.status.success() {
|
||||
return Ok(output_path.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
// Try import (ImageMagick) as another fallback
|
||||
let output = Command::new("import")
|
||||
.args(["-window", "root", output_path])
|
||||
.output();
|
||||
|
||||
if let Ok(output) = output {
|
||||
if output.status.success() {
|
||||
return Ok(output_path.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
Err(PeekabooError::system_error("No suitable screenshot tool found".to_string()))
|
||||
}
|
||||
|
||||
fn capture_window(&self, window_data: &WindowData, output_path: &str) -> PeekabooResult<String> {
|
||||
match self.display_server {
|
||||
DisplayServer::X11 => self.capture_window_x11(window_data, output_path),
|
||||
DisplayServer::Wayland => self.capture_window_wayland(window_data, output_path),
|
||||
DisplayServer::Unknown => self.capture_window_fallback(window_data, output_path),
|
||||
}
|
||||
}
|
||||
|
||||
fn capture_window_x11(&self, window_data: &WindowData, output_path: &str) -> PeekabooResult<String> {
|
||||
unsafe {
|
||||
let display = XOpenDisplay(ptr::null());
|
||||
if display.is_null() {
|
||||
return Err(PeekabooError::system_error("Failed to open X11 display".to_string()));
|
||||
}
|
||||
|
||||
let window_id = window_data.window_id as u64;
|
||||
|
||||
// Get window attributes
|
||||
let mut attrs: XWindowAttributes = std::mem::zeroed();
|
||||
let result = XGetWindowAttributes(display, window_id, &mut attrs);
|
||||
if result == 0 {
|
||||
XCloseDisplay(display);
|
||||
return Err(PeekabooError::system_error("Failed to get window attributes".to_string()));
|
||||
}
|
||||
|
||||
// Capture the window
|
||||
let image = XGetImage(
|
||||
display,
|
||||
window_id,
|
||||
0, 0,
|
||||
attrs.width as u32,
|
||||
attrs.height as u32,
|
||||
0xFFFFFFFF, // AllPlanes equivalent
|
||||
ZPixmap
|
||||
);
|
||||
|
||||
if image.is_null() {
|
||||
XCloseDisplay(display);
|
||||
return Err(PeekabooError::system_error("Failed to capture window image".to_string()));
|
||||
}
|
||||
|
||||
let result = self.save_x11_image_to_file(image, output_path, attrs.width as u32, attrs.height as u32);
|
||||
|
||||
XDestroyImage(image);
|
||||
XCloseDisplay(display);
|
||||
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
fn capture_window_wayland(&self, _window_data: &WindowData, output_path: &str) -> PeekabooResult<String> {
|
||||
// Wayland window capture is more complex, fall back to tools for now
|
||||
self.capture_window_fallback(_window_data, output_path)
|
||||
}
|
||||
|
||||
fn capture_window_fallback(&self, _window_data: &WindowData, output_path: &str) -> PeekabooResult<String> {
|
||||
let output = Command::new("gnome-screenshot")
|
||||
.args(["-w", "-f", output_path])
|
||||
.output()
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to capture window: {}", e)))?;
|
||||
|
||||
if output.status.success() {
|
||||
Ok(output_path.to_string())
|
||||
} else {
|
||||
Err(PeekabooError::system_error("Window capture failed".to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
fn get_available_screens(&self) -> PeekabooResult<Vec<ScreenInfo>> {
|
||||
// Use xrandr to get screen information
|
||||
let output = Command::new("xrandr")
|
||||
.arg("--query")
|
||||
.output()
|
||||
.map_err(|e| PeekabooError::system_error(format!("Failed to run xrandr: {}", e)))?;
|
||||
|
||||
if !output.status.success() {
|
||||
return Ok(vec![ScreenInfo {
|
||||
index: 0,
|
||||
width: 1920,
|
||||
height: 1080,
|
||||
is_primary: true,
|
||||
}]);
|
||||
}
|
||||
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let mut screens = Vec::new();
|
||||
let mut index = 0;
|
||||
|
||||
for line in stdout.lines() {
|
||||
if line.contains(" connected") {
|
||||
if let Some(resolution_part) = line.split_whitespace().nth(2) {
|
||||
if let Some(dimensions) = resolution_part.split('+').next() {
|
||||
if let Some((width_str, height_str)) = dimensions.split_once('x') {
|
||||
if let (Ok(width), Ok(height)) = (width_str.parse::<i32>(), height_str.parse::<i32>()) {
|
||||
screens.push(ScreenInfo {
|
||||
index,
|
||||
width,
|
||||
height,
|
||||
is_primary: line.contains("primary"),
|
||||
});
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if screens.is_empty() {
|
||||
screens.push(ScreenInfo {
|
||||
index: 0,
|
||||
width: 1920,
|
||||
height: 1080,
|
||||
is_primary: true,
|
||||
});
|
||||
}
|
||||
|
||||
Ok(screens)
|
||||
}
|
||||
}
|
||||
|
||||
impl ScreenCapture for LinuxScreenCapture {
|
||||
fn capture_screen(&self, screen_index: Option<i32>, output_path: &str) -> PeekabooResult<String> {
|
||||
match self.display_server {
|
||||
DisplayServer::X11 => self.capture_screen_x11(screen_index, output_path),
|
||||
DisplayServer::Wayland => self.capture_screen_wayland(output_path),
|
||||
DisplayServer::Unknown => self.capture_screen_fallback(output_path),
|
||||
}
|
||||
}
|
||||
|
||||
fn capture_window(&self, window_data: &WindowData, output_path: &str) -> PeekabooResult<String> {
|
||||
self.capture_window(window_data, output_path)
|
||||
}
|
||||
|
||||
fn get_available_screens(&self) -> PeekabooResult<Vec<ScreenInfo>> {
|
||||
self.get_available_screens()
|
||||
}
|
||||
}
|
||||
|
||||
/// Linux-specific permission checker
|
||||
pub struct LinuxPermissionChecker;
|
||||
|
||||
impl LinuxPermissionChecker {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
}
|
||||
|
||||
impl PermissionChecker for LinuxPermissionChecker {
|
||||
fn check_screen_recording_permission(&self) -> PeekabooResult<bool> {
|
||||
// On Linux, screen recording permissions are generally not as restrictive as macOS
|
||||
// Check if we can access display
|
||||
let has_display = std::env::var("DISPLAY").is_ok() || std::env::var("WAYLAND_DISPLAY").is_ok();
|
||||
Ok(has_display)
|
||||
}
|
||||
|
||||
fn check_accessibility_permission(&self) -> PeekabooResult<bool> {
|
||||
// Check if we can run window management tools
|
||||
let wmctrl_available = Command::new("wmctrl")
|
||||
.arg("--version")
|
||||
.output()
|
||||
.map(|o| o.status.success())
|
||||
.unwrap_or(false);
|
||||
|
||||
Ok(wmctrl_available)
|
||||
}
|
||||
|
||||
fn request_screen_recording_permission(&self) -> PeekabooResult<()> {
|
||||
// On Linux, permissions are typically handled at the system level
|
||||
// We can provide guidance but can't programmatically request permissions
|
||||
crate::logger::info("Screen recording permissions on Linux are typically managed by the desktop environment");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn request_accessibility_permission(&self) -> PeekabooResult<()> {
|
||||
crate::logger::info("Window management tools may need to be installed (wmctrl, xwininfo, etc.)");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Detect the current display server
|
||||
fn detect_display_server() -> DisplayServer {
|
||||
if std::env::var("WAYLAND_DISPLAY").is_ok() {
|
||||
DisplayServer::Wayland
|
||||
} else if std::env::var("DISPLAY").is_ok() {
|
||||
DisplayServer::X11
|
||||
} else {
|
||||
DisplayServer::Unknown
|
||||
}
|
||||
}
|
||||
76
peekaboo-native/src/platform/mod.rs
Normal file
76
peekaboo-native/src/platform/mod.rs
Normal file
@ -0,0 +1,76 @@
|
||||
use crate::traits::{ApplicationFinder, PermissionChecker, ScreenCapture, WindowManager};
|
||||
use crate::errors::PeekabooResult;
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
pub mod linux;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
pub mod windows;
|
||||
|
||||
/// Platform-specific implementations container
|
||||
pub struct PlatformManager {
|
||||
pub window_manager: Box<dyn WindowManager>,
|
||||
pub application_finder: Box<dyn ApplicationFinder>,
|
||||
pub screen_capture: Box<dyn ScreenCapture>,
|
||||
pub permission_checker: Box<dyn PermissionChecker>,
|
||||
}
|
||||
|
||||
impl PlatformManager {
|
||||
/// Create a new platform manager with appropriate implementations for the current platform
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
Ok(Self {
|
||||
window_manager: Box::new(linux::LinuxWindowManager::new()?),
|
||||
application_finder: Box::new(linux::LinuxApplicationFinder::new()?),
|
||||
screen_capture: Box::new(linux::LinuxScreenCapture::new()?),
|
||||
permission_checker: Box::new(linux::LinuxPermissionChecker::new()),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
Ok(Self {
|
||||
window_manager: Box::new(windows::WindowsWindowManager::new()?),
|
||||
application_finder: Box::new(windows::WindowsApplicationFinder::new()?),
|
||||
screen_capture: Box::new(windows::WindowsScreenCapture::new()?),
|
||||
permission_checker: Box::new(windows::WindowsPermissionChecker::new()),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
|
||||
{
|
||||
Err(PeekabooError::unsupported_platform(std::env::consts::OS.to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the window manager implementation
|
||||
pub fn get_window_manager(&self) -> PeekabooResult<&dyn WindowManager> {
|
||||
Ok(self.window_manager.as_ref())
|
||||
}
|
||||
|
||||
/// Get the application finder implementation
|
||||
pub fn get_application_finder(&self) -> PeekabooResult<&dyn ApplicationFinder> {
|
||||
Ok(self.application_finder.as_ref())
|
||||
}
|
||||
|
||||
/// Get the screen capture implementation
|
||||
pub fn get_screen_capture(&self) -> PeekabooResult<&dyn ScreenCapture> {
|
||||
Ok(self.screen_capture.as_ref())
|
||||
}
|
||||
|
||||
/// Get the permission checker implementation
|
||||
pub fn get_permission_checker(&self) -> PeekabooResult<&dyn PermissionChecker> {
|
||||
Ok(self.permission_checker.as_ref())
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the current platform name
|
||||
pub fn get_platform_name() -> &'static str {
|
||||
std::env::consts::OS
|
||||
}
|
||||
|
||||
/// Check if the current platform is supported
|
||||
pub fn is_platform_supported() -> bool {
|
||||
matches!(std::env::consts::OS, "linux" | "windows")
|
||||
}
|
||||
461
peekaboo-native/src/platform/windows.rs
Normal file
461
peekaboo-native/src/platform/windows.rs
Normal file
@ -0,0 +1,461 @@
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use crate::models::{ApplicationInfo, WindowBounds, WindowData, WindowInfo};
|
||||
use crate::traits::{ApplicationFinder, PermissionChecker, ScreenCapture, ScreenInfo, WindowManager};
|
||||
use std::collections::HashMap;
|
||||
use std::ffi::OsString;
|
||||
use std::os::windows::ffi::OsStringExt;
|
||||
use std::ptr;
|
||||
|
||||
// Windows API imports
|
||||
use winapi::shared::windef::{HWND, RECT};
|
||||
use winapi::shared::minwindef::{BOOL, DWORD, FALSE, TRUE, LPARAM};
|
||||
use winapi::um::winuser::{
|
||||
EnumWindows, GetWindowTextW, GetWindowThreadProcessId, IsWindowVisible,
|
||||
GetWindowRect, SetForegroundWindow, ShowWindow, SW_RESTORE,
|
||||
GetDesktopWindow, GetDC, ReleaseDC, GetDeviceCaps, HORZRES, VERTRES
|
||||
};
|
||||
use winapi::um::processthreadsapi::OpenProcess;
|
||||
use winapi::um::psapi::{EnumProcesses, GetProcessImageFileNameW};
|
||||
use winapi::um::handleapi::CloseHandle;
|
||||
use winapi::um::winnt::{PROCESS_QUERY_INFORMATION, PROCESS_VM_READ};
|
||||
use winapi::um::wingdi::{CreateCompatibleDC, CreateCompatibleBitmap, SelectObject, BitBlt, SRCCOPY};
|
||||
|
||||
/// Windows-specific window manager
|
||||
pub struct WindowsWindowManager;
|
||||
|
||||
impl WindowsWindowManager {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
Ok(Self)
|
||||
}
|
||||
|
||||
fn get_window_text(hwnd: HWND) -> String {
|
||||
unsafe {
|
||||
let mut buffer = [0u16; 512];
|
||||
let len = GetWindowTextW(hwnd, buffer.as_mut_ptr(), buffer.len() as i32);
|
||||
if len > 0 {
|
||||
OsString::from_wide(&buffer[..len as usize])
|
||||
.to_string_lossy()
|
||||
.to_string()
|
||||
} else {
|
||||
"Untitled".to_string()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn get_window_process_id(hwnd: HWND) -> DWORD {
|
||||
unsafe {
|
||||
let mut process_id = 0;
|
||||
GetWindowThreadProcessId(hwnd, &mut process_id);
|
||||
process_id
|
||||
}
|
||||
}
|
||||
|
||||
fn get_window_rect_bounds(hwnd: HWND) -> PeekabooResult<WindowBounds> {
|
||||
unsafe {
|
||||
let mut rect = RECT {
|
||||
left: 0,
|
||||
top: 0,
|
||||
right: 0,
|
||||
bottom: 0,
|
||||
};
|
||||
|
||||
if GetWindowRect(hwnd, &mut rect) != 0 {
|
||||
Ok(WindowBounds::new(
|
||||
rect.left,
|
||||
rect.top,
|
||||
rect.right - rect.left,
|
||||
rect.bottom - rect.top,
|
||||
))
|
||||
} else {
|
||||
Err(PeekabooError::system_error("Failed to get window rect".to_string()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowManager for WindowsWindowManager {
|
||||
fn get_windows_for_app(&self, pid: i32) -> PeekabooResult<Vec<WindowData>> {
|
||||
let mut windows = Vec::new();
|
||||
let target_pid = pid as DWORD;
|
||||
|
||||
unsafe extern "system" fn enum_windows_proc(hwnd: HWND, lparam: LPARAM) -> BOOL {
|
||||
let windows_ptr = lparam as *mut Vec<WindowData>;
|
||||
let windows = &mut *windows_ptr;
|
||||
let target_pid = *(windows.as_ptr() as *const DWORD);
|
||||
|
||||
let window_pid = WindowsWindowManager::get_window_process_id(hwnd);
|
||||
|
||||
if window_pid == target_pid && IsWindowVisible(hwnd) != 0 {
|
||||
let title = WindowsWindowManager::get_window_text(hwnd);
|
||||
let bounds = WindowsWindowManager::get_window_rect_bounds(hwnd)
|
||||
.unwrap_or_else(|_| WindowBounds::new(0, 0, 800, 600));
|
||||
|
||||
let window_data = WindowData {
|
||||
window_id: hwnd as u32,
|
||||
title,
|
||||
bounds,
|
||||
is_on_screen: true,
|
||||
window_index: windows.len() as i32,
|
||||
};
|
||||
|
||||
windows.push(window_data);
|
||||
}
|
||||
|
||||
TRUE
|
||||
}
|
||||
|
||||
unsafe {
|
||||
// Store target PID at the beginning of the vector's memory
|
||||
let mut context = vec![target_pid as WindowData; 1];
|
||||
context.clear();
|
||||
|
||||
EnumWindows(
|
||||
Some(enum_windows_proc),
|
||||
&mut context as *mut Vec<WindowData> as LPARAM,
|
||||
);
|
||||
|
||||
windows = context;
|
||||
}
|
||||
|
||||
Ok(windows)
|
||||
}
|
||||
|
||||
fn get_windows_info_for_app(
|
||||
&self,
|
||||
pid: i32,
|
||||
include_off_screen: bool,
|
||||
include_bounds: bool,
|
||||
include_ids: bool,
|
||||
) -> PeekabooResult<Vec<WindowInfo>> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
let mut window_infos = Vec::new();
|
||||
|
||||
for (index, window) in windows.iter().enumerate() {
|
||||
if !include_off_screen && !window.is_on_screen {
|
||||
continue;
|
||||
}
|
||||
|
||||
let window_info = WindowInfo {
|
||||
window_title: window.title.clone(),
|
||||
window_id: if include_ids { Some(window.window_id) } else { None },
|
||||
window_index: Some(index as i32),
|
||||
bounds: if include_bounds { Some(window.bounds.clone()) } else { None },
|
||||
is_on_screen: Some(window.is_on_screen),
|
||||
};
|
||||
|
||||
window_infos.push(window_info);
|
||||
}
|
||||
|
||||
Ok(window_infos)
|
||||
}
|
||||
|
||||
fn activate_window(&self, window_id: u32) -> PeekabooResult<()> {
|
||||
unsafe {
|
||||
let hwnd = window_id as HWND;
|
||||
|
||||
// Restore window if minimized
|
||||
ShowWindow(hwnd, SW_RESTORE);
|
||||
|
||||
// Bring to foreground
|
||||
if SetForegroundWindow(hwnd) != 0 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(PeekabooError::system_error("Failed to activate window".to_string()))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn get_window_by_title(&self, pid: i32, title: &str) -> PeekabooResult<WindowData> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
|
||||
for window in windows {
|
||||
if window.title.to_lowercase().contains(&title.to_lowercase()) {
|
||||
return Ok(window);
|
||||
}
|
||||
}
|
||||
|
||||
Err(PeekabooError::WindowNotFound)
|
||||
}
|
||||
|
||||
fn get_window_by_index(&self, pid: i32, index: i32) -> PeekabooResult<WindowData> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
|
||||
if index >= 0 && (index as usize) < windows.len() {
|
||||
Ok(windows[index as usize].clone())
|
||||
} else {
|
||||
Err(PeekabooError::invalid_window_index(index))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Windows-specific application finder
|
||||
pub struct WindowsApplicationFinder;
|
||||
|
||||
impl WindowsApplicationFinder {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
Ok(Self)
|
||||
}
|
||||
|
||||
fn get_process_name(&self, pid: DWORD) -> String {
|
||||
unsafe {
|
||||
let process_handle = OpenProcess(
|
||||
PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
|
||||
FALSE,
|
||||
pid,
|
||||
);
|
||||
|
||||
if process_handle.is_null() {
|
||||
return format!("Process {}", pid);
|
||||
}
|
||||
|
||||
let mut buffer = [0u16; 512];
|
||||
let len = GetProcessImageFileNameW(
|
||||
process_handle,
|
||||
buffer.as_mut_ptr(),
|
||||
buffer.len() as DWORD,
|
||||
);
|
||||
|
||||
CloseHandle(process_handle);
|
||||
|
||||
if len > 0 {
|
||||
let path = OsString::from_wide(&buffer[..len as usize])
|
||||
.to_string_lossy()
|
||||
.to_string();
|
||||
|
||||
// Extract just the filename
|
||||
if let Some(filename) = path.split('\\').last() {
|
||||
filename.trim_end_matches(".exe").to_string()
|
||||
} else {
|
||||
format!("Process {}", pid)
|
||||
}
|
||||
} else {
|
||||
format!("Process {}", pid)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ApplicationFinder for WindowsApplicationFinder {
|
||||
fn get_all_running_applications(&self) -> PeekabooResult<Vec<ApplicationInfo>> {
|
||||
let mut applications = Vec::new();
|
||||
let mut seen_names = HashMap::new();
|
||||
|
||||
unsafe {
|
||||
let mut processes = [0u32; 1024];
|
||||
let mut bytes_returned = 0;
|
||||
|
||||
if EnumProcesses(
|
||||
processes.as_mut_ptr(),
|
||||
(processes.len() * std::mem::size_of::<DWORD>()) as DWORD,
|
||||
&mut bytes_returned,
|
||||
) == 0 {
|
||||
return Err(PeekabooError::system_error("Failed to enumerate processes".to_string()));
|
||||
}
|
||||
|
||||
let process_count = bytes_returned as usize / std::mem::size_of::<DWORD>();
|
||||
|
||||
for &pid in &processes[..process_count] {
|
||||
if pid == 0 {
|
||||
continue;
|
||||
}
|
||||
|
||||
let app_name = self.get_process_name(pid);
|
||||
|
||||
// Skip system processes
|
||||
if app_name.starts_with("System") || app_name.contains("svchost") {
|
||||
continue;
|
||||
}
|
||||
|
||||
let entry = seen_names.entry(app_name.clone()).or_insert_with(|| {
|
||||
ApplicationInfo {
|
||||
app_name: app_name.clone(),
|
||||
bundle_id: format!("windows.{}", app_name),
|
||||
pid: pid as i32,
|
||||
is_active: false,
|
||||
window_count: 0,
|
||||
}
|
||||
});
|
||||
|
||||
// Update window count
|
||||
if let Ok(count) = self.get_window_count(pid as i32) {
|
||||
entry.window_count += count;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
applications.extend(seen_names.into_values());
|
||||
applications.sort_by(|a, b| a.app_name.cmp(&b.app_name));
|
||||
|
||||
Ok(applications)
|
||||
}
|
||||
|
||||
fn find_application(&self, identifier: &str) -> PeekabooResult<ApplicationInfo> {
|
||||
// Try to parse as PID first
|
||||
if let Ok(pid) = identifier.parse::<i32>() {
|
||||
let app_name = self.get_process_name(pid as DWORD);
|
||||
let window_count = self.get_window_count(pid).unwrap_or(0);
|
||||
return Ok(ApplicationInfo {
|
||||
app_name,
|
||||
bundle_id: format!("windows.pid.{}", pid),
|
||||
pid,
|
||||
is_active: self.is_application_active(pid).unwrap_or(false),
|
||||
window_count,
|
||||
});
|
||||
}
|
||||
|
||||
// Search by name
|
||||
let applications = self.get_all_running_applications()?;
|
||||
for app in applications {
|
||||
if app.app_name.to_lowercase().contains(&identifier.to_lowercase()) ||
|
||||
app.bundle_id.to_lowercase().contains(&identifier.to_lowercase()) {
|
||||
return Ok(app);
|
||||
}
|
||||
}
|
||||
|
||||
Err(PeekabooError::AppNotFound(identifier.to_string()))
|
||||
}
|
||||
|
||||
fn is_application_active(&self, _pid: i32) -> PeekabooResult<bool> {
|
||||
// On Windows, determining if an application is "active" requires checking foreground window
|
||||
// For now, return false and implement this later
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
fn get_window_count(&self, pid: i32) -> PeekabooResult<i32> {
|
||||
let window_manager = WindowsWindowManager::new()?;
|
||||
let windows = window_manager.get_windows_for_app(pid)?;
|
||||
Ok(windows.len() as i32)
|
||||
}
|
||||
}
|
||||
|
||||
/// Windows-specific screen capture
|
||||
pub struct WindowsScreenCapture;
|
||||
|
||||
impl WindowsScreenCapture {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
Ok(Self)
|
||||
}
|
||||
}
|
||||
|
||||
impl ScreenCapture for WindowsScreenCapture {
|
||||
fn capture_screen(&self, _screen_index: Option<i32>, output_path: &str) -> PeekabooResult<String> {
|
||||
// For now, use a simple implementation
|
||||
// In a full implementation, we'd use Windows GDI or newer APIs
|
||||
unsafe {
|
||||
let desktop_hwnd = GetDesktopWindow();
|
||||
let desktop_dc = GetDC(desktop_hwnd);
|
||||
|
||||
if desktop_dc.is_null() {
|
||||
return Err(PeekabooError::system_error("Failed to get desktop DC".to_string()));
|
||||
}
|
||||
|
||||
let width = GetDeviceCaps(desktop_dc, HORZRES);
|
||||
let height = GetDeviceCaps(desktop_dc, VERTRES);
|
||||
|
||||
let mem_dc = CreateCompatibleDC(desktop_dc);
|
||||
let bitmap = CreateCompatibleBitmap(desktop_dc, width, height);
|
||||
|
||||
if mem_dc.is_null() || bitmap.is_null() {
|
||||
ReleaseDC(desktop_hwnd, desktop_dc);
|
||||
return Err(PeekabooError::system_error("Failed to create compatible DC/bitmap".to_string()));
|
||||
}
|
||||
|
||||
SelectObject(mem_dc, bitmap as *mut _);
|
||||
BitBlt(mem_dc, 0, 0, width, height, desktop_dc, 0, 0, SRCCOPY);
|
||||
|
||||
// Here we would save the bitmap to file
|
||||
// For now, just return success
|
||||
ReleaseDC(desktop_hwnd, desktop_dc);
|
||||
|
||||
// TODO: Implement actual bitmap saving
|
||||
crate::logger::warn("Windows screen capture not fully implemented yet");
|
||||
Ok(output_path.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
fn capture_window(&self, window_data: &WindowData, output_path: &str) -> PeekabooResult<String> {
|
||||
// TODO: Implement window-specific capture
|
||||
crate::logger::warn("Windows window capture not fully implemented yet");
|
||||
Ok(output_path.to_string())
|
||||
}
|
||||
|
||||
fn get_available_screens(&self) -> PeekabooResult<Vec<ScreenInfo>> {
|
||||
unsafe {
|
||||
let desktop_hwnd = GetDesktopWindow();
|
||||
let desktop_dc = GetDC(desktop_hwnd);
|
||||
|
||||
if desktop_dc.is_null() {
|
||||
return Ok(vec![ScreenInfo {
|
||||
index: 0,
|
||||
width: 1920,
|
||||
height: 1080,
|
||||
is_primary: true,
|
||||
}]);
|
||||
}
|
||||
|
||||
let width = GetDeviceCaps(desktop_dc, HORZRES);
|
||||
let height = GetDeviceCaps(desktop_dc, VERTRES);
|
||||
|
||||
ReleaseDC(desktop_hwnd, desktop_dc);
|
||||
|
||||
Ok(vec![ScreenInfo {
|
||||
index: 0,
|
||||
width,
|
||||
height,
|
||||
is_primary: true,
|
||||
}])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Windows-specific permission checker
|
||||
pub struct WindowsPermissionChecker;
|
||||
|
||||
impl WindowsPermissionChecker {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
}
|
||||
|
||||
impl PermissionChecker for WindowsPermissionChecker {
|
||||
fn check_screen_recording_permission(&self) -> PeekabooResult<bool> {
|
||||
// On Windows, screen recording permissions are generally less restrictive
|
||||
// We can try to access the desktop
|
||||
unsafe {
|
||||
let desktop_hwnd = GetDesktopWindow();
|
||||
let desktop_dc = GetDC(desktop_hwnd);
|
||||
let has_access = !desktop_dc.is_null();
|
||||
if has_access {
|
||||
ReleaseDC(desktop_hwnd, desktop_dc);
|
||||
}
|
||||
Ok(has_access)
|
||||
}
|
||||
}
|
||||
|
||||
fn check_accessibility_permission(&self) -> PeekabooResult<bool> {
|
||||
// On Windows, we generally have access to window enumeration
|
||||
// Check if we can enumerate windows
|
||||
unsafe {
|
||||
let mut count = 0;
|
||||
extern "system" fn count_windows(_hwnd: HWND, lparam: LPARAM) -> BOOL {
|
||||
let counter = lparam as *mut i32;
|
||||
*counter += 1;
|
||||
TRUE
|
||||
}
|
||||
|
||||
EnumWindows(Some(count_windows), &mut count as *mut i32 as LPARAM);
|
||||
Ok(count > 0)
|
||||
}
|
||||
}
|
||||
|
||||
fn request_screen_recording_permission(&self) -> PeekabooResult<()> {
|
||||
crate::logger::info("Screen recording on Windows typically doesn't require special permissions");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn request_accessibility_permission(&self) -> PeekabooResult<()> {
|
||||
crate::logger::info("Window management on Windows typically doesn't require special permissions");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
190
peekaboo-native/src/screen_capture.rs
Normal file
190
peekaboo-native/src/screen_capture.rs
Normal file
@ -0,0 +1,190 @@
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use crate::models::{SavedFile, ImageCaptureData};
|
||||
use crate::cli::ImageFormat;
|
||||
use screenshots::Screen;
|
||||
use image::{ImageFormat as ImageFormatEnum, DynamicImage};
|
||||
use std::path::Path;
|
||||
|
||||
pub struct ScreenCapture;
|
||||
|
||||
impl ScreenCapture {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
|
||||
pub async fn capture_screens(
|
||||
&self,
|
||||
screen_index: Option<i32>,
|
||||
output_path: &str,
|
||||
format: &ImageFormat,
|
||||
) -> PeekabooResult<ImageCaptureData> {
|
||||
let screens = Screen::all().map_err(|_e| {
|
||||
PeekabooError::CaptureCreationFailed
|
||||
})?;
|
||||
|
||||
if screens.is_empty() {
|
||||
return Err(PeekabooError::NoDisplaysAvailable);
|
||||
}
|
||||
|
||||
let mut saved_files = Vec::new();
|
||||
|
||||
if let Some(index) = screen_index {
|
||||
// Capture specific screen
|
||||
if index >= 0 && (index as usize) < screens.len() {
|
||||
let screen = &screens[index as usize];
|
||||
let file_path = self.generate_screen_filename(output_path, Some(index), format);
|
||||
self.capture_single_screen(screen, &file_path, format)?;
|
||||
|
||||
saved_files.push(SavedFile::new(
|
||||
file_path,
|
||||
Some(format!("Display {} (Index {})", index + 1, index)),
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
format,
|
||||
));
|
||||
} else {
|
||||
return Err(PeekabooError::InvalidDisplayID);
|
||||
}
|
||||
} else {
|
||||
// Capture all screens
|
||||
for (index, screen) in screens.iter().enumerate() {
|
||||
let file_path = self.generate_screen_filename(output_path, Some(index as i32), format);
|
||||
self.capture_single_screen(screen, &file_path, format)?;
|
||||
|
||||
saved_files.push(SavedFile::new(
|
||||
file_path,
|
||||
Some(format!("Display {}", index + 1)),
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
format,
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(ImageCaptureData { saved_files })
|
||||
}
|
||||
|
||||
fn capture_single_screen(
|
||||
&self,
|
||||
screen: &Screen,
|
||||
file_path: &str,
|
||||
format: &ImageFormat,
|
||||
) -> PeekabooResult<()> {
|
||||
let image = screen.capture().map_err(|e| {
|
||||
crate::logger::error(&format!("Failed to capture screen: {}", e));
|
||||
PeekabooError::CaptureCreationFailed
|
||||
})?;
|
||||
|
||||
// Convert screenshots::Image to image::RgbaImage
|
||||
let rgba_image = image::RgbaImage::from_raw(
|
||||
image.width() as u32,
|
||||
image.height() as u32,
|
||||
image.as_raw().to_vec(),
|
||||
)
|
||||
.ok_or_else(|| PeekabooError::CaptureCreationFailed)?;
|
||||
|
||||
self.save_image_buffer(&rgba_image, file_path, format)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn save_image_buffer(
|
||||
&self,
|
||||
image: &image::RgbaImage,
|
||||
file_path: &str,
|
||||
format: &ImageFormat,
|
||||
) -> PeekabooResult<()> {
|
||||
// Convert to DynamicImage
|
||||
let dynamic_image = DynamicImage::ImageRgba8(image.clone());
|
||||
|
||||
// Ensure parent directory exists
|
||||
if let Some(parent) = Path::new(file_path).parent() {
|
||||
std::fs::create_dir_all(parent).map_err(|e| {
|
||||
PeekabooError::file_write_error(file_path.to_string(), Some(&e))
|
||||
})?;
|
||||
}
|
||||
|
||||
// Save the image
|
||||
let image_format = match format {
|
||||
ImageFormat::Png => ImageFormatEnum::Png,
|
||||
ImageFormat::Jpg => ImageFormatEnum::Jpeg,
|
||||
};
|
||||
|
||||
dynamic_image.save_with_format(file_path, image_format).map_err(|e| {
|
||||
PeekabooError::file_write_error(file_path.to_string(), Some(&e))
|
||||
})?;
|
||||
|
||||
crate::logger::debug(&format!("Successfully saved screen capture to: {}", file_path));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_screen_filename(
|
||||
&self,
|
||||
base_path: &str,
|
||||
screen_index: Option<i32>,
|
||||
format: &ImageFormat,
|
||||
) -> String {
|
||||
let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S").to_string();
|
||||
let ext = format.to_string();
|
||||
|
||||
if base_path.contains('.') && !base_path.ends_with('/') {
|
||||
// Treat as file path
|
||||
if let Some(index) = screen_index {
|
||||
let path = Path::new(base_path);
|
||||
let stem = path.file_stem().unwrap_or_default().to_string_lossy();
|
||||
let parent = path.parent().unwrap_or_else(|| Path::new("."));
|
||||
format!("{}/{}_{}.{}", parent.display(), stem, index + 1, ext)
|
||||
} else {
|
||||
base_path.to_string()
|
||||
}
|
||||
} else {
|
||||
// Treat as directory
|
||||
if let Some(index) = screen_index {
|
||||
format!("{}/screen_{}_{}.{}", base_path.trim_end_matches('/'), index + 1, timestamp, ext)
|
||||
} else {
|
||||
format!("{}/screen_{}.{}", base_path.trim_end_matches('/'), timestamp, ext)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use tempfile::TempDir;
|
||||
|
||||
#[test]
|
||||
fn test_generate_screen_filename() {
|
||||
let capture = ScreenCapture::new();
|
||||
let format = ImageFormat::Png;
|
||||
|
||||
// Test directory path
|
||||
let result = capture.generate_screen_filename("/tmp", Some(0), &format);
|
||||
assert!(result.starts_with("/tmp/screen_1_"));
|
||||
assert!(result.ends_with(".png"));
|
||||
|
||||
// Test file path
|
||||
let result = capture.generate_screen_filename("/tmp/test.png", Some(1), &format);
|
||||
assert_eq!(result, "/tmp/test_2.png");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_screen_enumeration() {
|
||||
let capture = ScreenCapture::new();
|
||||
|
||||
// This test just verifies the screen enumeration doesn't crash
|
||||
// Actual capture testing would require a display server
|
||||
let screens = Screen::all();
|
||||
|
||||
// On headless systems, this might return an error, which is expected
|
||||
match screens {
|
||||
Ok(screens) => {
|
||||
println!("Found {} screens", screens.len());
|
||||
}
|
||||
Err(e) => {
|
||||
println!("No screens available (expected in headless environment): {}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
78
peekaboo-native/src/traits.rs
Normal file
78
peekaboo-native/src/traits.rs
Normal file
@ -0,0 +1,78 @@
|
||||
use crate::errors::PeekabooResult;
|
||||
use crate::models::{ApplicationInfo, WindowData, WindowInfo};
|
||||
|
||||
/// Trait for platform-specific window management operations
|
||||
pub trait WindowManager: Send + Sync {
|
||||
/// Get all windows for a specific application process
|
||||
fn get_windows_for_app(&self, pid: i32) -> PeekabooResult<Vec<WindowData>>;
|
||||
|
||||
/// Get window information with optional details
|
||||
fn get_windows_info_for_app(
|
||||
&self,
|
||||
pid: i32,
|
||||
include_off_screen: bool,
|
||||
include_bounds: bool,
|
||||
include_ids: bool,
|
||||
) -> PeekabooResult<Vec<WindowInfo>>;
|
||||
|
||||
/// Activate/focus a specific window
|
||||
fn activate_window(&self, window_id: u32) -> PeekabooResult<()>;
|
||||
|
||||
/// Find a window by title substring
|
||||
fn get_window_by_title(&self, pid: i32, title: &str) -> PeekabooResult<WindowData>;
|
||||
|
||||
/// Get a window by its index (0-based)
|
||||
fn get_window_by_index(&self, pid: i32, index: i32) -> PeekabooResult<WindowData>;
|
||||
}
|
||||
|
||||
/// Trait for platform-specific application discovery
|
||||
pub trait ApplicationFinder: Send + Sync {
|
||||
/// Get all running applications
|
||||
fn get_all_running_applications(&self) -> PeekabooResult<Vec<ApplicationInfo>>;
|
||||
|
||||
/// Find an application by identifier (name, bundle ID, or PID)
|
||||
fn find_application(&self, identifier: &str) -> PeekabooResult<ApplicationInfo>;
|
||||
|
||||
/// Check if an application is currently active/focused
|
||||
fn is_application_active(&self, pid: i32) -> PeekabooResult<bool>;
|
||||
|
||||
/// Get the number of windows for an application
|
||||
fn get_window_count(&self, pid: i32) -> PeekabooResult<i32>;
|
||||
}
|
||||
|
||||
/// Trait for platform-specific screen capture operations
|
||||
pub trait ScreenCapture: Send + Sync {
|
||||
/// Capture the entire screen or a specific screen by index
|
||||
fn capture_screen(&self, screen_index: Option<i32>, output_path: &str) -> PeekabooResult<String>;
|
||||
|
||||
/// Capture a specific window
|
||||
fn capture_window(&self, window_data: &WindowData, output_path: &str) -> PeekabooResult<String>;
|
||||
|
||||
/// Get available screens/displays
|
||||
fn get_available_screens(&self) -> PeekabooResult<Vec<ScreenInfo>>;
|
||||
}
|
||||
|
||||
/// Information about a screen/display
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ScreenInfo {
|
||||
pub index: i32,
|
||||
pub width: i32,
|
||||
pub height: i32,
|
||||
pub is_primary: bool,
|
||||
}
|
||||
|
||||
/// Trait for platform-specific permission checking
|
||||
pub trait PermissionChecker: Send + Sync {
|
||||
/// Check if screen recording permission is granted
|
||||
fn check_screen_recording_permission(&self) -> PeekabooResult<bool>;
|
||||
|
||||
/// Check if accessibility permission is granted (for window management)
|
||||
fn check_accessibility_permission(&self) -> PeekabooResult<bool>;
|
||||
|
||||
/// Request screen recording permission (if possible)
|
||||
fn request_screen_recording_permission(&self) -> PeekabooResult<()>;
|
||||
|
||||
/// Request accessibility permission (if possible)
|
||||
fn request_accessibility_permission(&self) -> PeekabooResult<()>;
|
||||
}
|
||||
|
||||
266
peekaboo-native/src/window_manager.rs
Normal file
266
peekaboo-native/src/window_manager.rs
Normal file
@ -0,0 +1,266 @@
|
||||
use crate::errors::{PeekabooError, PeekabooResult};
|
||||
use crate::models::{WindowData, WindowInfo, WindowBounds, WindowDetailOption};
|
||||
use std::collections::HashSet;
|
||||
|
||||
pub struct WindowManager;
|
||||
|
||||
impl WindowManager {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
|
||||
pub fn get_windows_for_app(&self, pid: i32) -> PeekabooResult<Vec<WindowData>> {
|
||||
crate::logger::debug(&format!("Getting windows for app with PID: {}", pid));
|
||||
|
||||
// This is a placeholder implementation
|
||||
// In a real implementation, we would use X11 or Wayland APIs
|
||||
// to enumerate windows for the specific process
|
||||
|
||||
// For now, return a mock window to demonstrate the structure
|
||||
let mock_window = WindowData {
|
||||
window_id: 12345,
|
||||
title: "Mock Window".to_string(),
|
||||
bounds: WindowBounds::new(100, 100, 800, 600),
|
||||
is_on_screen: true,
|
||||
window_index: 0,
|
||||
};
|
||||
|
||||
Ok(vec![mock_window])
|
||||
}
|
||||
|
||||
pub fn get_windows_info_for_app(
|
||||
&self,
|
||||
pid: i32,
|
||||
include_off_screen: bool,
|
||||
include_bounds: bool,
|
||||
include_ids: bool,
|
||||
) -> PeekabooResult<Vec<WindowInfo>> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
let mut window_infos = Vec::new();
|
||||
|
||||
for (index, window) in windows.iter().enumerate() {
|
||||
// Filter off-screen windows if not requested
|
||||
if !include_off_screen && !window.is_on_screen {
|
||||
continue;
|
||||
}
|
||||
|
||||
let window_info = WindowInfo {
|
||||
window_title: window.title.clone(),
|
||||
window_id: if include_ids { Some(window.window_id) } else { None },
|
||||
window_index: Some(index as i32),
|
||||
bounds: if include_bounds { Some(window.bounds.clone()) } else { None },
|
||||
is_on_screen: Some(window.is_on_screen),
|
||||
};
|
||||
|
||||
window_infos.push(window_info);
|
||||
}
|
||||
|
||||
Ok(window_infos)
|
||||
}
|
||||
|
||||
pub fn parse_include_details(details_string: Option<&str>) -> HashSet<WindowDetailOption> {
|
||||
let mut options = HashSet::new();
|
||||
|
||||
if let Some(details) = details_string {
|
||||
for component in details.split(',') {
|
||||
let trimmed = component.trim();
|
||||
if let Some(option) = WindowDetailOption::from_str(trimmed) {
|
||||
options.insert(option);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
options
|
||||
}
|
||||
|
||||
pub fn activate_window(&self, window_id: u32) -> PeekabooResult<()> {
|
||||
crate::logger::debug(&format!("Activating window with ID: {}", window_id));
|
||||
|
||||
// This would use X11 or Wayland APIs to bring the window to front
|
||||
// For now, this is a placeholder
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn get_window_by_title(&self, pid: i32, title: &str) -> PeekabooResult<WindowData> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
|
||||
for window in windows {
|
||||
if window.title.contains(title) {
|
||||
return Ok(window);
|
||||
}
|
||||
}
|
||||
|
||||
Err(PeekabooError::WindowNotFound)
|
||||
}
|
||||
|
||||
pub fn get_window_by_index(&self, pid: i32, index: i32) -> PeekabooResult<WindowData> {
|
||||
let windows = self.get_windows_for_app(pid)?;
|
||||
|
||||
if index >= 0 && (index as usize) < windows.len() {
|
||||
Ok(windows[index as usize].clone())
|
||||
} else {
|
||||
Err(PeekabooError::invalid_window_index(index))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// X11-specific implementation (when X11 feature is enabled)
|
||||
#[cfg(feature = "x11")]
|
||||
mod x11_impl {
|
||||
use super::*;
|
||||
use x11rb::connection::Connection;
|
||||
use x11rb::protocol::xproto::*;
|
||||
use x11rb::COPY_DEPTH_FROM_PARENT;
|
||||
|
||||
pub struct X11WindowManager {
|
||||
connection: Option<x11rb::rust_connection::RustConnection>,
|
||||
screen_num: usize,
|
||||
}
|
||||
|
||||
impl X11WindowManager {
|
||||
pub fn new() -> PeekabooResult<Self> {
|
||||
match x11rb::connect(None) {
|
||||
Ok((conn, screen_num)) => {
|
||||
Ok(Self {
|
||||
connection: Some(conn),
|
||||
screen_num,
|
||||
})
|
||||
}
|
||||
Err(e) => {
|
||||
crate::logger::warn(&format!("Failed to connect to X11: {}", e));
|
||||
Ok(Self {
|
||||
connection: None,
|
||||
screen_num: 0,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_windows_for_app(&self, pid: i32) -> PeekabooResult<Vec<WindowData>> {
|
||||
let conn = self.connection.as_ref()
|
||||
.ok_or_else(|| PeekabooError::x11_error("No X11 connection available".to_string()))?;
|
||||
|
||||
let screen = &conn.setup().roots[self.screen_num];
|
||||
let root = screen.root;
|
||||
|
||||
// Query all windows
|
||||
let tree_reply = conn.query_tree(root)
|
||||
.map_err(|e| PeekabooError::x11_error(format!("Failed to query window tree: {}", e)))?
|
||||
.reply()
|
||||
.map_err(|e| PeekabooError::x11_error(format!("Failed to get tree reply: {}", e)))?;
|
||||
|
||||
let mut windows = Vec::new();
|
||||
|
||||
for (index, &window) in tree_reply.children.iter().enumerate() {
|
||||
// Get window properties to check PID
|
||||
if let Ok(window_pid) = self.get_window_pid(conn, window) {
|
||||
if window_pid == pid {
|
||||
if let Ok(window_data) = self.create_window_data(conn, window, index) {
|
||||
windows.push(window_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(windows)
|
||||
}
|
||||
|
||||
fn get_window_pid(&self, conn: &x11rb::rust_connection::RustConnection, window: Window) -> Result<i32, Box<dyn std::error::Error>> {
|
||||
// Try to get _NET_WM_PID property
|
||||
let pid_atom = conn.intern_atom(false, b"_NET_WM_PID")?.reply()?.atom;
|
||||
let property = conn.get_property(false, window, pid_atom, AtomEnum::CARDINAL, 0, 1)?.reply()?;
|
||||
|
||||
if property.value.len() >= 4 {
|
||||
let pid_bytes: [u8; 4] = property.value[0..4].try_into()?;
|
||||
let pid = u32::from_ne_bytes(pid_bytes) as i32;
|
||||
Ok(pid)
|
||||
} else {
|
||||
Err("No PID property found".into())
|
||||
}
|
||||
}
|
||||
|
||||
fn create_window_data(&self, conn: &x11rb::rust_connection::RustConnection, window: Window, index: usize) -> Result<WindowData, Box<dyn std::error::Error>> {
|
||||
// Get window title
|
||||
let title = self.get_window_title(conn, window)?;
|
||||
|
||||
// Get window geometry
|
||||
let geometry = conn.get_geometry(window)?.reply()?;
|
||||
|
||||
// Get window attributes to check if visible
|
||||
let attributes = conn.get_window_attributes(window)?.reply()?;
|
||||
let is_on_screen = attributes.map_state == MapState::VIEWABLE;
|
||||
|
||||
Ok(WindowData {
|
||||
window_id: window,
|
||||
title,
|
||||
bounds: WindowBounds::new(
|
||||
geometry.x as i32,
|
||||
geometry.y as i32,
|
||||
geometry.width as i32,
|
||||
geometry.height as i32,
|
||||
),
|
||||
is_on_screen,
|
||||
window_index: index as i32,
|
||||
})
|
||||
}
|
||||
|
||||
fn get_window_title(&self, conn: &x11rb::rust_connection::RustConnection, window: Window) -> Result<String, Box<dyn std::error::Error>> {
|
||||
// Try _NET_WM_NAME first (UTF-8)
|
||||
let name_atom = conn.intern_atom(false, b"_NET_WM_NAME")?.reply()?.atom;
|
||||
let utf8_atom = conn.intern_atom(false, b"UTF8_STRING")?.reply()?.atom;
|
||||
|
||||
if let Ok(property) = conn.get_property(false, window, name_atom, utf8_atom, 0, 1024)?.reply() {
|
||||
if !property.value.is_empty() {
|
||||
return Ok(String::from_utf8_lossy(&property.value).trim_end_matches('\0').to_string());
|
||||
}
|
||||
}
|
||||
|
||||
// Fall back to WM_NAME
|
||||
if let Ok(property) = conn.get_property(false, window, AtomEnum::WM_NAME, AtomEnum::STRING, 0, 1024)?.reply() {
|
||||
if !property.value.is_empty() {
|
||||
return Ok(String::from_utf8_lossy(&property.value).trim_end_matches('\0').to_string());
|
||||
}
|
||||
}
|
||||
|
||||
Ok("Untitled".to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_window_manager_creation() {
|
||||
let manager = WindowManager::new();
|
||||
// Just test that we can create the manager
|
||||
assert!(true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_include_details() {
|
||||
let options = WindowManager::parse_include_details(Some("off_screen,bounds,ids"));
|
||||
assert_eq!(options.len(), 3);
|
||||
assert!(options.contains(&WindowDetailOption::OffScreen));
|
||||
assert!(options.contains(&WindowDetailOption::Bounds));
|
||||
assert!(options.contains(&WindowDetailOption::Ids));
|
||||
|
||||
let empty_options = WindowManager::parse_include_details(None);
|
||||
assert!(empty_options.is_empty());
|
||||
|
||||
let partial_options = WindowManager::parse_include_details(Some("bounds"));
|
||||
assert_eq!(partial_options.len(), 1);
|
||||
assert!(partial_options.contains(&WindowDetailOption::Bounds));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_window_bounds_creation() {
|
||||
let bounds = WindowBounds::new(100, 200, 800, 600);
|
||||
assert_eq!(bounds.x_coordinate, 100);
|
||||
assert_eq!(bounds.y_coordinate, 200);
|
||||
assert_eq!(bounds.width, 800);
|
||||
assert_eq!(bounds.height, 600);
|
||||
}
|
||||
}
|
||||
@ -200,10 +200,58 @@ async function handleServerStatus(
|
||||
statusSections.push(generateServerStatusString(version));
|
||||
|
||||
// 2. Native Binary Status
|
||||
statusSections.push("\n## Native Binary (Swift CLI) Status");
|
||||
statusSections.push("\n## Native Binary Status");
|
||||
|
||||
const cliPath = process.env.PEEKABOO_CLI_PATH || path.join(packageRootDir, "peekaboo");
|
||||
let cliStatus = "❌ Not found";
|
||||
// Use the same platform detection logic as the main CLI path determination
|
||||
let cliPath: string;
|
||||
const envPath = process.env.PEEKABOO_CLI_PATH;
|
||||
if (envPath) {
|
||||
cliPath = envPath;
|
||||
} else {
|
||||
// Detect platform and use appropriate binary
|
||||
const platform = process.platform;
|
||||
|
||||
if (platform === "darwin") {
|
||||
// macOS - use Swift binary
|
||||
cliPath = path.join(packageRootDir, "peekaboo");
|
||||
} else if (platform === "linux") {
|
||||
// Linux - use Rust binary
|
||||
const linuxBinaryPath = path.resolve(packageRootDir, "peekaboo-native", "target", "release", "peekaboo");
|
||||
if (existsSync(linuxBinaryPath)) {
|
||||
cliPath = linuxBinaryPath;
|
||||
} else {
|
||||
// Fallback to debug build if release doesn't exist
|
||||
const debugBinaryPath = path.resolve(packageRootDir, "peekaboo-native", "target", "debug", "peekaboo");
|
||||
if (existsSync(debugBinaryPath)) {
|
||||
cliPath = debugBinaryPath;
|
||||
} else {
|
||||
cliPath = linuxBinaryPath; // Use expected path for error reporting
|
||||
}
|
||||
}
|
||||
} else if (platform === 'win32') {
|
||||
// Windows - use Rust binary
|
||||
const windowsBinaryPath = path.resolve(packageRootDir, "peekaboo-native", "target", "release", "peekaboo.exe");
|
||||
if (existsSync(windowsBinaryPath)) {
|
||||
cliPath = windowsBinaryPath;
|
||||
} else {
|
||||
// Fallback to debug build if release doesn't exist
|
||||
const debugBinaryPath = path.resolve(packageRootDir, "peekaboo-native", "target", "debug", "peekaboo.exe");
|
||||
if (existsSync(debugBinaryPath)) {
|
||||
cliPath = debugBinaryPath;
|
||||
} else {
|
||||
cliPath = windowsBinaryPath; // Use expected path for error reporting
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Unsupported platform
|
||||
cliPath = path.join(packageRootDir, "peekaboo");
|
||||
}
|
||||
}
|
||||
|
||||
const binaryType = (process.platform === 'linux' || process.platform === 'win32') ? 'Rust' : 'Swift';
|
||||
statusSections.push(`\n## Native Binary (${binaryType} CLI) Status`);
|
||||
|
||||
let cliStatus = "\u274c Not found";
|
||||
let cliVersion = "Unknown";
|
||||
let cliExecutable = false;
|
||||
|
||||
@ -221,12 +269,17 @@ async function handleServerStatus(
|
||||
|
||||
if (versionResult.success && versionResult.data) {
|
||||
cliVersion = versionResult.data.trim();
|
||||
cliStatus = "✅ Found and executable";
|
||||
// Extract just the version number if it includes the binary name
|
||||
const versionMatch = cliVersion.match(/(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)/);
|
||||
if (versionMatch) {
|
||||
cliVersion = versionMatch[1];
|
||||
}
|
||||
cliStatus = "\u2714 Found and executable";
|
||||
} else {
|
||||
cliStatus = "⚠️ Found but version check failed";
|
||||
cliStatus = "\u26a0 Found but version check failed";
|
||||
}
|
||||
} catch (_error) {
|
||||
cliStatus = "⚠️ Found but not executable";
|
||||
cliStatus = "\u26a0 Found but not executable";
|
||||
}
|
||||
}
|
||||
|
||||
@ -250,8 +303,8 @@ async function handleServerStatus(
|
||||
const status = JSON.parse(permissionsResult.data);
|
||||
if (status.data?.permissions) {
|
||||
const perms = status.data.permissions;
|
||||
statusSections.push(`- Screen Recording: ${perms.screen_recording ? "✅ Granted" : "❌ Not granted"}`);
|
||||
statusSections.push(`- Accessibility: ${perms.accessibility ? "✅ Granted" : "❌ Not granted"}`);
|
||||
statusSections.push(`- Screen Recording: ${perms.screen_recording ? "\u2714 Granted" : "\u274c Not granted"}`);
|
||||
statusSections.push(`- Accessibility: ${perms.accessibility ? "\u2714 Granted" : "\u274c Not granted"}`);
|
||||
} else {
|
||||
statusSections.push("- Unable to determine permissions status");
|
||||
}
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
import { spawn } from "child_process";
|
||||
import path from "path";
|
||||
// import { fileURLToPath } from 'url'; // No longer needed here
|
||||
import { Logger } from "pino";
|
||||
import fsPromises from "fs/promises";
|
||||
import { existsSync } from "fs";
|
||||
@ -25,7 +24,42 @@ function determineSwiftCliPath(packageRootDirForFallback?: string): string {
|
||||
}
|
||||
|
||||
if (packageRootDirForFallback) {
|
||||
return path.resolve(packageRootDirForFallback, "peekaboo");
|
||||
// Detect platform and use appropriate binary
|
||||
const platform = process.platform;
|
||||
|
||||
if (platform === "darwin") {
|
||||
// macOS - use Swift binary
|
||||
return path.resolve(packageRootDirForFallback, "peekaboo");
|
||||
} else if (platform === "linux") {
|
||||
// Linux - use Rust binary
|
||||
const linuxBinaryPath = path.resolve(packageRootDirForFallback, "peekaboo-native", "target", "release", "peekaboo");
|
||||
if (existsSync(linuxBinaryPath)) {
|
||||
return linuxBinaryPath;
|
||||
}
|
||||
// Fallback to debug build if release doesn't exist
|
||||
const debugBinaryPath = path.resolve(packageRootDirForFallback, "peekaboo-native", "target", "debug", "peekaboo");
|
||||
if (existsSync(debugBinaryPath)) {
|
||||
return debugBinaryPath;
|
||||
}
|
||||
// If neither exists, return the expected release path for error reporting
|
||||
return linuxBinaryPath;
|
||||
} else if (platform === 'win32') {
|
||||
// Windows - use Rust binary
|
||||
const windowsBinaryPath = path.resolve(packageRootDirForFallback, "peekaboo-native", "target", "release", "peekaboo.exe");
|
||||
if (existsSync(windowsBinaryPath)) {
|
||||
return windowsBinaryPath;
|
||||
}
|
||||
// Fallback to debug build if release doesn't exist
|
||||
const debugBinaryPath = path.resolve(packageRootDirForFallback, "peekaboo-native", "target", "debug", "peekaboo.exe");
|
||||
if (existsSync(debugBinaryPath)) {
|
||||
return debugBinaryPath;
|
||||
}
|
||||
// If neither exists, return the expected release path for error reporting
|
||||
return windowsBinaryPath;
|
||||
} else {
|
||||
// Unsupported platform - fallback to Swift binary
|
||||
return path.resolve(packageRootDirForFallback, "peekaboo");
|
||||
}
|
||||
}
|
||||
|
||||
// If neither PEEKABOO_CLI_PATH is valid nor packageRootDirForFallback is provided,
|
||||
@ -285,7 +319,7 @@ export async function execPeekaboo(
|
||||
packageRootDir: string,
|
||||
options: { expectSuccess?: boolean } = {},
|
||||
): Promise<{ success: boolean; data?: string; error?: string }> {
|
||||
const cliPath = process.env.PEEKABOO_CLI_PATH || path.resolve(packageRootDir, "peekaboo");
|
||||
const cliPath = determineSwiftCliPath(packageRootDir);
|
||||
|
||||
return new Promise((resolve) => {
|
||||
const process = spawn(cliPath, args);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user