zevairouter 1.0.15 → 1.0.16

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

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { getAutoclawBulkImportManager, buildLookupResponse } from "@/lib/oauth/services/autoclawBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(_request, { params }) {
+  const { jobId } = await params;
+  const manager = getAutoclawBulkImportManager();
+
+  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/autoclaw/bulk-import/latest/route.js

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { getAutoclawBulkImportManager, buildLookupResponse } from "@/lib/oauth/services/autoclawBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  const manager = getAutoclawBulkImportManager();
+  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/autoclaw/bulk-import/route.js

@@ -0,0 +1,52 @@
+import { NextResponse } from "next/server";
+import { getAutoclawBulkImportManager, parseKiroBulkAccounts } from "@/lib/oauth/services/autoclawBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const accounts = Array.isArray(body?.accounts) ? body.accounts : [];
+    const { parsed, invalidLines } = parseKiroBulkAccounts(accounts);
+
+    if (!parsed.length) {
+      return NextResponse.json(
+        { error: "At least one account entry is required" },
+        { status: 400 }
+      );
+    }
+
+    if (invalidLines.length > 0) {
+      return NextResponse.json(
+        {
+          error: "Invalid account format. Use one account per line: email@gmail.com:password or email@gmail.com|password",
+          invalidLines,
+        },
+        { status: 400 }
+      );
+    }
+
+    const manager = getAutoclawBulkImportManager();
+    const job = await manager.startJob({
+      accounts,
+      concurrency: body?.concurrency,
+      engine: body?.engine,
+      proxyPoolMode: body?.proxyPoolMode,
+      proxyPoolId: body?.proxyPoolId,
+    });
+
+    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 AutoClaw bulk import",
+        ...(Array.isArray(error?.invalidLines) ? { invalidLines: error.invalidLines } : {}),
+      },
+      { status }
+    );
+  }
+}

package/src/lib/autoclaw/constants.js

@@ -0,0 +1,54 @@
+import { createHash } from "crypto";
+import { randomUUID } from "crypto";
+
+// AutoClaw (autoclaw.z.ai by Z.ai / Zhipu AI) constants. These mirror the
+// public web app's client credentials — APP_KEY is embedded in the browser
+// bundle, so it is not a secret we own, but we keep it in one place so the
+// executor, bulk-import manager, and balance fetcher all sign the same way.
+export const AUTOCLAW_APP_ID = "100003";
+export const AUTOCLAW_APP_KEY = "38d2391985e2369a5fb8227d8e6cd5e5";
+export const AUTOCLAW_BASE_URL = "https://autoglm-api.autoglm.ai";
+export const AUTOCLAW_PROXY_URL = `${AUTOCLAW_BASE_URL}/autoclaw-proxy/proxy/autoclaw`;
+export const AUTOCLAW_OAUTH_URL_ENDPOINT = `${AUTOCLAW_BASE_URL}/userapi/overseasv1/google-oauth-url`;
+export const AUTOCLAW_REDIRECT_URI = `${AUTOCLAW_BASE_URL}/userapi/oauth/google/callback`;
+export const AUTOCLAW_REFRESH_ENDPOINT = `${AUTOCLAW_BASE_URL}/userapi/v1/refresh`;
+export const AUTOCLAW_WALLET_ENDPOINT = `${AUTOCLAW_BASE_URL}/agent-assetmgr/api/v2/wallets?biz_app_id=autoclaw`;
+export const AUTOCLAW_VERSION = "1.10.0";
+
+// AutoClaw selects the model via the X-Request-Model header, not the body's
+// `model` field (which is a dummy). id = X-Request-Model value.
+export const AUTOCLAW_MODELS = [
+  { id: "openrouter_glm-5.2", name: "GLM-5.2" },
+  { id: "zai_glm-5-turbo", name: "GLM-5-Turbo" },
+  { id: "zai_auto", name: "DeepSeek-V4-Pro (Auto)" },
+];
+
+// x-auth-sign = md5(f"{APP_ID}&{timestamp}&{APP_KEY}")
+export function generateAutoClawSign(timestamp) {
+  const raw = `${AUTOCLAW_APP_ID}&${timestamp}&${AUTOCLAW_APP_KEY}`;
+  return createHash("md5").update(raw).digest("hex");
+}
+
+// Base signed headers shared by the OAuth-url, wallet, and chat calls.
+export function buildAutoClawAuthHeaders(extra = {}) {
+  const ts = String(Math.floor(Date.now() / 1000));
+  return {
+    accept: "*/*",
+    "content-type": "application/json",
+    origin: "https://autoclaw.z.ai",
+    referer: "https://autoclaw.z.ai/",
+    "user-agent":
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
+    "x-auth-appid": AUTOCLAW_APP_ID,
+    "x-auth-timestamp": ts,
+    "x-auth-sign": generateAutoClawSign(ts),
+    "x-product": "autoclaw",
+    "x-version": AUTOCLAW_VERSION,
+    "x-tm": "web",
+    "x-channel": "official",
+    "x-client-type": "web",
+    "x-trace-id": randomUUID(),
+    "x-lang": "zh-CN",
+    ...extra,
+  };
+}

