zevairouter 1.0.43 → 1.0.46

package/cli/hooks/cloakbrowserRuntime.js

@@ -0,0 +1,105 @@
+// Lazy-install helper for cloakbrowser (stealth Chromium that can pass Turnstile).
+// Same shape as camoufoxRuntime / playwrightRuntime — optional package, install on demand.
+const { createRequire } = require("module");
+const fs = require("fs");
+const path = require("path");
+
+const { runNpmInstall, getRuntimeDir, getRuntimeNodeModules } = require("./sqliteRuntime");
+
+const CLOAKBROWSER_PACKAGE = "cloakbrowser";
+const CLOAKBROWSER_VERSION = "^0.3.31";
+
+const nodeRequire =
+  typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
+
+function getRuntimeRequire() {
+  try {
+    const anchor = path.join(getRuntimeDir(), "noop.js");
+    return createRequire(anchor);
+  } catch {
+    return null;
+  }
+}
+
+let cachedReady = null;
+
+function tryRequireCloakbrowser() {
+  try {
+    const rreq = getRuntimeRequire();
+    const candidate = path.join(getRuntimeNodeModules(), CLOAKBROWSER_PACKAGE);
+    if (rreq && fs.existsSync(path.join(candidate, "package.json"))) {
+      return rreq(candidate);
+    }
+  } catch {}
+  try {
+    return nodeRequire(CLOAKBROWSER_PACKAGE);
+  } catch {}
+  try {
+    const candidate = path.join(getRuntimeNodeModules(), CLOAKBROWSER_PACKAGE);
+    if (fs.existsSync(path.join(candidate, "package.json"))) {
+      return nodeRequire(candidate);
+    }
+  } catch {}
+  // Dev / user global installs
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const aurix = path.join(home, ".aurix/agent/node_modules", CLOAKBROWSER_PACKAGE);
+    if (fs.existsSync(path.join(aurix, "package.json"))) {
+      return nodeRequire(aurix);
+    }
+  } catch {}
+  return null;
+}
+
+function loadCloakbrowserModule() {
+  return tryRequireCloakbrowser();
+}
+
+function ensureCloakbrowserRuntime({ silent = false } = {}) {
+  if (cachedReady?.ok && cachedReady.module) {
+    return cachedReady;
+  }
+
+  let mod = tryRequireCloakbrowser();
+  if (mod?.launch) {
+    cachedReady = { ok: true, module: mod };
+    return cachedReady;
+  }
+
+  if (!silent) {
+    console.log(`[cloakbrowser] Installing ${CLOAKBROWSER_PACKAGE}@${CLOAKBROWSER_VERSION} into runtime…`);
+  }
+
+  try {
+    runNpmInstall([`${CLOAKBROWSER_PACKAGE}@${CLOAKBROWSER_VERSION}`], {
+      cwd: getRuntimeDir(),
+      silent,
+    });
+  } catch (error) {
+    const err = new Error(
+      `Failed to install cloakbrowser. Run: npm install ${CLOAKBROWSER_PACKAGE}@${CLOAKBROWSER_VERSION} — ${error.message}`
+    );
+    err.code = "CLOAKBROWSER_INSTALL_FAILED";
+    err.cause = error;
+    return { ok: false, error: err };
+  }
+
+  mod = tryRequireCloakbrowser();
+  if (!mod?.launch) {
+    const err = new Error(
+      `cloakbrowser installed but launch() is missing. Reinstall ${CLOAKBROWSER_PACKAGE}.`
+    );
+    err.code = "CLOAKBROWSER_API_MISMATCH";
+    return { ok: false, error: err };
+  }
+
+  cachedReady = { ok: true, module: mod };
+  return cachedReady;
+}
+
+module.exports = {
+  ensureCloakbrowserRuntime,
+  loadCloakbrowserModule,
+  CLOAKBROWSER_PACKAGE,
+  CLOAKBROWSER_VERSION,
+};

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.43",
+  "version": "1.0.46",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/services/usage.js

@@ -131,6 +131,15 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
       return await getMiniMaxUsage(apiKey, provider, proxyOptions);
     case "grok-cli":
       return await getGrokCliUsage(accessToken, providerSpecificData, proxyOptions);
+    case "xai":
+      return await getXaiUsage(accessToken || apiKey, providerSpecificData, proxyOptions);
+    case "cline":
+    case "clinepass":
+      return await getClineUsage(accessToken || apiKey, provider, proxyOptions);
+    case "kimchi":
+      return await getKimchiUsage(accessToken || apiKey, providerSpecificData, proxyOptions);
+    case "cursor":
+      return await getCursorUsage(accessToken, providerSpecificData);
     default:
       return { message: `Usage API not implemented for ${provider}` };
   }
