zevairouter 1.0.153 → 1.0.155

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

@@ -1,340 +0,0 @@
-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 "./googleAutomation.js";
-import { QoderService } from "./qoder.js";
-
-const QODER_PROVIDER_ID = "qoder";
-const QODER_LABEL = "Qoder";
-const QODER_POLL_TIMEOUT_MS = 3 * 60_000;
-const QODER_POLL_INTERVAL_MS = 2_000;
-
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function defaultSaveQoderConnection({ tokens, email }) {
-  const { createProviderConnection } = await import("../../../models/index.js");
-  const providerSpecificData = {
-    authMethod: "device",
-    userId: tokens.userId || "",
-    machineId: tokens.machineId || "",
-    organizationId: tokens.organizationId || "",
-    planTier: tokens.planTier || "",
-    loginEmail: email,
-    automation: "gsuite-bulk",
-  };
-
-  const connectionData = {
-    provider: QODER_PROVIDER_ID,
-    authType: "oauth",
-    accessToken: tokens.accessToken,
-    refreshToken: tokens.refreshToken || "",
-    email,
-    displayName: tokens.displayName || email.split("@")[0],
-    providerSpecificData,
-    expiresAt: tokens.expireTime
-      ? new Date(tokens.expireTime).toISOString()
-      : null,
-    testStatus: "active",
-  };
-
-  const connection = await createProviderConnection(connectionData);
-  return { connection };
-}
-
-async function defaultBrowserLauncher(proxyUrl) {
-  const { launchBulkImportBrowser } = await import("./bulkImportBrowserEngine.js");
-  // CloakBrowser-only, headed by default.
-  return launchBulkImportBrowser({
-    engine: "cloakbrowser",
-    proxyUrl,
-    headless: process.env.ZEVAI_QODER_HEADLESS === "1" || process.env.ZEVAI_QODER_HEADLESS === "true",
-    windowSize: { width: 1280, height: 900 },
-  });
-}
-
-class QoderBulkImportManager extends KiroBulkImportManager {
-  constructor({
-    browserLauncher = defaultBrowserLauncher,
-    saveConnection = defaultSaveQoderConnection,
-    qoderServiceFactory = () => new QoderService(),
-    storageName = "qoder-bulk-import",
-    proxyUrl = null,
-  } = {}) {
-    super({
-      browserLauncher: () => browserLauncher(proxyUrl),
-      googleAutomation: null,
-      socialExchange: null,
-      kiroServiceFactory: qoderServiceFactory,
-      storageName,
-    });
-    this.saveConnection = saveConnection;
-    this.qoderServiceFactory = qoderServiceFactory;
-    this.proxyUrl = proxyUrl;
-  }
-
-  async processAccount(job, account, workerId) {
-    if (job.cancelRequested || !job.browser) {
-      this.finalizeAccount(account, "cancelled", { error: "Job cancelled" });
-      return;
-    }
-
-    const qoderService = this.qoderServiceFactory();
-    const { verificationUriComplete, codeVerifier, nonce, machineId } = qoderService.initiateDeviceFlow();
-
-    const { context, page } = await createFreshContext(job.browser);
-    account.runtimeSession = { context, page };
-
-    const pollPromise = this.pollForToken(qoderService, nonce, codeVerifier, job);
-
-    try {
-      this.setAccountStep(account, "preparing_worker", `Worker ${workerId} preparing Qoder device flow`);
-      await this.persistJobSnapshot(job, { forcePreview: true });
-
-      const automationResult = await runGoogleAccountAutomation({
-        page,
-        authUrl: verificationUriComplete,
-        email: account.email,
-        password: account.password,
-        successPromise: pollPromise,
-        shortTimeoutMs: QODER_POLL_TIMEOUT_MS,
-        serviceLabel: QODER_LABEL,
-        openingStep: "opening_qoder_login",
-        openingMessage: "Opening Qoder device login page",
-        successStep: "qoder_token_received",
-        successMessage: "Qoder device token received",
-        onStep: (step, message) => {
-          this.setAccountStep(account, step, message);
-          void this.persistJobSnapshot(job, { forcePreview: false });
-        },
-      });
-
-      if (automationResult.status === "success") {
-        const tokenData = automationResult.tokenData || automationResult;
-        let displayName = "";
-        let organizationId = "";
-        let planTier = "";
-
-        this.setAccountStep(account, "fetching_profile", "Fetching Qoder profile");
-        await this.persistJobSnapshot(job, { forcePreview: true });
-        try {
-          const userInfo = await qoderService.fetchUserInfo(tokenData.accessToken);
-          displayName = userInfo.name || userInfo.email || "";
-          organizationId = userInfo.organizationId || "";
-        } catch {}
-
-        this.setAccountStep(account, "checking_plan", "Reading plan tier via browser session");
-        await this.persistJobSnapshot(job, { forcePreview: true });
-        try {
-          const plan = await page.evaluate(async () => {
-            try {
-              const r = await fetch("https://qoder.com/api/v1/me/userplan", {
-                credentials: "include",
-                headers: { accept: "application/json" },
-              });
-              if (!r.ok) return null;
-              return r.json();
-            } catch { return null; }
-          });
-          planTier = plan?.plan_tier || plan?.plan_tier_name || "";
-          const planStatus = plan?.status || "";
-          this.setAccountStep(account, "plan_checked", `Plan: ${planTier || "unknown"} (${planStatus || "unknown"})`);
-          await this.persistJobSnapshot(job, { forcePreview: false });
-        } catch {}
-
-        this.setAccountStep(account, "saving_connection", "Saving Qoder connection to database");
-        await this.persistJobSnapshot(job, { forcePreview: true });
-
-        const { connection } = await this.saveConnection({
-          tokens: {
-            accessToken: tokenData.accessToken,
-            refreshToken: tokenData.refreshToken || "",
-            userId: tokenData.userId || "",
-            machineId,
-            organizationId: organizationId || tokenData.organizationId || "",
-            expireTime: tokenData.expireTime || null,
-            displayName,
-            planTier,
-          },
-          email: account.email,
-        });
-
-        const planLabel = planTier ? ` (${planTier})` : "";
-        this.finalizeAccount(account, "success", {
-          connectionId: connection.id,
-          step: "connection_saved",
-          message: `Qoder connection saved successfully${planLabel}`,
-        });
-        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.runQoderManualFollowup(job, account, workerId, context, pollPromise, qoderService, machineId);
-        return;
-      }
-
-      const terminalStatus = automationResult.status?.startsWith("failed") ? automationResult.status : "failed";
-      this.finalizeAccount(account, terminalStatus, {
-        error: automationResult.error || "Qoder Google automation failed.",
-        step: terminalStatus,
-        message: automationResult.error || "Qoder 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 Qoder bulk import failure.",
-        step: "failed",
-        message: error.message || "Unexpected Qoder bulk import failure.",
-      });
-      account.runtimeSession = null;
-      await context.close().catch(() => null);
-      await this.persistJobSnapshot(job, { forcePreview: true });
-    } finally {
-      account.password = undefined;
-    }
-  }
-
-  async pollForToken(qoderService, nonce, codeVerifier, job) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < QODER_POLL_TIMEOUT_MS) {
-      if (job.cancelRequested) {
-        throw new Error("Job cancelled during token polling");
-      }
-      try {
-        const result = await qoderService.pollDeviceToken({ nonce, codeVerifier });
-        if (result.status === "ok") {
-          return { tokenData: result };
-        }
-      } catch (error) {
-        if (error.message && !error.message.includes("timeout")) {
-          throw error;
-        }
-      }
-      await wait(QODER_POLL_INTERVAL_MS);
-    }
-    throw new Error("Qoder device token poll timed out");
-  }
-
-  async runQoderManualFollowup(job, account, workerId, context, pollPromise, qoderService, machineId) {
-    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 {
-        const result = await pollPromise;
-        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;
-        }
-
-        const tokenData = result.tokenData || result;
-        this.setAccountStep(account, "saving_connection", "Saving Qoder connection");
-        await this.persistJobSnapshot(job, { forcePreview: true });
-
-        let displayName = "";
-        let organizationId = "";
-        try {
-          const userInfo = await qoderService.fetchUserInfo(tokenData.accessToken);
-          displayName = userInfo.name || userInfo.email || "";
-          organizationId = userInfo.organizationId || "";
-        } catch {}
-
-        const { connection } = await this.saveConnection({
-          tokens: {
-            accessToken: tokenData.accessToken,
-            refreshToken: tokenData.refreshToken || "",
-            userId: tokenData.userId || "",
-            machineId,
-            organizationId: organizationId || tokenData.organizationId || "",
-            expireTime: tokenData.expireTime || null,
-            displayName,
-          },
-          email: account.email,
-        });
-
-        this.finalizeAccount(account, "success", {
-          connectionId: connection.id,
-          step: "connection_saved",
-          message: "Qoder connection saved successfully",
-        });
-        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.__qoderBulkImportSingleton) {
-    globalThis.__qoderBulkImportSingleton = {
-      manager: new QoderBulkImportManager(),
-    };
-  }
-  return globalThis.__qoderBulkImportSingleton;
-}
-
-export function getQoderBulkImportManager() {
-  return getSingletonStore().manager;
-}
-
-export {
-  QoderBulkImportManager,
-  buildLookupResponse,
-  parseKiroBulkAccounts,
-  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
-  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
-  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
-};

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