package/src/lib/oauth/services/autoclawBulkImportManager.js

@@ -0,0 +1,321 @@
+import { randomUUID } from "crypto";
+import {
+  KiroBulkImportManager,
+  buildLookupResponse,
+  createFreshContext,
+  parseKiroBulkAccounts,
+  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
+  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
+  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
+} from "./kiroBulkImportManager.js";
+import { runGoogleAccountAutomation } from "./kiroGoogleAutomation.js";
+import {
+  createAutoClawTokenMonitor,
+  readAutoClawTokensFromStorage,
+} from "./autoclawTokenMonitor.js";
+import { proxyAwareFetch } from "../../../../open-sse/utils/proxyFetch.js";
+import {
+  AUTOCLAW_OAUTH_URL_ENDPOINT,
+  AUTOCLAW_REDIRECT_URI,
+  AUTOCLAW_WALLET_ENDPOINT,
+  buildAutoClawAuthHeaders,
+} from "../../autoclaw/constants.js";
+
+const AUTOCLAW_PROVIDER_ID = "autoclaw";
+const AUTOCLAW_LABEL = "AutoClaw";
+const AUTOCLAW_TOKEN_TIMEOUT_MS = 3 * 60_000;
+
+function proxyOptionsFor(account) {
+  if (!account?.proxyUrl) return null;
+  return { enabled: true, url: account.proxyUrl };
+}
+
+// Ask AutoClaw's API to mint the Google OAuth URL for this device.
+async function fetchAutoClawOAuthUrl(deviceId, proxyOptions) {
+  const response = await proxyAwareFetch(
+    AUTOCLAW_OAUTH_URL_ENDPOINT,
+    {
+      method: "POST",
+      headers: buildAutoClawAuthHeaders(),
+      body: JSON.stringify({
+        device_id: deviceId,
+        source_id: "web",
+        navigate_uri: AUTOCLAW_REDIRECT_URI,
+        client_type: "web",
+      }),
+    },
+    proxyOptions,
+  );
+  if (!response.ok) {
+    throw new Error(`AutoClaw oauth-url request failed (HTTP ${response.status})`);
+  }
+  const data = await response.json();
+  if (data?.code !== 0 || !data?.data?.oauth_url) {
+    throw new Error(`AutoClaw oauth-url response invalid: ${JSON.stringify(data).slice(0, 200)}`);
+  }
+  return { oauthUrl: data.data.oauth_url, state: data.data.state || "" };
+}
+
+async function fetchAutoClawBalance(accessToken, proxyOptions) {
+  try {
+    const response = await proxyAwareFetch(
+      AUTOCLAW_WALLET_ENDPOINT,
+      { method: "GET", headers: buildAutoClawAuthHeaders({ authorization: accessToken }) },
+      proxyOptions,
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (data?.code === 0) {
+      return data.data?.total_balance ?? null;
+    }
+  } catch {
+    /* balance is best-effort */
+  }
+  return null;
+}
+
+async function defaultSaveAutoClawConnection({ tokens, email, deviceId, balance }) {
+  const { createProviderConnection } = await import("../../../models/index.js");
+  const providerSpecificData = {
+    authMethod: "oauth",
+    deviceId: deviceId || "",
+    loginEmail: email,
+    balance: balance ?? null,
+    automation: "gsuite-bulk",
+  };
+
+  const connectionData = {
+    provider: AUTOCLAW_PROVIDER_ID,
+    authType: "oauth",
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken || "",
+    email,
+    displayName: email.split("@")[0],
+    providerSpecificData,
+    // AutoClaw access tokens expire in ~24h.
+    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+    testStatus: "active",
+  };
+
+  const connection = await createProviderConnection(connectionData);
+  return { connection };
+}
+
+async function defaultBrowserLauncher(job) {
+  const { launchBulkImportBrowser } = await import("./bulkImportBrowserEngine.js");
+  return launchBulkImportBrowser({ engine: job?.engine || "chromium" });
+}
+
+class AutoClawBulkImportManager extends KiroBulkImportManager {
+  constructor({
+    saveConnection = defaultSaveAutoClawConnection,
+    browserLauncher = defaultBrowserLauncher,
+    storageName = "autoclaw-bulk-import",
+  } = {}) {
+    super({ browserLauncher, storageName });
+    this.saveConnection = saveConnection;
+  }
+
+  async processAccount(job, account, workerId) {
+    if (job.cancelRequested || !job.browser) {
+      this.finalizeAccount(account, "cancelled", { error: "Job cancelled" });
+      return;
+    }
+
+    const { context, page } = await createFreshContext(job.browser, account.proxyUrl);
+    account.runtimeSession = { context, page };
+
+    const deviceId = randomUUID();
+    const proxyOptions = proxyOptionsFor(account);
+
+    let oauthUrl;
+    try {
+      this.setAccountStep(account, "preparing_worker", `Worker ${workerId} requesting AutoClaw OAuth URL`);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+      ({ oauthUrl } = await fetchAutoClawOAuthUrl(deviceId, proxyOptions));
+    } catch (error) {
+      this.finalizeAccount(account, "failed", {
+        error: `Failed to get AutoClaw OAuth URL: ${error.message}`,
+        step: "failed",
+        message: error.message,
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+      return;
+    }
+
+    const tokenPromise = createAutoClawTokenMonitor(context, page, {
+      timeoutMs: AUTOCLAW_TOKEN_TIMEOUT_MS,
+    });
+
+    try {
+      const automationResult = await runGoogleAccountAutomation({
+        page,
+        authUrl: oauthUrl,
+        email: account.email,
+        password: account.password,
+        successPromise: tokenPromise,
+        shortTimeoutMs: AUTOCLAW_TOKEN_TIMEOUT_MS,
+        serviceLabel: AUTOCLAW_LABEL,
+        openingStep: "opening_autoclaw_login",
+        openingMessage: "Opening AutoClaw Google OAuth page",
+        successStep: "autoclaw_tokens_received",
+        successMessage: "AutoClaw tokens intercepted",
+        onStep: (step, message) => {
+          this.setAccountStep(account, step, message);
+          void this.persistJobSnapshot(job, { forcePreview: false });
+        },
+      });
+
+      if (automationResult.status === "success") {
+        const tokens = {
+          accessToken: automationResult.accessToken,
+          refreshToken: automationResult.refreshToken || "",
+        };
+        if (!tokens.accessToken) {
+          throw new Error("AutoClaw automation succeeded but no access token captured");
+        }
+        await this.finishSuccess(job, account, tokens, deviceId, proxyOptions);
+        account.runtimeSession = null;
+        await context.close().catch(() => null);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        return;
+      }
+
+      if (automationResult.status === "needs_manual") {
+        account.manualSession = { context, page, opened: false, openedAt: null };
+        this.setAccountStep(account, "awaiting_manual", "Waiting for manual completion");
+        this.finalizeAccount(account, "needs_manual", {
+          error: automationResult.error,
+          step: "awaiting_manual",
+          message: automationResult.error,
+        });
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        await this.runAutoClawManualFollowup(job, account, context, page, tokenPromise, deviceId, proxyOptions);
+        return;
+      }
+
+      const terminalStatus = automationResult.status?.startsWith("failed") ? automationResult.status : "failed";
+      this.finalizeAccount(account, terminalStatus, {
+        error: automationResult.error || "AutoClaw Google automation failed.",
+        step: terminalStatus,
+        message: automationResult.error || "AutoClaw Google automation failed.",
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    } catch (error) {
+      this.finalizeAccount(account, "failed", {
+        error: error.message || "Unexpected AutoClaw bulk import failure.",
+        step: "failed",
+        message: error.message || "Unexpected AutoClaw bulk import failure.",
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    }
+  }
+
+  async finishSuccess(job, account, tokens, deviceId, proxyOptions) {
+    this.setAccountStep(account, "fetching_balance", "Fetching AutoClaw balance");
+    await this.persistJobSnapshot(job, { forcePreview: true });
+    const balance = await fetchAutoClawBalance(tokens.accessToken, proxyOptions);
+
+    this.setAccountStep(account, "saving_connection", "Saving AutoClaw connection to database");
+    await this.persistJobSnapshot(job, { forcePreview: true });
+    const { connection } = await this.saveConnection({
+      tokens,
+      email: account.email,
+      deviceId,
+      balance,
+    });
+
+    const balanceLabel = balance != null ? ` (${balance} pts)` : "";
+    this.finalizeAccount(account, "success", {
+      connectionId: connection.id,
+      step: "connection_saved",
+      message: `AutoClaw connection saved successfully${balanceLabel}`,
+    });
+  }
+
+  async runAutoClawManualFollowup(job, account, context, page, tokenPromise, deviceId, proxyOptions) {
+    const followupPromise = (async () => {
+      const closeManualResources = async () => {
+        const ms = account.manualSession;
+        const ctx = ms?.context || context;
+        const headed = ms?.headedBrowser || null;
+        if (ctx) await ctx.close().catch(() => null);
+        if (headed) await headed.close().catch(() => null);
+      };
+      try {
+        let tokens = null;
+        try {
+          tokens = await tokenPromise;
+        } catch {
+          // Monitor timed out — try the localStorage fallback before giving up.
+          tokens = await readAutoClawTokensFromStorage(account.manualSession?.page || page);
+        }
+        if (job.cancelRequested) {
+          this.finalizeAccount(account, "cancelled", {
+            error: "Job cancelled",
+            step: "cancelled",
+            message: "Job cancelled while waiting for manual completion",
+          });
+          await this.persistJobSnapshot(job, { forcePreview: true });
+          return;
+        }
+        if (!tokens?.accessToken) {
+          throw new Error("Manual flow finished but no AutoClaw token captured");
+        }
+        await this.finishSuccess(job, account, tokens, deviceId, proxyOptions);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      } catch (error) {
+        if (job.cancelRequested) {
+          this.finalizeAccount(account, "cancelled", {
+            error: "Job cancelled",
+            step: "cancelled",
+            message: "Job cancelled while waiting for manual completion",
+          });
+        } else {
+          this.finalizeAccount(account, "failed", {
+            error: error.message || "Manual assist flow failed.",
+            step: "failed",
+            message: error.message || "Manual assist flow failed.",
+          });
+        }
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      } finally {
+        await closeManualResources();
+        account.manualSession = null;
+        account.runtimeSession = null;
+        job.manualFollowups.delete(followupPromise);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      }
+    })();
+
+    job.manualFollowups.add(followupPromise);
+  }
+}
+
+function getSingletonStore() {
+  if (!globalThis.__autoclawBulkImportSingleton) {
+    globalThis.__autoclawBulkImportSingleton = {
+      manager: new AutoClawBulkImportManager(),
+    };
+  }
+  return globalThis.__autoclawBulkImportSingleton;
+}
+
+export function getAutoclawBulkImportManager() {
+  return getSingletonStore().manager;
+}
+
+export {
+  AutoClawBulkImportManager,
+  buildLookupResponse,
+  parseKiroBulkAccounts,
+  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
+  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
+  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
+};

package/src/lib/oauth/services/autoclawTokenMonitor.js

@@ -0,0 +1,144 @@
+// AutoClaw captures its OWN access/refresh tokens from a network RESPONSE body
+// after Google login (unlike the antigravity flow which reads a ?code= from a
+// redirect URL). This monitor hooks page.on("response") across the context and
+// every popup page, resolving { accessToken, refreshToken } as soon as a
+// matching AutoClaw auth response arrives. Structure mirrors
+// createGenericCallbackMonitor in kiroGoogleAutomation.js (multi-page bind +
+// cleanup + timeout).
+
+const DEFAULT_TOKEN_TIMEOUT_MS = 3 * 60_000;
+
+// Response URLs that carry AutoClaw's tokens.
+const TOKEN_URL_MARKERS = [
+  "/userapi/overseasv1/google-oauth-login",
+  "/userapi/v1/refresh",
+  "/userapi/overseasv1/refresh",
+];
+
+function urlLooksLikeTokenResponse(url) {
+  if (!url) return false;
+  return TOKEN_URL_MARKERS.some((marker) => url.includes(marker));
+}
+
+function extractTokens(body) {
+  if (!body || typeof body !== "object") return null;
+  // AutoClaw wraps success as { code: 0, data: { access_token, refresh_token } }
+  const data = body.data && typeof body.data === "object" ? body.data : body;
+  const accessToken = data.access_token || data.accessToken;
+  if (!accessToken) return null;
+  return {
+    accessToken,
+    refreshToken: data.refresh_token || data.refreshToken || "",
+  };
+}
+
+export function createAutoClawTokenMonitor(context, page, { timeoutMs = DEFAULT_TOKEN_TIMEOUT_MS } = {}) {
+  let resolveOuter;
+  let rejectOuter;
+  const promise = new Promise((resolve, reject) => {
+    resolveOuter = resolve;
+    rejectOuter = reject;
+  });
+
+  let settled = false;
+  const trackedPages = new Set();
+  const contextCleanups = new Map();
+  const timeoutHandle = setTimeout(() => {
+    settle(null, new Error("Timed out waiting for AutoClaw tokens"));
+  }, timeoutMs);
+
+  function settle(result, error = null) {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeoutHandle);
+    for (const fns of contextCleanups.values()) {
+      for (const fn of fns) {
+        try { fn(); } catch {}
+      }
+    }
+    contextCleanups.clear();
+    if (error) rejectOuter(error);
+    else resolveOuter(result);
+  }
+
+  async function inspectResponse(response) {
+    if (settled || !response) return;
+    let url = "";
+    try { url = response.url() || ""; } catch { return; }
+    if (!urlLooksLikeTokenResponse(url)) return;
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      return;
+    }
+    const tokens = extractTokens(body);
+    if (tokens) settle(tokens);
+  }
+
+  function registerPage(trackedPage, ownerCleanups) {
+    if (!trackedPage || trackedPages.has(trackedPage)) return;
+    trackedPages.add(trackedPage);
+
+    const onResponse = (response) => { void inspectResponse(response); };
+    trackedPage.on("response", onResponse);
+    ownerCleanups.push(() => {
+      trackedPage.off("response", onResponse);
+    });
+  }
+
+  function bind(ctx, pg) {
+    if (settled) return;
+    if (contextCleanups.has(ctx)) return;
+    const cleanups = [];
+    contextCleanups.set(ctx, cleanups);
+    const onPage = (newPage) => registerPage(newPage, cleanups);
+    ctx.on("page", onPage);
+    cleanups.push(() => ctx.off("page", onPage));
+    if (pg) registerPage(pg, cleanups);
+  }
+
+  bind(context, page);
+  promise.rebind = ({ context: newContext, page: newPage } = {}) => {
+    if (newContext) bind(newContext, newPage);
+  };
+
+  return promise;
+}
+
+// Fallback: after the page has landed on autoclaw, tokens may only live in
+// localStorage. Scan for JWT-looking values (mirrors the Python reference).
+export async function readAutoClawTokensFromStorage(page) {
+  if (!page) return null;
+  let storage;
+  try {
+    storage = await page.evaluate(() => {
+      const out = {};
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        const val = localStorage.getItem(key);
+        if (val && (val.includes("eyJ") || key.toLowerCase().includes("token"))) {
+          out[key] = val;
+        }
+      }
+      return out;
+    });
+  } catch {
+    return null;
+  }
+  if (!storage) return null;
+
+  let accessToken = "";
+  let refreshToken = "";
+  for (const [key, val] of Object.entries(storage)) {
+    const cleaned = String(val).replace(/^Bearer\s+/i, "");
+    if (!cleaned.startsWith("eyJ")) continue;
+    if (key.toLowerCase().includes("refresh")) {
+      refreshToken = cleaned;
+    } else if (!accessToken) {
+      accessToken = cleaned;
+    }
+  }
+  if (!accessToken) return null;
+  return { accessToken, refreshToken };
+}

package/src/shared/constants/providers.js

@@ -65,6 +65,7 @@ export const OAUTH_PROVIDERS = {
   // "kimi-coding": { id: "kimi-coding", alias: "kmc", name: "Kimi Coding", icon: "psychology", color: "#1E40AF", textIcon: "KC" },
   kilocode: { id: "kilocode", alias: "kc", name: "Kilo Code", icon: "code", color: "#FF6B35", textIcon: "KC", website: "https://kilocode.ai", notice: { signupUrl: "https://kilocode.ai" } },
   cline: { id: "cline", alias: "cl", name: "Cline", icon: "smart_toy", color: "#5B9BD5", textIcon: "CL", website: "https://cline.bot", notice: { signupUrl: "https://cline.bot" } },
+  autoclaw: { id: "autoclaw", alias: "acl", name: "AutoClaw", icon: "bolt", color: "#7C3AED", textIcon: "AC", website: "https://autoclaw.z.ai", notice: { signupUrl: "https://autoclaw.z.ai" } },
   // opencode: { id: "opencode", alias: "oc", name: "OpenCode", icon: "terminal", color: "#E87040", textIcon: "OC" },
 };
 
@@ -280,6 +281,7 @@ export const USAGE_SUPPORTED_PROVIDERS = [
   "glm-cn",
   "minimax",
   "minimax-cn",
+  "autoclaw",
 ];
 
 // Subset that uses apikey auth (still surfaced on quota page)