@fleettools/opencode-plugin 0.2.0 → 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# FleetTools OpenCode Plugin
+
+Integrates FleetTools AI Agent Coordination System into OpenCode.
+
+## Installation
+
+### From npm (Recommended)
+```bash
+npm install @fleettools/opencode-plugin
+```
+
+### From OpenCode CLI
+```bash
+opencode plugin install @fleettools/opencode-plugin
+```
+
+## Usage
+
+Once installed, the plugin provides three tools:
+
+### 🚀 `fleet-start`
+Start FleetTools services (API, Squawk coordination)
+
+```bash
+# Start all services
+fleet-start
+
+# Start specific services
+fleet-start --services api,squawk
+
+# Run in foreground
+fleet-start --foreground
+```
+
+### 🛑 `fleet-stop`
+Stop FleetTools services
+
+```bash
+# Graceful stop
+fleet-stop
+
+# Force stop
+fleet-stop --force
+```
+
+### 📊 `fleet-status`
+Get FleetTools service status and configuration
+
+```bash
+# Human-readable status
+fleet-status
+
+# JSON format
+fleet-status --format json
+```
+
+## Features
+
+- ✅ **Service Management**: Start, stop, and monitor FleetTools services
+- ✅ **JSON & Text Output**: Flexible output formats for different use cases  
+- ✅ **Error Handling**: Graceful error reporting and process management
+- ✅ **Background/Foreground**: Choose how services run
+- ✅ **Service Selection**: Start specific services or all services
+
+## Requirements
+
+- OpenCode >= 1.0.0
+- FleetTools CLI >= 0.1.0
+- Node.js >= 18.0.0
+
+## License
+
+MIT License - see LICENSE file for details.

package/assets/icon.svg

@@ -0,0 +1,6 @@
+<svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="32" height="32" rx="8" fill="#3B82F6"/>
+<path d="M8 12h2M12 12h8M8 16h2M12 16h8M8 20h2M12 20h8" stroke="white" stroke-width="2" stroke-linecap="round"/>
+<path d="M16 8l4 4M16 12l4 4M16 16l4 4" stroke="#60A5FA" stroke-width="2" stroke-linecap="round"/>
+<circle cx="24" cy="8" r="2" fill="#60A5FA"/>
+</svg>

package/dist/index.js

