swarmhack-cli 0.1.0

package/README.md

@@ -0,0 +1,103 @@
+# @prancer/swarmhack
+
+Neural swarm-based penetration testing framework.
+
+## Installation
+
+```bash
+npm install -g @prancer/swarmhack
+```
+
+Or use npx:
+
+```bash
+npx @prancer/swarmhack --help
+```
+
+## CLI Usage
+
+```bash
+# Run SQL injection scan
+swarmhack spawn --agents sqli \
+  --target "http://example.com" \
+  --customer "your-customer" \
+  --token "your-token"
+
+# Run multiple agents
+swarmhack spawn --agents sqli,xss,csrf \
+  --target "http://example.com" \
+  --customer "your-customer" \
+  --token "your-token"
+
+# List available agents
+swarmhack agents list
+
+# Check system health
+swarmhack doctor
+```
+
+## Node.js API
+
+```javascript
+const swarmhack = require('@prancer/swarmhack');
+
+// Run a scan
+const results = await swarmhack.scan({
+  target: 'http://example.com',
+  agents: ['sqli', 'xss'],
+  customer: 'your-customer',
+  token: 'your-token',
+});
+
+console.log(results);
+
+// Check version
+const version = await swarmhack.version();
+console.log(version);
+
+// Run any command
+const result = await swarmhack.run(['spawn', '--help']);
+console.log(result.stdout);
+```
+
+## Supported Platforms
+
+| Platform | Architecture |
+|----------|--------------|
+| Linux | x64, arm64 |
+| macOS | x64, arm64 |
+| Windows | x64 |
+
+## Docker Alternative
+
+If npm installation fails, use Docker:
+
+```bash
+docker run --rm \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  -v $(pwd)/reports:/app/reports \
+  prancer/swarmhack:0.1.0 \
+  spawn --agents sqli --target "http://example.com" \
+  --customer "your-customer" --token "your-token"
+```
+
+## Available Agents
+
+| Agent | Description |
+|-------|-------------|
+| `crawler` | Web crawling and discovery |
+| `sqli` | SQL injection detection |
+| `xss` | Cross-site scripting |
+| `csrf` | CSRF vulnerabilities |
+| `idor` | Insecure direct object reference |
+| `auth_bypass` | Authentication bypass |
+| `cmdi` | Command injection |
+
+## Requirements
+
+- Node.js 16+
+- Prancer Portal account (for `--token` and `--customer`)
+
+## License
+
+MIT

package/bin/swarmhack.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * SwarmHack CLI Wrapper
+ * Executes the native binary with all arguments passed through
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Determine binary path based on platform
+function getBinaryPath() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  let binaryName = 'swarmhack';
+  if (platform === 'win32') {
+    binaryName = 'swarmhack.exe';
+  }
+
+  // Check multiple locations
+  const locations = [
+    // Installed in package
+    path.join(__dirname, '..', 'native', `${platform}-${arch}`, binaryName),
+    // Fallback to generic
+    path.join(__dirname, '..', 'native', binaryName),
+    // Development: in release folder
+    path.join(__dirname, '..', '..', binaryName),
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      return loc;
+    }
+  }
+
+  // Not found - show helpful error
+  console.error(`
+SwarmHack binary not found for ${platform}-${arch}
+
+This could mean:
+  1. The postinstall script failed to download the binary
+  2. Your platform is not supported yet
+
+Supported platforms:
+  - linux-x64
+  - linux-arm64
+  - darwin-x64 (macOS Intel)
+  - darwin-arm64 (macOS Apple Silicon)
+  - win32-x64 (Windows)
+
+To manually install:
+  1. Download binary from: https://github.com/prancer-io/swarmhack/releases
+  2. Place in: ${path.join(__dirname, '..', 'native', `${platform}-${arch}`)}
+  3. Make executable: chmod +x swarmhack
+
+Or use Docker instead:
+  docker run --rm prancer/swarmhack:0.1.0 --help
+`);
+  process.exit(1);
+}
+
+// Get binary path
+const binaryPath = getBinaryPath();
+
+// Spawn the binary with all arguments
+const args = process.argv.slice(2);
+const child = spawn(binaryPath, args, {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    // Ensure proper terminal handling
+    TERM: process.env.TERM || 'xterm-256color',
+  },
+});
+
+// Forward exit code
+child.on('close', (code) => {
+  process.exit(code || 0);
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error(`Error: Binary not found at ${binaryPath}`);
+  } else if (err.code === 'EACCES') {
+    console.error(`Error: Binary not executable. Run: chmod +x ${binaryPath}`);
+  } else {
+    console.error(`Error executing SwarmHack: ${err.message}`);
+  }
+  process.exit(1);
+});

