swayrouter 1.0.0

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

@@ -0,0 +1,89 @@
+import { NextResponse } from "next/server";
+import { exportDb, importDb } from "@/lib/localDb";
+import { verifyDashboardPassword } from "@/lib/auth/dashboardSession";
+import { hasValidCliToken } from "@/dashboardGuard";
+
+const PASSWORD_HEADER = "x-swayrouter-password";
+const HEADERS = { "Cache-Control": "no-store" };
+
+export async function GET(request) {
+  try {
+    if (!(await hasValidCliToken(request)) && !(await verifyDashboardPassword(request.headers.get(PASSWORD_HEADER)))) {
+      return NextResponse.json(
+        { error: "Invalid password", code: "invalid_reauthentication" },
+        { status: 401, headers: HEADERS },
+      );
+    }
+    const scope = new URL(request.url).searchParams.get("scope") || "configuration";
+    if (scope !== "configuration" && scope !== "full") {
+      return NextResponse.json(
+        { error: "Invalid backup scope" },
+        { status: 400, headers: HEADERS },
+      );
+    }
+    const payload = await exportDb({ scope });
+    return NextResponse.json(payload, { headers: HEADERS });
+  } catch (error) {
+    console.log("Error exporting database:", error);
+    return NextResponse.json(
+      { error: "Failed to export database" },
+      { status: 500, headers: HEADERS },
+    );
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { password, ...payload } = await request.json();
+    if (!(await hasValidCliToken(request)) && !(await verifyDashboardPassword(password))) {
+      return NextResponse.json(
+        { error: "Invalid password", code: "invalid_reauthentication" },
+        { status: 401, headers: HEADERS },
+      );
+    }
+    await importDb(payload);
+
+    return NextResponse.json(
+      {
+        success: true,
+        message: "Backup restored successfully",
+        result: {
+          connectionsImported: Array.isArray(payload.providerConnections)
+            ? payload.providerConnections.length
+            : 0,
+          nodesImported: Array.isArray(payload.providerNodes)
+            ? payload.providerNodes.length
+            : 0,
+          poolsImported: Array.isArray(payload.proxyPools)
+            ? payload.proxyPools.length
+            : 0,
+          combosImported: Array.isArray(payload.combos)
+            ? payload.combos.length
+            : 0,
+          settingsImported: Boolean(payload.settings),
+          apiKeysImported:
+            payload.apiKeysRedacted === true
+              ? 0
+              : Array.isArray(payload.apiKeys)
+                ? payload.apiKeys.length
+                : 0,
+          backupScope: payload.backupScope === "full" ? "full" : "configuration",
+        },
+      },
+      { headers: HEADERS },
+    );
+  } catch (error) {
+    console.log("Error importing database:", error);
+    console.error("[Settings][DatabaseImport]", error);
+    const message = typeof error?.message === "string" && (
+      error.message.startsWith("Invalid database payload:")
+      || error.message === "API key material is required for database import"
+    )
+      ? error.message
+      : "Failed to import database";
+    return NextResponse.json(
+      { error: message },
+      { status: 400, headers: HEADERS },
+    );
+  }
+}

package/src/routes/api/settings/migrate-9router/route.js