@@ -1,170 +0,0 @@
-import open from "open";
-import { QWEN_CONFIG } from "../constants/oauth.js";
-import { getServerCredentials } from "../config/index.js";
-import { generatePKCE } from "../utils/pkce.js";
-import { spinner as createSpinner } from "../utils/ui.js";
-
-/**
- * Qwen OAuth Service
- * Uses Device Code Flow with PKCE
- */
-export class QwenService {
-  constructor() {
-    this.config = QWEN_CONFIG;
-  }
-
-  /**
-   * Request device code
-   */
-  async requestDeviceCode(codeChallenge) {
-    const response = await fetch(this.config.deviceCodeUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json",
-      },
-      body: new URLSearchParams({
-        client_id: this.config.clientId,
-        scope: this.config.scope,
-        code_challenge: codeChallenge,
-        code_challenge_method: this.config.codeChallengeMethod,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Device code request failed: ${error}`);
-    }
-
-    return await response.json();
-  }
-
-  /**
-   * Poll for token
-   */
-  async pollForToken(deviceCode, codeVerifier, interval = 5) {
-    const maxAttempts = 60; // 5 minutes
-    const pollInterval = interval * 1000;
-
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      await new Promise((r) => setTimeout(r, pollInterval));
-
-      const response = await fetch(this.config.tokenUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Accept: "application/json",
-        },
-        body: new URLSearchParams({
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-          client_id: this.config.clientId,
-          device_code: deviceCode,
-          code_verifier: codeVerifier,
-        }),
-      });
-
-      if (response.ok) {
-        return await response.json();
-      }
-
-      const error = await response.json();
-
-      if (error.error === "authorization_pending") {
-        continue;
-      } else if (error.error === "slow_down") {
-        await new Promise((r) => setTimeout(r, 5000));
-        continue;
-      } else if (error.error === "expired_token") {
-        throw new Error("Device code expired");
-      } else if (error.error === "access_denied") {
-        throw new Error("Access denied");
-      } else {
-        throw new Error(error.error_description || error.error);
-      }
-    }
-
-    throw new Error("Authorization timeout");
-  }
-
-  /**
-   * Save Qwen tokens to server
-   */
-  async saveTokens(tokens) {
-    const { server, token, userId } = getServerCredentials();
-
-    const response = await fetch(`${server}/api/cli/providers/qwen`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-        "X-User-Id": userId,
-      },
-      body: JSON.stringify({
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        expiresIn: tokens.expires_in,
-        resourceUrl: tokens.resource_url,
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.error || "Failed to save tokens");
-    }
-
-    return await response.json();
-  }
-
-  /**
-   * Complete Qwen OAuth flow
-   */
-  async connect() {
-    const spinner = createSpinner("Starting Qwen OAuth...").start();
-
-    try {
-      spinner.text = "Generating PKCE...";
-
-      // Generate PKCE
-      const { codeVerifier, codeChallenge } = generatePKCE();
-
-      spinner.text = "Requesting device code...";
-
-      // Request device code
-      const deviceData = await this.requestDeviceCode(codeChallenge);
-
-      spinner.stop();
-
-      console.log("\n📋 Please visit the following URL and enter the code:\n");
-      console.log(`   ${deviceData.verification_uri}\n`);
-      console.log(`   Code: ${deviceData.user_code}\n`);
-
-      // Open browser
-      if (deviceData.verification_uri_complete) {
-        await open(deviceData.verification_uri_complete);
-      } else {
-        await open(deviceData.verification_uri);
-      }
-
-      spinner.start("Waiting for authorization...");
-
-      // Poll for token
-      const tokens = await this.pollForToken(
-        deviceData.device_code,
-        codeVerifier,
-        deviceData.interval || 5
-      );
-
-      spinner.text = "Saving tokens to server...";
-
-      // Save tokens to server
-      await this.saveTokens(tokens);
-
-      spinner.succeed("Qwen connected successfully!");
-      return true;
-    } catch (error) {
-      spinner.fail(`Failed: ${error.message}`);
-      throw error;
-    }
-  }
-}
-

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

@@ -1,165 +0,0 @@
-/**
- * Local SOCKS5-to-HTTP proxy bridge for Playwright/Chromium.
- *
- * Chromium cannot authenticate SOCKS5 natively. This module spins up a local
- * unauthenticated HTTP proxy that forwards CONNECT tunnels through an
- * authenticated SOCKS5 upstream via the `socks` package.
- *
- * Usage:
- *   const handle = await ensureSocksHttpBridge("socks5://user:pass@host:port");
- *   // use handle.httpProxyUrl as Playwright proxy server (no auth)
- *   // ...
- *   await handle.release();
- */
-
-import http from "node:http";
-import { SocksClient } from "socks";
-
-const bridges = new Map(); // key -> Promise<{ server, port, refCount, httpProxyUrl }>
-
-function parseSocksUrl(proxyUrl) {
-  const url = new URL(String(proxyUrl).trim());
-  const protocol = (url.protocol || "").replace(/:$/, "").toLowerCase();
-  if (!protocol.startsWith("socks")) {
-    return null;
-  }
-  return {
-    host: url.hostname,
-    port: Number(url.port) || (protocol.includes("4") ? 1080 : 1080),
-    type: protocol.includes("4") ? 4 : 5,
-    userId: url.username ? decodeURIComponent(url.username) : undefined,
-    password: url.password ? decodeURIComponent(url.password) : undefined,
-    key: `${protocol}://${url.username}:${url.password}@${url.hostname}:${url.port || 1080}`,
-  };
-}
-
-function socksConnect(socks, host, port) {
-  return SocksClient.createConnection({
-    proxy: {
-      host: socks.host,
-      port: socks.port,
-      type: socks.type,
-      userId: socks.userId,
-      password: socks.password,
-    },
-    command: "connect",
-    destination: { host, port: Number(port) },
-    timeout: 25_000,
-  });
-}
-
-function pipe(a, b) {
-  a.pipe(b);
-  b.pipe(a);
-  const close = () => {
-    a.destroy();
-    b.destroy();
-  };
-  a.on("error", close);
-  b.on("error", close);
-  a.on("close", () => b.destroy());
-  b.on("close", () => a.destroy());
-}
-
-async function startBridge(socks) {
-  const server = http.createServer((req, res) => {
-    // Plain HTTP requests are uncommon for Playwright (uses CONNECT for HTTPS).
-    res.writeHead(405, { "Content-Type": "text/plain" });
-    res.end("CONNECT only");
-  });
-
-  server.on("connect", async (req, clientSocket, head) => {
-    try {
-      const [host, portStr] = String(req.url || "").split(":");
-      const port = Number(portStr) || 443;
-      if (!host) {
-        clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
-        clientSocket.destroy();
-        return;
-      }
-      const info = await socksConnect(socks, host, port);
-      const remote = info.socket;
-      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
-      if (head && head.length) remote.write(head);
-      pipe(clientSocket, remote);
-    } catch (error) {
-      try {
-        clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
-      } catch {
-        // ignore
-      }
-      clientSocket.destroy();
-    }
-  });
-
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    // port 0 = ephemeral
-    server.listen(0, "127.0.0.1", () => resolve());
-  });
-
-  const address = server.address();
-  const port = typeof address === "object" && address ? address.port : 0;
-  const httpProxyUrl = `http://127.0.0.1:${port}`;
-
-  return {
-    server,
-    port,
-    httpProxyUrl,
-    refCount: 0,
-    async close() {
-      await new Promise((resolve) => server.close(() => resolve()));
-    },
-  };
-}
-
-/**
- * Ensure a local HTTP proxy bridge for the given SOCKS5 URL.
- * Returns { httpProxyUrl, release } — call release() when the browser context closes.
- */
-export async function ensureSocksHttpBridge(proxyUrl) {
-  const socks = parseSocksUrl(proxyUrl);
-  if (!socks) return null;
-
-  // No auth needed for socks without credentials — Playwright can use it directly
-  if (!socks.userId && !socks.password) return null;
-
-  let entryPromise = bridges.get(socks.key);
-  if (!entryPromise) {
-    entryPromise = startBridge(socks);
-    bridges.set(socks.key, entryPromise);
-  }
-
-  let entry;
-  try {
-    entry = await entryPromise;
-  } catch (error) {
-    if (bridges.get(socks.key) === entryPromise) bridges.delete(socks.key);
-    throw error;
-  }
-  entry.refCount += 1;
-
-  let released = false;
-  return {
-    httpProxyUrl: entry.httpProxyUrl,
-    async release() {
-      if (released) return;
-      released = true;
-      entry.refCount = Math.max(0, entry.refCount - 1);
-      if (entry.refCount === 0) {
-        if (bridges.get(socks.key) === entryPromise) bridges.delete(socks.key);
-        await entry.close().catch(() => null);
-      }
-    },
-  };
-}
-
-export function isSocksProxyUrl(proxyUrl) {
-  if (!proxyUrl) return false;
-  try {
-    const protocol = new URL(String(proxyUrl).trim()).protocol.replace(/:$/, "").toLowerCase();
-    return protocol.startsWith("socks");
-  } catch {
-    return /^socks/i.test(String(proxyUrl));
-  }
-}