package/index.js

@@ -0,0 +1,137 @@
+/**
+ * SwarmHack Node.js API
+ * Programmatic interface for running SwarmHack scans
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Get path to SwarmHack binary
+ */
+function getBinaryPath() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const binaryName = platform === 'win32' ? 'swarmhack.exe' : 'swarmhack';
+
+  const locations = [
+    path.join(__dirname, 'native', `${platform}-${arch}`, binaryName),
+    path.join(__dirname, 'native', binaryName),
+    path.join(__dirname, '..', binaryName),
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      return loc;
+    }
+  }
+
+  throw new Error(`SwarmHack binary not found for ${platform}-${arch}`);
+}
+
+/**
+ * Run SwarmHack with arguments
+ * @param {string[]} args - Command line arguments
+ * @param {object} options - Spawn options
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+function run(args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const binaryPath = getBinaryPath();
+    const stdout = [];
+    const stderr = [];
+
+    const child = spawn(binaryPath, args, {
+      ...options,
+      env: { ...process.env, ...options.env },
+    });
+
+    child.stdout?.on('data', (data) => stdout.push(data));
+    child.stderr?.on('data', (data) => stderr.push(data));
+
+    child.on('close', (code) => {
+      resolve({
+        code: code || 0,
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString(),
+      });
+    });
+
+    child.on('error', reject);
+  });
+}
+
+/**
+ * Run a security scan
+ * @param {object} config - Scan configuration
+ * @param {string} config.target - Target URL
+ * @param {string[]} config.agents - Agents to run (sqli, xss, etc.)
+ * @param {string} config.customer - Prancer customer ID
+ * @param {string} config.token - Prancer API token
+ * @param {string} config.output - Output file path
+ * @returns {Promise<object>} - Scan results
+ */
+async function scan(config) {
+  const args = ['spawn'];
+
+  if (config.target) args.push('--target', config.target);
+  if (config.agents) args.push('--agents', config.agents.join(','));
+  if (config.customer) args.push('--customer', config.customer);
+  if (config.token) args.push('--token', config.token);
+  if (config.output) args.push('--output', config.output);
+  if (config.timeout) args.push('--timeout', String(config.timeout));
+
+  args.push('--format', 'json');
+
+  const result = await run(args);
+
+  if (result.code !== 0) {
+    throw new Error(`Scan failed: ${result.stderr || result.stdout}`);
+  }
+
+  // Try to parse JSON output
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return { raw: result.stdout };
+  }
+}
+
+/**
+ * Get SwarmHack version
+ */
+async function version() {
+  const result = await run(['--version']);
+  return result.stdout.trim();
+}
+
+/**
+ * Check if SwarmHack is installed and working
+ */
+async function doctor() {
+  try {
+    const binaryPath = getBinaryPath();
+    const result = await run(['doctor']);
+    return {
+      installed: true,
+      binaryPath,
+      healthy: result.code === 0,
+      output: result.stdout,
+    };
+  } catch (err) {
+    return {
+      installed: false,
+      error: err.message,
+    };
+  }
+}
+
+module.exports = {
+  run,
+  scan,
+  version,
+  doctor,
+  getBinaryPath,
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "swarmhack-cli",
+  "version": "0.1.0",
+  "description": "SwarmHack - Neural swarm-based penetration testing framework",
+  "author": "Prancer <support@prancer.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prancer-io/swarmhack"
+  },
+  "homepage": "https://prancer.io",
+  "keywords": [
+    "security",
+    "pentesting",
+    "vulnerability-scanner",
+    "sql-injection",
+    "xss",
+    "web-security",
+    "ocsf"
+  ],
+  "bin": {
+    "swarmhack": "./bin/swarmhack.js"
+  },
+  "main": "index.js",
+  "files": [
+    "bin/",
+    "scripts/",
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node bin/swarmhack.js --version"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}

package/scripts/build.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * SwarmHack npm Package Build Script
+ * Builds binaries for all platforms and packages for npm
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const VERSION = require('../package.json').version;
+const ROOT = path.join(__dirname, '..');
+const PROJECT_ROOT = path.join(ROOT, '..', '..');
+
+// Build targets
+const TARGETS = [
+  { platform: 'linux', arch: 'x64', rust_target: 'x86_64-unknown-linux-gnu' },
+  { platform: 'linux', arch: 'arm64', rust_target: 'aarch64-unknown-linux-gnu' },
+  { platform: 'darwin', arch: 'x64', rust_target: 'x86_64-apple-darwin' },
+  { platform: 'darwin', arch: 'arm64', rust_target: 'aarch64-apple-darwin' },
+  { platform: 'win32', arch: 'x64', rust_target: 'x86_64-pc-windows-msvc' },
+];
+
+function exec(cmd, options = {}) {
+  console.log(`$ ${cmd}`);
+  try {
+    return execSync(cmd, { stdio: 'inherit', cwd: PROJECT_ROOT, ...options });
+  } catch (err) {
+    console.error(`Command failed: ${cmd}`);
+    throw err;
+  }
+}
+
+function buildTarget(target) {
+  console.log(`\n=== Building ${target.platform}-${target.arch} ===\n`);
+
+  const nativeDir = path.join(ROOT, 'native', `${target.platform}-${target.arch}`);
+  fs.mkdirSync(nativeDir, { recursive: true });
+
+  const binaryName = target.platform === 'win32' ? 'swarmhack.exe' : 'swarmhack';
+  const binaryPath = path.join(nativeDir, binaryName);
+
+  // Build with cross-compilation
+  try {
+    exec(`cross build --release --target ${target.rust_target}`);
+
+    const srcBinary = path.join(
+      PROJECT_ROOT,
+      'target',
+      target.rust_target,
+      'release',
+      binaryName
+    );
+
+    fs.copyFileSync(srcBinary, binaryPath);
+    fs.chmodSync(binaryPath, 0o755);
+    console.log(`✓ Built: ${binaryPath}`);
+
+  } catch (err) {
+    console.warn(`⚠ Skipping ${target.rust_target}: ${err.message}`);
+  }
+}
+
+function buildLocal() {
+  console.log('\n=== Building for current platform ===\n');
+
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const nativeDir = path.join(ROOT, 'native', `${platform}-${arch}`);
+  fs.mkdirSync(nativeDir, { recursive: true });
+
+  const binaryName = platform === 'win32' ? 'swarmhack.exe' : 'swarmhack';
+
+  exec('cargo build --release');
+
+  const srcBinary = path.join(PROJECT_ROOT, 'target', 'release', binaryName);
+  const destBinary = path.join(nativeDir, binaryName);
+
+  fs.copyFileSync(srcBinary, destBinary);
+  fs.chmodSync(destBinary, 0o755);
+
+  console.log(`✓ Built: ${destBinary}`);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--all')) {
+    // Build all platforms (requires cross)
+    console.log('Building all platforms...');
+    for (const target of TARGETS) {
+      try {
+        buildTarget(target);
+      } catch (err) {
+        console.error(`Failed to build ${target.platform}-${target.arch}`);
+      }
+    }
+  } else {
+    // Build for current platform only
+    buildLocal();
+  }
+
+  console.log(`\n✓ Build complete! Version: ${VERSION}\n`);
+  console.log('To publish:');
+  console.log('  cd npm && npm publish --access public\n');
+}
+
+main();

