zevairouter 1.0.153 → 1.0.155

package/src/app/api/proxy-pools/[id]/route.js

@@ -1,123 +0,0 @@
-import { NextResponse } from "next/server";
-import {
-  deleteProxyPool,
-  getProviderConnections,
-  getProxyPoolById,
-  updateProxyPool,
-} from "@/models";
-
-function normalizeProxyPoolUpdate(body = {}) {
-  const updates = {};
-
-  if (Object.prototype.hasOwnProperty.call(body, "name")) {
-    const name = typeof body?.name === "string" ? body.name.trim() : "";
-    if (!name) {
-      return { error: "Name is required" };
-    }
-    updates.name = name;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(body, "proxyUrl")) {
-    const proxyUrl = typeof body?.proxyUrl === "string" ? body.proxyUrl.trim() : "";
-    if (!proxyUrl) {
-      return { error: "Proxy URL is required" };
-    }
-    updates.proxyUrl = proxyUrl;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(body, "noProxy")) {
-    updates.noProxy = typeof body?.noProxy === "string" ? body.noProxy.trim() : "";
-  }
-
-  if (Object.prototype.hasOwnProperty.call(body, "isActive")) {
-    updates.isActive = body?.isActive === true;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(body, "strictProxy")) {
-    updates.strictProxy = body?.strictProxy === true;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(body, "type")) {
-    const validTypes = ["http", "vercel", "cloudflare"];
-    updates.type = validTypes.includes(body?.type) ? body.type : "http";
-  }
-
-  return { updates };
-}
-
-function countBoundConnections(connections = [], proxyPoolId) {
-  return connections.filter((connection) => connection?.providerSpecificData?.proxyPoolId === proxyPoolId).length;
-}
-
-// GET /api/proxy-pools/[id] - Get proxy pool
-export async function GET(request, { params }) {
-  try {
-    const { id } = await params;
-    const proxyPool = await getProxyPoolById(id);
-
-    if (!proxyPool) {
-      return NextResponse.json({ error: "Proxy pool not found" }, { status: 404 });
-    }
-
-    return NextResponse.json({ proxyPool });
-  } catch (error) {
-    console.log("Error fetching proxy pool:", error);
-    return NextResponse.json({ error: "Failed to fetch proxy pool" }, { status: 500 });
-  }
-}
-
-// PUT /api/proxy-pools/[id] - Update proxy pool
-export async function PUT(request, { params }) {
-  try {
-    const { id } = await params;
-    const existing = await getProxyPoolById(id);
-
-    if (!existing) {
-      return NextResponse.json({ error: "Proxy pool not found" }, { status: 404 });
-    }
-
-    const body = await request.json();
-    const normalized = normalizeProxyPoolUpdate(body);
-
-    if (normalized.error) {
-      return NextResponse.json({ error: normalized.error }, { status: 400 });
-    }
-
-    const updated = await updateProxyPool(id, normalized.updates);
-    return NextResponse.json({ proxyPool: updated });
-  } catch (error) {
-    console.log("Error updating proxy pool:", error);
-    return NextResponse.json({ error: "Failed to update proxy pool" }, { status: 500 });
-  }
-}
-
-// DELETE /api/proxy-pools/[id] - Delete proxy pool
-export async function DELETE(request, { params }) {
-  try {
-    const { id } = await params;
-    const existing = await getProxyPoolById(id);
-
-    if (!existing) {
-      return NextResponse.json({ error: "Proxy pool not found" }, { status: 404 });
-    }
-
-    const connections = await getProviderConnections();
-    const boundConnectionCount = countBoundConnections(connections, id);
-
-    if (boundConnectionCount > 0) {
-      return NextResponse.json(
-        {
-          error: "Proxy pool is currently in use",
-          boundConnectionCount,
-        },
-        { status: 409 }
-      );
-    }
-
-    await deleteProxyPool(id);
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.log("Error deleting proxy pool:", error);
-    return NextResponse.json({ error: "Failed to delete proxy pool" }, { status: 500 });
-  }
-}

