diffsurge 0.3.0

package/README.md

@@ -0,0 +1,136 @@
+# diffsurge
+
+> Catch breaking API changes before your users do.
+
+Diffsurge helps you detect breaking API changes before they reach production.
+
+## Install
+
+```bash
+npm install -g diffsurge
+```
+
+Or use Docker:
+
+```bash
+docker run equixankit/diffsurge-cli --help
+```
+
+## Setup
+
+1. **Create an API key** in the [Diffsurge dashboard](https://app.diffsurge.com) → Settings → API Keys
+2. **Add it to your `.env` file** in your project root:
+
+```env
+SURGE_API_KEY=tvc_live_your_key_here
+SURGE_PROJECT_ID=your-project-uuid
+```
+
+3. **Verify it works:**
+
+```bash
+surge whoami
+```
+
+## Commands
+
+### `surge whoami`
+
+Verify your API key is valid and see account info:
+
+```bash
+surge whoami
+```
+
+### `surge check`
+
+Run API checks in your CI/CD pipeline:
+
+```bash
+# Basic check — validates API key, fetches traffic & schema stats
+surge check --project-id abc-123
+
+# With local schema diff — detect breaking changes before deploy
+surge check --project-id abc-123 --schema openapi.yaml --fail-on-breaking
+```
+
+### `surge diff`
+
+Compare two JSON API responses:
+
+```bash
+surge diff --old response-v1.json --new response-v2.json
+```
+
+### `surge schema diff`
+
+Compare two OpenAPI/Swagger schema files and detect breaking changes:
+
+```bash
+surge schema diff --old api-v1.yaml --new api-v2.yaml --fail-on-breaking
+```
+
+### `surge replay`
+
+Replay captured traffic against a target server:
+
+```bash
+surge replay --source captured.json --target http://localhost:8080
+```
+
+## CI/CD Integration
+
+### GitHub Actions
+
+```yaml
+name: API Check
+on: [push, pull_request]
+jobs:
+  api-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install -g diffsurge
+      - run: surge check --project-id ${{ secrets.SURGE_PROJECT_ID }}
+        env:
+          SURGE_API_KEY: ${{ secrets.SURGE_API_KEY }}
+```
+
+### GitLab CI
+
+```yaml
+api-check:
+  image: node:20
+  script:
+    - npm install -g diffsurge
+    - surge check --project-id $SURGE_PROJECT_ID
+  variables:
+    SURGE_API_KEY: $SURGE_API_KEY
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|---|---|---|
+| `SURGE_API_KEY` | Your API key (starts with `tvc_live_`) | — |
+| `SURGE_API_URL` | API base URL | `https://api.diffsurge.com` |
+| `SURGE_PROJECT_ID` | Default project ID | — |
+
+All variables can also use the `TVC_` prefix (e.g., `TVC_API_KEY`) as a fallback.
+
+## Flags
+
+All commands support these global flags:
+
+```
+--api-key     API key (overrides SURGE_API_KEY)
+--api-url     API base URL (overrides SURGE_API_URL)
+--project-id  Project ID (overrides SURGE_PROJECT_ID)
+```
+
+## License
+
+MIT

package/bin/surge

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require("child_process");
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+
+const isWindows = os.platform() === "win32";
+const binaryName = isWindows ? "surge.exe" : "surge";
+const binaryPath = path.join(__dirname, binaryName);
+
+// Load .env from the current working directory and merge into process.env
+function loadDotEnv() {
+  const envPath = path.join(process.cwd(), ".env");
+  try {
+    const content = fs.readFileSync(envPath, "utf8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      let val = trimmed.slice(eqIdx + 1).trim();
+      // Remove surrounding quotes
+      if (
+        (val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))
+      ) {
+        val = val.slice(1, -1);
+      }
+      // Only set if not already in env (real env vars take priority)
+      if (!(key in process.env)) {
+        process.env[key] = val;
+      }
+    }
+  } catch {
+    // .env file not found or unreadable — that's fine
+  }
+}
+
+loadDotEnv();
+
+try {
+  execFileSync(binaryPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+} catch (err) {
+  if (err.status !== undefined) {
+    process.exit(err.status);
+  }
+  console.error(`Failed to run surge: ${err.message}`);
+  console.error(`Run "npm rebuild diffsurge" to re-download the binary.`);
+  process.exit(1);
+}

package/install.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+function getPlatformBinary() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const mapping = {
+    "darwin-x64": "surge-darwin-amd64",
+    "darwin-arm64": "surge-darwin-arm64",
+    "linux-x64": "surge-linux-amd64",
+    "linux-arm64": "surge-linux-arm64",
+    "win32-x64": "surge-windows-amd64.exe",
+  };
+
+  const key = `${platform}-${arch}`;
+  const binary = mapping[key];
+
+  if (!binary) {
+    console.error(
+      `Unsupported platform: ${platform}-${arch}\n` +
+        `Supported: ${Object.keys(mapping).join(", ")}\n` +
+        `You can use Docker instead: docker run equixankit/diffsurge-cli`
+    );
+    process.exit(1);
+  }
+
+  return binary;
+}
+
+function main() {
+  const binaryName = getPlatformBinary();
+  const isWindows = os.platform() === "win32";
+  const binDir = path.join(__dirname, "bin");
+  const dest = path.join(binDir, isWindows ? "surge.exe" : "surge");
+
+  if (fs.existsSync(dest)) {
+    return;
+  }
+
+  const gzPath = path.join(__dirname, "binaries", `${binaryName}.gz`);
+
+  if (!fs.existsSync(gzPath)) {
+    console.error(`Binary not found: ${gzPath}`);
+    console.error(`Use Docker instead: docker run equixankit/diffsurge-cli`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  console.log(`Installing surge for ${os.platform()}-${os.arch()}...`);
+
+  const compressed = fs.readFileSync(gzPath);
+  const decompressed = zlib.gunzipSync(compressed);
+  fs.writeFileSync(dest, decompressed);
+
+  if (!isWindows) {
+    fs.chmodSync(dest, 0o755);
+  }
+
+  console.log("surge installed successfully!");
+}
+
+main();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "diffsurge",
+  "version": "0.3.0",
+  "description": "Diffsurge CLI — API traffic capture, diff, schema comparison, replay, and CI/CD checks with API key auth",
+  "keywords": [
+    "api",
+    "traffic",
+    "diff",
+    "schema",
+    "replay",
+    "testing",
+    "proxy",
+    "cli"
+  ],
+  "homepage": "https://github.com/ankit12301/tvc#readme",
+  "bugs": {
+    "url": "https://github.com/ankit12301/tvc/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ankit12301/tvc.git"
+  },
+  "license": "MIT",
+  "author": "Ankit Mahopatra",
+  "bin": {
+    "surge": "bin/surge"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}