opencode-plugin-selector 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,211 @@
+# opencode-plugin-selector
+
+> Interactive plugin selector for OpenCode - easily manage your plugins with a beautiful TUI
+
+[![npm version](https://badge.fury.io/js/opencode-plugin-selector.svg)](https://badge.fury.io/js/opencode-plugin-selector)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🎨 **Beautiful TUI** - Interactive multiselect interface powered by @clack/prompts
+- ⚡ **Fast** - Instant loading with known plugins list
+- ✓ **Status indicators** - See which plugins are installed/active at a glance
+- 💾 **Auto-sync** - Automatically updates your `opencode.json` configuration
+- 🔄 **Preserves versions** - Maintains version specifiers for existing plugins
+- 🌍 **Cross-platform** - Works on Windows, macOS, and Linux
+
+## Installation
+
+### From npm (Recommended)
+
+Add to your OpenCode configuration:
+
+```json
+{
+  "plugin": ["opencode-plugin-selector"]
+}
+```
+
+OpenCode will automatically install it on startup.
+
+### Manual Installation
+
+```bash
+npm install -g opencode-plugin-selector
+```
+
+Or add to your project:
+
+```bash
+npm install opencode-plugin-selector
+```
+
+## Usage
+
+### In OpenCode
+
+Just type the command:
+
+```
+/plugins
+```
+
+This opens an interactive menu where you can:
+
+- **↑↓** - Navigate through plugins
+- **Space** - Toggle plugin selection
+- **Enter** - Confirm selection
+- **Esc** - Cancel
+
+### Example
+
+```
+╭─────────────────────────────────────╮
+│ OpenCode Plugin Selector            │
+├─────────────────────────────────────┤
+│ ◉ opencode-firecrawl ✓              │
+│   Web scraping via Firecrawl        │
+│                                     │
+│ ◯ oh-my-opencode ✓                  │
+│   Background agents, LSP tools      │
+│                                     │
+│ ◯ opencode-wakatime ✗               │
+│   Track usage with Wakatime         │
+╰─────────────────────────────────────╯
+
+[↑↓ Navigate] [Space Toggle] [Enter Confirm]
+```
+
+## How It Works
+
+1. **Plugin Discovery** - Loads known plugins from the OpenCode ecosystem
+2. **Status Check** - Scans `~/.cache/opencode/node_modules/` for installed plugins
+3. **Config Sync** - Reads `~/.config/opencode/opencode.json` for active plugins
+4. **Interactive Selection** - Presents a multiselect TUI
+5. **Config Update** - Saves your selection back to `opencode.json`
+6. **Restart Required** - Restart OpenCode to apply changes
+
+## Supported Plugins
+
+The selector includes all known plugins from the OpenCode ecosystem:
+
+- **Auth plugins**: `opencode-antigravity-auth`, `opencode-openai-codex-auth`, `opencode-gemini-auth`
+- **Development**: `opencode-daytona`, `opencode-devcontainers`, `opencode-worktree`
+- **Monitoring**: `opencode-helicone-session`, `opencode-wakatime`, `opencode-sentry-monitor`
+- **Utilities**: `opencode-firecrawl`, `opencode-pty`, `opencode-scheduler`
+- **Agents**: `oh-my-opencode`, `opencode-background-agents`, `opencode-workspace`
+- And many more...
+
+## Configuration
+
+The plugin respects your existing `opencode.json` configuration:
+
+```json
+{
+  "plugin": [
+    "opencode-plugin-selector",
+    "opencode-firecrawl@1.2.0",
+    "oh-my-opencode@latest"
+  ]
+}
+```
+
+Version specifiers are preserved when you update your selection.
+
+## Development
+
+### Prerequisites
+
+- Node.js 18+
+- Bun (for running OpenCode)
+
+### Setup
+
+```bash
+git clone https://github.com/yourusername/opencode-plugin-selector.git
+cd opencode-plugin-selector
+npm install
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+### Test Locally
+
+Add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["./path/to/opencode-plugin-selector"]
+}
+```
+
+## API Reference
+
+### Plugin Hook
+
+The plugin implements the `tui.command.execute` hook:
+
+```typescript
+{
+  'tui.command.execute': async (input, output) => {
+    if (input.command === 'plugins') {
+      // Show interactive selector
+    }
+  }
+}
+```
+
+### Functions
+
+- `getAllPlugins()` - Get all available plugins with status
+- `getActivePlugins()` - Get currently enabled plugins
+- `updatePlugins(plugins: string[])` - Update configuration
+- `getInstalledPlugins()` - Get plugins installed in cache
+
+## Troubleshooting
+
+### Plugin not loading?
+
+1. Check your `opencode.json` syntax
+2. Ensure the plugin is in the `plugin` array
+3. Restart OpenCode
+
+### Config not updating?
+
+1. Check file permissions on `~/.config/opencode/opencode.json`
+2. Ensure the file is valid JSON
+3. Check OpenCode logs for errors
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- [OpenCode](https://opencode.ai) - The AI coding assistant
+- [@clack/prompts](https://github.com/natemoo-re/clack) - Beautiful CLI prompts
+- [picocolors](https://github.com/alexeyraspopov/picocolors) - Terminal colors
+
+## Related
+
+- [OpenCode Documentation](https://opencode.ai/docs)
+- [OpenCode Ecosystem](https://opencode.ai/docs/ecosystem)
+- [Plugin Development Guide](https://opencode.ai/docs/plugins)
+
+---
+
+Made with ❤️ for the OpenCode community

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "opencode-plugin-selector",
+  "version": "1.0.0",
+  "description": "Interactive plugin selector for OpenCode - easily manage your plugins with a beautiful TUI",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "plugin",
+    "selector",
+    "tui",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/illusionaireal/opencode-plugin-selector.git"
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.1",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "latest"
+  }
+}

package/src/config.ts

@@ -0,0 +1,81 @@
+/**
+ * Configuration file management for OpenCode
+ */
+
+import { readFile, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { homedir } from 'os'
+import type { OpenCodeConfig } from './types.js'
+
+const CONFIG_PATH = join(homedir(), '.config', 'opencode', 'opencode.json')
+
+/**
+ * Read OpenCode configuration file
+ */
+export async function readConfig(): Promise<OpenCodeConfig> {
+  try {
+    const content = await readFile(CONFIG_PATH, 'utf-8')
+    return JSON.parse(content)
+  } catch (error) {
+    // If file doesn't exist, return default config
+    if ((error as any).code === 'ENOENT') {
+      return { plugin: [] }
+    }
+    throw error
+  }
+}
+
+/**
+ * Write OpenCode configuration file
+ */
+export async function writeConfig(config: OpenCodeConfig): Promise<void> {
+  const content = JSON.stringify(config, null, 2)
+  await writeFile(CONFIG_PATH, content, 'utf-8')
+}
+
+/**
+ * Get current active plugins from config
+ */
+export async function getActivePlugins(): Promise<string[]> {
+  const config = await readConfig()
+  return config.plugin || []
+}
+
+/**
+ * Update plugin list in config
+ * Preserves version specifiers for existing plugins
+ */
+export async function updatePlugins(selectedPlugins: string[]): Promise<void> {
+  const config = await readConfig()
+  
+  // Build version map from existing plugins
+  const versionMap = new Map<string, string>()
+  if (config.plugin) {
+    for (const p of config.plugin) {
+      const name = stripVersion(p)
+      versionMap.set(name, p)
+    }
+  }
+  
+  // Apply new selection with preserved versions
+  config.plugin = selectedPlugins.map(name => {
+    return versionMap.get(name) || name
+  })
+  
+  await writeConfig(config)
+}
+
+/**
+ * Strip version specifier from plugin name
+ * @example 'plugin@1.0.0' -> 'plugin'
+ */
+export function stripVersion(name: string): string {
+  return name.replace(/@.*$/, '')
+}
+
+/**
+ * Get config file path
+ */
+export function getConfigPath(): string {
+  return CONFIG_PATH
+}

package/src/discovery.ts

@@ -0,0 +1,110 @@
+/**
+ * Plugin discovery - finds available OpenCode plugins from multiple sources
+ */
+
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+import { homedir } from 'os'
+import type { PluginInfo } from './types.js'
+import { getActivePlugins, stripVersion } from './config.js'
+
+const CACHE_DIR = join(homedir(), '.cache', 'opencode', 'node_modules')
+
+/**
+ * Known plugins from the OpenCode ecosystem
+ * Sourced from https://opencode.ai/docs/ecosystem/
+ */
+const KNOWN_PLUGINS: Array<{ name: string; description: string }> = [
+  { name: 'opencode-daytona', description: 'Run sessions in isolated Daytona sandboxes with git sync' },
+  { name: 'opencode-helicone-session', description: 'Inject Helicone session headers for request grouping' },
+  { name: 'opencode-type-inject', description: 'Auto-inject TypeScript/Svelte types into file reads' },
+  { name: 'opencode-openai-codex-auth', description: 'Use ChatGPT Plus/Pro subscription instead of API credits' },
+  { name: 'opencode-gemini-auth', description: 'Use existing Gemini plan instead of API billing' },
+  { name: 'opencode-antigravity-auth', description: 'Use Antigravity free models instead of API billing' },
+  { name: 'opencode-devcontainers', description: 'Multi-branch devcontainer isolation with shallow clones' },
+  { name: 'opencode-google-antigravity-auth', description: 'Google Antigravity OAuth with Google Search support' },
+  { name: 'opencode-dynamic-context-pruning', description: 'Optimize token usage by pruning obsolete tool outputs' },
+  { name: 'opencode-vibeguard', description: 'Redact secrets/PII into VibeGuard placeholders before LLM calls' },
+  { name: 'opencode-websearch-cited', description: 'Native websearch with Google grounded style citations' },
+  { name: 'opencode-pty', description: 'Run background processes in a PTY with interactive input' },
+  { name: 'opencode-shell-strategy', description: 'Instructions for non-interactive shell commands' },
+  { name: 'opencode-wakatime', description: 'Track OpenCode usage with Wakatime' },
+  { name: 'opencode-md-table-formatter', description: 'Clean up markdown tables produced by LLMs' },
+  { name: 'opencode-morph-plugin', description: 'Fast Apply editing, WarpGrep search, context compaction' },
+  { name: 'oh-my-opencode', description: 'Background agents, LSP/AST/MCP tools, Claude Code compatible' },
+  { name: 'opencode-notificator', description: 'Desktop notifications and sound alerts for sessions' },
+  { name: 'opencode-notifier', description: 'Notifications for permission, completion, error events' },
+  { name: 'opencode-zellij-namer', description: 'AI-powered Zellij session naming from context' },
+  { name: 'opencode-skillful', description: 'Lazy load prompts on demand with skill discovery' },
+  { name: 'opencode-supermemory', description: 'Persistent memory across sessions via Supermemory' },
+  { name: 'plannotator-opencode', description: 'Interactive plan review with visual annotation' },
+  { name: 'openspoon-subtask2', description: 'Extend /commands into orchestration with flow control' },
+  { name: 'opencode-scheduler', description: 'Schedule recurring jobs with cron syntax (launchd/systemd)' },
+  { name: 'micode', description: 'Structured Brainstorm-Plan-Implement workflow with continuity' },
+  { name: 'octto', description: 'Interactive browser UI for AI brainstorming' },
+  { name: 'opencode-background-agents', description: 'Claude Code-style background agents with async delegation' },
+  { name: 'opencode-notify', description: 'Native OS notifications for task completion' },
+  { name: 'opencode-workspace', description: 'Multi-agent orchestration harness - 16 components' },
+  { name: 'opencode-worktree', description: 'Zero-friction git worktrees for OpenCode' },
+  { name: 'opencode-sentry-monitor', description: 'Trace and debug AI agents with Sentry' },
+  { name: 'opencode-firecrawl', description: 'Web scraping, crawling, and search via Firecrawl' }
+]
+
+/**
+ * Get installed plugins from cache directory
+ */
+export async function getInstalledPlugins(): Promise<Set<string>> {
+  try {
+    const dirs = await readdir(CACHE_DIR)
+    return new Set(dirs)
+  } catch {
+    return new Set()
+  }
+}
+
+/**
+ * Search npm for additional OpenCode plugins
+ * Returns plugin names
+ */
+export async function searchNpmPlugins(): Promise<string[]> {
+  try {
+    // Use Bun's shell API or spawn process to run npm search
+    const proc = Bun.spawn(['npm', 'search', 'opencode-plugin', '--json'])
+    const text = await new Response(proc.stdout).text()
+    await proc.exited
+    
+    if (text) {
+      const results = JSON.parse(text)
+      return results.map((pkg: any) => pkg.name)
+    }
+  } catch (error) {
+    // Silently fail - npm search is optional enhancement
+  }
+  return []
+}
+
+/**
+ * Get all available plugins with their status
+ */
+export async function getAllPlugins(): Promise<PluginInfo[]> {
+  const [installed, activeList] = await Promise.all([
+    getInstalledPlugins(),
+    getActivePlugins()
+  ])
+  
+  const activeSet = new Set(activeList.map(stripVersion))
+  
+  // Start with known plugins
+  const plugins: PluginInfo[] = KNOWN_PLUGINS.map(p => ({
+    name: p.name,
+    description: p.description,
+    installed: installed.has(p.name),
+    active: activeSet.has(p.name)
+  }))
+  
+  // Add any additional plugins from npm search (in background, non-blocking)
+  // For now, we'll skip this to keep the UI fast
+  // Could be added as an async enhancement later
+  
+  return plugins
+}

package/src/index.ts

@@ -0,0 +1,117 @@
+/**
+ * opencode-plugin-selector
+ * Interactive plugin selector for OpenCode
+ */
+
+import * as p from '@clack/prompts'
+import pc from 'picocolors'
+import type { PluginContext, PluginHooks, PluginInfo } from './types.js'
+import { getAllPlugins } from './discovery.js'
+import { updatePlugins, stripVersion, getActivePlugins } from './config.js'
+
+/**
+ * Main plugin export
+ */
+export const PluginSelector = async (ctx: PluginContext): Promise<PluginHooks> => {
+  return {
+    /**
+     * Handle TUI command execution
+     * Triggers on /plugins command
+     */
+    'tui.command.execute': async (input, output) => {
+      if (input.command === 'plugins') {
+        await handlePluginsCommand(ctx)
+      }
+    }
+  }
+}
+
+/**
+ * Handle the /plugins command
+ */
+async function handlePluginsCommand(ctx: PluginContext): Promise<void> {
+  console.clear()
+  
+  p.intro(pc.bgCyan(pc.black(' OpenCode Plugin Selector ')))
+  
+  const spinner = p.spinner()
+  spinner.start('Loading plugins...')
+  
+  try {
+    // Get all plugins with their status
+    const plugins = await getAllPlugins()
+    
+    spinner.stop(`Found ${plugins.length} plugins`)
+    
+    // Build options for multiselect
+    const options = plugins.map(p => ({
+      value: p.name,
+      label: `${p.name} ${p.installed ? pc.green('✓') : pc.red('✗')}`,
+      hint: p.description
+    }))
+    
+    // Get currently active plugins
+    const activePlugins = await getActivePlugins()
+    const initialValues = activePlugins.map(stripVersion)
+    
+    // Show interactive selector
+    const selected = await p.multiselect({
+      message: 'Select plugins to enable (Space to toggle, Enter to confirm):',
+      options,
+      initialValues
+    })
+    
+    if (p.isCancel(selected)) {
+      p.outro(pc.yellow('Cancelled'))
+      return
+    }
+    
+    // Update configuration
+    spinner.start('Updating configuration...')
+    
+    await updatePlugins(selected as string[])
+    
+    spinner.stop('Configuration updated')
+    
+    // Show summary
+    const enabledCount = (selected as string[]).length
+    p.outro(pc.green(`✓ ${enabledCount} plugins enabled`))
+    
+    // Show what changed
+    const enabled = selected as string[]
+    const previouslyActive = new Set(initialValues)
+    
+    const newlyEnabled = enabled.filter(n => !previouslyActive.has(n))
+    const newlyDisabled = initialValues.filter(n => !enabled.includes(n))
+    
+    if (newlyEnabled.length > 0) {
+      console.log(pc.green('\nEnabled:'))
+      newlyEnabled.forEach(n => console.log(pc.green(`  + ${n}`)))
+    }
+    
+    if (newlyDisabled.length > 0) {
+      console.log(pc.red('\nDisabled:'))
+      newlyDisabled.forEach(n => console.log(pc.red(`  - ${n}`)))
+    }
+    
+    // Suggest restart
+    console.log(pc.dim('\nRestart OpenCode to apply changes.'))
+    
+  } catch (error) {
+    spinner.stop('Failed')
+    p.outro(pc.red(`Error: ${(error as Error).message}`))
+    
+    // Log error via OpenCode client
+    await ctx.client.app.log({
+      body: {
+        service: 'plugin-selector',
+        level: 'error',
+        message: 'Failed to load plugins',
+        extra: { error: (error as Error).message }
+      }
+    })
+  }
+}
+
+// Default export for OpenCode plugin system
+export default PluginSelector

package/src/types.ts

@@ -0,0 +1,61 @@
+/**
+ * Type definitions for opencode-plugin-selector
+ */
+
+/**
+ * Plugin metadata
+ */
+export interface PluginInfo {
+  name: string
+  description: string
+  installed: boolean
+  active: boolean
+}
+
+/**
+ * OpenCode configuration structure
+ */
+export interface OpenCodeConfig {
+  $schema?: string
+  plugin?: string[]
+  [key: string]: any
+}
+
+/**
+ * Plugin context provided by OpenCode
+ */
+export interface PluginContext {
+  project: any
+  client: any
+  $: any
+  directory: string
+  worktree: string
+}
+
+/**
+ * Plugin hooks
+ */
+export interface PluginHooks {
+  [event: string]: (input: any, output: any) => Promise<void> | void
+}
+
+/**
+ * Plugin function signature
+ */
+export type PluginFunction = (ctx: PluginContext) => Promise<PluginHooks>
+
+/**
+ * TUI command input
+ */
+export interface TUICommandInput {
+  command: string
+  args: string[]
+}
+
+/**
+ * TUI command output
+ */
+export interface TUICommandOutput {
+  result?: any
+  error?: Error
+}