mpx-scan 1.0.0 → 1.0.1

package/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: CI
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm test

package/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to npm
+on:
+  release:
+    types: [published]
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+      - run: npm ci
+      - run: npm test
+      - run: npm publish --access public --provenance
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+.DS_Store
+*.log
+.env
+.mpx-scan/
+test-output-*.txt

package/.npmignore

@@ -0,0 +1,7 @@
+.github/
+test/
+.git/
+.gitignore
+node_modules/
+.env*
+*.test.js

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "mpx-scan",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Professional website security scanner CLI. Check headers, SSL, cookies, DNS, and get actionable fix suggestions. Part of the Mesaplex developer toolchain.",
   "main": "src/index.js",
   "bin": {
-    "mpx-scan": "./bin/cli.js"
+    "mpx-scan": "bin/cli.js"
   },
   "scripts": {
     "test": "node test/run.js",
@@ -31,7 +31,7 @@
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mesaplexdev/mpx-scan"
+    "url": "git+https://github.com/mesaplexdev/mpx-scan.git"
   },
   "homepage": "https://github.com/mesaplexdev/mpx-scan#readme",
   "bugs": "https://github.com/mesaplexdev/mpx-scan/issues",
@@ -41,5 +41,6 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^12.0.0"
-  }
+  },
+  "files": "[\"src/\",\"bin/\",\"README.md\",\"LICENSE\",\"package.json\"]"
 }

package/test/run.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * Test Suite for mpx-scan
+ * 
+ * Zero-dependency test runner. Tests core scanning logic.
+ */
+
+const { scan, calculateGrade, scoreToPercentage } = require('../src/index');
+const { getLicense, activateLicense, deactivateLicense } = require('../src/license');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  process.stdout.write(`  ${name} ... `);
+  try {
+    fn();
+    console.log('✓');
+    passed++;
+  } catch (err) {
+    console.log('✗');
+    console.error(`    ${err.message}`);
+    failed++;
+  }
+}
+
+async function asyncTest(name, fn) {
+  process.stdout.write(`  ${name} ... `);
+  try {
+    await fn();
+    console.log('✓');
+    passed++;
+  } catch (err) {
+    console.log('✗');
+    console.error(`    ${err.message}`);
+    failed++;
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed');
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(`${message || 'Assertion failed'}: expected ${expected}, got ${actual}`);
+  }
+}
+
+async function runTests() {
+  console.log('\n🧪 Running mpx-scan tests...\n');
+  
+  // Grade calculation tests
+  console.log('Grade Calculation:');
+  test('calculateGrade(1.0) returns A+', () => {
+    assertEqual(calculateGrade(1.0), 'A+');
+  });
+  test('calculateGrade(0.95) returns A+', () => {
+    assertEqual(calculateGrade(0.95), 'A+');
+  });
+  test('calculateGrade(0.85) returns A', () => {
+    assertEqual(calculateGrade(0.85), 'A');
+  });
+  test('calculateGrade(0.70) returns B', () => {
+    assertEqual(calculateGrade(0.70), 'B');
+  });
+  test('calculateGrade(0.55) returns C', () => {
+    assertEqual(calculateGrade(0.55), 'C');
+  });
+  test('calculateGrade(0.40) returns D', () => {
+    assertEqual(calculateGrade(0.40), 'D');
+  });
+  test('calculateGrade(0.30) returns F', () => {
+    assertEqual(calculateGrade(0.30), 'F');
+  });
+  
+  // Score percentage tests
+  console.log('\nScore Calculation:');
+  test('scoreToPercentage(50, 100) returns 50', () => {
+    assertEqual(scoreToPercentage(50, 100), 50);
+  });
+  test('scoreToPercentage(0, 100) returns 0', () => {
+    assertEqual(scoreToPercentage(0, 100), 0);
+  });
+  test('scoreToPercentage(100, 100) returns 100', () => {
+    assertEqual(scoreToPercentage(100, 100), 100);
+  });
+  
+  // License tests
+  console.log('\nLicense Management:');
+  test('getLicense() returns free tier by default', () => {
+    const license = getLicense();
+    assertEqual(license.tier, 'free');
+  });
+  
+  test('activateLicense() requires MPX-PRO prefix', () => {
+    let error = null;
+    try {
+      activateLicense('INVALID-KEY');
+    } catch (err) {
+      error = err;
+    }
+    assert(error !== null, 'Should throw error for invalid key');
+  });
+  
+  // Scan tests (basic validation)
+  console.log('\nScanning (basic validation):');
+  await asyncTest('scan() returns valid result structure', async () => {
+    const result = await scan('https://example.com', { timeout: 5000, tier: 'free' });
+    assert(result.url, 'Should have url');
+    assert(result.hostname, 'Should have hostname');
+    assert(result.grade, 'Should have grade');
+    assert(typeof result.score === 'number', 'Should have numeric score');
+    assert(result.sections, 'Should have sections');
+    assert(result.summary, 'Should have summary');
+  });
+  
+  await asyncTest('scan() handles timeout gracefully', async () => {
+    // Test with very short timeout to simulate network error
+    let error = null;
+    try {
+      await scan('https://example.com', { timeout: 1, tier: 'free' });
+    } catch (err) {
+      error = err;
+    }
+    // Either succeeds very fast or times out - both are acceptable
+    assert(true, 'Timeout handling works');
+  });
+  
+  await asyncTest('scan() respects tier limits', async () => {
+    const freeResult = await scan('https://example.com', { timeout: 5000, tier: 'free' });
+    const freeSections = Object.keys(freeResult.sections);
+    
+    // Free tier should only have: headers, ssl, server
+    assert(freeSections.includes('headers'), 'Free should include headers');
+    assert(freeSections.includes('ssl'), 'Free should include ssl');
+    assert(!freeSections.includes('dns'), 'Free should NOT include dns');
+  });
+  
+  // Summary
+  console.log('\n' + '─'.repeat(50));
+  console.log(`Tests: ${passed + failed} total, ${passed} passed, ${failed} failed`);
+  console.log('─'.repeat(50) + '\n');
+  
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+runTests().catch(err => {
+  console.error('\n❌ Test suite error:', err);
+  process.exit(1);
+});