package/src/app/api/proxy-pools/[id]/test/route.js

@@ -1,70 +0,0 @@
-import { NextResponse } from "next/server";
-import { getProxyPoolById, updateProxyPool } from "@/models";
-import { testProxyUrl } from "@/lib/network/proxyTest";
-import { fetch as undiciFetch } from "undici";
-
-async function testVercelRelay(relayUrl, timeoutMs = 10000) {
-  const controller = new AbortController();
-  const startedAt = Date.now();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const res = await undiciFetch(relayUrl, {
-      method: "GET",
-      headers: {
-        "x-relay-target": "https://httpbin.org",
-        "x-relay-path": "/get",
-      },
-      signal: controller.signal,
-    });
-    return {
-      ok: res.ok,
-      status: res.status,
-      statusText: res.statusText,
-      elapsedMs: Date.now() - startedAt,
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      status: 500,
-      error: err?.name === "AbortError" ? "Relay test timed out" : (err?.message || String(err)),
-    };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// POST /api/proxy-pools/[id]/test - Test proxy pool entry
-export async function POST(request, { params }) {
-  try {
-    const { id } = await params;
-    const proxyPool = await getProxyPoolById(id);
-
-    if (!proxyPool) {
-      return NextResponse.json({ error: "Proxy pool not found" }, { status: 404 });
-    }
-
-    const result = proxyPool.type === "vercel" || proxyPool.type === "cloudflare" || proxyPool.type === "deno"
-      ? await testVercelRelay(proxyPool.proxyUrl)
-      : await testProxyUrl({ proxyUrl: proxyPool.proxyUrl });
-    const now = new Date().toISOString();
-
-    await updateProxyPool(id, {
-      testStatus: result.ok ? "active" : "error",
-      lastTestedAt: now,
-      lastError: result.ok ? null : (result.error || `Proxy test failed with status ${result.status}`),
-      isActive: result.ok,
-    });
-
-    return NextResponse.json({
-      ok: result.ok,
-      status: result.status,
-      statusText: result.statusText || null,
-      error: result.error || null,
-      elapsedMs: result.elapsedMs || 0,
-      testedAt: now,
-    });
-  } catch (error) {
-    console.log("Error testing proxy pool:", error);
-    return NextResponse.json({ error: "Failed to test proxy pool" }, { status: 500 });
-  }
-}

package/src/app/api/proxy-pools/cloudflare-deploy/route.js

@@ -1,145 +0,0 @@
-import { NextResponse } from "next/server";
-import { createProxyPool } from "@/models";
-
-// Relay worker source code deployed to Cloudflare
-const RELAY_WORKER_CODE = `
-export default {
-  async fetch(request, env, ctx) {
-    const target = request.headers.get("x-relay-target");
-    const relayPath = request.headers.get("x-relay-path") || "/";
-    
-    if (!target) {
-      return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), {
-        status: 400,
-        headers: { "content-type": "application/json" },
-      });
-    }
-
-    const targetUrl = target.replace(/\\/$/, "") + relayPath;
-    const newRequestInit = {
-      method: request.method,
-      headers: new Headers(request.headers),
-    };
-
-    if (request.method !== "GET" && request.method !== "HEAD") {
-      newRequestInit.body = request.body;
-      newRequestInit.duplex = "half";
-    }
-
-    newRequestInit.headers.delete("x-relay-target");
-    newRequestInit.headers.delete("x-relay-path");
-    newRequestInit.headers.delete("host");
-
-    try {
-      const response = await fetch(targetUrl, newRequestInit);
-      return new Response(response.body, {
-        status: response.status,
-        headers: response.headers,
-      });
-    } catch (error) {
-      return new Response(JSON.stringify({ error: error.message }), {
-        status: 502,
-        headers: { "content-type": "application/json" },
-      });
-    }
-  },
-};
-`;
-
-// POST /api/proxy-pools/cloudflare-deploy
-export async function POST(request) {
-  try {
-    const body = await request.json();
-    const accountId = body.accountId?.trim();
-    const apiToken = body.apiToken?.trim();
-    const projectName = body.projectName?.trim() || `relay-${Date.now().toString(36)}`;
-
-    if (!accountId || !apiToken) {
-      return NextResponse.json({ error: "Cloudflare Account ID and API Token are required" }, { status: 400 });
-    }
-
-    // 1. Upload Worker Script
-    const workerScriptUrl = `https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/scripts/${projectName}`;
-    
-    // Cloudflare requires multipart/form-data for worker script upload
-    const formData = new FormData();
-    formData.append("index.js", new Blob([RELAY_WORKER_CODE], { type: "application/javascript+module" }), "index.js");
-    formData.append("metadata", new Blob([JSON.stringify({
-      main_module: "index.js",
-      compatibility_date: "2024-03-20",
-      observability: { enabled: true }
-    })], { type: "application/json" }), "metadata.json");
-
-    const uploadRes = await fetch(workerScriptUrl, {
-      method: "PUT",
-      headers: {
-        Authorization: `Bearer ${apiToken}`,
-      },
-      body: formData,
-    });
-
-    if (!uploadRes.ok) {
-      const err = await uploadRes.json().catch(() => ({}));
-      console.error("Cloudflare upload error:", err);
-      return NextResponse.json(
-        { error: err.errors?.[0]?.message || "Failed to upload Worker to Cloudflare" },
-        { status: uploadRes.status }
-      );
-    }
-
-    // 2. Enable workers.dev subdomain for the script
-    const enableSubdomainRes = await fetch(`${workerScriptUrl}/subdomain`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ enabled: true }),
-    });
-
-    if (!enableSubdomainRes.ok) {
-      const err = await enableSubdomainRes.json().catch(() => ({}));
-      console.error("Cloudflare subdomain enable error:", err);
-      // We don't fail completely here, just continue
-    }
-
-    // 3. Get the workers.dev subdomain for the account to construct the final URL
-    let deployUrl = "";
-    const subdomainRes = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/subdomain`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiToken}`,
-        "Content-Type": "application/json",
-      },
-    });
-
-    if (subdomainRes.ok) {
-      const subdomainData = await subdomainRes.json();
-      if (subdomainData.result && subdomainData.result.subdomain) {
-        deployUrl = `https://${projectName}.${subdomainData.result.subdomain}.workers.dev`;
-      }
-    }
-
-    if (!deployUrl) {
-       return NextResponse.json(
-        { error: "Worker deployed but failed to retrieve workers.dev subdomain. Make sure you have setup a workers.dev subdomain in Cloudflare Dashboard." },
-        { status: 400 }
-      );
-    }
-
-    // Create proxy pool entry with type cloudflare
-    const proxyPool = await createProxyPool({
-      name: projectName,
-      proxyUrl: deployUrl,
-      type: "cloudflare",
-      noProxy: "",
-      isActive: true,
-      strictProxy: false,
-    });
-
-    return NextResponse.json({ proxyPool, deployUrl }, { status: 201 });
-  } catch (error) {
-    console.log("Error deploying Cloudflare relay:", error);
-    return NextResponse.json({ error: error.message || "Deploy failed" }, { status: 500 });
-  }
-}

