# Download and run the installer
DevTools Hub Setup 1.2.0.exe

# List all available tools
devtoolshub list

# Install single or multiple tools
devtoolshub install git
devtoolshub install node python docker

# Check installation status
devtoolshub status

# Show detailed diagnostics
devtoolshub diagnose

# Export current configuration
devtoolshub export-config > devtools-config.json

# Update installed tools (via winget)
devtoolshub update git
devtoolshub update --all

# Uninstall tools (UAC-elevated)
devtoolshub uninstall docker

# Clone repository
git clone https://github.com/lszdeveloping/devtoolshub.git
cd devtoolshub

# Install dependencies
npm install

# Run in development mode
npm run dev

# Build renderer, main process, and CLI
npm run build

# Create distributable
npm run dist

src/
  cli/              # Command-line interface
  main/             # Electron main process and IPC handlers
  renderer/         # React application (Vite + Tailwind CSS)
  shared/           # Shared tool metadata and types
installers/
  windows/          # PowerShell installers (asar-unpacked)
resources/          # App icons and packaged assets

export interface Tool {
  id: string;
  name: string;
  category: string;
  description: string;
  installer: string;  // PowerShell script filename
  wingetId?: string;  // For update support
}

export const tools: Tool[] = [
  // ... existing tools
  {
    id: 'newtool',
    name: 'New Tool',
    category: 'Runtimes',
    description: 'Description of the tool',
    installer: 'newtool.ps1',
    wingetId: 'Publisher.NewTool'
  }
];

# newtool.ps1
param(
    [string]$InstallPath = "C:\Program Files\NewTool"
)

Write-Host "Installing New Tool..."

try {
    # Download installer
    $url = "https://example.com/newtool-installer.exe"
    $installer = "$env:TEMP\newtool-installer.exe"
    Invoke-WebRequest -Uri $url -OutFile $installer

    # Run installer
    Start-Process -FilePath $installer -ArgumentList "/S" -Wait

    # Add to PATH if needed
    $currentPath = [Environment]::GetEnvironmentVariable("Path", "Machine")
    if ($currentPath -notlike "*$InstallPath*") {
        [Environment]::SetEnvironmentVariable(
            "Path",
            "$currentPath;$InstallPath",
            "Machine"
        )
    }

    Write-Host "New Tool installed successfully"
    exit 0
} catch {
    Write-Error "Installation failed: $_"
    exit 1
}

export async function detectInstalledTools(): Promise<Map<string, boolean>> {
  const installed = new Map<string, boolean>();
  
  for (const tool of tools) {
    try {
      // Check PATH, registry, or filesystem
      const isInstalled = await checkToolInstalled(tool.id);
      installed.set(tool.id, isInstalled);
    } catch {
      installed.set(tool.id, false);
    }
  }
  
  return installed;
}

async function checkToolInstalled(toolId: string): Promise<boolean> {
  // Check common installation indicators
  const checks = [
    () => checkPath(toolId),
    () => checkRegistry(toolId),
    () => checkFileSystem(toolId)
  ];
  
  for (const check of checks) {
    if (await check()) return true;
  }
  
  return false;
}

devtoolshub export-config > my-dev-setup.json

{
  "version": "1.2.0",
  "platform": "win32",
  "installed": [
    "git",
    "node",
    "python",
    "docker",
    "vscode"
  ],
  "timestamp": "2026-05-17T12:34:56.789Z"
}

// src/renderer/profiles.ts
export interface Profile {
  id: string;
  name: string;
  description: string;
  tools: string[];
}

export const profiles: Profile[] = [
  {
    id: 'web-dev',
    name: 'Web Development',
    description: 'Essential tools for web development',
    tools: ['git', 'node', 'vscode', 'docker', 'postgresql']
  },
  {
    id: 'python-dev',
    name: 'Python Development',
    description: 'Python development environment',
    tools: ['git', 'python', 'vscode', 'postgresql']
  }
];

# Install all tools from a profile (requires custom implementation)
devtoolshub install git node vscode docker postgresql

// src/main/installer.ts
export async function installTools(toolIds: string[]): Promise<InstallResult[]> {
  const results: InstallResult[] = [];
  
  for (const toolId of toolIds) {
    try {
      const tool = tools.find(t => t.id === toolId);
      if (!tool) {
        results.push({ toolId, success: false, error: 'Tool not found' });
        continue;
      }
      
      // Execute PowerShell installer with elevated privileges
      const scriptPath = path.join(installersDir, tool.installer);
      const result = await execElevated(scriptPath);
      
      results.push({ toolId, success: true, output: result.stdout });
    } catch (error) {
      results.push({
        toolId,
        success: false,
        error: error instanceof Error ? error.message : String(error)
      });
    }
  }
  
  return results;
}

# Allow script execution (run as Administrator)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

# Clean and rebuild
rm -rf node_modules dist
npm install
npm run build