@@ -1,7 +1,12 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-export class FleetToolsOpenCodePluginImpl {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fleetToolsPlugin = exports.FleetToolsOpenCodePluginImpl = void 0;
+exports.createPlugin = createPlugin;
+exports.fallbackRegister = fallbackRegister;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class FleetToolsOpenCodePluginImpl {
     /** Plugin name */
     name = 'FleetTools';
     /** Plugin version */
@@ -146,14 +151,15 @@ export class FleetToolsOpenCodePluginImpl {
         console.log(`\n--- ${title} ---\n${content}\n`);
     }
 }
+exports.FleetToolsOpenCodePluginImpl = FleetToolsOpenCodePluginImpl;
 let plugin = null;
-export function createPlugin() {
+function createPlugin() {
     if (!plugin) {
         plugin = new FleetToolsOpenCodePluginImpl();
     }
     return plugin;
 }
-export const fleetToolsPlugin = {
+exports.fleetToolsPlugin = {
     name: 'FleetTools',
     version: '0.1.0',
     register: async (commands) => {
@@ -161,7 +167,7 @@ export const fleetToolsPlugin = {
         await fleetPlugin.registerCommands(commands);
     },
 };
-export async function fallbackRegister() {
+async function fallbackRegister() {
     console.warn('[FleetTools] OpenCode SDK not available. Running in CLI fallback mode.');
     console.warn('[FleetTools] The following commands are available via fleet CLI:');
     console.warn('  - fleet status');
@@ -170,5 +176,5 @@ export async function fallbackRegister() {
     console.warn('  - fleet services');
     console.warn('  - fleet help');
 }
-export default fleetToolsPlugin;
+exports.default = exports.fleetToolsPlugin;
 //# sourceMappingURL=index.js.map

package/dist/plugin.d.ts

@@ -0,0 +1,69 @@
+/**
+ * FleetTools OpenCode Plugin
+ *
+ * Integrates FleetTools CLI functionality into OpenCode
+ */
+export default function FleetToolsPlugin(): Promise<{
+    tool: {
+        'fleet-status': {
+            description: string;
+            parameters: {
+                type: string;
+                properties: {
+                    format: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                };
+            };
+            execute: ({ format }: {
+                format?: string;
+            }) => Promise<{
+                success: boolean;
+                data: string;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                data?: undefined;
+            }>;
+        };
+        'fleet-start': {
+            description: string;
+            parameters: {
+                type: string;
+                properties: {
+                    services: {
+                        type: string;
+                        description: string;
+                    };
+                    foreground: {
+                        type: string;
+                        description: string;
+                    };
+                };
+            };
+            execute: ({ services, foreground }: {
+                services?: string;
+                foreground?: boolean;
+            }) => Promise<unknown>;
+        };
+        'fleet-stop': {
+            description: string;
+            parameters: {
+                type: string;
+                properties: {
+                    force: {
+                        type: string;
+                        description: string;
+                    };
+                };
+            };
+            execute: ({ force }: {
+                force?: boolean;
+            }) => Promise<unknown>;
+        };
+    };
+}>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * FleetTools OpenCode Plugin
+ *
+ * Integrates FleetTools CLI functionality into OpenCode
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = FleetToolsPlugin;
+async function FleetToolsPlugin() {
+    console.log('FleetTools plugin initialized!');
+    // Return tool definitions for FleetTools
+    return {
+        tool: {
+            'fleet-status': {
+                description: 'Get FleetTools service status and configuration',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        format: {
+                            type: 'string',
+                            enum: ['json', 'text'],
+                            description: 'Output format (default: text)'
+                        }
+                    }
+                },
+                execute: async ({ format = 'text' }) => {
+                    const { execSync } = await import('node:child_process');
+                    try {
+                        const result = execSync(`fleet status${format === 'json' ? ' --json' : ''}`, {
+                            encoding: 'utf-8'
+                        });
+                        return { success: true, data: result };
+                    }
+                    catch (error) {
+                        return {
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error)
+                        };
+                    }
+                }
+            },
+            'fleet-start': {
+                description: 'Start FleetTools services',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        services: {
+                            type: 'string',
+                            description: 'Comma-separated list of services to start (api,squawk)'
+                        },
+                        foreground: {
+                            type: 'boolean',
+                            description: 'Run in foreground instead of background'
+                        }
+                    }
+                },
+                execute: async ({ services, foreground }) => {
+                    const { spawn } = await import('node:child_process');
+                    return new Promise((resolve) => {
+                        const args = ['start'];
+                        if (services)
+                            args.push('--services', services);
+                        if (foreground)
+                            args.push('--foreground');
+                        const process = spawn('fleet', args, { stdio: 'pipe' });
+                        let stdout = '';
+                        let stderr = '';
+                        process.stdout?.on('data', (data) => stdout += data);
+                        process.stderr?.on('data', (data) => stderr += data);
+                        process.on('close', (code) => {
+                            if (code === 0) {
+                                resolve({
+                                    success: true,
+                                    data: stdout || 'FleetTools services started successfully'
+                                });
+                            }
+                            else {
+                                resolve({
+                                    success: false,
+                                    error: stderr || `Process exited with code ${code}`
+                                });
+                            }
+                        });
+                        process.on('error', (error) => {
+                            resolve({
+                                success: false,
+                                error: error.message
+                            });
+                        });
+                    });
+                }
+            },
+            'fleet-stop': {
+                description: 'Stop FleetTools services',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        force: {
+                            type: 'boolean',
+                            description: 'Force stop services'
+                        }
+                    }
+                },
+                execute: async ({ force }) => {
+                    const { spawn } = await import('node:child_process');
+                    return new Promise((resolve) => {
+                        const args = ['stop'];
+                        if (force)
+                            args.push('--force');
+                        const process = spawn('fleet', args, { stdio: 'pipe' });
+                        let stdout = '';
+                        let stderr = '';
+                        process.stdout?.on('data', (data) => stdout += data);
+                        process.stderr?.on('data', (data) => stderr += data);
+                        process.on('close', (code) => {
+                            if (code === 0) {
+                                resolve({
+                                    success: true,
+                                    data: stdout || 'FleetTools services stopped successfully'
+                                });
+                            }
+                            else {
+                                resolve({
+                                    success: false,
+                                    error: stderr || `Process exited with code ${code}`
+                                });
+                            }
+                        });
+                        process.on('error', (error) => {
+                            resolve({
+                                success: false,
+                                error: error.message
+                            });
+                        });
+                    });
+                }
+            }
+        }
+    };
+}
+//# sourceMappingURL=plugin.js.map