package/src/app/api/proxy-pools/deno-deploy/route.js

@@ -1,175 +0,0 @@
-import { NextResponse } from "next/server";
-import { createProxyPool } from "@/models";
-
-const DENO_V2_API = "https://api.deno.com/v2";
-
-const DENO_RELAY_CODE = `Deno.serve(async (request) => {
-  const target = request.headers.get("x-relay-target");
-  const relayPath = request.headers.get("x-relay-path") || "/";
-
-  if (!target) {
-    return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), {
-      status: 400,
-      headers: { "content-type": "application/json" },
-    });
-  }
-
-  const targetUrl = target.replace(/\\/$/, "") + relayPath;
-  const newHeaders = new Headers(request.headers);
-  newHeaders.delete("x-relay-target");
-  newHeaders.delete("x-relay-path");
-  newHeaders.delete("host");
-
-  const init = {
-    method: request.method,
-    headers: newHeaders,
-  };
-
-  if (request.method !== "GET" && request.method !== "HEAD") {
-    init.body = request.body;
-    init.duplex = "half";
-  }
-
-  try {
-    const response = await fetch(targetUrl, init);
-    return new Response(response.body, {
-      status: response.status,
-      headers: response.headers,
-    });
-  } catch (error) {
-    return new Response(JSON.stringify({ error: error.message }), {
-      status: 502,
-      headers: { "content-type": "application/json" },
-    });
-  }
-});`;
-
-export async function POST(request) {
-  try {
-    const body = await request.json();
-    const denoToken = body.denoToken?.trim();
-    const orgDomain = body.orgDomain?.trim();
-    const projectName = body.projectName?.trim() || `relay-${Date.now().toString(36)}`;
-
-    if (!orgDomain) {
-      return NextResponse.json({ error: "Organization domain is required" }, { status: 400 });
-    }
-
-    if (!denoToken) {
-      return NextResponse.json({ error: "Deno Deploy API token is required" }, { status: 400 });
-    }
-
-    const headers = {
-      Authorization: `Bearer ${denoToken}`,
-      "Content-Type": "application/json",
-    };
-
-    const createAppRes = await fetch(`${DENO_V2_API}/apps`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        slug: projectName,
-        labels: { "custom.kind": "zevai-relay" },
-        config: {
-          install: "deno install",
-          runtime: {
-            type: "dynamic",
-            entrypoint: "main.ts",
-          },
-        },
-      }),
-    });
-
-    if (!createAppRes.ok) {
-      const text = await createAppRes.text().catch(() => "");
-      if (createAppRes.status === 409) {
-        return NextResponse.json(
-          { error: `App "${projectName}" already exists. Choose a different name.` },
-          { status: 409 }
-        );
-      }
-      return NextResponse.json(
-        { error: `Failed to create app (${createAppRes.status}): ${text}` },
-        { status: createAppRes.status }
-      );
-    }
-
-    const app = await createAppRes.json();
-
-    const deployRes = await fetch(`${DENO_V2_API}/apps/${app.id}/deploy`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        assets: {
-          "main.ts": {
-            kind: "file",
-            content: DENO_RELAY_CODE,
-            encoding: "utf-8",
-          },
-        },
-      }),
-    });
-
-    if (!deployRes.ok) {
-      const text = await deployRes.text().catch(() => "");
-      console.error("Deno Deploy error:", deployRes.status, text);
-      await fetch(`${DENO_V2_API}/apps/${app.id}`, {
-        method: "DELETE",
-        headers: { Authorization: `Bearer ${denoToken}` },
-      }).catch(() => {});
-      return NextResponse.json(
-        { error: `Deploy failed (${deployRes.status}): ${text}` },
-        { status: deployRes.status }
-      );
-    }
-
-    const revision = await deployRes.json();
-    const revisionId = revision.id;
-
-    let status = revision.status;
-    let attempts = 0;
-    const maxAttempts = 30; // 30 * 2s = 60s max
-    while (status === "queued" || status === "building") {
-      if (attempts >= maxAttempts) {
-        throw new Error("Deploy timed out after 60 seconds");
-      }
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-      const statusRes = await fetch(`${DENO_V2_API}/revisions/${revisionId}`, {
-        headers: { Authorization: `Bearer ${denoToken}` },
-      });
-      if (!statusRes.ok) break;
-      const statusData = await statusRes.json();
-      status = statusData.status;
-      attempts++;
-    }
-
-    if (status !== "succeeded") {
-      await fetch(`${DENO_V2_API}/apps/${app.id}`, {
-        method: "DELETE",
-        headers: { Authorization: `Bearer ${denoToken}` },
-      }).catch(() => {});
-      return NextResponse.json(
-        { error: `Deploy failed with status: ${status}` },
-        { status: 500 }
-      );
-    }
-
-    const orgSlug = orgDomain.split(".")[0];
-    const deployUrl = `https://${projectName}.${orgSlug}.deno.net`;
-    console.log("Deno deployUrl:", deployUrl);
-
-    const proxyPool = await createProxyPool({
-      name: projectName,
-      proxyUrl: deployUrl,
-      type: "deno",
-      noProxy: "",
-      isActive: true,
-      strictProxy: false,
-    });
-
-    return NextResponse.json({ proxyPool, deployUrl }, { status: 201 });
-  } catch (error) {
-    console.log("Error deploying Deno Deploy relay:", error);
-    return NextResponse.json({ error: error.message || "Deploy failed" }, { status: 500 });
-  }
-}