@@ -1976,3 +1985,303 @@ export async function getGrokCliUsage(accessToken, providerSpecificData = null,
     return { message: `Grok CLI usage error: ${error.message}` };
   }
 }
+
+// ─── Shared: dig credit-like fields from arbitrary JSON ─────────────────────
+
+function digCreditFields(obj, depth = 0, path = "") {
+  if (!obj || typeof obj !== "object" || depth > 4) return null;
+  const candidates = [];
+  const keys = Object.entries(obj);
+  for (const [k, v] of keys) {
+    const lk = k.toLowerCase();
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      const nested = digCreditFields(v, depth + 1, path ? `${path}.${k}` : k);
+      if (nested) candidates.push(nested);
+      continue;
+    }
+    if (typeof v !== "number" && typeof v !== "string") continue;
+    const n = toFiniteNumber(v, NaN);
+    if (!Number.isFinite(n)) continue;
+    if (/(remaining|balance|credit|quota|limit|allowance|cap|used|spent|consumed)/i.test(lk)) {
+      candidates.push({ key: path ? `${path}.${k}` : k, name: k, value: n, kind: lk });
+    }
+  }
+  if (!candidates.length) return null;
+  // Prefer explicit remaining/balance pairs
+  return candidates;
+}
+
+function buildQuotaFromCreditFields(fields) {
+  if (!fields?.length) return null;
+  const by = (re) => fields.find((f) => re.test(f.kind) || re.test(f.name));
+  const remaining = by(/remaining|balance|credit(?!s_used)/i);
+  const total = by(/limit|cap|allowance|total|quota(?!_used)/i);
+  const used = by(/used|spent|consumed/i);
+  if (total && Number(total.value) > 0) {
+    const u = used
+      ? Math.max(0, Number(used.value))
+      : remaining
+        ? Math.max(0, Number(total.value) - Number(remaining.value))
+        : 0;
+    const rem = Math.max(0, Number(total.value) - u);
+    return {
+      used: u,
+      total: Number(total.value),
+      remainingPercentage: (rem / Number(total.value)) * 100,
+      resetAt: null,
+      unlimited: false,
+    };
+  }
+  if (remaining && Number(remaining.value) >= 0) {
+    const bal = Number(remaining.value);
+    return {
+      used: 0,
+      total: bal > 0 ? bal : 1,
+      remainingPercentage: bal > 0 ? 100 : 0,
+      resetAt: null,
+      unlimited: false,
+    };
+  }
+  return null;
+}
+
+// ─── Cline / ClinePass ──────────────────────────────────────────────────────
+
+export async function getClineUsage(accessToken, provider = "cline", proxyOptions = null) {
+  if (!accessToken) return { message: "Cline access token not available." };
+  try {
+    // Dynamic import avoids circular deps with package.json in browser bundles
+    const { buildClineHeaders } = await import("../../src/shared/utils/clineAuth.js");
+    const headers = buildClineHeaders(accessToken, { Accept: "application/json" });
+    const res = await proxyAwareFetch("https://api.cline.bot/api/v1/users/me", {
+      method: "GET",
+      headers,
+    }, proxyOptions);
+
+    if (res.status === 401 || res.status === 403) {
+      return { message: "Cline authentication expired. Please re-authorize." };
+    }
+    if (!res.ok) {
+      return { message: `Cline user API error (${res.status})` };
+    }
+
+    const data = await res.json().catch(() => null);
+    if (!data || typeof data !== "object") {
+      return { message: "Cline user response was not JSON." };
+    }
+
+    // Cline wraps payload in { data: {...} } sometimes
+    const user = data.data && typeof data.data === "object" ? data.data : data;
+    const email = user.email || user.user?.email || null;
+    const plan =
+      user.plan ||
+      user.subscription?.plan ||
+      user.subscription?.name ||
+      user.organization?.plan ||
+      user.organizations?.[0]?.plan ||
+      (provider === "clinepass" ? "ClinePass" : "Cline") ;
+
+    const fields = digCreditFields(user) || [];
+    const quota = buildQuotaFromCreditFields(fields);
+    const quotas = {};
+    if (quota) quotas.Credits = quota;
+
+    // Organization seats / orgs count as informational quota rows when no credits
+    const orgs = user.organizations || user.organization;
+    if (!Object.keys(quotas).length && orgs) {
+      quotas.Account = {
+        used: 0,
+        total: 0,
+        remainingPercentage: 100,
+        resetAt: null,
+        unlimited: true,
+      };
+    }
+
+    if (!Object.keys(quotas).length) {
+      return {
+        plan: typeof plan === "string" ? plan : "Cline",
+        email,
+        message: "Cline connected. No credit allotment was returned by the account API.",
+        quotas: {},
+      };
+    }
+
+    return {
+      plan: typeof plan === "string" ? plan : "Cline",
+      email,
+      quotas,
+    };
+  } catch (error) {
+    return { message: `Cline usage error: ${error.message}` };
+  }
+}
+
+// ─── Kimchi ─────────────────────────────────────────────────────────────────
+
+export async function getKimchiUsage(accessToken, providerSpecificData = null, proxyOptions = null) {
+  if (!accessToken) return { message: "Kimchi access token not available." };
+  try {
+    const url = "https://app.kimchi.dev/api/v1/me";
+    const res = await proxyAwareFetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "User-Agent": "kimchi/0.1.50",
+      },
+    }, proxyOptions);
+
+    if (res.status === 401 || res.status === 403) {
+      return { message: "Kimchi authentication expired. Please re-authorize." };
+    }
+    if (!res.ok) {
+      return { message: `Kimchi user API error (${res.status})` };
+    }
+
+    const user = await res.json().catch(() => null);
+    if (!user || typeof user !== "object") {
+      return { message: "Kimchi user response was not JSON." };
+    }
+
+    const email = user.email || providerSpecificData?.username || null;
+    const plan = user.plan || user.tier || user.subscription?.name || "Kimchi";
+    const fields = digCreditFields(user) || [];
+    const quota = buildQuotaFromCreditFields(fields);
+    const quotas = {};
+    if (quota) quotas.Credits = quota;
+    else {
+      quotas.Account = {
+        used: 0,
+        total: 0,
+        remainingPercentage: 100,
+        resetAt: null,
+        unlimited: true,
+      };
+    }
+
+    return {
+      plan: typeof plan === "string" ? plan : "Kimchi",
+      email,
+      quotas,
+    };
+  } catch (error) {
+    return { message: `Kimchi usage error: ${error.message}` };
+  }
+}
+
+// ─── xAI (API key or OAuth → api.x.ai) ──────────────────────────────────────
+
+export async function getXaiUsage(token, providerSpecificData = null, proxyOptions = null) {
+  if (!token) return { message: "xAI token not available." };
+  try {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+    };
+
+    // Prefer management-style key probe when available; fall back to models list.
+    const probes = [
+      "https://api.x.ai/v1/api-key",
+      "https://api.x.ai/v1/models",
+    ];
+
+    let lastStatus = 0;
+    let body = null;
+    let okUrl = null;
+    for (const url of probes) {
+      const res = await proxyAwareFetch(url, { method: "GET", headers }, proxyOptions);
+      lastStatus = res.status;
+      if (res.status === 401 || res.status === 403) {
+        return { message: "xAI authentication expired. Please re-authorize or update the API key." };
+      }
+      if (res.ok) {
+        body = await res.json().catch(() => null);
+        okUrl = url;
+        break;
+      }
+    }
+
+    if (!body) {
+      return { message: `xAI API error (${lastStatus || "unknown"})` };
+    }
+
+    const fields = digCreditFields(body) || [];
+    const quota = buildQuotaFromCreditFields(fields);
+    const quotas = {};
+    if (quota) {
+      quotas.Credits = quota;
+    } else {
+      // Connected / healthy without numeric allotment
+      const modelCount = Array.isArray(body?.data) ? body.data.length : 0;
+      quotas.API = {
+        used: 0,
+        total: 0,
+        remainingPercentage: 100,
+        resetAt: null,
+        unlimited: true,
+      };
+      if (modelCount > 0) {
+        // informational only via plan string
+      }
+    }
+
+    const email = providerSpecificData?.email || null;
+    const plan =
+      body.name ||
+      body.api_key_name ||
+      body.team?.name ||
+      (okUrl?.includes("api-key") ? "xAI API Key" : "xAI");
+
+    return {
+      plan: typeof plan === "string" ? plan : "xAI",
+      email,
+      quotas,
+    };
+  } catch (error) {
+    return { message: `xAI usage error: ${error.message}` };
+  }
+}
+
+// ─── Cursor (session token — no public quota API) ───────────────────────────
+
+export async function getCursorUsage(accessToken, providerSpecificData = null) {
+  if (!accessToken) return { message: "Cursor access token not available." };
+
+  // Cursor uses a long-lived session JWT; there is no stable public quota endpoint.
+  // Surface connection health + any plan hints from stored providerSpecificData / JWT claims.
+  let plan = providerSpecificData?.plan || providerSpecificData?.membershipType || "Cursor";
+  let email = providerSpecificData?.email || null;
+
+  try {
+    const parts = String(accessToken).split(".");
+    if (parts.length === 3) {
+      const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+      const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
+      const payload = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+      email = email || payload.email || payload.preferred_username || null;
+      plan =
+        payload.plan ||
+        payload.subscription ||
+        payload.membershipType ||
+        payload.tier ||
+        plan;
+    }
+  } catch {
+    /* ignore JWT decode errors */
+  }
+
+  return {
+    plan: typeof plan === "string" ? plan : "Cursor",
+    email,
+    quotas: {
+      Session: {
+        used: 0,
+        total: 0,
+        remainingPercentage: 100,
+        resetAt: null,
+        unlimited: true,
+      },
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.43",
+  "version": "1.0.46",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"
@@ -68,10 +68,12 @@
   "optionalDependencies": {
     "better-sqlite3": "^12.6.2",
     "camoufox-js": "^0.11.0",
+    "cloakbrowser": "^0.3.32",
     "playwright": "^1.54.2"
   },
   "comment_better_sqlite3": "kept in optionalDependencies so npm install doesn't fail on systems without build tools — sql.js is used as fallback at runtime",
   "comment_camoufox_js": "optional stealth-Firefox engine for bulk-import; runtime auto-installs to user data dir if user picks Camoufox in the modal but the package is missing — Chromium remains the default and works without this dep",
+  "comment_cloakbrowser": "optional stealth Chromium for xAI Turnstile (Grok tempmail bulk); lazy-installed via cloakbrowserRuntime when user selects CloakBrowser engine",
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",
     "esbuild": "^0.28.1",

package/src/app/(dashboard)/dashboard/automation/page.js

@@ -596,6 +596,65 @@ function AutoClawAutomationPanel({ onRefresh }) {
   );
 }
 
+function GrokCliAutomationPanel({ providerInfo, onRefresh }) {
+  const [isBulkOpen, setIsBulkOpen] = useState(false);
+  const [isOAuthOpen, setIsOAuthOpen] = useState(false);
+
+  return (
+    <>
+      <div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
+        <button
+          type="button"
+          onClick={() => setIsBulkOpen(true)}
+          className="flex min-h-[112px] min-w-0 flex-col gap-2 rounded-lg border border-border bg-surface px-4 py-3 text-left transition-colors hover:border-primary/40 hover:bg-primary/5"
+        >
+          <span className="flex items-center gap-2 text-sm font-semibold text-text-main">
+            <span className="material-symbols-outlined text-[20px] text-primary">group_add</span>
+            Bulk Register / Login
+          </span>
+          <span className="text-xs leading-relaxed text-text-muted">
+            Tempmail (@zevai.web.id) + CloakBrowser (Turnstile) → xAI email signup → Grok CLI device token.
+            Paste <code className="text-[11px]">auto</code> / <code className="text-[11px]">auto:5</code> or existing <code className="text-[11px]">email:password</code>.
+          </span>
+        </button>
+        <button
+          type="button"
+          onClick={() => setIsOAuthOpen(true)}
+          className="flex min-h-[112px] min-w-0 flex-col gap-2 rounded-lg border border-border bg-surface px-4 py-3 text-left transition-colors hover:border-primary/40 hover:bg-primary/5"
+        >
+          <span className="flex items-center gap-2 text-sm font-semibold text-text-main">
+            <span className="material-symbols-outlined text-[20px] text-primary">login</span>
+            Device OAuth Login
+          </span>
+          <span className="text-xs leading-relaxed text-text-muted">
+            Open xAI device login in browser and poll until the Grok CLI token is saved.
+          </span>
+        </button>
+      </div>
+      <BulkAccountAutomationModal
+        isOpen={isBulkOpen}
+        provider="grok-cli"
+        title="Grok CLI Bulk (Tempmail + CloakBrowser)"
+        serviceName="Grok CLI"
+        defaultEngine="cloakbrowser"
+        accountsPlaceholder={"auto\nauto:3\n# or existing:\n# user@zevai.web.id:password"}
+        onSuccess={onRefresh}
+        onClose={() => setIsBulkOpen(false)}
+      />
+      <OAuthModal
+        isOpen={isOAuthOpen}
+        provider="grok-cli"
+        providerInfo={providerInfo}
+        onSuccess={() => {
+          onRefresh?.();
+          setIsOAuthOpen(false);
+        }}
+        onClose={() => setIsOAuthOpen(false)}
+      />
+    </>
+  );
+}
+
 const AUTOMATION_PROVIDERS = [
   {
     id: "kiro",
@@ -645,6 +704,14 @@ const AUTOMATION_PROVIDERS = [
     supportedModes: ["bulk-account"],
     component: AutoClawAutomationPanel,
   },
+  {
+    id: "grok-cli",
+    label: "Grok CLI",
+    icon: "auto_awesome",
+    description: "Bulk tempmail + CloakBrowser signup/login for Grok Build (Turnstile-capable).",
+    supportedModes: ["bulk-account", "device-oauth"],
+    component: GrokCliAutomationPanel,
+  },
 ];
 
 export default function AutomationPage() {

package/src/app/api/oauth/grok-cli/bulk-import/[jobId]/cancel/route.js

@@ -0,0 +1,19 @@
+import { NextResponse } from "next/server";
+import { getGrokCliBulkImportManager } from "@/lib/oauth/services/grokCliBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const { jobId } = await params;
+  const manager = getGrokCliBulkImportManager();
+  const job = manager.cancelJob(jobId);
+
+  if (!job) {
+    return NextResponse.json({ error: "Bulk import job not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    success: true,
+    job,
+  });
+}

package/src/app/api/oauth/grok-cli/bulk-import/[jobId]/manual/[workerId]/route.js

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { getGrokCliBulkImportManager } from "@/lib/oauth/services/grokCliBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const { jobId, workerId } = await params;
+  const manager = getGrokCliBulkImportManager();
+  const result = await manager.openManualSession(jobId, workerId);
+
+  if (!result) {
+    return NextResponse.json({ error: "Bulk import job not found" }, { status: 404 });
+  }
+
+  if (!result.ok) {
+    return NextResponse.json(
+      {
+        error: result.error || "Manual session not found for this worker",
+        job: result.job,
+      },
+      { status: 404 }
+    );
+  }
+
+  return NextResponse.json({
+    success: true,
+    job: result.job,
+    account: result.account,
+  });
+}

package/src/app/api/oauth/grok-cli/bulk-import/[jobId]/route.js

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { getGrokCliBulkImportManager, buildLookupResponse } from "@/lib/oauth/services/grokCliBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(_request, { params }) {
+  const { jobId } = await params;
+  const manager = getGrokCliBulkImportManager();
+
+  const job = await manager.getJobWithPreview(jobId);
+
+  if (!job) {
+    return NextResponse.json({
+      success: true,
+      ...buildLookupResponse(null, { stale: true }),
+    });
+  }
+
+  return NextResponse.json({
+    success: true,
+    ...buildLookupResponse(job),
+  });
+}

package/src/app/api/oauth/grok-cli/bulk-import/latest/route.js

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { getGrokCliBulkImportManager, buildLookupResponse } from "@/lib/oauth/services/grokCliBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  const manager = getGrokCliBulkImportManager();
+  const searchParams = new URL(request.url).searchParams;
+  const scope = searchParams.get("scope");
+  const includeRecentTerminal = scope === "recent" || scope === "recoverable" || scope === "all";
+  const job = await manager.getLatestJobWithPreview({ includeRecentTerminal });
+
+  if (!job) {
+    return NextResponse.json({
+      success: true,
+      ...buildLookupResponse(null),
+    });
+  }
+
+  return NextResponse.json({
+    success: true,
+    ...buildLookupResponse(job),
+  });
+}

package/src/app/api/oauth/grok-cli/bulk-import/route.js

@@ -0,0 +1,39 @@
+import { NextResponse } from "next/server";
+import { getGrokCliBulkImportManager } from "@/lib/oauth/services/grokCliBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const accounts = Array.isArray(body?.accounts) ? body.accounts : [];
+
+    if (!accounts.length) {
+      return NextResponse.json(
+        { error: "At least one account entry is required (e.g. auto, auto:3, or email:password)" },
+        { status: 400 }
+      );
+    }
+
+    const manager = getGrokCliBulkImportManager();
+    const job = await manager.startJob({
+      accounts,
+      concurrency: body?.concurrency ?? 1,
+      engine: body?.engine || "cloakbrowser",
+    });
+
+    return NextResponse.json({
+      success: true,
+      job,
+    });
+  } catch (error) {
+    const status = Array.isArray(error?.invalidLines) ? 400 : 500;
+    return NextResponse.json(
+      {
+        error: error?.error || error?.message || "Failed to start Grok CLI bulk import",
+        ...(Array.isArray(error?.invalidLines) ? { invalidLines: error.invalidLines } : {}),
+      },
+      { status }
+    );
+  }
+}