@@ -0,0 +1,81 @@
+import { NextResponse } from "next/server";
+import { hasValidCliToken, isLocalRequest } from "@/dashboardGuard";
+import { verifyDashboardPassword } from "@/lib/auth/dashboardSession";
+import {
+  applyNineRouterMigration,
+  getNineRouterDetection,
+  previewNineRouterMigration,
+  readDetectedNineRouterDatabase,
+  validateNineRouterPayload,
+} from "@/lib/db/nineRouterMigration.js";
+
+const HEADERS = { "Cache-Control": "no-store" };
+
+async function resolveSource(request, body) {
+  if (body.source === "local") {
+    if (!isLocalRequest(request)) {
+      const error = new Error("Local 9Router migration is only available from this machine");
+      error.code = "LOCAL_SOURCE_FORBIDDEN";
+      throw error;
+    }
+    return await readDetectedNineRouterDatabase();
+  }
+  if (body.source === "json") return validateNineRouterPayload(body.payload);
+  const error = new Error("Choose a local installation or a 9Router JSON backup");
+  error.code = "INVALID_MIGRATION_SOURCE";
+  throw error;
+}
+
+function publicMigrationError(error) {
+  const allowedCodes = new Set([
+    "INVALID_9ROUTER_SOURCE",
+    "LOCAL_SOURCE_UNAVAILABLE",
+    "LOCAL_SOURCE_FORBIDDEN",
+    "INVALID_MIGRATION_SOURCE",
+    "NOTHING_TO_MIGRATE",
+  ]);
+  if (allowedCodes.has(error?.code) && typeof error?.message === "string") return error.message;
+  return "9Router migration failed";
+}
+
+export async function GET(request) {
+  if (!isLocalRequest(request)) {
+    return NextResponse.json({ available: false, localOnly: true }, { headers: HEADERS });
+  }
+  try {
+    return NextResponse.json(await getNineRouterDetection(), { headers: HEADERS });
+  } catch {
+    return NextResponse.json({ available: false }, { headers: HEADERS });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+      return NextResponse.json({ error: "Invalid migration request" }, { status: 400, headers: HEADERS });
+    }
+    const payload = await resolveSource(request, body);
+    if (body.action === "preview") {
+      const preview = await previewNineRouterMigration(payload, body.options);
+      return NextResponse.json({ success: true, preview }, { headers: HEADERS });
+    }
+    if (body.action !== "migrate") {
+      return NextResponse.json({ error: "Invalid migration action" }, { status: 400, headers: HEADERS });
+    }
+    if (!(await hasValidCliToken(request)) && !(await verifyDashboardPassword(body.password))) {
+      return NextResponse.json(
+        { error: "Invalid password", code: "invalid_reauthentication" },
+        { status: 401, headers: HEADERS },
+      );
+    }
+    return NextResponse.json(await applyNineRouterMigration(payload, body.options), { headers: HEADERS });
+  } catch (error) {
+    const message = publicMigrationError(error);
+    console.error(`[Settings][9RouterMigration] ${error?.code || "FAILED"}: ${message}`);
+    return NextResponse.json(
+      { error: message, code: error?.code || "MIGRATION_FAILED" },
+      { status: 400, headers: HEADERS },
+    );
+  }
+}

package/src/routes/api/settings/require-login/route.js

@@ -0,0 +1,14 @@
+import { NextResponse } from "next/server";
+import { getSettings } from "@/lib/localDb";
+
+export async function GET() {
+  try {
+    const settings = await getSettings();
+    const requireLogin = settings.requireLogin !== false;
+    const tunnelDashboardAccess = settings.tunnelDashboardAccess !== false;
+    const tunnelUrl = settings.tunnelUrl || "";
+    return NextResponse.json({ requireLogin, tunnelDashboardAccess, tunnelUrl });
+  } catch (error) {
+    return NextResponse.json({ requireLogin: true }, { status: 200 });
+  }
+}

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

