@the-agenticflow/openflows 0.1.5 → 0.1.8-dev.230.5aa03a0

package/bin/openflows-dashboard.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const { spawn } = require('child_process');
 const path = require('path');
-const binaryPath = path.join(__dirname, '..', 'bin', 'agentflow-dashboard-bin');
+const binaryPath = path.join(__dirname, '..', 'bin', 'openflows-dashboard-bin');
 const proc = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
 proc.on('exit', (code) => process.exit(code));

package/bin/openflows-setup.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const { spawn } = require('child_process');
 const path = require('path');
-const binaryPath = path.join(__dirname, '..', 'bin', 'agentflow-setup-bin');
+const binaryPath = path.join(__dirname, '..', 'bin', 'openflows-setup-bin');
 const proc = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
 proc.on('exit', (code) => process.exit(code));

package/bin/openflows.js

@@ -1,288 +1,6 @@
 #!/usr/bin/env node
-/**
- * OpenFlows - Autonomous AI Development Team
- * 
- * This wrapper handles:
- * 1. Automatic proxy management (for LLM API translation if needed)
- * 2. Environment configuration
- * 3. Graceful startup and shutdown
- * 
- * Users don't need to know about proxies - everything is handled automatically.
- */
-const { spawn, execSync, fork } = require('child_process');
+const { spawn } = require('child_process');
 const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const http = require('http');