package/manifest.json

@@ -0,0 +1,28 @@
+{
+  "name": "FleetTools",
+  "description": "AI Agent Coordination System",
+  "version": "1.0.0",
+  "author": "FleetTools",
+  "license": "MIT",
+  "entry": "dist/plugin.js",
+  "icon": "assets/icon.svg",
+  "permissions": [
+    "bash",
+    "read", 
+    "write"
+  ],
+  "hooks": [
+    "tool.execute.before",
+    "chat.params"
+  ],
+  "tools": [
+    "fleet-status",
+    "fleet-start", 
+    "fleet-stop"
+  ],
+  "categories": [
+    "development",
+    "automation",
+    "ai"
+  ]
+}

package/package.json

@@ -1,38 +1,40 @@
 {
   "name": "@fleettools/opencode-plugin",
-  "version": "0.2.0",
-  "description": "FleetTools plugin for OpenCode editor - /fleet commands",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "exports": {
-    "import": "./dist/index.js",
-    "types": "./dist/index.d.ts"
-  },
-  "bin": {
-    "fleet-opencode": "./dist/index.js"
-  },
+  "version": "1.0.0",
+  "description": "FleetTools OpenCode Plugin - AI Agent Coordination System",
+  "main": "dist/plugin.js",
+  "types": "dist/plugin.d.ts",
   "scripts": {
-    "build": "tsc --project tsconfig.json",
-    "test": "echo 'No tests configured'",
-    "clean": "rm -rf dist"
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "package": "npm run build && node scripts/package.js"
   },
   "keywords": [
     "fleettools",
     "opencode",
-    "plugin",
+    "ai",
+    "agents",
+    "coordination",
     "cli"
   ],
-  "author": "FleetTools Contributors",
+  "author": "FleetTools",
   "license": "MIT",
-  "engines": {
-    "bun": ">=1.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "typescript": "^5.9.3",
-    "@types/node": "^20.10.6"
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "peerDependencies": {
+    "opencode": "^1.0.0"
   },
-  "publishConfig": {
-    "access": "public"
+  "opencode": {
+    "displayName": "FleetTools",
+    "description": "AI Agent Coordination System for FleetTools",
+    "icon": "assets/icon.svg",
+    "permissions": [
+      "bash",
+      "read",
+      "write"
+    ]
   }
-}
+}

package/scripts/package.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+/**
+ * Plugin Packaging Script
+ * 
+ * Creates a distributable plugin package
+ */
+
+import { readFileSync, writeFileSync, createWriteStream } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import archiver from 'archiver';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function createPluginPackage() {
+  console.log('📦 Creating FleetTools OpenCode plugin package...');
+  
+  try {
+    // Ensure the build is up to date
+    execSync('npm run build', { stdio: 'inherit' });
+    
+    // Create a zip file
+    const output = createWriteStream(join(__dirname, '../fleettools-opencode-plugin.zip'));
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    
+    output.on('close', () => {
+      console.log(`✅ Plugin package created: ${archive.pointer()} bytes`);
+    });
+    
+    archive.on('error', (err) => {
+      throw err;
+    });
+    
+    archive.pipe(output);
+    
+    // Add essential files
+    archive.file(join(__dirname, '../dist/plugin.js'), { name: 'plugin.js' });
+    archive.file(join(__dirname, '../dist/plugin.d.ts'), { name: 'plugin.d.ts' });
+    archive.file(join(__dirname, '../package.json'), { name: 'package.json' });
+    archive.file(join(__dirname, '../manifest.json'), { name: 'manifest.json' });
+    archive.file(join(__dirname, '../README.md'), { name: 'README.md' });
+    
+    await archive.finalize();
+    
+  } catch (error) {
+    console.error('❌ Failed to create plugin package:', error);
+    process.exit(1);
+  }
+}
+
+createPluginPackage();