zevairouter 1.0.14 → 1.0.16

package/open-sse/services/usage.js

@@ -115,6 +115,8 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
       return await getCodeBuddyUsage(accessToken, providerSpecificData, proxyOptions, apiKey, provider);
     case "qoder":
       return await getQoderUsage(accessToken, proxyOptions);
+    case "autoclaw":
+      return await getAutoclawUsage(accessToken, proxyOptions);
     case "qwen":
       return await getQwenUsage(accessToken, providerSpecificData);
     case "iflow":
@@ -1690,3 +1692,41 @@ async function getQoderUsage(accessToken, proxyOptions = null) {
     return { message: `Qoder connected. Unable to fetch usage: ${error.message}` };
   }
 }
+
+async function getAutoclawUsage(accessToken, proxyOptions = null) {
+  if (!accessToken) {
+    return { message: "AutoClaw usage unavailable: no access token" };
+  }
+  try {
+    const { AUTOCLAW_WALLET_ENDPOINT, buildAutoClawAuthHeaders } = await import("../../src/lib/autoclaw/constants.js");
+    const response = await proxyAwareFetch(
+      AUTOCLAW_WALLET_ENDPOINT,
+      { method: "GET", headers: buildAutoClawAuthHeaders({ authorization: accessToken }) },
+      proxyOptions,
+    );
+    if (!response.ok) {
+      return { message: `AutoClaw connected. Usage fetch returned ${response.status}.` };
+    }
+    const body = await response.json().catch(() => null);
+    if (!body || body.code !== 0) {
+      return { message: "AutoClaw connected. Unable to read balance." };
+    }
+    const total = Number(body.data?.total_balance);
+    const remaining = Number.isFinite(total) ? total : 0;
+    return {
+      quotas: {
+        points: {
+          total: remaining,
+          used: 0,
+          remaining,
+          unit: "points",
+          resetAt: null,
+        },
+      },
+      totalUsagePercentage: 0,
+      isQuotaExceeded: remaining <= 0,
+    };
+  } catch (error) {
+    return { message: `AutoClaw connected. Unable to fetch balance: ${error.message}` };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"

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

@@ -396,6 +396,38 @@ function AntigravityAutomationPanel({ providerInfo, onRefresh }) {
   );
 }
 
+function AutoClawAutomationPanel({ onRefresh }) {
+  const [isBulkOpen, setIsBulkOpen] = 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>
+            Auto Register Bulk
+          </span>
+          <span className="text-xs leading-relaxed text-text-muted">
+            Run bulk gmail:password or gmail|password automation via Google OAuth to register AutoClaw accounts (GLM-5.2, GLM-5-Turbo, DeepSeek-V4). Each new account gets bonus points.
+          </span>
+        </button>
+      </div>
+      <BulkAccountAutomationModal
+        isOpen={isBulkOpen}
+        provider="autoclaw"
+        title="AutoClaw Bulk GSuite Auto Register"
+        serviceName="AutoClaw"
+        onSuccess={onRefresh}
+        onClose={() => setIsBulkOpen(false)}
+      />
+    </>
+  );
+}
+
 const AUTOMATION_PROVIDERS = [
   {
     id: "kiro",
@@ -429,6 +461,14 @@ const AUTOMATION_PROVIDERS = [
     supportedModes: ["bulk-account", "oauth"],
     component: AntigravityAutomationPanel,
   },
+  {
+    id: "autoclaw",
+    label: "AutoClaw",
+    icon: "bolt",
+    description: "Bulk auto-register via Google OAuth. OpenAI-compatible GLM/DeepSeek proxy.",
+    supportedModes: ["bulk-account"],
+    component: AutoClawAutomationPanel,
+  },
 ];
 
 export default function AutomationPage() {

package/src/app/(dashboard)/dashboard/usage/components/ProviderTopology.js

@@ -77,7 +77,7 @@ ProviderNode.propTypes = {
   data: PropTypes.object.isRequired,
 };
 
-// Center 9Router node
+// Center ZevaiRouter node
 function RouterNode({ data }) {
   return (
     <div className="flex items-center justify-center px-5 py-3 rounded-xl border-2 border-primary bg-primary/5 shadow-md min-w-[130px]">
@@ -86,8 +86,8 @@ function RouterNode({ data }) {
       <Handle type="source" position={Position.Left} id="left" className="!bg-transparent !border-0 !w-0 !h-0" />
       <Handle type="source" position={Position.Right} id="right" className="!bg-transparent !border-0 !w-0 !h-0" />
 
-      <img src="/favicon.svg" alt="9Router" className="w-6 h-6 mr-2" />
-      <span className="text-sm font-bold text-primary">9Router</span>
+      <img src="/favicon.svg" alt="ZevaiRouter" className="w-6 h-6 mr-2" />
+      <span className="text-sm font-bold text-primary">ZevaiRouter</span>
       {data.activeCount > 0 && (
         <span className="ml-2 px-1.5 py-0.5 rounded-full bg-primary text-white text-xs font-bold">
           {data.activeCount}

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

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

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { getAutoclawBulkImportManager } from "@/lib/oauth/services/autoclawBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const { jobId, workerId } = await params;
+  const manager = getAutoclawBulkImportManager();
+  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/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,
+};