-
-const binaryPath = path.join(__dirname, '..', 'bin', 'agentflow-bin');
-const PROXY_PORT = process.env.PROXY_PORT || 8765;
-const PROXY_STARTUP_TIMEOUT = 5000;
-
-// Check if a port is in use
-function isPortInUse(port) {
-    return new Promise((resolve) => {
-        const req = http.request({
-            method: 'GET',
-            hostname: 'localhost',
-            port: port,
-            path: '/health',
-            timeout: 500
-        }, (res) => {
-            resolve(res.statusCode === 200);
-        });
-        req.on('error', () => resolve(false));
-        req.on('timeout', () => {
-            req.destroy();
-            resolve(false);
-        });
-        req.end();
-    });
-}
-
-// Check if user needs proxy (no direct API keys, but has gateway config)
-function needsProxy() {
-    // If user explicitly set PROXY_URL, respect it
-    if (process.env.PROXY_URL) {
-        return { needed: false, reason: 'PROXY_URL already set' };
-    }
-    
-    // If user has Fireworks API key, they can use it directly
-    if (process.env.FIREWORKS_API_KEY) {
-        return { needed: false, reason: 'Fireworks direct mode' };
-    }
-    
-    // If user has Anthropic API key, they can use it directly
-    if (process.env.ANTHROPIC_API_KEY) {
-        return { needed: false, reason: 'Anthropic direct mode' };
-    }
-    
-    // If user has Gateway config but no direct keys, they need proxy
-    if (process.env.GATEWAY_URL || process.env.GATEWAY_API_KEY) {
-        return { needed: true, reason: 'Gateway configured, no direct keys' };
-    }
-    
-    // No API config at all - let the binary handle the error
-    return { needed: false, reason: 'No API config - will error in binary' };
-}
-
-// Start the built-in proxy (anthropic-proxy binary)
-async function startProxy() {
-    console.log('[openflows] Starting built-in API proxy...');
-    
-    const proxyBinary = path.join(__dirname, '..', 'bin', 'anthropic-proxy-bin');
-    
-    // Check if proxy binary exists
-    if (!fs.existsSync(proxyBinary)) {
-        // Try alternative location
-        const altProxy = path.join(__dirname, '..', 'bin', 'anthropic-proxy');
-        if (!fs.existsSync(altProxy)) {
-            console.log('[openflows] No built-in proxy found, skipping proxy startup');
-            return null;
-        }
-    }
-    
-    const proxy = spawn(proxyBinary, [], {
-        env: {
-            ...process.env,
-            PORT: PROXY_PORT.toString(),
-            RUST_LOG: process.env.RUST_LOG || 'info'
-        },
-        stdio: ['ignore', 'pipe', 'pipe']
-    });
-    
-    let proxyReady = false;
-    
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            if (!proxyReady) {
-                console.warn('[openflows] Proxy startup timeout, continuing without proxy');
-                resolve(null);
-            }
-        }, PROXY_STARTUP_TIMEOUT);
-        
-        proxy.stdout.on('data', (data) => {
-            const line = data.toString();
-            if (line.includes('listening') || line.includes('Proxy') || line.includes('started')) {
-                proxyReady = true;
-                clearTimeout(timeout);
-                console.log(`[openflows] ✓ Proxy started on port ${PROXY_PORT}`);
-                resolve(proxy);
-            }
-        });
-        
-        proxy.stderr.on('data', (data) => {
-            const line = data.toString();
-            // Log proxy errors but don't fail
-            if (line.includes('ERROR') || line.includes('error')) {
-                console.error('[openflows proxy]', line.trim());
-            }
-        });
-        
-        proxy.on('error', (err) => {
-            clearTimeout(timeout);
-            console.warn(`[openflows] Proxy failed to start: ${err.message}`);
-            resolve(null);
-        });
-        
-        proxy.on('exit', (code) => {
-            if (!proxyReady) {
-                clearTimeout(timeout);
-                resolve(null);
-            } else {
-                console.log(`[openflows] Proxy exited with code ${code}`);
-            }
-        });
-    });
-}
-
-// Clean up function
-let cleanupCalled = false;
-function cleanup(proxy, signal = 'SIGTERM') {
-    if (cleanupCalled) return;
-    cleanupCalled = true;
-    
-    if (proxy) {
-        console.log('[openflows] Stopping proxy...');
-        try {
-            proxy.kill(signal);
-        } catch (err) {
-            // Ignore cleanup errors
-        }
-    }
-}
-
-// Main entry point
-async function main() {
-    const args = process.argv.slice(2);
-    
-    // Handle special commands
-    if (args[0] === '--help' || args[0] === '-h') {
-        console.log(`
-OpenFlows - Autonomous AI Development Team
-
-Usage:
-  openflows [options]
-
-Options:
-  --help, -h        Show this help
-  --version, -v     Show version
-  --no-proxy        Disable automatic proxy startup
-  --proxy-only      Start only the proxy (for testing)
-
-Commands:
-  openflows-setup     Guided setup wizard
-  openflows-dashboard Live monitoring TUI
-  openflows-doctor    Diagnostic checks
-
-Environment Variables:
-  FIREWORKS_API_KEY   Use Fireworks AI directly (recommended)
-  ANTHROPIC_API_KEY   Use Anthropic directly
-  GATEWAY_URL         Custom gateway URL (requires proxy)
-  GATEWAY_API_KEY     Custom gateway API key
-  PROXY_PORT          Port for built-in proxy (default: 8765)
-
-Examples:
-  # Quick start with Fireworks (no proxy needed)
-  FIREWORKS_API_KEY=your-key openflows
-
-  # Use custom gateway (proxy auto-starts)
-  GATEWAY_URL=https://your-gateway.com/v1 \\
-  GATEWAY_API_KEY=your-key openflows
-
-Documentation: https://openflows.dev
-`);
-        process.exit(0);
-    }
-    
-    if (args[0] === '--version' || args[0] === '-v') {
-        try {
-            const pkg = require('../package.json');
-            console.log(`openflows v${pkg.version}`);
-        } catch {
-            console.log('openflows (version unknown)');
-        }
-        process.exit(0);
-    }
-    
-    // Skip proxy if --no-proxy flag
-    const skipProxy = args.includes('--no-proxy');
-    
-    // Start proxy only mode
-    if (args[0] === '--proxy-only') {
-        const proxy = await startProxy();
-        if (proxy) {
-            console.log(`[openflows] Proxy running on http://localhost:${PROXY_PORT}`);
-            console.log('[openflows] Press Ctrl+C to stop');
-            
-            // Keep running until killed
-            process.on('SIGINT', () => cleanup(proxy, 'SIGINT'));
-            process.on('SIGTERM', () => cleanup(proxy, 'SIGTERM'));
-        } else {
-            console.error('[openflows] Failed to start proxy');
-            process.exit(1);
-        }
-        return;
-    }
-    
-    // Check if we need to start proxy
-    let proxy = null;
-    let env = { ...process.env };
-    
-    if (!skipProxy) {
-        const { needed, reason } = needsProxy();
-        
-        if (needed) {
-            console.log(`[openflows] ${reason} - starting proxy...`);
-            
-            // Check if proxy is already running
-            const proxyRunning = await isPortInUse(PROXY_PORT);
-            
-            if (proxyRunning) {
-                console.log(`[openflows] ✓ Proxy already running on port ${PROXY_PORT}`);
-            } else {
-                proxy = await startProxy();
-                if (proxy) {
-                    // Set PROXY_URL for the main binary
-                    env.PROXY_URL = `http://localhost:${PROXY_PORT}/v1`;
-                }
-            }
-        } else {
-            console.log(`[openflows] Mode: ${reason}`);
-        }
-    }
-    
-    // Spawn the main binary
-    const proc = spawn(binaryPath, args, {
-        env,
-        stdio: 'inherit'
-    });
-    
-    // Handle signals
-    process.on('SIGINT', () => {
-        cleanup(proxy, 'SIGINT');
-        proc.kill('SIGINT');
-    });
-    
-    process.on('SIGTERM', () => {
-        cleanup(proxy, 'SIGTERM');
-        proc.kill('SIGTERM');
-    });
-    
-    // Handle exit
-    proc.on('exit', (code) => {
-        cleanup(proxy);
-        process.exit(code || 0);
-    });
-    
-    proc.on('error', (err) => {
-        console.error('[openflows] Failed to start:', err.message);
-        cleanup(proxy);
-        process.exit(1);
-    });
-}
-
-main().catch(err => {
-    console.error('[openflows] Error:', err.message);
-    process.exit(1);
-});
+const binaryPath = path.join(__dirname, '..', 'bin', 'openflows-bin');
+const proc = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
+proc.on('exit', (code) => process.exit(code));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-agenticflow/openflows",
-  "version": "0.1.5",
+  "version": "0.1.8-dev.230.5aa03a0",
   "description": "Autonomous AI development team — turns GitHub issues into working PRs",
   "main": "index.js",
   "bin": {
@@ -21,10 +21,7 @@
     "autonomous",
     "development",
     "agents",
-    "github",
-    "claude",
-    "fireworks",
-    "anthropic"
+    "github"
   ],
   "author": "The AgenticFlow Team",
   "license": "MIT",
