@solongate/proxy 0.3.1 → 0.4.1

package/dist/pull-push.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+// src/pull-push.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+async function fetchCloudPolicy(apiKey, apiUrl, policyId) {
+  let resolvedId = policyId;
+  if (!resolvedId) {
+    const listRes = await fetch(`${apiUrl}/api/v1/policies`, {
+      headers: { "Authorization": `Bearer ${apiKey}` }
+    });
+    if (!listRes.ok) {
+      const body = await listRes.text().catch(() => "");
+      throw new Error(`Failed to list policies from cloud (${listRes.status}): ${body}`);
+    }
+    const listData = await listRes.json();
+    const policies = listData.policies ?? [];
+    if (policies.length === 0) {
+      throw new Error("No policies found in cloud. Create one in the dashboard first.");
+    }
+    resolvedId = policies[0].id;
+  }
+  const url = `${apiUrl}/api/v1/policies/${resolvedId}`;
+  const res = await fetch(url, {
+    headers: { "Authorization": `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Failed to fetch policy from cloud (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  return {
+    id: String(data.id ?? "cloud"),
+    name: String(data.name ?? "Cloud Policy"),
+    version: Number(data._version ?? 1),
+    rules: data.rules ?? [],
+    createdAt: String(data._created_at ?? ""),
+    updatedAt: ""
+  };
+}
+
+// src/pull-push.ts
+var log = (...args) => process.stderr.write(`[SolonGate] ${args.map(String).join(" ")}
+`);
+function loadEnv() {
+  if (process.env.SOLONGATE_API_KEY) return;
+  const envPath = resolve2(".env");
+  if (!existsSync2(envPath)) return;
+  try {
+    const content = readFileSync2(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      const key = trimmed.slice(0, eq).trim();
+      const val = trimmed.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+      if (key === "SOLONGATE_API_KEY") {
+        process.env.SOLONGATE_API_KEY = val;
+        return;
+      }
+    }
+  } catch {
+  }
+}
+function parseCliArgs() {
+  loadEnv();
+  const args = process.argv.slice(2);
+  const command = args[0];
+  let apiKey = process.env.SOLONGATE_API_KEY || "";
+  let file = "policy.json";
+  let policyId;
+  for (let i = 1; i < args.length; i++) {
+    switch (args[i]) {
+      case "--api-key":
+        apiKey = args[++i];
+        break;
+      case "--policy":
+      case "--output":
+      case "--file":
+      case "-f":
+      case "-o":
+        file = args[++i];
+        break;
+      case "--policy-id":
+      case "--id":
+        policyId = args[++i];
+        break;
+    }
+  }
+  if (!apiKey) {
+    log("ERROR: API key not found.");
+    log("");
+    log("Set it in .env file:");
+    log("  SOLONGATE_API_KEY=sg_live_...");
+    log("");
+    log("Or pass via environment:");
+    log(`  SOLONGATE_API_KEY=sg_live_... solongate-proxy ${command}`);
+    process.exit(1);
+  }
+  if (!apiKey.startsWith("sg_live_")) {
+    log("ERROR: Pull/push requires a live API key (sg_live_...).");
+    process.exit(1);
+  }
+  return { command, apiKey, file: resolve2(file), policyId };
+}
+async function pull(apiKey, file, policyId) {
+  const apiUrl = "https://api.solongate.com";
+  log(`Pulling policy from dashboard...`);
+  const policy = await fetchCloudPolicy(apiKey, apiUrl, policyId);
+  const json = JSON.stringify(policy, null, 2) + "\n";
+  writeFileSync(file, json, "utf-8");
+  log(`Saved: ${file}`);
+  log(`  Name: ${policy.name}`);
+  log(`  Version: ${policy.version}`);
+  log(`  Rules: ${policy.rules.length}`);
+  log("");
+  log("Done. Policy pulled from dashboard to local file.");
+}
+async function push(apiKey, file) {
+  const apiUrl = "https://api.solongate.com";
+  if (!existsSync2(file)) {
+    log(`ERROR: File not found: ${file}`);
+    process.exit(1);
+  }
+  const content = readFileSync2(file, "utf-8");
+  let policy;
+  try {
+    policy = JSON.parse(content);
+  } catch {
+    log(`ERROR: Invalid JSON in ${file}`);
+    process.exit(1);
+  }
+  log(`Pushing policy to dashboard...`);
+  log(`  File: ${file}`);
+  log(`  Name: ${policy.name || "Unnamed"}`);
+  log(`  Rules: ${(policy.rules || []).length}`);
+  const res = await fetch(`${apiUrl}/api/v1/policies`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      id: policy.id || "default",
+      name: policy.name || "Local Policy",
+      description: policy.description || "Pushed from local file",
+      version: policy.version || 1,
+      rules: policy.rules || []
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    log(`ERROR: Push failed (${res.status}): ${body}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  log(`  Cloud version: ${data._version ?? "created"}`);
+  log("");
+  log("Done. Policy pushed from local file to dashboard.");
+}
+async function main() {
+  const { command, apiKey, file, policyId } = parseCliArgs();
+  try {
+    if (command === "pull") {
+      await pull(apiKey, file, policyId);
+    } else if (command === "push") {
+      await push(apiKey, file);
+    } else {
+      log(`Unknown command: ${command}`);
+      log("Usage: solongate-proxy pull|push [--file policy.json]");
+      process.exit(1);
+    }
+  } catch (err) {
+    log(`ERROR: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solongate/proxy",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "MCP security proxy — protect any MCP server with customizable policies, path/command constraints, rate limiting, and audit logging. Zero code changes required.",
   "type": "module",
   "bin": {