@@ -0,0 +1,186 @@
+import { NextResponse } from "next/server";
+import { getSettings, updateSettings } from "@/lib/localDb";
+import { stripRemovedSettings } from "@/lib/db/repos/settingsRepo.js";
+import { resetComboRotation } from "open-sse/services/combo.js";
+import bcrypt from "bcryptjs";
+import { cookies } from "next/headers";
+import { getDashboardAuthSession, setDashboardAuthCookie } from "@/lib/auth/dashboardSession";
+import { env } from "@/lib/env.ts";
+import { logRouteError } from "@/lib/errors/publicError";
+
+const SETTINGS_ERROR = "Unable to process settings request";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
+const SETTINGS_RESPONSE_HEADERS = {
+  "Cache-Control": "no-store"
+};
+
+const PROTECTED_SETTING_KEYS = ["password", "dbPath", "tunnelEnabled", "tunnelUrl"];
+
+const CLI_MODEL_MAPPING_KEYS = new Set(["enabled", "entries"]);
+
+function sanitizeSettingsForResponse(settings) {
+  const {
+    password: _password,
+    dbPath: _dbPath,
+    ...safeSettings
+  } = stripRemovedSettings(settings);
+  return safeSettings;
+}
+
+export const __test__ = { sanitizeSettingsForResponse };
+
+function sanitizeCliModelMappings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const result = {};
+  for (const [toolId, snapshot] of Object.entries(value)) {
+    if (!/^[a-z0-9_-]{1,64}$/i.test(toolId) || !snapshot || typeof snapshot !== "object") continue;
+    const entries = Array.isArray(snapshot.entries)
+      ? snapshot.entries.map((entry) => ({
+          sourceModel: typeof entry?.sourceModel === "string" ? entry.sourceModel.trim().slice(0, 512) : "",
+          targetModel: typeof entry?.targetModel === "string" ? entry.targetModel.trim().slice(0, 512) : "",
+          enabled: entry?.enabled !== false,
+        })).filter((entry) => entry.sourceModel && entry.targetModel).slice(0, 256)
+      : [];
+    result[toolId] = { enabled: snapshot.enabled !== false, entries };
+  }
+  return result;
+}
+
+export async function GET() {
+  try {
+    const settings = await getSettings();
+    const safeSettings = sanitizeSettingsForResponse(settings);
+
+    const enableRequestLogs = env.requestLogsEnabled;
+    const enableTranslator = env.translatorEnabled;
+
+    return NextResponse.json({
+      ...safeSettings,
+      enableRequestLogs,
+      enableTranslator,
+      hasPassword: !!settings.password,
+    }, { headers: SETTINGS_RESPONSE_HEADERS });
+
+  } catch (error) {
+    logRouteError("Settings][Get", error);
+    return NextResponse.json({ error: SETTINGS_ERROR }, { status: 500 });
+  }
+}
+
+export async function PATCH(request) {
+  try {
+    const body = await request.json();
+    const cookieStore = await cookies();
+    const session = await getDashboardAuthSession(cookieStore.get("auth_token")?.value);
+    const forcedPasswordChange = session?.mustChangePassword === true;
+
+    if (forcedPasswordChange) {
+      const keys = Object.keys(body || {});
+      if (!body || typeof body !== "object" || !body.newPassword || keys.some((key) => key !== "newPassword")) {
+        return NextResponse.json({ error: "Set a new dashboard password before continuing" }, { status: 403 });
+      }
+    }
+
+    for (const key of PROTECTED_SETTING_KEYS) delete body[key];
+
+    const currentSettings = await getSettings();
+    if (
+      currentSettings.tunnelEnabled === true &&
+      (body.requireApiKey === false || body.requireLogin === false)
+    ) {
+      return NextResponse.json(
+        { error: "Disable the Cloudflare Tunnel before turning off API key or login protection" },
+        { status: 409 },
+      );
+    }
+
+    if (body.newPassword) {
+      const settings = await getSettings();
+      const currentHash = settings.password;
+
+      if (currentHash) {
+        if (!body.currentPassword) {
+          return NextResponse.json({ error: "Current password required" }, { status: 400 });
+        }
+        const isValid = await bcrypt.compare(body.currentPassword, currentHash);
+        if (!isValid) {
+          return NextResponse.json({ error: "Invalid current password" }, { status: 401 });
+        }
+      } else {
+
+        if (body.currentPassword) {
+          return NextResponse.json({ error: "Invalid current password" }, { status: 401 });
+        }
+      }
+
+      const salt = await bcrypt.genSalt(10);
+      body.password = await bcrypt.hash(body.newPassword, salt);
+      delete body.newPassword;
+      delete body.currentPassword;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(body, "cliModelMappings")) {
+      body.cliModelMappings = sanitizeCliModelMappings(body.cliModelMappings);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(body, "profileName")) {
+      body.profileName = typeof body.profileName === "string"
+        ? body.profileName.trim().replace(/\s+/g, " ").slice(0, 40)
+        : "";
+    }
+
+    if (Object.prototype.hasOwnProperty.call(body, "currency")) {
+      body.currency = body.currency === "IDR" ? "IDR" : "USD";
+    }
+
+    if (Object.prototype.hasOwnProperty.call(body, "profileAvatar")) {
+      const avatar = typeof body.profileAvatar === "string" ? body.profileAvatar.trim() : "";
+      const isValidAvatar = avatar === ""
+        || (avatar.length <= 700_000
+          && /^data:image\/(?:png|jpeg|webp|gif);base64,[A-Za-z0-9+/=\r\n]+$/.test(avatar));
+      if (!isValidAvatar) {
+        return NextResponse.json(
+          { error: "Profile photo must be a PNG, JPG, WEBP, or GIF up to 512 KB" },
+          { status: 400 },
+        );
+      }
+      body.profileAvatar = avatar;
+    }
+
+    const settings = await updateSettings(body);
+
+    if (forcedPasswordChange) {
+
+      await setDashboardAuthCookie(cookieStore, request);
+    }
+
+    if (
+      Object.prototype.hasOwnProperty.call(body, "comboStrategy") ||
+      Object.prototype.hasOwnProperty.call(body, "comboStickyRoundRobinLimit") ||
+      Object.prototype.hasOwnProperty.call(body, "comboStrategies")
+    ) {
+      resetComboRotation();
+    }
+
+    if (
+      Object.prototype.hasOwnProperty.call(body, "claudeAutoPing") ||
+      Object.prototype.hasOwnProperty.call(body, "codexAutoPing")
+    ) {
+
+      import("@/shared/services/quotaAutoPing")
+        .then(({ configureQuotaAutoPing }) => {
+          configureQuotaAutoPing(settings);
+        })
+        .catch((error) => console.warn("[AutoPing] settings update failed:", error.message));
+    }
+
+    const safeSettings = sanitizeSettingsForResponse(settings);
+    return NextResponse.json(safeSettings, { headers: SETTINGS_RESPONSE_HEADERS });
+  } catch (error) {
+    logRouteError("Settings][Patch", error);
+    return NextResponse.json({ error: SETTINGS_ERROR }, { status: 500 });
+  }
+}