@@ -32,12 +29,6 @@
     "url": "https://github.com/The-AgenticFlow/AgentFlow/issues"
   },
   "homepage": "https://openflows.dev",
-  "files": [
-    "bin/",
-    "scripts/",
-    "README.md",
-    ".env.example"
-  ],
   "engines": {
     "node": ">=18.0.0"
   },
@@ -49,7 +40,6 @@
     "x64",
     "arm64"
   ],
-  "dependencies": {},
   "optionalDependencies": {
     "@openflows/linux-x64-gnu": "0.1.0",
     "@openflows/linux-x64-musl": "0.1.0",

package/scripts/install.js

@@ -1,22 +1,16 @@
 #!/usr/bin/env node
 /**
- * Post-install script for @the-agenticflow/openflows
- * 
- * This script:
- * 1. Downloads the correct pre-built binary for the current platform
- * 2. Installs mcp-proxy (required for GitHub MCP connectivity)
- * 3. Verifies all dependencies are ready
+ * Post-install script: downloads the correct pre-built binary for the current platform.
  */
 const https = require('https');
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
 
 const REPO = 'The-AgenticFlow/AgentFlow';
 const BIN_DIR = path.join(__dirname, '..', 'bin');
-const POSTINSTALL_LOG = path.join(__dirname, '..', '.postinstall-done');
 
 function detectPlatform() {
     const platform = os.platform();
@@ -98,182 +92,65 @@ function extractTarGz(tarPath, destDir) {
     });
 }
 
