@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/services/usage/misc.js

@@ -0,0 +1,288 @@
+/**
+ * Misc usage handlers (Qwen, iFlow, Ollama, GLM, Vercel AI Gateway, Qoder)
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { U } from "./shared.js";
+
+// GLM quota endpoints (region-aware) — url from registry transport.usage
+const GLM_QUOTA_URLS = {
+  international: U("glm").url,
+  china: U("glm-cn").url,
+};
+
+// Vercel AI Gateway credits endpoint
+// Returns { balance: "95.50", total_used: "4.50" } (USD as decimal strings).
+const VERCEL_AI_GATEWAY_CREDITS_URL = U("vercel-ai-gateway").url;
+
+/**
+ * Qwen Usage
+ */
+export async function getQwenUsage(accessToken, providerSpecificData) {
+  try {
+    const resourceUrl = providerSpecificData?.resourceUrl;
+    if (!resourceUrl) {
+      return { message: "Qwen connected. No resource URL available." };
+    }
+
+    // Qwen may have usage endpoint at resource URL
+    return { message: "Qwen connected. Usage tracked per request." };
+  } catch (error) {
+    return { message: "Unable to fetch Qwen usage." };
+  }
+}
+
+/**
+ * iFlow Usage
+ */
+export async function getIflowUsage(accessToken) {
+  try {
+    // iFlow may have usage endpoint
+    return { message: "iFlow connected. Usage tracked per request." };
+  } catch (error) {
+    return { message: "Unable to fetch iFlow usage." };
+  }
+}
+
+/**
+ * Ollama Cloud Usage
+ * Ollama Cloud uses an API key from ollama.com/settings/keys
+ * and has no public usage API — free tier has light usage limits (resets every 5h & 7d).
+ * This returns an informational message with the plan details.
+ */
+export async function getOllamaUsage(accessToken, providerSpecificData) {
+  try {
+    // Ollama Cloud does not expose a public quota/usage API.
+    // The provider is configured as noAuth with a notice explaining limits.
+    // We return a graceful message so the UI shows a friendly state instead of an error.
+    const plan = providerSpecificData?.plan || "Free";
+    return {
+      plan,
+      message: "Ollama Cloud uses a free tier with light usage limits (resets every 5h & 7d). For detailed usage tracking, visit ollama.com/settings/keys.",
+      quotas: [],
+    };
+  } catch (error) {
+    return { message: "Unable to fetch Ollama Cloud usage." };
+  }
+}
+
+/**
+ * GLM Coding Plan usage (international + China regions)
+ */
+export async function getGlmUsage(apiKey, provider, proxyOptions = null) {
+  if (!apiKey) {
+    return { message: "GLM API key not available." };
+  }
+
+  const region = provider === "glm-cn" ? "china" : "international";
+  const quotaUrl = GLM_QUOTA_URLS[region];
+
+  try {
+    const response = await proxyAwareFetch(quotaUrl, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    }, proxyOptions);
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        return { message: "GLM API key invalid or expired." };
+      }
+      return { message: `GLM quota API error (${response.status}).` };
+    }
+
+    const json = await response.json();
+    const data = json?.data && typeof json.data === "object" ? json.data : {};
+    const limits = Array.isArray(data.limits) ? data.limits : [];
+    const quotas = {};
+
+    for (const limit of limits) {
+      if (!limit || limit.type !== "TOKENS_LIMIT") continue;
+      const usedPercent = Number(limit.percentage) || 0;
+      const resetMs = Number(limit.nextResetTime) || 0;
+      const remaining = Math.max(0, 100 - usedPercent);
+
+      quotas["session"] = {
+        used: usedPercent,
+        total: 100,
+        remaining,
+        remainingPercentage: remaining,
+        resetAt: resetMs > 0 ? new Date(resetMs).toISOString() : null,
+        unlimited: false,
+      };
+    }
+
+    const levelRaw = typeof data.level === "string" ? data.level : "";
+    const plan = levelRaw
+      ? levelRaw.charAt(0).toUpperCase() + levelRaw.slice(1).toLowerCase()
+      : "Unknown";
+
+    return { plan, quotas };
+  } catch (error) {
+    return { message: `GLM error: ${error.message}` };
+  }
+}
+
+/**
+ * Vercel AI Gateway usage — credit balance for the API key
+ *
+ * Calls GET /v1/credits which returns:
+ *   { "balance": "95.50", "total_used": "4.50" }   (USD as decimal strings)
+ *
+ * We surface this as a single "Balance ($)" quota row so the existing
+ * QuotaTable / progress-bar UI can render it. used = total_used,
+ * total = balance + total_used (the original credit allotment), so the
+ * remaining percentage equals balance / total.
+ *
+ * Docs: https://vercel.com/docs/ai-gateway/usage
+ */
+export async function getVercelAiGatewayUsage(apiKey, proxyOptions = null) {
+  if (!apiKey) {
+    return { message: "Vercel AI Gateway API key not available." };
+  }
+
+  try {
+    const response = await proxyAwareFetch(VERCEL_AI_GATEWAY_CREDITS_URL, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    }, proxyOptions);
+
+    if (response.status === 401 || response.status === 403) {
+      return { message: "Vercel AI Gateway API key invalid or expired." };
+    }
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      const trimmed = errorText ? `: ${errorText.slice(0, 200)}` : "";
+      return { message: `Vercel AI Gateway credits API error (${response.status})${trimmed}` };
+    }
+
+    const data = await response.json();
+
+    // Vercel returns numeric strings; coerce safely.
+    const balance = Number(data?.balance) || 0;
+    const totalUsed = Number(data?.total_used) || 0;
+
+    // Vercel gives $5/month free credit. The API doesn't return the
+    // monthly allocation so we use the known constant as the denominator.
+    const MONTHLY_CREDIT = 5;
+    const remainingPercentage = (balance / MONTHLY_CREDIT) * 100;
+
+    if (balance <= 0 && totalUsed <= 0) {
+      return {
+        plan: "Pay-as-you-go",
+        message: "Vercel AI Gateway connected. No credit allocation found (BYOK or unfunded account).",
+        quotas: {},
+      };
+    }
+
+    // "Used (USD)": how much has been spent this month (no fixed cap → unlimited).
+    // "Remaining (USD)": balance remaining out of the $5 monthly allocation.
+    return {
+      plan: "Pay-as-you-go",
+      quotas: {
+        "Used (USD)": {
+          used: totalUsed,
+          total: 0,
+          remaining: 0,
+          remainingPercentage: 100,
+          unlimited: true,
+        },
+        "Remaining (USD)": {
+          used: balance,
+          total: MONTHLY_CREDIT,
+          remaining: balance,
+          remainingPercentage,
+          unlimited: false,
+        },
+      },
+    };
+  } catch (error) {
+    return { message: `Vercel AI Gateway error: ${error.message}` };
+  }
+}
+
+export async function getQoderUsage(accessToken, proxyOptions = null) {
+  if (!accessToken) {
+    return { message: "Qoder usage unavailable: no access token" };
+  }
+  try {
+    const response = await proxyAwareFetch(
+      U("qoder").url,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          Accept: "application/json",
+        },
+      },
+      proxyOptions,
+    );
+    if (!response.ok) {
+      return { message: `Qoder connected. Usage fetch returned ${response.status}.` };
+    }
+    const body = await response.json().catch(() => null);
+    if (!body) {
+      return { message: "Qoder connected. Usage response was not JSON." };
+    }
+    // Quota records live under `quotas`; scalar metadata
+    // (totalUsagePercentage, isQuotaExceeded, expiresAt) are surfaced as
+    // siblings so the dashboard parser doesn't try to render them as rows.
+    const userQuota = body.userQuota || {};
+    const orgQuota = body.orgResourcePackage || {};
+    // Qoder publishes a single absolute reset timestamp (`expiresAt` in ms);
+    // surface it on every quota record as ISO so the table can render
+    // "resets at" alongside used/total.
+    const expiresAtMs = Number.isFinite(Number(body.expiresAt)) && Number(body.expiresAt) > 0
+      ? Number(body.expiresAt)
+      : null;
+    const resetAt = expiresAtMs ? new Date(expiresAtMs).toISOString() : null;
+    const quotas = {
+      user: {
+        total: Number(userQuota.total) || 0,
+        used: Number(userQuota.used) || 0,
+        remaining: Number(userQuota.remaining) || 0,
+        unit: userQuota.unit || "credits",
+        resetAt,
+      },
+      organization: {
+        total: Number(orgQuota.total) || 0,
+        used: Number(orgQuota.used) || 0,
+        remaining: Number(orgQuota.remaining) || 0,
+        unit: orgQuota.unit || "credits",
+        resetAt,
+      },
+    };
+    return {
+      quotas,
+      totalUsagePercentage: Number(body.totalUsagePercentage) || 0,
+      isQuotaExceeded: !!body.isQuotaExceeded,
+      expiresAt: expiresAtMs,
+    };
+  } catch (error) {
+    return { message: `Qoder connected. Unable to fetch usage: ${error.message}` };
+  }
+}
+
+/**
+ * Cloudflare Workers AI Usage
+ * Free tier: 10,000 neurons/day. No public usage API — returns free tier info.
+ */
+export async function getCloudflareAiUsage(apiKey, providerSpecificData) {
+  return {
+    plan: "Workers AI Free",
+    quotas: {
+      neurons: {
+        used: 0,
+        total: 10000,
+        resetAt: null,
+        unlimited: false,
+        displayName: "Neurons (daily free)",
+      },
+    },
+  };
+}

