swayrouter 1.0.0

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

@@ -0,0 +1,129 @@
+import { NextResponse } from "next/server";
+import {
+  deleteProxyPool,
+  countConnectionsByProxyPool,
+  getProxyPoolById,
+  updateProxyPool,
+} from "@/models";
+import { normalizeProxyUrl } from "@/lib/network/proxyUrl.js";
+import { publicProxyPool } from "@/lib/network/relay.js";
+
+function normalizeProxyPoolUpdate(body = {}, existing = {}) {
+  const updates = {};
+  const has = (key) => Object.prototype.hasOwnProperty.call(body, key);
+
+  if (has("name")) {
+    const name = typeof body?.name === "string" ? body.name.trim() : "";
+    if (!name) {
+      return { error: "Name is required" };
+    }
+    updates.name = name;
+  }
+
+  if (has("proxyUrl")) {
+    const proxyUrl = typeof body?.proxyUrl === "string" ? body.proxyUrl.trim() : "";
+    if (!proxyUrl) {
+      return { error: "Proxy URL is required" };
+    }
+    updates.proxyUrl = proxyUrl;
+  }
+
+  if (has("noProxy")) {
+    updates.noProxy = typeof body?.noProxy === "string" ? body.noProxy.trim() : "";
+  }
+
+  if (has("isActive")) {
+    updates.isActive = body?.isActive === true;
+  }
+
+  if (has("strictProxy")) {
+    updates.strictProxy = body?.strictProxy === true;
+  }
+
+  if (has("type")) {
+    const validTypes = ["http", "https", "socks5", "socks5h", "vercel", "cloudflare"];
+    updates.type = validTypes.includes(body?.type) ? body.type : "http";
+  }
+
+  if (has("proxyUrl") || has("type")) {
+    const proxyUrl = updates.proxyUrl ?? existing.proxyUrl;
+    const proxyType = updates.type ?? existing.type ?? "http";
+    try {
+      normalizeProxyUrl(proxyUrl, proxyType);
+    } catch {
+      return { error: "Proxy URL is invalid" };
+    }
+  }
+
+  return { updates };
+}
+
+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: publicProxyPool(proxyPool) });
+  } catch (error) {
+    console.log("Error fetching proxy pool:", error);
+    return NextResponse.json({ error: "Failed to fetch proxy pool" }, { status: 500 });
+  }
+}
+
+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, existing);
+
+    if (normalized.error) {
+      return NextResponse.json({ error: normalized.error }, { status: 400 });
+    }
+
+    const updated = await updateProxyPool(id, normalized.updates);
+    return NextResponse.json({ proxyPool: publicProxyPool(updated) });
+  } catch (error) {
+    console.log("Error updating proxy pool:", error);
+    return NextResponse.json({ error: "Failed to update proxy pool" }, { status: 500 });
+  }
+}
+
+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 usageMap = await countConnectionsByProxyPool();
+    const boundConnectionCount = usageMap.get(id) || 0;
+
+    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/routes/api/proxy-pools/[id]/test/route.js