-/**
- * Install mcp-proxy - required for GitHub MCP connectivity
- * 
- * mcp-proxy is a Python tool from PyPI (sparfenyuk/mcp-proxy)
- * It bridges stdio to HTTP MCP servers like GitHub Copilot's MCP endpoint.
- * 
- * Strategy:
- * 1. Check if mcp-proxy is already available
- * 2. Install via uv (fast) or pipx (alternative)
- * 3. Fall back to Docker mode instructions if Python tools unavailable
- */
-async function ensureMcpProxy() {
-    console.log(`[openflows] Checking mcp-proxy installation...`);
-    
-    // Check if already installed
-    try {
-        execSync('which mcp-proxy', { stdio: 'pipe' });
-        console.log(`[openflows] ✓ mcp-proxy already installed`);
-        return true;
-    } catch {
-        // Not installed, proceed with installation
-    }
-    
-    console.log(`[openflows] Installing mcp-proxy (required for GitHub MCP)...`);
-    
-    // Try uv first (fastest)
-    try {
-        execSync('which uv', { stdio: 'pipe' });
-        console.log(`[openflows] Installing via uv...`);
-        execSync('uv tool install mcp-proxy', {
-            stdio: 'inherit',
-            timeout: 120000 
-        });
-        console.log(`[openflows] ✓ mcp-proxy installed via uv`);
-        return true;
-    } catch (err) {
-        // uv failed or not available
-    }
-    
-    // Try pipx as alternative
-    try {
-        execSync('which pipx', { stdio: 'pipe' });
-        console.log(`[openflows] Installing via pipx...`);
-        execSync('pipx install mcp-proxy', {
-            stdio: 'inherit',
-            timeout: 120000 
-        });
-        console.log(`[openflows] ✓ mcp-proxy installed via pipx`);
-        return true;
-    } catch (err) {
-        // pipx failed or not available
-    }
-    
-    // Try pip3 as last resort
-    try {
-        execSync('which pip3', { stdio: 'pipe' });
-        console.log(`[openflows] Installing via pip3...`);
-        execSync('pip3 install --user mcp-proxy', {
-            stdio: 'inherit',
-            timeout: 120000 
-        });
-        console.log(`[openflows] ✓ mcp-proxy installed via pip3`);
-        return true;
-    } catch (err) {
-        // pip3 failed or not available
-    }
-    
-    console.warn(`[openflows] ⚠ Could not install mcp-proxy automatically.`);
-    console.warn(`[openflows]   Please install manually:`);
-    console.warn(`[openflows]     uv tool install mcp-proxy`);
-    console.warn(`[openflows]   Or use Docker mode:`);
-    console.warn(`[openflows]     export GITHUB_MCP_TYPE=docker`);
-    return false;
-}
+async function fetchLatestTag(includePrerelease = false) {
+    const url = includePrerelease
+        ? `https://api.github.com/repos/${REPO}/releases?per_page=10`
+        : `https://api.github.com/repos/${REPO}/releases/latest`;
 
-/**
- * Check if essential tools are available
- */
-function checkPrerequisites() {
-    const checks = [
-        { name: 'git', cmd: 'git --version' },
-        { name: 'node', cmd: 'node --version' },
-    ];
-    
-    console.log(`[openflows] Checking prerequisites...`);
-    
-    let allPassed = true;
-    for (const check of checks) {
-        try {
-            execSync(check.cmd, { stdio: 'pipe' });
-            console.log(`[openflows] ✓ ${check.name} available`);
-        } catch {
-            console.warn(`[openflows] ✗ ${check.name} not found - please install it`);
-            allPassed = false;
-        }
-    }
-    
-    return allPassed;
+    return new Promise((resolve, reject) => {
+        https.get(url, {
+            headers: { 'User-Agent': 'openflows-npm-installer' }
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    if (includePrerelease) {
+                        const pre = json.find(r => r.prerelease);
+                        resolve(pre ? pre.tag_name : null);
+                    } else {
+                        resolve(json.tag_name);
+                    }
+                } catch {
+                    reject(new Error('Failed to parse release info'));
+                }
+            });
+        }).on('error', reject);
+    });
 }
 
 async function main() {
-    // Skip postinstall if already done (e.g., during npm link)
-    if (fs.existsSync(POSTINSTALL_LOG)) {
-        const age = Date.now() - fs.statSync(POSTINSTALL_LOG).mtimeMs;
-        if (age < 60000) { // Less than 1 minute old
-            console.log(`[openflows] Postinstall already completed, skipping...`);
-            return;
-        }
-    }
-
     const platform = detectPlatform();
-    console.log(``);
-    console.log(`╔══════════════════════════════════════════════╗`);
-    console.log(`║     OpenFlows Installation                    ║`);
-    console.log(`║     Autonomous AI Development Team            ║`);
-    console.log(`╚══════════════════════════════════════════════╝`);
-    console.log(``);
-    console.log(`[openflows] Platform: ${platform}`);
+    const channel = process.env.AGENTFLOW_CHANNEL || (process.env.npm_package_version?.includes('-dev.') ? 'edge' : 'stable');
+    console.log(`[@the-agenticflow/openflows] Downloading binary for ${platform} (${channel})...`);
 
     // Ensure bin directory exists
     if (!fs.existsSync(BIN_DIR)) {
         fs.mkdirSync(BIN_DIR, { recursive: true });
     }
 
-    // Get latest release tag with better error handling
+    // Get release tag based on channel
     let tag;
     try {
-        tag = await new Promise((resolve, reject) => {
-            const req = https.get(`https://api.github.com/repos/${REPO}/releases/latest`, {
-                headers: { 
-                    'User-Agent': 'openflows-npm-installer',
-                    'Accept': 'application/vnd.github.v3+json'
-                }
-            }, (res) => {
-                if (res.statusCode !== 200) {
-                    reject(new Error(`GitHub API returned ${res.statusCode}`));
-                    return;
-                }
-                let data = '';
-                res.on('data', (chunk) => data += chunk);
-                res.on('end', () => {
-                    try {
-                        const json = JSON.parse(data);
-                        if (!json.tag_name) {
-                            reject(new Error('No tag_name in release response'));
-                        } else {
-                            resolve(json.tag_name);
-                        }
-                    } catch (parseErr) {
-                        reject(new Error(`Failed to parse release info: ${parseErr.message}`));
-                    }
-                });
-            });
-            req.on('error', reject);
-            req.setTimeout(30000, () => {
-                req.destroy();
-                reject(new Error('GitHub API request timeout'));
-            });
-        });
-    } catch (apiErr) {
-        console.error(`[openflows] GitHub API error: ${apiErr.message}`);
-        console.error('[openflows] Falling back to latest known version: v0.1.3');
-        tag = 'v0.1.3';
+        if (channel === 'edge') {
+            tag = await fetchLatestTag(true);
+            if (!tag) {
+                console.warn('[@the-agenticflow/openflows] No edge release found, falling back to latest stable');
+                tag = await fetchLatestTag(false);
+            }
+        } else {
+            tag = await fetchLatestTag(false);
+        }
+    } catch {
+        tag = await fetchLatestTag(false);
     }
 
     const archiveName = `openflows-${tag}-${platform}.tar.gz`;
     const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${archiveName}`;
-    // Use package's temp directory instead of system /tmp to avoid permission issues
-    const tmpDir = path.join(__dirname, '..', '.tmp');
-    if (!fs.existsSync(tmpDir)) {
-        fs.mkdirSync(tmpDir, { recursive: true });
-    }
-    const tmpFile = path.join(tmpDir, archiveName);
+    const tmpFile = path.join(os.tmpdir(), archiveName);
 
     try {
-        console.log(`[openflows] Downloading binary for ${platform}...`);
         await download(downloadUrl, tmpFile);
         await extractTarGz(tmpFile, BIN_DIR);
     } catch (err) {
@@ -281,8 +158,8 @@ async function main() {
         if (platform === 'x86_64-unknown-linux-gnu') {
             const muslArchiveName = `openflows-${tag}-x86_64-unknown-linux-musl.tar.gz`;
             const muslDownloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${muslArchiveName}`;
-            const muslTmpFile = path.join(tmpDir, muslArchiveName);
-            console.log(`[openflows] Trying musl fallback...`);
+            const muslTmpFile = path.join(os.tmpdir(), muslArchiveName);
+            console.log(`[@the-agenticflow/openflows] Trying musl fallback...`);
             await download(muslDownloadUrl, muslTmpFile);
             await extractTarGz(muslTmpFile, BIN_DIR);
             fs.unlinkSync(muslTmpFile);
@@ -292,7 +169,7 @@ async function main() {
     }
 
     // Rename binaries to match expected names
-    const binaries = ['agentflow', 'agentflow-setup', 'agentflow-dashboard', 'agentflow-doctor'];
+    const binaries = ['openflows', 'openflows-setup', 'openflows-dashboard', 'openflows-doctor', 'anthropic-proxy'];
     for (const bin of binaries) {
         const src = path.join(BIN_DIR, bin);
         const dst = path.join(BIN_DIR, `${bin}-bin`);
@@ -305,46 +182,7 @@ async function main() {
     if (fs.existsSync(tmpFile)) {
         fs.unlinkSync(tmpFile);
     }
-    // Clean up temp directory if empty
-    try {
-        if (fs.existsSync(tmpDir) && fs.readdirSync(tmpDir).length === 0) {
-            fs.rmdirSync(tmpDir);
-        }
-    } catch (cleanupErr) {
-        // Ignore cleanup errors
-    }
-
-    console.log(`[openflows] ✓ Binaries installed`);
-
-    // Install mcp-proxy
-    await ensureMcpProxy();
-    
-    // Check prerequisites
-    checkPrerequisites();
-
-    // Mark postinstall as done
-    fs.writeFileSync(POSTINSTALL_LOG, new Date().toISOString());
-
-    console.log(``);
-    console.log(`╔══════════════════════════════════════════════╗`);
-    console.log(`║     Installation Complete!                    ║`);
-    console.log(`╚══════════════════════════════════════════════╝`);
-    console.log(``);
-    console.log(`  Available commands:`);
-    console.log(`    openflows           - Start orchestration`);
-    console.log(`    openflows-setup     - Guided setup wizard`);
-    console.log(`    openflows-dashboard - Live monitoring TUI`);
-    console.log(`    openflows-doctor    - Diagnostic checks`);
-    console.log(``);
-    console.log(`  Quick start:`);
-    console.log(`    1. openflows-setup     # Configure API keys`);
-    console.log(`    2. openflows           # Start the autonomous team`);
-    console.log(``);
-    console.log(`  Docs: https://openflows.dev`);
-    console.log(``);
+    console.log(`[openflows] Installation complete!`);
 }
 
-main().catch(err => {
-    console.error('[openflows] Installation failed:', err.message);
-    process.exit(1);
-});
+main();