wyxrouter 0.4.71

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

@@ -0,0 +1,123 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,175 @@
+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": "9router-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

@@ -0,0 +1,93 @@
+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 });
+  }
+}