@@ -0,0 +1,64 @@
+import { NextResponse } from "next/server";
+import { getProxyPoolById, updateProxyPool } from "@/models";
+import { testProxyUrl } from "@/lib/network/proxyTest";
+import { logRouteError } from "@/lib/errors/publicError";
+import { safeProxyError } from "@/lib/network/proxyUrl.js";
+import { isRelayProxyType, isSupportedProxyType, testRelayEndpoint } from "@/lib/network/relay.js";
+
+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 });
+    }
+
+    if (!isSupportedProxyType(proxyPool.type)) {
+      return NextResponse.json({ error: "Proxy pool type is unsupported" }, { status: 400 });
+    }
+
+    const result = isRelayProxyType(proxyPool.type)
+      ? await testRelayEndpoint(proxyPool.proxyUrl, proxyPool.relayToken)
+      : await testProxyUrl({ proxyUrl: proxyPool.proxyUrl, proxyType: proxyPool.type });
+    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}`),
+    });
+
+    const elapsedMs = Number.isFinite(Number(result.elapsedMs)) ? Math.max(0, Math.round(Number(result.elapsedMs))) : 0;
+    const status = Number.isFinite(Number(result.status)) ? Number(result.status) : 0;
+    if (result.ok) {
+      console.info("[PROXY_POOL_TEST]", {
+        poolId: id,
+        poolName: proxyPool.name || id,
+        outcome: "ok",
+        status,
+        elapsedMs,
+      });
+    } else {
+      console.warn("[PROXY_POOL_TEST]", {
+        poolId: id,
+        poolName: proxyPool.name || id,
+        outcome: "error",
+        status,
+        elapsedMs,
+        error: "Proxy test failed",
+      });
+    }
+
+    return NextResponse.json({
+      ok: result.ok,
+      status: result.status,
+      error: result.error || null,
+      elapsedMs: result.elapsedMs || 0,
+      testedAt: now,
+    });
+  } catch (error) {
+    logRouteError("ProxyPoolTest", safeProxyError(error));
+    return NextResponse.json({ error: "Failed to test proxy pool" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,183 @@
+import { NextResponse } from "next/server";
+import { createProxyPool } from "@/models";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+import {
+  createRelayToken,
+  normalizeRelayProjectName,
+  publicProxyPool,
+  testRelayEndpoint,
+} from "@/lib/network/relay.js";
+
+const DEPLOYMENT_ERROR = publicError("deployment");
+
+function relayWorkerCode(relayToken) {
+  return `
+const RELAY_TOKEN = ${JSON.stringify(relayToken)};
+
+export default {
+  async fetch(request, env, ctx) {
+    if (request.headers.get("x-sway-relay-token") !== RELAY_TOKEN) {
+      return new Response(JSON.stringify({ error: "Unauthorized relay request" }), {
+        status: 401,
+        headers: { "content-type": "application/json" },
+      });
+    }
+
+    const target = request.headers.get("x-relay-target");
+    const relayPath = request.headers.get("x-relay-path") || "/";
+
+    if (!target || !relayPath.startsWith("/") || relayPath.startsWith("//")) {
+      return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), {
+        status: 400,
+        headers: { "content-type": "application/json" },
+      });
+    }
+
+    let targetUrl;
+    try {
+      const targetOrigin = new URL(target);
+      if (targetOrigin.protocol !== "http:" && targetOrigin.protocol !== "https:") throw new Error("Unsupported target protocol");
+      targetUrl = new URL(relayPath, targetOrigin.origin).toString();
+    } catch {
+      return new Response(JSON.stringify({ error: "Invalid relay target" }), {
+        status: 400,
+        headers: { "content-type": "application/json" },
+      });
+    }
+
+    const newRequestInit = {
+      method: request.method,
+      headers: new Headers(request.headers),
+    };
+
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      newRequestInit.body = request.body;
+    }
+
+    newRequestInit.headers.delete("x-sway-relay-token");
+    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) {
+      console.error("[CloudflareRelay]", error);
+      return new Response(JSON.stringify({ error: "Relay request failed" }), {
+        status: 502,
+        headers: { "content-type": "application/json" },
+      });
+    }
+  },
+};
+`;
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const accountId = body.accountId?.trim();
+    const apiToken = body.apiToken?.trim();
+    let projectName;
+    try {
+      projectName = normalizeRelayProjectName(body.projectName);
+    } catch {
+      return NextResponse.json({ error: "Project name must use lowercase letters, numbers, and hyphens" }, { status: 400 });
+    }
+
+    if (!accountId || !apiToken) {
+      return NextResponse.json({ error: "Cloudflare Account ID and API Token are required" }, { status: 400 });
+    }
+
+    const relayToken = createRelayToken();
+
+    const workerScriptUrl = `https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/scripts/${projectName}`;
+
+    const formData = new FormData();
+    formData.append("index.js", new Blob([relayWorkerCode(relayToken)], { type: "application/javascript+module" }), "index.js");
+    formData.append("metadata", new Blob([JSON.stringify({
+      main_module: "index.js",
+      compatibility_date: new Date().toISOString().slice(0, 10),
+      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(() => ({}));
+      logRouteError("ProxyPool][CloudflareUpload", err);
+      return NextResponse.json(
+        { error: DEPLOYMENT_ERROR },
+        { status: uploadRes.status }
+      );
+    }
+
+    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(() => ({}));
+      logRouteError("ProxyPool][CloudflareSubdomain", err);
+      return NextResponse.json({ error: DEPLOYMENT_ERROR }, { status: enableSubdomainRes.status });
+    }
+
+    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 }
+      );
+    }
+
+    const relayTest = await testRelayEndpoint(deployUrl, relayToken);
+    if (!relayTest.ok) {
+      throw new Error(`Cloudflare relay health check failed with status ${relayTest.status}`);
+    }
+
+    const proxyPool = await createProxyPool({
+      name: projectName,
+      proxyUrl: deployUrl,
+      type: "cloudflare",
+      noProxy: "",
+      isActive: true,
+      strictProxy: false,
+      relayToken,
+    });
+
+    return NextResponse.json({ proxyPool: publicProxyPool(proxyPool), deployUrl }, { status: 201 });
+  } catch (error) {
+    logRouteError("ProxyPool][CloudflareDeploy", error);
+    return NextResponse.json({ error: DEPLOYMENT_ERROR }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,85 @@
+import { NextResponse } from "next/server";
+import { countConnectionsByProxyPool, createProxyPool, getProxyPools } from "@/models";
+import { normalizeProxyUrl } from "@/lib/network/proxyUrl.js";
+import { publicProxyPool } from "@/lib/network/relay.js";
+
+function toBoolean(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return undefined;
+}
+
+const VALID_PROXY_TYPES = ["http", "https", "socks5", "socks5h", "vercel", "cloudflare"];
+
+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" };
+  }
+
+  try {
+    normalizeProxyUrl(proxyUrl, type);
+  } catch {
+    return { error: "Proxy URL is invalid" };
+  }
+
+  return { name, proxyUrl, noProxy, isActive, strictProxy, type };
+}
+
+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: proxyPools.map(publicProxyPool) });
+    }
+
+    const usageMap = await countConnectionsByProxyPool();
+
+    const enrichedProxyPools = proxyPools.map((pool) => ({
+      ...publicProxyPool(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 });
+  }
+}
+
+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 });
+  }
+}

package/src/routes/api/proxy-pools/vercel-deploy/route.js

@@ -0,0 +1,181 @@
+import { NextResponse } from "next/server";
+import { createProxyPool } from "@/models";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+import {
+  createRelayToken,
+  normalizeRelayProjectName,
+  publicProxyPool,
+  testRelayEndpoint,
+} from "@/lib/network/relay.js";
+
+const DEPLOYMENT_ERROR = publicError("deployment");
+
+const VERCEL_API = "https://api.vercel.com";
+
+function relayFunctionCode(relayToken) {
+  return `
+export const config = { runtime: "edge" };
+
+const RELAY_TOKEN = ${JSON.stringify(relayToken)};
+
+export default async function handler(req) {
+  if (req.headers.get("x-sway-relay-token") !== RELAY_TOKEN) {
+    return new Response(JSON.stringify({ error: "Unauthorized relay request" }), {
+      status: 401,
+      headers: { "content-type": "application/json" },
+    });
+  }
+
+  const target = req.headers.get("x-relay-target");
+  const relayPath = req.headers.get("x-relay-path") || "/";
+  if (!target || !relayPath.startsWith("/") || relayPath.startsWith("//")) {
+    return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), {
+      status: 400,
+      headers: { "content-type": "application/json" },
+    });
+  }
+
+  let targetUrl;
+  try {
+    const targetOrigin = new URL(target);
+    if (targetOrigin.protocol !== "http:" && targetOrigin.protocol !== "https:") throw new Error("Unsupported target protocol");
+    targetUrl = new URL(relayPath, targetOrigin.origin).toString();
+  } catch {
+    return new Response(JSON.stringify({ error: "Invalid relay target" }), {
+      status: 400,
+      headers: { "content-type": "application/json" },
+    });
+  }
+
+  const headers = new Headers(req.headers);
+  headers.delete("x-sway-relay-token");
+  headers.delete("x-relay-target");
+  headers.delete("x-relay-path");
+  headers.delete("host");
+
+  const response = await fetch(targetUrl, {
+    method: req.method,
+    headers,
+    body: req.method !== "GET" && req.method !== "HEAD" ? req.body : undefined,
+  });
+
+  return new Response(response.body, {
+    status: response.status,
+    headers: response.headers,
+  });
+}
+`;
+}
+
+async function pollDeployment(deploymentId, token, maxMs = 120000) {
+  const start = Date.now();
+  while (Date.now() - start < maxMs) {
+    const res = await fetch(`${VERCEL_API}/v13/deployments/${deploymentId}`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    const data = await res.json();
+    if (data.readyState === "READY") return data;
+    if (data.readyState === "ERROR" || data.readyState === "CANCELED") {
+      throw new Error(`Deployment failed: ${data.readyState}`);
+    }
+    await new Promise((r) => setTimeout(r, 3000));
+  }
+  throw new Error("Deployment timed out");
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const vercelToken = body.vercelToken?.trim();
+    let projectName;
+    try {
+      projectName = normalizeRelayProjectName(body.projectName);
+    } catch {
+      return NextResponse.json({ error: "Project name must use lowercase letters, numbers, and hyphens" }, { status: 400 });
+    }
+
+    if (!vercelToken) {
+      return NextResponse.json({ error: "Vercel API token is required" }, { status: 400 });
+    }
+
+    const relayToken = createRelayToken();
+
+    const deployRes = await fetch(`${VERCEL_API}/v13/deployments`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${vercelToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        name: projectName,
+        files: [
+          {
+            file: "api/relay.js",
+            data: relayFunctionCode(relayToken),
+          },
+          {
+            file: "package.json",
+            data: JSON.stringify({ name: projectName, version: "1.0.0" }),
+          },
+          {
+            file: "vercel.json",
+            data: JSON.stringify({
+              rewrites: [{ source: "/(.*)", destination: "/api/relay" }],
+            }),
+          },
+        ],
+        projectSettings: {
+          framework: null,
+        },
+        target: "production",
+      }),
+    });
+
+    if (!deployRes.ok) {
+      const err = await deployRes.json().catch(() => ({}));
+      logRouteError("ProxyPool][VercelCreate", err);
+      return NextResponse.json(
+        { error: DEPLOYMENT_ERROR },
+        { status: deployRes.status }
+      );
+    }
+
+    const deployment = await deployRes.json();
+    const deploymentId = deployment.id || deployment.uid;
+
+    const projectId = deployment.projectId || projectName;
+    await fetch(`${VERCEL_API}/v9/projects/${projectId}`, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${vercelToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ ssoProtection: null }),
+    });
+
+    const ready = await pollDeployment(deploymentId, vercelToken);
+    const rawDeployUrl = ready.url || deployment.url;
+    if (!rawDeployUrl) throw new Error("Vercel deployment did not return a URL");
+    const deployUrl = rawDeployUrl.startsWith("http") ? rawDeployUrl : `https://${rawDeployUrl}`;
+
+    const relayTest = await testRelayEndpoint(deployUrl, relayToken);
+    if (!relayTest.ok) {
+      throw new Error(`Vercel relay health check failed with status ${relayTest.status}`);
+    }
+
+    const proxyPool = await createProxyPool({
+      name: projectName,
+      proxyUrl: deployUrl,
+      type: "vercel",
+      noProxy: "",
+      isActive: true,
+      strictProxy: false,
+      relayToken,
+    });
+
+    return NextResponse.json({ proxyPool: publicProxyPool(proxyPool), deployUrl }, { status: 201 });
+  } catch (error) {
+    logRouteError("ProxyPool][VercelDeploy", error);
+    return NextResponse.json({ error: DEPLOYMENT_ERROR }, { status: 500 });
+  }
+}