package/src/routes/api/shutdown/route.js

@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { requestShutdown } from "@/lifecycle/appLifecycle";
+
+export async function POST() {
+  const result = requestShutdown(0);
+
+  if (result === "unavailable") {
+    return NextResponse.json(
+      { success: false, code: "shutdown_unavailable", message: "Shutdown handler is not ready" },
+      { status: 503 },
+    );
+  }
+
+  if (result === "already_requested") {
+    return NextResponse.json(
+      { success: false, code: "shutdown_in_progress", message: "Shutdown is already in progress" },
+      { status: 409 },
+    );
+  }
+
+  return NextResponse.json(
+    { success: true, code: "shutdown_accepted", message: "Shutdown initiated" },
+    { status: 202, headers: { "Cache-Control": "no-store" } },
+  );
+}

package/src/routes/api/tags/route.js

@@ -0,0 +1,17 @@
+import { ollamaModels } from "open-sse/config/ollamaModels.js";
+
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+
+export async function OPTIONS() {
+  return new Response(null, { headers: CORS_HEADERS });
+}
+
+export async function GET() {
+  return new Response(JSON.stringify(ollamaModels), {
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}

package/src/routes/api/translator/console-logs/route.js

@@ -0,0 +1,28 @@
+import { NextResponse } from "next/server";
+
+function logRouteError(scope, error) {
+  console.error(`[${scope}]`, error);
+}
+import { clearConsoleLogs, getConsoleLogs, initConsoleLogCapture } from "@/lib/consoleLogBuffer";
+
+initConsoleLogCapture();
+
+export async function GET() {
+  try {
+    const logs = getConsoleLogs();
+    return NextResponse.json({ success: true, logs });
+  } catch (error) {
+    logRouteError("Translator][ConsoleLogs][Get", error);
+    return NextResponse.json({ success: false, error: "Unable to retrieve console logs" }, { status: 500 });
+  }
+}
+
+export async function DELETE() {
+  try {
+    clearConsoleLogs();
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    logRouteError("Translator][ConsoleLogs][Delete", error);
+    return NextResponse.json({ success: false, error: "Unable to clear console logs" }, { status: 500 });
+  }
+}

package/src/routes/api/translator/console-logs/stream/route.js

@@ -0,0 +1,95 @@
+import { getConsoleEntries, getConsoleEmitter, initConsoleLogCapture } from "@/lib/consoleLogBuffer";
+
+export const dynamic = "force-dynamic";
+
+initConsoleLogCapture();
+
+export async function GET(request) {
+  const encoder = new TextEncoder();
+  const emitter = getConsoleEmitter();
+  const state = {
+    closed: false,
+    send: null,
+    sendLines: null,
+    sendClear: null,
+    keepalive: null,
+    abortHandler: null,
+    ready: false,
+    pending: [],
+  };
+
+  const cleanup = () => {
+    if (state.closed) return;
+    state.closed = true;
+    if (state.send) emitter.off("line", state.send);
+    if (state.sendLines) emitter.off("lines", state.sendLines);
+    if (state.sendClear) emitter.off("clear", state.sendClear);
+    if (state.keepalive) clearInterval(state.keepalive);
+    if (state.abortHandler) request.signal.removeEventListener("abort", state.abortHandler);
+  };
+
+  state.abortHandler = cleanup;
+  request.signal.addEventListener("abort", state.abortHandler, { once: true });
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const enqueueEvent = (event) => {
+        if (state.closed) return;
+        if (!state.ready) {
+          state.pending.push(event);
+          return;
+        }
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+        } catch {
+          cleanup();
+        }
+      };
+
+      state.send = (line) => enqueueEvent({ type: "line", line });
+      state.sendLines = (lines) => {
+        if (Array.isArray(lines) && lines.length > 0) {
+          enqueueEvent({ type: "lines", lines });
+        }
+      };
+
+      state.sendClear = () => enqueueEvent({ type: "clear" });
+
+      emitter.on("line", state.send);
+      emitter.on("lines", state.sendLines);
+      emitter.on("clear", state.sendClear);
+
+      const buffered = getConsoleEntries();
+      if (buffered.length > 0) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "init", entries: buffered })}\n\n`));
+      }
+
+      state.ready = true;
+      for (const event of state.pending.splice(0, state.pending.length)) {
+        enqueueEvent(event);
+      }
+
+      state.keepalive = setInterval(() => {
+        if (state.closed) { clearInterval(state.keepalive); return; }
+        try {
+          controller.enqueue(encoder.encode(": ping\n\n"));
+        } catch {
+          cleanup();
+        }
+      }, 25000);
+    },
+
+    cancel() {
+      cleanup();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

package/src/routes/api/tunnel/disable/route.js

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { disableTunnel } from "@/lib/tunnel";
+import { getSettings } from "@/lib/localDb";
+import { configureTunnelMonitoring } from "@/shared/services/initializeApp";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+export async function POST() {
+  try {
+    const result = await disableTunnel();
+    getSettings()
+      .then(configureTunnelMonitoring)
+      .catch((error) => console.warn("Tunnel monitor update failed:", error.message));
+    return NextResponse.json(result);
+  } catch (error) {
+    logRouteError("Tunnel][Disable", error);
+    return NextResponse.json({ error: publicError("tunnel") }, { status: 500 });
+  }
+}

package/src/routes/api/tunnel/enable/route.js

@@ -0,0 +1,32 @@
+import { NextResponse } from "next/server";
+import { enableTunnel } from "@/lib/tunnel";
+import { getSettings } from "@/lib/localDb";
+import { configureTunnelMonitoring } from "@/shared/services/initializeApp";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+import { getTunnelEnableError } from "@/lib/tunnel/cloudflare/requirements.js";
+
+const DNS_WARMUP_DELAY_MS = 8000;
+
+export async function POST() {
+  try {
+    const settings = await getSettings();
+    const requirementError = getTunnelEnableError(settings);
+    if (requirementError) {
+      return NextResponse.json(
+        { success: false, error: requirementError },
+        { status: 400 },
+      );
+    }
+
+    const result = await enableTunnel();
+    getSettings()
+      .then(configureTunnelMonitoring)
+      .catch((error) => console.warn("Tunnel monitor start failed:", error.message));
+
+    await new Promise((r) => setTimeout(r, DNS_WARMUP_DELAY_MS));
+    return NextResponse.json(result);
+  } catch (error) {
+    logRouteError("Tunnel][Enable", error);
+    return NextResponse.json({ error: publicError("tunnel") }, { status: 500 });
+  }
+}

package/src/routes/api/tunnel/status/route.js

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { getTunnelStatus, getDownloadStatus } from "@/lib/tunnel";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const STATUS_CACHE_TTL_MS = 3000;
+
+const statusCache = (global.__tunnelStatusCache ??= { value: null, fetchedAt: 0 });
+
+export async function GET() {
+  try {
+    let tunnel = statusCache.value;
+    if (!tunnel || Date.now() - statusCache.fetchedAt >= STATUS_CACHE_TTL_MS) {
+      tunnel = await getTunnelStatus();
+      statusCache.value = tunnel;
+      statusCache.fetchedAt = Date.now();
+    }
+    const download = getDownloadStatus();
+    return NextResponse.json({ tunnel, download });
+  } catch (error) {
+    logRouteError("Tunnel][Status", error);
+    return NextResponse.json({ error: publicError("tunnel") }, { status: 500 });
+  }
+}

package/src/routes/api/update/route.js

@@ -0,0 +1,42 @@
+import { NextResponse } from "next/server";
+import { checkForUpdate } from "@/lib/update/version.js";
+import { canInstallUpdate, installPackageVersion } from "@/lib/update/installer.js";
+
+export async function POST() {
+  const version = await checkForUpdate({ force: true });
+
+  if (!version.updateAvailable || !version.latestVersion) {
+    return NextResponse.json({
+      success: false,
+      code: "no_update_available",
+      ...version,
+    }, { status: 409, headers: { "Cache-Control": "no-store" } });
+  }
+
+  if (!canInstallUpdate()) {
+    return NextResponse.json({
+      success: false,
+      code: "update_unavailable",
+      message: "Package updates are unavailable for this runtime",
+      ...version,
+    }, { status: 409, headers: { "Cache-Control": "no-store" } });
+  }
+
+  try {
+    const result = await installPackageVersion(version.latestVersion);
+    return NextResponse.json({
+      success: true,
+      code: "update_installed",
+      message: `Updated to v${result.version}. Restart the router to apply it.`,
+      restartRequired: true,
+      ...version,
+    }, { status: 200, headers: { "Cache-Control": "no-store" } });
+  } catch (error) {
+    return NextResponse.json({
+      success: false,
+      code: "update_failed",
+      message: error instanceof Error ? error.message : String(error),
+      ...version,
+    }, { status: 500, headers: { "Cache-Control": "no-store" } });
+  }
+}