create-byan-agent 2.7.8 → 2.8.0

package/setup-parakeet.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+/**
+ * Parakeet TDT Setup Script
+ *
+ * Installs NVIDIA Parakeet TDT as the preferred STT engine.
+ * Falls back to Whisper when hardware requirements are not met.
+ *
+ * Usage:
+ *   node setup-parakeet.js [mode]
+ *   mode: local | docker | auto (default: auto)
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { detect, detectGPU, commandExists, checkPython, printDetectionSummary } = require('./lib/stt/engine');
+const parakeet = require('./lib/stt/parakeet-backend');
+const whisper = require('./lib/stt/whisper-backend');
+
+class ParakeetInstaller {
+  /**
+   * @param {string} projectRoot
+   * @param {'local'|'docker'|'auto'} mode
+   */
+  constructor(projectRoot, mode = 'auto') {
+    this.projectRoot = projectRoot;
+    this.mode = mode;
+    this.scriptsDir = path.join(projectRoot, 'scripts');
+  }
+
+  /**
+   * Run the full setup flow.
+   *
+   * @returns {Promise<{ success: boolean, engine: string, mode: string, fallback: boolean }>}
+   */
+  async setup() {
+    console.log(chalk.blue('\n  Parakeet TDT — STT Engine Setup'));
+    console.log(chalk.gray('  ================================\n'));
+
+    const detection = detect();
+    console.log(chalk.bold('  Detection:'));
+    printDetectionSummary(detection);
+    console.log('');
+
+    const resolvedMode = this.resolveMode(detection);
+
+    // Attempt Parakeet first
+    if (detection.engine === 'parakeet') {
+      try {
+        const result = await parakeet.setup({
+          mode: resolvedMode,
+          projectRoot: this.projectRoot
+        });
+        await this.createLaunchScript('parakeet', resolvedMode);
+        this.printSuccess('parakeet', result);
+        return { success: true, engine: 'parakeet', mode: resolvedMode, fallback: false };
+      } catch (err) {
+        console.log(chalk.yellow(`\n  Parakeet setup failed: ${err.message}`));
+        console.log(chalk.yellow('  Falling back to Whisper...\n'));
+      }
+    }
+
+    // Fallback to Whisper
+    if (detection.engine !== 'none') {
+      try {
+        const result = await whisper.setup({
+          mode: resolvedMode,
+          projectRoot: this.projectRoot
+        });
+        await this.createLaunchScript('whisper', resolvedMode);
+        this.printSuccess('whisper', result);
+        return { success: true, engine: 'whisper', mode: resolvedMode, fallback: detection.engine === 'parakeet' };
+      } catch (err) {
+        console.error(chalk.red(`\n  Whisper setup also failed: ${err.message}`));
+        return { success: false, engine: 'none', mode: resolvedMode, fallback: true };
+      }
+    }
+
+    console.log(chalk.red('\n  No STT engine could be installed.'));
+    console.log(chalk.gray('  Install Docker or Python 3 and try again.'));
+    return { success: false, engine: 'none', mode: 'none', fallback: false };
+  }
+
+  /**
+   * Resolve auto mode into a concrete mode based on what's available.
+   *
+   * @param {{ engine: string, gpu: object }} detection
+   * @returns {'local'|'docker'}
+   */
+  resolveMode(detection) {
+    if (this.mode !== 'auto') return this.mode;
+
+    // Prefer Docker when available — cleaner isolation
+    if (commandExists('docker')) return 'docker';
+
+    const python = checkPython();
+    if (python.available) return 'local';
+
+    return 'docker';
+  }
+
+  /**
+   * Create a convenience launch script for the installed engine.
+   *
+   * @param {'parakeet'|'whisper'} engine
+   * @param {'local'|'docker'} mode
+   */
+  async createLaunchScript(engine, mode) {
+    await fs.ensureDir(this.scriptsDir);
+
+    const port = engine === 'parakeet' ? parakeet.PARAKEET_PORT : whisper.WHISPER_PORT;
+    const composeFile = engine === 'parakeet'
+      ? 'docker-compose.parakeet.yml'
+      : 'docker-compose.turbo-whisper.yml';
+
+    const script = `#!/bin/bash
+# Launch ${engine} STT server
+# Generated by setup-parakeet.js
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+PORT=${port}
+
+echo "Checking ${engine} STT server on port $PORT..."
+
+if curl -sf http://localhost:$PORT/health > /dev/null 2>&1; then
+    echo "Server already running on port $PORT"
+    exit 0
+fi
+
+${mode === 'docker' ? `
+COMPOSE_FILE="$PROJECT_DIR/${composeFile}"
+if [ ! -f "$COMPOSE_FILE" ]; then
+    echo "Error: $COMPOSE_FILE not found"
+    exit 1
+fi
+echo "Starting ${engine} via Docker..."
+docker compose -f "$COMPOSE_FILE" up -d
+
+echo "Waiting for server (up to 60s)..."
+for i in $(seq 1 12); do
+    sleep 5
+    if curl -sf http://localhost:$PORT/health > /dev/null 2>&1; then
+        echo "Server ready on port $PORT"
+        exit 0
+    fi
+done
+echo "Server did not become ready in time. Check: docker compose -f $COMPOSE_FILE logs"
+exit 1
+` : `
+echo "Starting ${engine} locally..."
+${engine === 'parakeet'
+  ? `python3 -c "
+from nemo.collections.asr.models import EncDecRNNTBPEModel
+import json, http.server, io, soundfile as sf, numpy as np
+model = EncDecRNNTBPEModel.from_pretrained('${parakeet.DEFAULT_MODEL}')
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        if self.path == '/health':
+            self.send_response(200); self.end_headers(); self.wfile.write(b'ok')
+        else:
+            self.send_response(404); self.end_headers()
+    def do_POST(self):
+        length = int(self.headers['Content-Length'])
+        audio_bytes = self.rfile.read(length)
+        audio, sr = sf.read(io.BytesIO(audio_bytes))
+        transcription = model.transcribe([audio])
+        result = json.dumps({'text': transcription[0] if transcription else ''})
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.end_headers()
+        self.wfile.write(result.encode())
+    def log_message(self, format, *args): pass
+
+httpd = http.server.HTTPServer(('', $PORT), Handler)
+print('Parakeet TDT server listening on port $PORT')
+httpd.serve_forever()
+" &`
+  : `cd "$HOME/faster-whisper-server"
+source .venv/bin/activate
+uvicorn --factory faster_whisper_server.main:create_app --port $PORT &`}
+SERVER_PID=$!
+
+echo "Waiting for server (up to 60s)..."
+for i in $(seq 1 12); do
+    sleep 5
+    if curl -sf http://localhost:$PORT/health > /dev/null 2>&1; then
+        echo "Server ready on port $PORT (PID: $SERVER_PID)"
+        exit 0
+    fi
+done
+echo "Server did not start in time."
+exit 1
+`}
+`;
+
+    const scriptPath = path.join(this.scriptsDir, `launch-${engine}-stt.sh`);
+    await fs.writeFile(scriptPath, script, 'utf-8');
+    await fs.chmod(scriptPath, '755');
+
+    // Stop script for Docker mode
+    if (mode === 'docker') {
+      const stopScript = `#!/bin/bash
+# Stop ${engine} STT Docker container
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+COMPOSE_FILE="$PROJECT_DIR/${composeFile}"
+
+if [ ! -f "$COMPOSE_FILE" ]; then
+    echo "Error: $COMPOSE_FILE not found"
+    exit 1
+fi
+
+echo "Stopping ${engine} server..."
+docker compose -f "$COMPOSE_FILE" down
+echo "Done."
+`;
+
+      const stopPath = path.join(this.scriptsDir, `stop-${engine}-stt.sh`);
+      await fs.writeFile(stopPath, stopScript, 'utf-8');
+      await fs.chmod(stopPath, '755');
+    }
+  }
+
+  /**
+   * @param {string} engine
+   * @param {{ model: string, mode: string }} result
+   */
+  printSuccess(engine, result) {
+    console.log(chalk.green(`\n  STT engine installed: ${engine}`));
+    console.log(chalk.gray(`  Model: ${result.model}`));
+    console.log(chalk.gray(`  Mode:  ${result.mode}`));
+    console.log(chalk.gray(`  Port:  ${engine === 'parakeet' ? parakeet.PARAKEET_PORT : whisper.WHISPER_PORT}`));
+    console.log(chalk.blue('\n  Launch:'));
+    console.log(chalk.white(`    ./scripts/launch-${engine}-stt.sh\n`));
+  }
+}
+
+module.exports = ParakeetInstaller;
+
+// CLI entry point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const mode = args[0] || 'auto';
+  const projectRoot = path.resolve(__dirname, '..');
+
+  const installer = new ParakeetInstaller(projectRoot, mode);
+  installer.setup()
+    .then(result => process.exit(result.success ? 0 : 1))
+    .catch(err => {
+      console.error(chalk.red('Fatal:'), err.message);
+      process.exit(1);
+    });
+}