package/src/app/api/proxy-pools/route.js

@@ -1,93 +0,0 @@
-import { NextResponse } from "next/server";
-import { createProxyPool, getProviderConnections, getProxyPools } from "@/models";
-
-function toBoolean(value) {
-  if (value === "true") return true;
-  if (value === "false") return false;
-  return undefined;
-}
-
-const VALID_PROXY_TYPES = ["http", "vercel", "cloudflare", "deno"];
-
-function normalizeProxyPoolInput(body = {}) {
-  const name = typeof body?.name === "string" ? body.name.trim() : "";
-  const proxyUrl = typeof body?.proxyUrl === "string" ? body.proxyUrl.trim() : "";
-  const noProxy = typeof body?.noProxy === "string" ? body.noProxy.trim() : "";
-  const isActive = body?.isActive === undefined ? true : body.isActive === true;
-  const strictProxy = body?.strictProxy === true;
-  const type = VALID_PROXY_TYPES.includes(body?.type) ? body.type : "http";
-
-  if (!name) {
-    return { error: "Name is required" };
-  }
-
-  if (!proxyUrl) {
-    return { error: "Proxy URL is required" };
-  }
-
-  return { name, proxyUrl, noProxy, isActive, strictProxy, type };
-}
-
-function buildUsageMap(connections = []) {
-  const usageMap = new Map();
-
-  for (const connection of connections) {
-    const proxyPoolId = connection?.providerSpecificData?.proxyPoolId;
-    if (!proxyPoolId) continue;
-
-    usageMap.set(proxyPoolId, (usageMap.get(proxyPoolId) || 0) + 1);
-  }
-
-  return usageMap;
-}
-
-// GET /api/proxy-pools - List proxy pools
-export async function GET(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const isActive = toBoolean(searchParams.get("isActive"));
-    const includeUsage = searchParams.get("includeUsage") === "true";
-
-    const filter = {};
-    if (isActive !== undefined) {
-      filter.isActive = isActive;
-    }
-
-    const proxyPools = await getProxyPools(filter);
-
-    if (!includeUsage) {
-      return NextResponse.json({ proxyPools });
-    }
-
-    const connections = await getProviderConnections();
-    const usageMap = buildUsageMap(connections);
-
-    const enrichedProxyPools = proxyPools.map((pool) => ({
-      ...pool,
-      boundConnectionCount: usageMap.get(pool.id) || 0,
-    }));
-
-    return NextResponse.json({ proxyPools: enrichedProxyPools });
-  } catch (error) {
-    console.log("Error fetching proxy pools:", error);
-    return NextResponse.json({ error: "Failed to fetch proxy pools" }, { status: 500 });
-  }
-}
-
-// POST /api/proxy-pools - Create proxy pool
-export async function POST(request) {
-  try {
-    const body = await request.json();
-    const normalized = normalizeProxyPoolInput(body);
-
-    if (normalized.error) {
-      return NextResponse.json({ error: normalized.error }, { status: 400 });
-    }
-
-    const proxyPool = await createProxyPool(normalized);
-    return NextResponse.json({ proxyPool }, { status: 201 });
-  } catch (error) {
-    console.log("Error creating proxy pool:", error);
-    return NextResponse.json({ error: "Failed to create proxy pool" }, { status: 500 });
-  }
-}