package/open-sse/services/usage/shared.js

@@ -0,0 +1,70 @@
+/**
+ * Shared usage helpers (cross-provider)
+ */
+
+import { PROVIDERS } from "../../providers/index.js";
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+
+// usage endpoints: single source from registry transport.usage
+export const U = (id) => PROVIDERS[id]?.usage || {};
+
+/**
+ * Parse reset date/time to ISO string
+ * Handles multiple formats: Unix timestamp (ms), ISO date string, etc.
+ */
+export function parseResetTime(resetValue) {
+  if (!resetValue) return null;
+
+  try {
+    // If it's already a Date object
+    if (resetValue instanceof Date) {
+      return resetValue.toISOString();
+    }
+
+    // Unix timestamps from provider APIs may be seconds or milliseconds.
+    if (typeof resetValue === 'number') {
+      return new Date(resetValue < 1e12 ? resetValue * 1000 : resetValue).toISOString();
+    }
+
+    // If it's a numeric string, treat it like a Unix timestamp too.
+    if (typeof resetValue === 'string') {
+      if (/^\d+$/.test(resetValue)) {
+        const timestamp = Number(resetValue);
+        return new Date(timestamp < 1e12 ? timestamp * 1000 : timestamp).toISOString();
+      }
+      return new Date(resetValue).toISOString();
+    }
+
+    return null;
+  } catch (error) {
+    console.warn(`Failed to parse reset time: ${resetValue}`, error);
+    return null;
+  }
+}
+
+export function toFiniteNumber(value, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+
+export function normalizeCloudCodeProjectId(project) {
+  if (typeof project === "string") return project.trim() || null;
+  if (project && typeof project === "object" && typeof project.id === "string") {
+    return project.id.trim() || null;
+  }
+  return null;
+}
+
+export async function fetchWithTimeout(url, opts, ms = 10000, proxyOptions = null) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), ms);
+  try {
+    return await proxyAwareFetch(url, { ...opts, signal: controller.signal }, proxyOptions);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

package/open-sse/services/usage.js

@@ -0,0 +1,62 @@
+/**
+ * Usage Fetcher - Get usage data from provider APIs
+ */
+
+import { getGitHubUsage } from "./usage/github.js";
+import { getGeminiUsage, getAntigravityUsage } from "./usage/google.js";
+import { getClaudeUsage } from "./usage/claude.js";
+import { getCodexUsage, consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits } from "./usage/codex.js";
+
+export { consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits };
+import { getKiroUsage } from "./usage/kiro.js";
+import { getMiniMaxUsage } from "./usage/minimax.js";
+import { getCodeBuddyCnUsage } from "./usage/codebuddy-cn.js";
+import { getGrokCliUsage } from "./usage/grok-cli.js";
+import { getCloudflareAiUsage } from "./usage/misc.js";
+import {
+  getQwenUsage,
+  getIflowUsage,
+  getOllamaUsage,
+  getGlmUsage,
+  getVercelAiGatewayUsage,
+  getQoderUsage,
+} from "./usage/misc.js";
+
+/**
+ * Get usage data for a provider connection
+ * @param {Object} connection - Provider connection with accessToken
+ * @returns {Object} Usage data with quotas
+ */
+// provider → usage handler (ctx carries every arg each handler needs)
+const USAGE_HANDLERS = {
+  github: (c) => getGitHubUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  "gemini-cli": (c) => getGeminiUsage(c.accessToken, c.providerDataWithProjectId, c.proxyOptions),
+  antigravity: (c) => getAntigravityUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  claude: (c) => getClaudeUsage(c.accessToken, c.proxyOptions),
+  codex: (c) => getCodexUsage(c.accessToken, c.proxyOptions),
+  kiro: (c) => getKiroUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  qoder: (c) => getQoderUsage(c.accessToken, c.proxyOptions),
+  qwen: (c) => getQwenUsage(c.accessToken, c.providerSpecificData),
+  iflow: (c) => getIflowUsage(c.accessToken),
+  ollama: (c) => getOllamaUsage(c.accessToken),
+  glm: (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
+  "glm-cn": (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
+  minimax: (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
+  "minimax-cn": (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
+  "vercel-ai-gateway": (c) => getVercelAiGatewayUsage(c.apiKey, c.proxyOptions),
+  "codebuddy-cn": (c) => getCodeBuddyCnUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
+  "grok-cli": (c) => getGrokCliUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  "cloudflare-ai": (c) => getCloudflareAiUsage(c.apiKey, c.providerSpecificData),
+};
+
+export async function getUsageForProvider(connection, proxyOptions = null) {
+  const { provider, accessToken, apiKey, providerSpecificData, projectId } = connection;
+  const providerDataWithProjectId = {
+    ...(providerSpecificData || {}),
+    ...(projectId ? { projectId } : {}),
+  };
+
+  const handler = USAGE_HANDLERS[provider];
+  if (!handler) return { message: `Usage API not implemented for ${provider}` };
+  return await handler({ provider, accessToken, apiKey, providerSpecificData, providerDataWithProjectId, proxyOptions });
+}

package/open-sse/services/usageDb.js

@@ -0,0 +1,2 @@
+export function saveCallLog() {}
+export function getCallLog() { return []; }

package/open-sse/services/webSearchRouting.js

@@ -0,0 +1,25 @@
+function asString(value) {
+  return typeof value === "string" ? value : "";
+}
+function hasNativeWebSearchTool(body) {
+  if (!body || typeof body !== "object") return false;
+  const tools = body.tools;
+  if (!Array.isArray(tools)) return false;
+  return tools.some((tool) => {
+    if (!tool || typeof tool !== "object") return false;
+    const record = tool;
+    if (record.function) return false;
+    return asString(record.type).startsWith("web_search");
+  });
+}
+function resolveWebSearchRouteOverride(currentModel, body, settings) {
+  const fallthrough = { wasRouted: false, model: currentModel };
+  if (!hasNativeWebSearchTool(body)) return fallthrough;
+  const configured = asString(settings?.webSearchRouteModel).trim();
+  if (!configured || configured === currentModel) return fallthrough;
+  return { wasRouted: true, model: configured };
+}
+export {
+  hasNativeWebSearchTool,
+  resolveWebSearchRouteOverride
+};

package/open-sse/services/wildcardRouter.js

@@ -0,0 +1,59 @@
+function wildcardMatch(model, pattern) {
+  if (!model || !pattern) return false;
+  if (pattern === "*") return true;
+  if (pattern === model) return true;
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexStr}$`, "i");
+  return regex.test(model);
+}
+function getSpecificity(pattern) {
+  if (!pattern) return 0;
+  let score = 0;
+  const segments = pattern.split(/[/*?]/);
+  for (const seg of segments) {
+    if (seg.length > 0) score += seg.length * 10;
+  }
+  const wildcardCount = (pattern.match(/\*/g) || []).length;
+  const questionCount = (pattern.match(/\?/g) || []).length;
+  score -= wildcardCount * 50;
+  score -= questionCount * 5;
+  score += pattern.length;
+  return score;
+}
+function resolveWildcardAlias(model, aliases) {
+  if (!model || !aliases || !Array.isArray(aliases)) return null;
+  const matches = [];
+  for (const alias of aliases) {
+    const pattern = alias.pattern || alias.alias || alias.from;
+    const target = alias.target || alias.model || alias.to;
+    if (!pattern || !target) continue;
+    if (wildcardMatch(model, pattern)) {
+      matches.push({
+        pattern,
+        target,
+        specificity: getSpecificity(pattern),
+        ...alias
+      });
+    }
+  }
+  if (matches.length === 0) return null;
+  matches.sort((a, b) => b.specificity - a.specificity);
+  return matches[0];
+}
+function resolveModel(model, exactAliases = {}, wildcardAliases = []) {
+  if (!model) return model;
+  if (exactAliases instanceof Map) {
+    if (exactAliases.has(model)) return exactAliases.get(model);
+  } else if (exactAliases[model]) {
+    return exactAliases[model];
+  }
+  const match = resolveWildcardAlias(model, wildcardAliases);
+  if (match) return match.target;
+  return model;
+}
+export {
+  getSpecificity,
+  resolveModel,
+  resolveWildcardAlias,
+  wildcardMatch
+};

package/open-sse/shared/clineAuth.js

@@ -0,0 +1,37 @@
+import pkg from "../../package.json" with { type: "json" };
+
+const APP_VERSION = pkg.version || "0.0.0";
+
+export function getClineAccessToken(token) {
+  if (typeof token !== "string") return "";
+  const trimmed = token.trim();
+  if (!trimmed) return "";
+  return trimmed.startsWith("workos:") ? trimmed : `workos:${trimmed}`;
+}
+
+export function getClineAuthorizationHeader(token) {
+  const accessToken = getClineAccessToken(token);
+  return accessToken ? `Bearer ${accessToken}` : "";
+}
+
+export function buildClineHeaders(token, extraHeaders = {}) {
+  const authorization = getClineAuthorizationHeader(token);
+  const headers = {
+    "HTTP-Referer": "https://cline.bot",
+    "X-Title": "Cline",
+    "User-Agent": `9Router/${APP_VERSION}`,
+    "X-PLATFORM": process.platform || "unknown",
+    "X-PLATFORM-VERSION": process.version || "unknown",
+    "X-CLIENT-TYPE": "9router",
+    "X-CLIENT-VERSION": APP_VERSION,
+    "X-CORE-VERSION": APP_VERSION,
+    "X-IS-MULTIROOT": "false",
+    ...extraHeaders,
+  };
+
+  if (authorization) {
+    headers.Authorization = authorization;
+  }
+
+  return headers;
+}

package/open-sse/shared/machineId.js

@@ -0,0 +1,19 @@
+import { machineIdSync } from "node-machine-id";
+import crypto from "node:crypto";
+
+let cachedRawId = null;
+
+function loadRawMachineId() {
+  if (cachedRawId) return cachedRawId;
+  try {
+    cachedRawId = machineIdSync();
+  } catch {
+    cachedRawId = crypto.randomUUID();
+  }
+  return cachedRawId;
+}
+
+export async function getConsistentMachineId(salt = "endpoint-proxy-salt") {
+  const rawId = loadRawMachineId();
+  return crypto.createHash("sha256").update(rawId + salt).digest("hex").substring(0, 16);
+}

package/open-sse/shared/qoder/constants.js

@@ -0,0 +1,64 @@
+/**
+ * Qoder API constants ported from CLIProxyAPIPlus qoder-provider branch.
+ *
+ * Endpoint set:
+ *   openapi.qoder.sh   - device flow + userinfo + quota usage
+ *   center.qoder.sh    - token refresh (best-effort, currently 403 for device tokens)
+ *   api3.qoder.sh      - inference (chat) + model list, requires COSY signing
+ *   qoder.com/device   - browser landing page for device authorization
+ */
+
+export const QODER_OPENAPI_BASE = "https://openapi.qoder.sh";
+export const QODER_CENTER_BASE = "https://center.qoder.sh";
+export const QODER_CHAT_BASE = "https://api3.qoder.sh";
+
+export const QODER_LOGIN_URL = "https://qoder.com/device/selectAccounts";
+
+// Device flow endpoints
+export const QODER_DEVICE_TOKEN_URL = `${QODER_OPENAPI_BASE}/api/v1/deviceToken/poll`;
+export const QODER_USERINFO_URL = `${QODER_OPENAPI_BASE}/api/v1/userinfo`;
+export const QODER_QUOTA_USAGE_URL = `${QODER_OPENAPI_BASE}/api/v2/quota/usage`;
+export const QODER_REFRESH_TOKEN_URL = `${QODER_CENTER_BASE}/algo/api/v3/user/refresh_token`;
+
+// Inference endpoints (under /algo on api3.qoder.sh, all COSY-signed)
+export const QODER_CHAT_SIG_PATH = "/api/v2/service/pro/sse/agent_chat_generation";
+export const QODER_CHAT_URL = `${QODER_CHAT_BASE}/algo${QODER_CHAT_SIG_PATH}?FetchKeys=llm_model_result&AgentId=agent_common`;
+export const QODER_CHAT_URL_ENCODED = `${QODER_CHAT_URL}&Encode=1`;
+export const QODER_MODEL_LIST_URL = `${QODER_CHAT_BASE}/algo/api/v2/model/list`;
+
+// COSY header constants. These are not arbitrary — the upstream signature
+// validation matches them against the values used at signing time.
+export const QODER_IDE_VERSION = "1.0.0";
+export const QODER_CLIENT_TYPE = "5";
+export const QODER_DATA_POLICY = "disagree";
+export const QODER_LOGIN_VERSION = "v2";
+export const QODER_MACHINE_OS = "x86_64_windows";
+export const QODER_MACHINE_TYPE = "5";
+
+// Canonical model identifiers. Identity map — keep as a map so callers can
+// cheaply test "is this a known qoder model?" before sending the request.
+export const QODER_MODEL_MAP = {
+  // Tier models
+  auto: "auto",
+  ultimate: "ultimate",
+  performance: "performance",
+  efficient: "efficient",
+  lite: "lite",
+  // Frontier models
+  qmodel: "qmodel",
+  qmodel_latest: "qmodel_latest",
+  dmodel: "dmodel",
+  dfmodel: "dfmodel",
+  gm51model: "gm51model",
+  kmodel: "kmodel",
+  mmodel: "mmodel",
+};
+
+// RSA public key for COSY encryption (extracted from Qoder IDE v0.9).
+// Matches the CLIProxyAPIPlus branch and live qodercli traffic.
+export const QODER_RSA_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;