package/src/routes/api/settings/currency/route.js

@@ -0,0 +1,29 @@
+import { NextResponse } from "next/server";
+import { getSettings } from "@/lib/localDb";
+import { getUsdToIdrRate } from "@/services/currencyRate.js";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
+export async function GET() {
+  try {
+    const [settings, rate] = await Promise.all([getSettings(), getUsdToIdrRate()]);
+    return NextResponse.json({
+      currency: settings.currency === "IDR" ? "IDR" : "USD",
+      usdToIdr: rate.rate,
+      rateUpdatedAt: rate.updatedAt,
+      rateSource: rate.source,
+    }, {
+      headers: { "Cache-Control": "no-store" },
+    });
+  } catch {
+    return NextResponse.json({
+      currency: "USD",
+      usdToIdr: 16_500,
+      rateUpdatedAt: null,
+      rateSource: "fallback",
+    }, {
+      headers: { "Cache-Control": "no-store" },
+    });
+  }
+}

package/src/routes/api/settings/database/path/route.js

@@ -0,0 +1,8 @@
+import { NextResponse } from "next/server";
+import { DATA_FILE } from "@/lib/db/paths.js";
+
+const HEADERS = { "Cache-Control": "no-store" };
+
+export function GET() {
+  return NextResponse.json({ dbPath: DATA_FILE }, { headers: HEADERS });
+}