package/scripts/pack-local.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+/**
+ * Pack local binary for npm
+ * Use this when you already have a built binary
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ROOT = path.join(__dirname, '..');
+const RELEASE_DIR = path.join(ROOT, '..');
+
+function main() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const binaryName = platform === 'win32' ? 'swarmhack.exe' : 'swarmhack';
+
+  // Source: release/swarmhack
+  const srcBinary = path.join(RELEASE_DIR, 'swarmhack');
+
+  if (!fs.existsSync(srcBinary)) {
+    console.error(`Binary not found: ${srcBinary}`);
+    console.error('Build first with: cargo build --release && cp target/release/swarmhack release/');
+    process.exit(1);
+  }
+
+  // Destination: npm/native/<platform>-<arch>/swarmhack
+  const nativeDir = path.join(ROOT, 'native', `${platform}-${arch}`);
+  fs.mkdirSync(nativeDir, { recursive: true });
+
+  const destBinary = path.join(nativeDir, binaryName);
+  fs.copyFileSync(srcBinary, destBinary);
+  fs.chmodSync(destBinary, 0o755);
+
+  console.log(`✓ Packed binary for ${platform}-${arch}`);
+  console.log(`  Source: ${srcBinary}`);
+  console.log(`  Dest: ${destBinary}`);
+  console.log();
+  console.log('Package structure:');
+  console.log('  npm/');
+  console.log('  ├── package.json');
+  console.log('  ├── bin/swarmhack.js');
+  console.log('  ├── index.js');
+  console.log(`  └── native/${platform}-${arch}/${binaryName}`);
+  console.log();
+  console.log('To test locally:');
+  console.log('  cd npm && npm link');
+  console.log('  swarmhack --version');
+  console.log();
+  console.log('To publish:');
+  console.log('  cd npm && npm publish --access public');
+}
+
+main();

package/scripts/postinstall.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * SwarmHack Postinstall Script
+ * Downloads the appropriate binary for the current platform
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const VERSION = '0.1.0';
+const GITHUB_REPO = 'prancer-io/swarmhack';
+const BASE_URL = `https://github.com/${GITHUB_REPO}/releases/download/v${VERSION}`;
+
+// Platform mapping
+const PLATFORM_MAP = {
+  'linux-x64': 'swarmhack-linux-x64',
+  'linux-arm64': 'swarmhack-linux-arm64',
+  'darwin-x64': 'swarmhack-darwin-x64',
+  'darwin-arm64': 'swarmhack-darwin-arm64',
+  'win32-x64': 'swarmhack-windows-x64.exe',
+};
+
+function getPlatformKey() {
+  const platform = os.platform();
+  const arch = os.arch();
+  return `${platform}-${arch}`;
+}
+
+function getBinaryName() {
+  const platform = os.platform();
+  return platform === 'win32' ? 'swarmhack.exe' : 'swarmhack';
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    const request = https.get(url, (response) => {
+      // Handle redirects (GitHub releases use redirects)
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        fs.unlinkSync(dest);
+        return downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(dest);
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+
+      response.pipe(file);
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+    });
+
+    request.on('error', (err) => {
+      file.close();
+      fs.unlinkSync(dest);
+      reject(err);
+    });
+
+    request.setTimeout(60000, () => {
+      request.destroy();
+      reject(new Error('Download timeout'));
+    });
+  });
+}
+
+async function main() {
+  const platformKey = getPlatformKey();
+  const remoteBinary = PLATFORM_MAP[platformKey];
+
+  if (!remoteBinary) {
+    console.log(`
+╔════════════════════════════════════════════════════════════╗
+║  SwarmHack: Platform not supported                         ║
+╠════════════════════════════════════════════════════════════╣
+║  Your platform: ${platformKey.padEnd(40)}║
+║                                                            ║
+║  Supported platforms:                                      ║
+║    - linux-x64, linux-arm64                                ║
+║    - darwin-x64, darwin-arm64                              ║
+║    - win32-x64                                             ║
+║                                                            ║
+║  Alternative: Use Docker                                   ║
+║    docker run prancer/swarmhack:${VERSION} --help             ║
+╚════════════════════════════════════════════════════════════╝
+`);
+    // Don't fail install - just warn
+    return;
+  }
+
+  const nativeDir = path.join(__dirname, '..', 'native', platformKey);
+  const binaryPath = path.join(nativeDir, getBinaryName());
+
+  // Skip if already exists
+  if (fs.existsSync(binaryPath)) {
+    console.log(`SwarmHack binary already exists: ${binaryPath}`);
+    return;
+  }
+
+  // Create directory
+  fs.mkdirSync(nativeDir, { recursive: true });
+
+  const url = `${BASE_URL}/${remoteBinary}`;
+
+  console.log(`
+╔════════════════════════════════════════════════════════════╗
+║  SwarmHack: Downloading binary...                          ║
+╠════════════════════════════════════════════════════════════╣
+║  Version: ${VERSION.padEnd(48)}║
+║  Platform: ${platformKey.padEnd(47)}║
+╚════════════════════════════════════════════════════════════╝
+`);
+
+  try {
+    await downloadFile(url, binaryPath);
+
+    // Make executable on Unix
+    if (os.platform() !== 'win32') {
+      fs.chmodSync(binaryPath, 0o755);
+    }
+
+    console.log(`✓ SwarmHack installed successfully!`);
+    console.log(`  Binary: ${binaryPath}`);
+    console.log(`\n  Run: npx swarmhack --help\n`);
+
+  } catch (err) {
+    console.error(`
+╔════════════════════════════════════════════════════════════╗
+║  SwarmHack: Download failed                                ║
+╠════════════════════════════════════════════════════════════╣
+║  ${err.message.substring(0, 56).padEnd(56)}║
+║                                                            ║
+║  Manual installation:                                      ║
+║  1. Download from GitHub releases                          ║
+║  2. Place binary in: native/${platformKey}/                   ║
+║  3. Make executable: chmod +x swarmhack                    ║
+║                                                            ║
+║  Or use Docker:                                            ║
+║    docker run prancer/swarmhack:${VERSION} --help             ║
+╚════════════════════════════════════════════════════════════╝
+`);
+    // Don't fail the install
+  }
+}
+
+main().catch(console.error);