package/src/webui/api.js

@@ -0,0 +1,293 @@
+/**
+ * BYAN WebUI REST API handlers.
+ * Each handler receives (req, res, server) where server is ByanWebUI instance.
+ */
+
+let yanstaller = null;
+let detector = null;
+let backuper = null;
+let sttEngine = null;
+
+try { yanstaller = require('../../lib/yanstaller'); } catch { yanstaller = null; }
+try { detector = require('../../lib/yanstaller/detector'); } catch { detector = null; }
+try { backuper = require('../../lib/yanstaller/backuper'); } catch { backuper = null; }
+try { sttEngine = require('../../lib/stt/engine'); } catch { sttEngine = null; }
+
+const fs = require('fs');
+const path = require('path');
+
+function json(res, statusCode, data) {
+  res.writeHead(statusCode);
+  res.end(JSON.stringify(data));
+}
+
+function readPackageVersion() {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.resolve(__dirname, '..', '..', 'package.json'), 'utf8')
+    );
+    return pkg.version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function isByanInstalled(projectRoot) {
+  return fs.existsSync(path.join(projectRoot, '_bmad'));
+}
+
+function detectPlatforms(projectRoot) {
+  const found = [];
+  const checks = [
+    { name: 'copilot-cli', path: '.github/agents' },
+    { name: 'vscode', path: '.vscode' },
+    { name: 'claude', path: '.claude' },
+    { name: 'codex', path: '.codex/prompts' }
+  ];
+  for (const check of checks) {
+    if (fs.existsSync(path.join(projectRoot, check.path))) {
+      found.push(check.name);
+    }
+  }
+  return found;
+}
+
+const routes = {
+  'GET status': async (req, res, server) => {
+    const projectRoot = server.projectRoot;
+    const version = readPackageVersion();
+    const installed = isByanInstalled(projectRoot);
+
+    let platforms = detectPlatforms(projectRoot);
+    let detectionResult = null;
+
+    if (detector) {
+      try {
+        detectionResult = await detector.detect();
+        platforms = detectionResult.platforms
+          .filter(p => p.detected)
+          .map(p => p.name);
+      } catch {
+        // Fallback to fs-based detection
+      }
+    }
+
+    json(res, 200, {
+      version,
+      installed,
+      platforms,
+      detection: detectionResult,
+      sttEngine: sttEngine ? 'available' : 'not-installed',
+      projectRoot
+    });
+  },
+
+  'GET update/check': async (req, res, server) => {
+    const version = readPackageVersion();
+
+    // Simulated update check; real implementation would query npm registry
+    json(res, 200, {
+      updateAvailable: false,
+      installed: version,
+      latest: version,
+      changes: []
+    });
+  },
+
+  'POST install': async (req, res, server) => {
+    json(res, 200, { status: 'started' });
+
+    const config = req.body || {};
+    const projectRoot = server.projectRoot;
+    const steps = [
+      'Detecting environment',
+      'Validating prerequisites',
+      'Creating directory structure',
+      'Installing core module',
+      'Installing selected modules',
+      'Configuring platforms',
+      'Generating agent stubs',
+      'Writing configuration',
+      'Validating installation'
+    ];
+
+    try {
+      for (let i = 0; i < steps.length; i++) {
+        server.broadcastProgress(i + 1, steps.length, steps[i]);
+        server.broadcastLog('info', steps[i] + '...');
+        await sleep(300);
+      }
+
+      if (yanstaller) {
+        try {
+          await yanstaller.install({
+            mode: config.mode || 'full',
+            platforms: config.platforms,
+            yes: true,
+            projectRoot
+          });
+        } catch (err) {
+          server.broadcastLog('warn', `Yanstaller: ${err.message} (continuing with stub install)`);
+        }
+      }
+
+      ensureDirectoryStructure(projectRoot);
+      writeBaseConfig(projectRoot, config);
+
+      server.broadcastProgress(steps.length, steps.length, 'Complete');
+      server.broadcastComplete(true, {
+        message: 'BYAN installed successfully',
+        projectRoot,
+        mode: config.mode || 'auto',
+        platforms: config.platforms || detectPlatforms(projectRoot)
+      });
+    } catch (err) {
+      server.broadcastLog('error', err.message);
+      server.broadcastComplete(false, { message: err.message });
+    }
+  },
+
+  'POST update': async (req, res, server) => {
+    json(res, 200, { status: 'started' });
+
+    const steps = [
+      'Checking current version',
+      'Creating backup',
+      'Downloading update',
+      'Applying changes',
+      'Merging configuration',
+      'Validating update'
+    ];
+
+    try {
+      for (let i = 0; i < steps.length; i++) {
+        server.broadcastProgress(i + 1, steps.length, steps[i]);
+        server.broadcastLog('info', steps[i] + '...');
+        await sleep(400);
+      }
+
+      if (yanstaller && yanstaller.update) {
+        try {
+          await yanstaller.update('latest');
+        } catch (err) {
+          server.broadcastLog('warn', `Update module: ${err.message}`);
+        }
+      }
+
+      server.broadcastComplete(true, { message: 'BYAN updated successfully' });
+    } catch (err) {
+      server.broadcastLog('error', err.message);
+      server.broadcastComplete(false, { message: err.message });
+    }
+  },
+
+  'POST rollback': async (req, res, server) => {
+    const { backupPath } = req.body || {};
+
+    if (!backuper) {
+      json(res, 503, { error: 'Backup module not available' });
+      return;
+    }
+
+    try {
+      const targetPath = path.join(server.projectRoot, '_bmad');
+      await backuper.restore(backupPath, targetPath);
+      json(res, 200, { success: true, message: 'Rollback complete' });
+    } catch (err) {
+      json(res, 500, { error: err.message });
+    }
+  },
+
+  'GET backups': async (req, res, server) => {
+    if (!backuper) {
+      json(res, 200, { backups: [] });
+      return;
+    }
+
+    try {
+      const list = await backuper.listBackups(server.projectRoot);
+      json(res, 200, { backups: list });
+    } catch (err) {
+      json(res, 500, { error: err.message });
+    }
+  },
+
+  'GET stt/status': async (req, res) => {
+    if (!sttEngine) {
+      json(res, 200, { available: false, reason: 'STT engine module not installed' });
+      return;
+    }
+
+    try {
+      const status = typeof sttEngine.status === 'function'
+        ? await sttEngine.status()
+        : { available: true };
+      json(res, 200, status);
+    } catch (err) {
+      json(res, 500, { error: err.message });
+    }
+  },
+
+  'POST stt/test': async (req, res) => {
+    if (!sttEngine) {
+      json(res, 503, { error: 'STT engine not available' });
+      return;
+    }
+
+    try {
+      const result = typeof sttEngine.test === 'function'
+        ? await sttEngine.test()
+        : { success: false, reason: 'Test not implemented' };
+      json(res, 200, result);
+    } catch (err) {
+      json(res, 500, { error: err.message });
+    }
+  }
+};
+
+function resolve(method, route) {
+  const key = `${method} ${route}`;
+  return routes[key] || null;
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+function ensureDirectoryStructure(projectRoot) {
+  const dirs = [
+    '_bmad',
+    '_bmad/_config',
+    '_bmad/_memory',
+    '_bmad/core',
+    '_bmad/core/agents',
+    '_bmad/core/workflows',
+    '_bmad/core/tasks',
+    '_bmad-output',
+    '_bmad-output/planning-artifacts',
+    '_bmad-output/implementation-artifacts'
+  ];
+
+  for (const dir of dirs) {
+    const full = path.join(projectRoot, dir);
+    if (!fs.existsSync(full)) {
+      fs.mkdirSync(full, { recursive: true });
+    }
+  }
+}
+
+function writeBaseConfig(projectRoot, config) {
+  const configPath = path.join(projectRoot, '_bmad', 'core', 'config.yaml');
+  if (fs.existsSync(configPath)) return;
+
+  const content = [
+    `user_name: ${config.userName || 'User'}`,
+    `communication_language: ${config.language || 'English'}`,
+    `document_output_language: ${config.language || 'English'}`,
+    `output_folder: "{project-root}/_bmad-output"`
+  ].join('\n') + '\n';
+
+  fs.writeFileSync(configPath, content, 'utf8');
+}
+
+module.exports = { resolve, routes };