mirror of
https://github.com/Finesssee/ProxyPilot.git
synced 2026-11-19 02:17:46 +00:00
Replace `for i, part := range` with `for _, part := range` since the index variable was captured but never used (just discarded with `_ = i`). Co-Authored-By: Claude (gemini-claude-opus-4-5-thinking) <noreply@anthropic.com>
891 lines
23 KiB
Go
891 lines
23 KiB
Go
package cmd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/pelletier/go-toml/v2"
|
|
"github.com/router-for-me/CLIProxyAPI/v6/internal/config"
|
|
)
|
|
|
|
// SetupResult contains the result of a setup operation
|
|
type SetupResult struct {
|
|
CLI string
|
|
Success bool
|
|
Message string
|
|
BackupPath string
|
|
ConfigPath string
|
|
}
|
|
|
|
// backupFile creates a timestamped backup of the file if it exists
|
|
// Returns the backup path if created, empty string if file didn't exist
|
|
func backupFile(path string) (string, error) {
|
|
if !fileExists(path) {
|
|
return "", nil
|
|
}
|
|
|
|
// Create backup directory
|
|
backupDir := filepath.Join(filepath.Dir(path), ".proxypilot-backups")
|
|
if err := os.MkdirAll(backupDir, 0755); err != nil {
|
|
return "", fmt.Errorf("failed to create backup directory: %w", err)
|
|
}
|
|
|
|
// Generate timestamped backup filename
|
|
timestamp := time.Now().Format("20060102-150405")
|
|
baseName := filepath.Base(path)
|
|
backupPath := filepath.Join(backupDir, fmt.Sprintf("%s.%s.bak", baseName, timestamp))
|
|
|
|
// Read original file
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to read original file: %w", err)
|
|
}
|
|
|
|
// Write backup
|
|
if err := os.WriteFile(backupPath, data, 0644); err != nil {
|
|
return "", fmt.Errorf("failed to write backup: %w", err)
|
|
}
|
|
|
|
return backupPath, nil
|
|
}
|
|
|
|
// DoSetupClaude generates Claude Code configuration with backup and safe merge
|
|
func DoSetupClaude(cfg *config.Config) {
|
|
result := SetupClaudeSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupClaudeSafe configures Claude Code with backup and returns result
|
|
func SetupClaudeSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
settingsPath := expandPath("~/.claude/settings.json")
|
|
|
|
// Backup existing config
|
|
backupPath, err := backupFile(settingsPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "Claude Code",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup config: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing settings or create new
|
|
var settings map[string]any
|
|
if existing := readJSONFile(settingsPath); existing != nil {
|
|
settings = existing
|
|
} else {
|
|
settings = make(map[string]any)
|
|
}
|
|
|
|
// Ensure env map exists
|
|
var envMap map[string]any
|
|
if existingEnv, ok := settings["env"].(map[string]any); ok {
|
|
envMap = existingEnv
|
|
} else {
|
|
envMap = make(map[string]any)
|
|
}
|
|
|
|
// Only set ProxyPilot-specific values (safe merge - preserve user's other settings)
|
|
envMap["ANTHROPIC_BASE_URL"] = fmt.Sprintf("http://127.0.0.1:%d", port)
|
|
envMap["ANTHROPIC_AUTH_TOKEN"] = "proxypal-local"
|
|
|
|
settings["env"] = envMap
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(filepath.Dir(settingsPath), 0755); err != nil {
|
|
return SetupResult{
|
|
CLI: "Claude Code",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to create config directory: %v", err),
|
|
}
|
|
}
|
|
|
|
// Write settings
|
|
if err := writeJSONFile(settingsPath, settings); err != nil {
|
|
return SetupResult{
|
|
CLI: "Claude Code",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write config: %v", err),
|
|
}
|
|
}
|
|
|
|
return SetupResult{
|
|
CLI: "Claude Code",
|
|
Success: true,
|
|
Message: "Configured successfully. Restart Claude Code to apply changes.",
|
|
BackupPath: backupPath,
|
|
ConfigPath: settingsPath,
|
|
}
|
|
}
|
|
|
|
// DoSetupCodex generates Codex CLI configuration with backup and safe merge
|
|
func DoSetupCodex(cfg *config.Config) {
|
|
result := SetupCodexSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupCodexSafe configures Codex CLI with backup and returns result
|
|
func SetupCodexSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
configDir := expandPath("~/.codex")
|
|
configPath := filepath.Join(configDir, "config.toml")
|
|
authPath := filepath.Join(configDir, "auth.json")
|
|
|
|
// Backup existing configs
|
|
configBackup, err := backupFile(configPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "Codex CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup config.toml: %v", err),
|
|
}
|
|
}
|
|
|
|
authBackup, err := backupFile(authPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "Codex CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup auth.json: %v", err),
|
|
}
|
|
}
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(configDir, 0755); err != nil {
|
|
return SetupResult{
|
|
CLI: "Codex CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to create config directory: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing config.toml or create new
|
|
existingConfig := make(map[string]any)
|
|
if data, err := os.ReadFile(configPath); err == nil {
|
|
_ = toml.Unmarshal(data, &existingConfig)
|
|
}
|
|
|
|
// Safe merge - only set ProxyPilot-specific values
|
|
existingConfig["model_provider"] = "cliproxyapi"
|
|
existingConfig["base_url"] = fmt.Sprintf("http://127.0.0.1:%d/v1", port)
|
|
|
|
// Write config.toml preserving other settings
|
|
var configBuilder strings.Builder
|
|
configBuilder.WriteString("# Modified by ProxyPilot (original settings preserved)\n")
|
|
for k, v := range existingConfig {
|
|
switch val := v.(type) {
|
|
case string:
|
|
configBuilder.WriteString(fmt.Sprintf("%s = %q\n", k, val))
|
|
case bool:
|
|
configBuilder.WriteString(fmt.Sprintf("%s = %v\n", k, val))
|
|
case int, int64, float64:
|
|
configBuilder.WriteString(fmt.Sprintf("%s = %v\n", k, val))
|
|
}
|
|
}
|
|
|
|
if err := os.WriteFile(configPath, []byte(configBuilder.String()), 0644); err != nil {
|
|
return SetupResult{
|
|
CLI: "Codex CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write config.toml: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing auth.json or create new
|
|
var authData map[string]any
|
|
if existing := readJSONFile(authPath); existing != nil {
|
|
authData = existing
|
|
} else {
|
|
authData = make(map[string]any)
|
|
}
|
|
|
|
// Safe merge - only set the API key
|
|
authData["OPENAI_API_KEY"] = "proxypal-local"
|
|
|
|
if err := writeJSONFile(authPath, authData); err != nil {
|
|
return SetupResult{
|
|
CLI: "Codex CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write auth.json: %v", err),
|
|
}
|
|
}
|
|
|
|
backupInfo := ""
|
|
if configBackup != "" || authBackup != "" {
|
|
backupInfo = configBackup
|
|
if authBackup != "" && backupInfo != "" {
|
|
backupInfo += ", " + authBackup
|
|
} else if authBackup != "" {
|
|
backupInfo = authBackup
|
|
}
|
|
}
|
|
|
|
return SetupResult{
|
|
CLI: "Codex CLI",
|
|
Success: true,
|
|
Message: "Configured successfully.",
|
|
BackupPath: backupInfo,
|
|
ConfigPath: configPath,
|
|
}
|
|
}
|
|
|
|
// DoSetupDroid generates Factory Droid configuration with backup
|
|
func DoSetupDroid(cfg *config.Config) {
|
|
result := SetupDroidSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupDroidSafe configures Factory Droid with backup and returns result
|
|
func SetupDroidSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
configPath := expandPath("~/.factory/config.json")
|
|
|
|
// Backup existing config
|
|
backupPath, err := backupFile(configPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "Factory Droid",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup config: %v", err),
|
|
}
|
|
}
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(filepath.Dir(configPath), 0755); err != nil {
|
|
return SetupResult{
|
|
CLI: "Factory Droid",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to create config directory: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing config or create new
|
|
var droidConfig map[string]any
|
|
if existing := readJSONFile(configPath); existing != nil {
|
|
droidConfig = existing
|
|
} else {
|
|
droidConfig = make(map[string]any)
|
|
}
|
|
|
|
// Build ProxyPilot custom_models
|
|
proxypalModels := []map[string]any{
|
|
{
|
|
"name": "proxypal-claude-opus",
|
|
"base_url": fmt.Sprintf("http://127.0.0.1:%d/v1", port),
|
|
"api_key": "proxypal-local",
|
|
"model": "claude-opus-4-5-20251101",
|
|
},
|
|
{
|
|
"name": "proxypal-claude-sonnet",
|
|
"base_url": fmt.Sprintf("http://127.0.0.1:%d/v1", port),
|
|
"api_key": "proxypal-local",
|
|
"model": "claude-sonnet-4-5-20250929",
|
|
},
|
|
{
|
|
"name": "proxypal-claude-haiku",
|
|
"base_url": fmt.Sprintf("http://127.0.0.1:%d/v1", port),
|
|
"api_key": "proxypal-local",
|
|
"model": "claude-haiku-4-5-20251001",
|
|
},
|
|
}
|
|
|
|
// Merge: keep user's non-proxypal models, replace proxypal models
|
|
var finalModels []map[string]any
|
|
finalModels = append(finalModels, proxypalModels...)
|
|
|
|
if existing, ok := droidConfig["custom_models"].([]any); ok {
|
|
for _, entry := range existing {
|
|
if m, ok := entry.(map[string]any); ok {
|
|
name, _ := m["name"].(string)
|
|
if !strings.HasPrefix(name, "proxypal-") {
|
|
finalModels = append(finalModels, m)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
droidConfig["custom_models"] = finalModels
|
|
|
|
if err := writeJSONFile(configPath, droidConfig); err != nil {
|
|
return SetupResult{
|
|
CLI: "Factory Droid",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write config: %v", err),
|
|
}
|
|
}
|
|
|
|
return SetupResult{
|
|
CLI: "Factory Droid",
|
|
Success: true,
|
|
Message: "Configured with ProxyPilot models: proxypal-claude-opus, proxypal-claude-sonnet, proxypal-claude-haiku",
|
|
BackupPath: backupPath,
|
|
ConfigPath: configPath,
|
|
}
|
|
}
|
|
|
|
// DoSetupOpenCode generates OpenCode configuration with backup and safe merge
|
|
func DoSetupOpenCode(cfg *config.Config) {
|
|
result := SetupOpenCodeSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupOpenCodeSafe configures OpenCode with backup and returns result
|
|
func SetupOpenCodeSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
// OpenCode uses ~/.config/opencode/opencode.json for global config
|
|
configDir := expandPath("~/.config/opencode")
|
|
configPath := filepath.Join(configDir, "opencode.json")
|
|
|
|
// Backup existing config
|
|
backupPath, err := backupFile(configPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "OpenCode",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup config: %v", err),
|
|
}
|
|
}
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(configDir, 0755); err != nil {
|
|
return SetupResult{
|
|
CLI: "OpenCode",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to create config directory: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing config or create new
|
|
var openCodeConfig map[string]any
|
|
if existing := readJSONFile(configPath); existing != nil {
|
|
openCodeConfig = existing
|
|
} else {
|
|
openCodeConfig = map[string]any{
|
|
"$schema": "https://opencode.ai/config.json",
|
|
}
|
|
}
|
|
|
|
// Safe merge - configure provider with ProxyPilot endpoint
|
|
// OpenCode uses provider config for custom API base URLs
|
|
provider := make(map[string]any)
|
|
if existingProvider, ok := openCodeConfig["provider"].(map[string]any); ok {
|
|
provider = existingProvider
|
|
}
|
|
|
|
// Add ProxyPilot as a custom "local" provider
|
|
provider["local"] = map[string]any{
|
|
"name": "ProxyPilot",
|
|
"options": map[string]any{
|
|
"baseURL": fmt.Sprintf("http://127.0.0.1:%d/v1", port),
|
|
"apiKey": "proxypal-local",
|
|
},
|
|
}
|
|
|
|
openCodeConfig["provider"] = provider
|
|
|
|
// Set default model to use ProxyPilot if not already set
|
|
if _, hasModel := openCodeConfig["model"]; !hasModel {
|
|
openCodeConfig["model"] = "local/gpt-4"
|
|
}
|
|
|
|
if err := writeJSONFile(configPath, openCodeConfig); err != nil {
|
|
return SetupResult{
|
|
CLI: "OpenCode",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write config: %v", err),
|
|
}
|
|
}
|
|
|
|
return SetupResult{
|
|
CLI: "OpenCode",
|
|
Success: true,
|
|
Message: "Configured with ProxyPilot provider. Use 'opencode -m local/gpt-4' or select in TUI.",
|
|
BackupPath: backupPath,
|
|
ConfigPath: configPath,
|
|
}
|
|
}
|
|
|
|
// DoSetupGeminiCLI generates Gemini CLI configuration with backup and safe merge
|
|
func DoSetupGeminiCLI(cfg *config.Config) {
|
|
result := SetupGeminiCLISafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupGeminiCLISafe configures Gemini CLI with backup and returns result
|
|
func SetupGeminiCLISafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
// Gemini CLI uses ~/.gemini/settings.json
|
|
configPath := expandPath("~/.gemini/settings.json")
|
|
|
|
// Backup existing config
|
|
backupPath, err := backupFile(configPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "Gemini CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup config: %v", err),
|
|
}
|
|
}
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(filepath.Dir(configPath), 0755); err != nil {
|
|
return SetupResult{
|
|
CLI: "Gemini CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to create config directory: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing config or create new
|
|
var geminiConfig map[string]any
|
|
if existing := readJSONFile(configPath); existing != nil {
|
|
geminiConfig = existing
|
|
} else {
|
|
geminiConfig = make(map[string]any)
|
|
}
|
|
|
|
// Safe merge - set ProxyPilot as the API endpoint
|
|
// Gemini CLI uses GOOGLE_API_KEY and can use custom endpoints
|
|
geminiConfig["api_base"] = fmt.Sprintf("http://127.0.0.1:%d", port)
|
|
|
|
if err := writeJSONFile(configPath, geminiConfig); err != nil {
|
|
return SetupResult{
|
|
CLI: "Gemini CLI",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write config: %v", err),
|
|
}
|
|
}
|
|
|
|
return SetupResult{
|
|
CLI: "Gemini CLI",
|
|
Success: true,
|
|
Message: "Configured successfully. You may also need to set GEMINI_API_KEY=proxypal-local",
|
|
BackupPath: backupPath,
|
|
ConfigPath: configPath,
|
|
}
|
|
}
|
|
|
|
// DoSetupCursor generates Cursor configuration with backup and safe merge
|
|
func DoSetupCursor(cfg *config.Config) {
|
|
result := SetupCursorSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupCursorSafe configures Cursor with backup and returns result
|
|
func SetupCursorSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
// Find Cursor settings path based on platform
|
|
var settingsPath string
|
|
if home, err := os.UserHomeDir(); err == nil {
|
|
// Try different platform-specific paths
|
|
paths := []string{}
|
|
// Windows via APPDATA
|
|
if appData := os.Getenv("APPDATA"); appData != "" {
|
|
paths = append(paths, filepath.Join(appData, "Cursor", "User", "settings.json"))
|
|
}
|
|
paths = append(paths,
|
|
filepath.Join(home, ".config", "Cursor", "User", "settings.json"), // Linux
|
|
filepath.Join(home, "Library", "Application Support", "Cursor", "User", "settings.json"), // macOS
|
|
)
|
|
for _, p := range paths {
|
|
if fileExists(p) {
|
|
settingsPath = p
|
|
break
|
|
}
|
|
// If file doesn't exist but parent dir does, use that path
|
|
if dirExists(filepath.Dir(p)) {
|
|
settingsPath = p
|
|
break
|
|
}
|
|
}
|
|
// Fallback to first available path
|
|
if settingsPath == "" && len(paths) > 0 {
|
|
settingsPath = paths[0]
|
|
}
|
|
}
|
|
|
|
if settingsPath == "" {
|
|
return SetupResult{
|
|
CLI: "Cursor",
|
|
Success: false,
|
|
Message: "Could not determine Cursor settings path",
|
|
}
|
|
}
|
|
|
|
// Backup existing config
|
|
backupPath, err := backupFile(settingsPath)
|
|
if err != nil {
|
|
return SetupResult{
|
|
CLI: "Cursor",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to backup config: %v", err),
|
|
}
|
|
}
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(filepath.Dir(settingsPath), 0755); err != nil {
|
|
return SetupResult{
|
|
CLI: "Cursor",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to create config directory: %v", err),
|
|
}
|
|
}
|
|
|
|
// Read existing settings or create new
|
|
var settings map[string]any
|
|
if existing := readJSONFile(settingsPath); existing != nil {
|
|
settings = existing
|
|
} else {
|
|
settings = make(map[string]any)
|
|
}
|
|
|
|
// Safe merge - add ProxyPilot as an OpenAI-compatible custom model
|
|
// Cursor uses models configuration for custom API endpoints
|
|
var models map[string]any
|
|
if existingModels, ok := settings["models"].(map[string]any); ok {
|
|
models = existingModels
|
|
} else {
|
|
models = make(map[string]any)
|
|
}
|
|
|
|
// Add ProxyPilot model configuration
|
|
models["proxypilot"] = map[string]any{
|
|
"name": "ProxyPilot",
|
|
"apiKey": "proxypal-local",
|
|
"baseUrl": fmt.Sprintf("http://127.0.0.1:%d/v1", port),
|
|
"contextLength": 200000,
|
|
}
|
|
|
|
settings["models"] = models
|
|
|
|
if err := writeJSONFile(settingsPath, settings); err != nil {
|
|
return SetupResult{
|
|
CLI: "Cursor",
|
|
Success: false,
|
|
Message: fmt.Sprintf("Failed to write config: %v", err),
|
|
}
|
|
}
|
|
|
|
return SetupResult{
|
|
CLI: "Cursor",
|
|
Success: true,
|
|
Message: "Configured with ProxyPilot model. Select 'proxypilot' in Cursor AI settings.",
|
|
BackupPath: backupPath,
|
|
ConfigPath: settingsPath,
|
|
}
|
|
}
|
|
|
|
// DoSetupKiloCode shows manual configuration instructions for Kilo Code
|
|
func DoSetupKiloCode(cfg *config.Config) {
|
|
result := SetupKiloCodeSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupKiloCodeSafe returns manual configuration instructions for Kilo Code
|
|
// Kilo Code is a VS Code extension that stores config in globalStorage,
|
|
// which cannot be reliably configured programmatically
|
|
func SetupKiloCodeSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
instructions := fmt.Sprintf(`Kilo Code requires manual configuration:
|
|
|
|
1. Open Kilo Code in VS Code/Cursor/Antigravity
|
|
2. Click Settings (gear icon)
|
|
3. Select "OpenAI Compatible" provider
|
|
4. Set Base URL: http://127.0.0.1:%d/v1
|
|
5. Set API Key: proxypal-local
|
|
6. Choose a model (e.g., gpt-4, claude-sonnet-4-20250514)
|
|
|
|
Or use Import/Export:
|
|
1. Go to Settings > About Kilo Code > Export
|
|
2. Edit the JSON file to add ProxyPilot as a provider
|
|
3. Import via Settings > About Kilo Code > Import`, port)
|
|
|
|
return SetupResult{
|
|
CLI: "Kilo Code",
|
|
Success: true,
|
|
Message: instructions,
|
|
}
|
|
}
|
|
|
|
// DoSetupRooCode shows manual configuration instructions for RooCode
|
|
func DoSetupRooCode(cfg *config.Config) {
|
|
result := SetupRooCodeSafe(cfg)
|
|
printSetupResult(result)
|
|
}
|
|
|
|
// SetupRooCodeSafe returns manual configuration instructions for RooCode
|
|
// RooCode is a VS Code extension that stores config in globalStorage,
|
|
// which cannot be reliably configured programmatically
|
|
func SetupRooCodeSafe(cfg *config.Config) SetupResult {
|
|
port := cfg.Port
|
|
if port == 0 {
|
|
port = 8317
|
|
}
|
|
|
|
instructions := fmt.Sprintf(`RooCode requires manual configuration:
|
|
|
|
1. Open RooCode in VS Code/Cursor/Antigravity
|
|
2. Click Settings (gear icon)
|
|
3. Select "OpenAI Compatible" provider
|
|
4. Set Base URL: http://127.0.0.1:%d/v1
|
|
5. Set API Key: proxypal-local
|
|
6. Choose a model (e.g., gpt-4, claude-sonnet-4-20250514)
|
|
|
|
Or use Import/Export:
|
|
1. Go to Settings > About Roo Code > Export
|
|
2. Edit the JSON file to add ProxyPilot as a provider
|
|
3. Import via Settings > About Roo Code > Import`, port)
|
|
|
|
return SetupResult{
|
|
CLI: "RooCode",
|
|
Success: true,
|
|
Message: instructions,
|
|
}
|
|
}
|
|
|
|
// DoSetupAll configures all detected CLI agents
|
|
func DoSetupAll(cfg *config.Config) {
|
|
fmt.Println("ProxyPilot Unified Setup Wizard")
|
|
fmt.Println("================================")
|
|
fmt.Println()
|
|
fmt.Println("This wizard will configure all detected AI CLI tools to use ProxyPilot.")
|
|
fmt.Println("Your existing configurations will be backed up before any changes.")
|
|
fmt.Println()
|
|
|
|
// Detect installed agents
|
|
agents := DetectAgents()
|
|
detected := 0
|
|
for _, agent := range agents {
|
|
if agent.Detected {
|
|
detected++
|
|
}
|
|
}
|
|
|
|
if detected == 0 {
|
|
fmt.Println("No CLI agents detected. Install one of the supported tools first:")
|
|
fmt.Println(" - Claude Code (claude)")
|
|
fmt.Println(" - Codex CLI (codex)")
|
|
fmt.Println(" - Factory Droid (droid)")
|
|
fmt.Println(" - OpenCode (opencode)")
|
|
fmt.Println(" - Gemini CLI (gemini)")
|
|
fmt.Println(" - Cursor (cursor)")
|
|
fmt.Println(" - Kilo Code (kilocode)")
|
|
fmt.Println(" - RooCode (VS Code extension)")
|
|
return
|
|
}
|
|
|
|
fmt.Printf("Detected %d CLI agent(s). Configuring...\n", detected)
|
|
fmt.Println()
|
|
|
|
var results []SetupResult
|
|
|
|
for _, agent := range agents {
|
|
if !agent.Detected {
|
|
continue
|
|
}
|
|
|
|
var result SetupResult
|
|
switch agent.Name {
|
|
case "Claude Code":
|
|
result = SetupClaudeSafe(cfg)
|
|
case "Codex CLI":
|
|
result = SetupCodexSafe(cfg)
|
|
case "Factory Droid":
|
|
result = SetupDroidSafe(cfg)
|
|
case "OpenCode":
|
|
result = SetupOpenCodeSafe(cfg)
|
|
case "Gemini CLI":
|
|
result = SetupGeminiCLISafe(cfg)
|
|
case "Cursor":
|
|
result = SetupCursorSafe(cfg)
|
|
case "Kilo Code":
|
|
result = SetupKiloCodeSafe(cfg)
|
|
case "RooCode":
|
|
result = SetupRooCodeSafe(cfg)
|
|
default:
|
|
continue
|
|
}
|
|
results = append(results, result)
|
|
}
|
|
|
|
// Print summary
|
|
fmt.Println()
|
|
fmt.Println("Setup Summary")
|
|
fmt.Println("=============")
|
|
fmt.Println()
|
|
|
|
successCount := 0
|
|
for _, result := range results {
|
|
printSetupResult(result)
|
|
if result.Success {
|
|
successCount++
|
|
}
|
|
}
|
|
|
|
fmt.Println()
|
|
fmt.Printf("Configured %d/%d agents successfully.\n", successCount, len(results))
|
|
|
|
if successCount > 0 {
|
|
fmt.Println()
|
|
fmt.Println("Next steps:")
|
|
fmt.Println(" 1. Start ProxyPilot: proxypilot")
|
|
fmt.Println(" 2. Login to your providers: proxypilot --claude-login, --codex-login, etc.")
|
|
fmt.Println(" 3. Restart your CLI tools to apply the configuration")
|
|
}
|
|
}
|
|
|
|
// printSetupResult prints a formatted setup result
|
|
func printSetupResult(result SetupResult) {
|
|
status := "[OK]"
|
|
if !result.Success {
|
|
status = "[FAIL]"
|
|
}
|
|
|
|
fmt.Printf("%s %s\n", status, result.CLI)
|
|
if result.Success {
|
|
fmt.Printf(" Config: %s\n", result.ConfigPath)
|
|
if result.BackupPath != "" {
|
|
fmt.Printf(" Backup: %s\n", result.BackupPath)
|
|
}
|
|
fmt.Printf(" %s\n", result.Message)
|
|
} else {
|
|
fmt.Printf(" Error: %s\n", result.Message)
|
|
}
|
|
fmt.Println()
|
|
}
|
|
|
|
// RestoreBackup restores a configuration file from its backup
|
|
func RestoreBackup(backupPath string) error {
|
|
if !fileExists(backupPath) {
|
|
return fmt.Errorf("backup file does not exist: %s", backupPath)
|
|
}
|
|
|
|
// Determine original path from backup path
|
|
// Backup format: config.json.20240101-120000.bak -> config.json
|
|
dir := filepath.Dir(filepath.Dir(backupPath)) // Go up from .proxypilot-backups
|
|
baseName := filepath.Base(backupPath)
|
|
|
|
// Remove timestamp and .bak suffix
|
|
parts := strings.Split(baseName, ".")
|
|
if len(parts) < 3 {
|
|
return fmt.Errorf("invalid backup filename format: %s", baseName)
|
|
}
|
|
|
|
// Reconstruct original filename (everything before the timestamp)
|
|
// e.g., "config.json.20240101-120000.bak" -> "config.json"
|
|
var originalParts []string
|
|
for _, part := range parts {
|
|
// Stop before timestamp (which looks like 20XXXXXX-XXXXXX)
|
|
if len(part) == 15 && strings.Contains(part, "-") {
|
|
break
|
|
}
|
|
// Stop at .bak
|
|
if part == "bak" {
|
|
break
|
|
}
|
|
originalParts = append(originalParts, part)
|
|
}
|
|
|
|
originalName := strings.Join(originalParts, ".")
|
|
originalPath := filepath.Join(dir, originalName)
|
|
|
|
// Read backup
|
|
data, err := os.ReadFile(backupPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read backup: %w", err)
|
|
}
|
|
|
|
// Write to original location
|
|
if err := os.WriteFile(originalPath, data, 0644); err != nil {
|
|
return fmt.Errorf("failed to restore: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ListBackups lists all ProxyPilot backups in a directory
|
|
func ListBackups(configDir string) ([]string, error) {
|
|
backupDir := filepath.Join(configDir, ".proxypilot-backups")
|
|
if !dirExists(backupDir) {
|
|
return nil, nil
|
|
}
|
|
|
|
entries, err := os.ReadDir(backupDir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var backups []string
|
|
for _, entry := range entries {
|
|
if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".bak") {
|
|
backups = append(backups, filepath.Join(backupDir, entry.Name()))
|
|
}
|
|
}
|
|
|
|
return backups, nil
|
|
}
|
|
|
|
func expandPath(path string) string {
|
|
if strings.HasPrefix(path, "~/") {
|
|
home, err := os.UserHomeDir()
|
|
if err != nil {
|
|
return path
|
|
}
|
|
return filepath.Join(home, path[2:])
|
|
}
|
|
return path
|
|
}
|
|
|
|
func readJSONFile(path string) map[string]any {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
var result map[string]any
|
|
if err := json.Unmarshal(data, &result); err != nil {
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
|
|
func writeJSONFile(path string, data any) error {
|
|
content, err := json.MarshalIndent(data, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(path, content, 0644)
|
|
}
|