Session Management Methods

const session = await client.createSession(options);

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  fingerprint: {
    platform: "Windows",
    language: "en-US",
    timezone: "America/New_York",
    screen: { width: 1920, height: 1080 }
  }
});

const session = await client.createSession({
  fingerprint: {
    timezone: "Europe/London",
    language: "en-GB"
  }
});

console.log("Session created:", session.sessionId);

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  proxy: "http://proxy.example.com:8080"
});

const sessionWithDefaultProxy = await client.createSession();
console.log("Uses default proxy: http://proxy.example.com:8080");

const sessionWithCustomProxy = await client.createSession({
  proxy: "http://other-proxy.example.com:9090"
});
console.log("Uses custom proxy: http://other-proxy.example.com:9090");

const sessionWithoutProxy = await client.createSession({
  proxy: null
});
console.log("No proxy used for this session");

{
  "success": true,
  "sessionId": "sess_a1b2c3d4e5f6",
  "expiresAt": "2024-12-15T14:30:00.000Z",
  "profile": {
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "platform": "Windows",
    "language": "en-US",
    "screen": { "width": 1920, "height": 1080 },
    "timezone": "America/New_York"
  }
}

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function createBasicSession() {
  const session = await client.createSession();

  console.log("Session ID:", session.sessionId);
  console.log("Expires at:", session.expiresAt);
  console.log("Profile:", session.profile);

  return session;
}

createBasicSession();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function createCustomSession() {
  const session = await client.createSession({
    mode: "adaptive",
    sensibility: "high",
    fingerprint: {
      platform: "MacIntel",
      language: "en-US",
      timezone: "America/Los_Angeles",
      screen: { width: 2560, height: 1440 }
    },
    proxy: "http://us-west.proxy.example.com:8080",
    timeout: 1800
  });

  console.log("Session ID:", session.sessionId);
  console.log("Expires at:", session.expiresAt);
  console.log("Mode: adaptive, Sensibility: high");
  console.log("Timeout: 1800 seconds (30 minutes)");

  return session;
}

createCustomSession();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function safeCreateSession(options) {
  try {
    const session = await client.createSession(options);
    console.log("Session created successfully:", session.sessionId);
    return session;
  } catch (error) {
    const message = error.message.toLowerCase();

    if (message.includes("limit") || message.includes("maximum")) {
      console.log("Session limit reached. Close existing sessions before creating new ones.");
    } else if (message.includes("balance") || message.includes("insufficient")) {
      console.log("Insufficient balance to create a session. Recharge your account.");
    } else if (message.includes("mode")) {
      console.log("Invalid mode specified. Use 'passive' or 'adaptive'.");
    } else if (message.includes("sensibility")) {
      console.log("Invalid sensibility specified. Use 'low', 'medium', or 'high'.");
    } else {
      console.log("Session creation failed:", error.message);
    }

    return null;
  }
}

safeCreateSession({ mode: "adaptive", sensibility: "medium" });

const result = await client.closeSession(sessionId);

{
  "success": true
}

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function createAndCloseSession() {
  const session = await client.createSession({ mode: "passive" });
  console.log("Session created:", session.sessionId);

  const result = await client.closeSession(session.sessionId);
  console.log("Session closed:", result.success);
}

createAndCloseSession();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function safeCloseSession(sessionId) {
  try {
    const result = await client.closeSession(sessionId);
    console.log("Session closed successfully");
    return true;
  } catch (error) {
    const message = error.message.toLowerCase();

    if (message.includes("not found")) {
      console.log("Session does not exist. It may have already been cleaned up.");
    } else if (message.includes("expired")) {
      console.log("Session has already expired. No action needed.");
    } else if (message.includes("closed")) {
      console.log("Session was already closed.");
    } else {
      console.log("Failed to close session:", error.message);
    }

    return false;
  }
}

safeCloseSession("sess_a1b2c3d4e5f6");

const status = await client.getSessionStatus(sessionId);

{
  "success": true,
  "status": "active",
  "expiresAt": "2024-12-15T14:30:00.000Z",
  "profile": {
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "platform": "Windows",
    "language": "en-US",
    "screen": { "width": 1920, "height": 1080 },
    "timezone": "America/New_York"
  }
}

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function checkSessionHealth(sessionId) {
  const status = await client.getSessionStatus(sessionId);

  console.log("Session status:", status.status);
  console.log("Expires at:", status.expiresAt);
  console.log("Profile:", status.profile);

  return status;
}

checkSessionHealth("sess_a1b2c3d4e5f6");

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function getRemainingTime(sessionId) {
  const status = await client.getSessionStatus(sessionId);

  if (status.status !== "active") {
    console.log("Session is not active. Status:", status.status);
    return 0;
  }

  const expiresAt = new Date(status.expiresAt);
  const now = new Date();
  const remainingMs = expiresAt.getTime() - now.getTime();
  const remainingSeconds = Math.max(0, Math.floor(remainingMs / 1000));

  console.log("Remaining time:", remainingSeconds, "seconds");
  return remainingSeconds;
}

async function shouldCreateNewSession(sessionId, minimumSecondsNeeded) {
  const remaining = await getRemainingTime(sessionId);

  if (remaining < minimumSecondsNeeded) {
    console.log("Session has insufficient time remaining. Creating a new session.");
    return true;
  }

  console.log("Session has enough time remaining. Continuing with existing session.");
  return false;
}

shouldCreateNewSession("sess_a1b2c3d4e5f6", 120);

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function safeGetSessionStatus(sessionId) {
  try {
    const status = await client.getSessionStatus(sessionId);
    return { available: true, data: status };
  } catch (error) {
    const message = error.message.toLowerCase();

    if (message.includes("not found")) {
      console.log("Session not found. It may have expired and been cleaned up.");
    } else {
      console.log("Failed to get session status:", error.message);
    }

    return { available: false, error: error.message };
  }
}

safeGetSessionStatus("sess_a1b2c3d4e5f6");

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  mode: "passive",
  sensibility: "medium"
});

async function sessionLifecycleExample() {
  let sessionId = null;

  try {
    const session = await client.createSession({ timeout: 900 });
    sessionId = session.sessionId;
    console.log("1. Session created:", sessionId);
    console.log("   Expires at:", session.expiresAt);

    const response = await client.request({
      url: "https://api.example.com/data",
      method: "GET",
      sessionId: sessionId
    });
    console.log("2. Request completed. Status:", response.statusCode);

    const status = await client.getSessionStatus(sessionId);
    console.log("3. Session status:", status.status);
    console.log("   Profile available:", status.profile !== null);

  } catch (error) {
    console.log("Workflow error:", error.message);
  } finally {
    if (sessionId) {
      try {
        await client.closeSession(sessionId);
        console.log("4. Session closed successfully");
      } catch (closeError) {
        console.log("4. Session cleanup note:", closeError.message);
      }
    }
  }
}

sessionLifecycleExample();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sensibility: "high"
});

async function authenticatedDataRetrieval() {
  let sessionId = null;

  try {
    const session = await client.createSession({
      mode: "adaptive",
      sensibility: "high",
      timeout: 1200,
      fingerprint: {
        platform: "MacIntel",
        language: "en-US"
      }
    });
    sessionId = session.sessionId;
    console.log("Session created:", sessionId);

    const loginResponse = await client.request({
      url: "https://app.example.com/login",
      method: "POST",
      body: {
        username: "[email protected]",
        password: "secure_password"
      },
      sessionId: sessionId
    });
    console.log("Login status:", loginResponse.statusCode);

    const dataResponse = await client.request({
      url: "https://app.example.com/api/dashboard",
      method: "GET",
      sessionId: sessionId
    });
    console.log("Dashboard data retrieved:", dataResponse.statusCode);

    const logoutResponse = await client.request({
      url: "https://app.example.com/logout",
      method: "POST",
      sessionId: sessionId
    });
    console.log("Logout status:", logoutResponse.statusCode);

    return dataResponse.data;

  } catch (error) {
    console.log("Workflow failed:", error.message);
    return null;
  } finally {
    if (sessionId) {
      try {
        await client.closeSession(sessionId);
        console.log("Session closed");
      } catch (closeError) {
        console.log("Session cleanup:", closeError.message);
      }
    }
  }
}

authenticatedDataRetrieval();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function isSessionAlive(sessionId) {
  try {
    const status = await client.getSessionStatus(sessionId);
    if (status.status !== "active") {
      return false;
    }
    const expiresAt = new Date(status.expiresAt);
    const now = new Date();
    const remainingMs = expiresAt.getTime() - now.getTime();
    return remainingMs > 30000;
  } catch (error) {
    return false;
  }
}

async function processUrlsWithSession(urls) {
  let sessionId = null;
  const results = [];

  try {
    const session = await client.createSession({ timeout: 1800 });
    sessionId = session.sessionId;
    console.log("Session created:", sessionId);

    for (let i = 0; i < urls.length; i++) {
      const alive = await isSessionAlive(sessionId);

      if (!alive) {
        console.log("Session expired or closing soon. Creating a new session.");
        try { await client.closeSession(sessionId); } catch (e) {}

        const newSession = await client.createSession({ timeout: 1800 });
        sessionId = newSession.sessionId;
        console.log("New session created:", sessionId);
      }

      const response = await client.request({
        url: urls[i],
        method: "GET",
        sessionId: sessionId
      });

      results.push({ url: urls[i], status: response.statusCode });
      console.log("Processed", i + 1, "of", urls.length);
    }

  } catch (error) {
    console.log("Processing error:", error.message);
  } finally {
    if (sessionId) {
      try { await client.closeSession(sessionId); } catch (e) {}
    }
  }

  return results;
}

const urls = [
  "https://api.example.com/products/1",
  "https://api.example.com/products/2",
  "https://api.example.com/products/3"
];

processUrlsWithSession(urls);

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  mode: "passive",
  sensibility: "medium"
});

function createSessionPool(maxSize) {
  const available = [];
  const inUse = new Set();

  async function acquire(options) {
    if (available.length > 0) {
      const sessionId = available.pop();

      try {
        const status = await client.getSessionStatus(sessionId);
        if (status.status === "active") {
          inUse.add(sessionId);
          console.log("Reusing session:", sessionId);
          return sessionId;
        }
      } catch (error) {
        console.log("Stale session removed:", sessionId);
      }
    }

    if (inUse.size >= maxSize) {
      throw new Error("Session pool exhausted. All " + maxSize + " sessions are in use.");
    }

    const session = await client.createSession(options || {});
    inUse.add(session.sessionId);
    console.log("New session created:", session.sessionId);
    return session.sessionId;
  }

  async function release(sessionId) {
    if (inUse.has(sessionId)) {
      inUse.delete(sessionId);
      available.push(sessionId);
      console.log("Session released back to pool:", sessionId);
    }
  }

  async function destroy(sessionId) {
    inUse.delete(sessionId);
    const index = available.indexOf(sessionId);
    if (index !== -1) {
      available.splice(index, 1);
    }
    try {
      await client.closeSession(sessionId);
      console.log("Session destroyed:", sessionId);
    } catch (error) {
      console.log("Session destroy note:", error.message);
    }
  }

  async function destroyAll() {
    const allSessions = [...available, ...inUse];
    available.length = 0;
    inUse.clear();

    for (const sessionId of allSessions) {
      try {
        await client.closeSession(sessionId);
      } catch (error) {
        console.log("Cleanup note for", sessionId, ":", error.message);
      }
    }
    console.log("All sessions destroyed. Pool is empty.");
  }

  function stats() {
    return {
      available: available.length,
      inUse: inUse.size,
      total: available.length + inUse.size,
      maxSize: maxSize
    };
  }

  return { acquire, release, destroy, destroyAll, stats };
}

async function useSessionPool() {
  const pool = createSessionPool(5);

  const session1 = await pool.acquire({ mode: "passive" });
  const session2 = await pool.acquire({ mode: "passive" });

  console.log("Pool stats:", pool.stats());

  await client.request({
    url: "https://api.example.com/data",
    method: "GET",
    sessionId: session1
  });

  await pool.release(session1);
  console.log("Pool stats after release:", pool.stats());

  const session3 = await pool.acquire();
  console.log("Acquired session (may reuse):", session3);

  await pool.destroyAll();
  console.log("Final pool stats:", pool.stats());
}

useSessionPool();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  mode: "passive",
  sensibility: "medium"
});

async function processWithPool(urls, concurrency, pool) {
  const results = [];
  let index = 0;

  async function worker() {
    while (index < urls.length) {
      const currentIndex = index;
      index++;
      const url = urls[currentIndex];

      let sessionId = null;
      try {
        sessionId = await pool.acquire({ timeout: 600 });

        const response = await client.request({
          url: url,
          method: "GET",
          sessionId: sessionId
        });

        results[currentIndex] = {
          url: url,
          status: response.statusCode,
          success: true
        };

      } catch (error) {
        results[currentIndex] = {
          url: url,
          error: error.message,
          success: false
        };
      } finally {
        if (sessionId) {
          await pool.release(sessionId);
        }
      }
    }
  }

  const workers = [];
  for (let i = 0; i < concurrency; i++) {
    workers.push(worker());
  }
  await Promise.all(workers);

  return results;
}

async function main() {
  const pool = createSessionPool(3);

  const urls = [
    "https://api.example.com/products/1",
    "https://api.example.com/products/2",
    "https://api.example.com/products/3",
    "https://api.example.com/products/4",
    "https://api.example.com/products/5"
  ];

  const results = await processWithPool(urls, 3, pool);
  console.log("Results:", results);

  await pool.destroyAll();
}

main();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

function classifySessionError(error) {
  const message = error.message.toLowerCase();

  if (message.includes("api key") || message.includes("invalid")) {
    return { type: "auth", retryable: false };
  }

  if (message.includes("limit") || message.includes("maximum")) {
    return { type: "limit", retryable: false };
  }

  if (message.includes("balance") || message.includes("insufficient")) {
    return { type: "balance", retryable: false };
  }

  if (message.includes("not found")) {
    return { type: "not_found", retryable: false };
  }

  if (message.includes("expired")) {
    return { type: "expired", retryable: false };
  }

  if (message.includes("closed")) {
    return { type: "already_closed", retryable: false };
  }

  if (message.includes("unavailable") || message.includes("timeout")) {
    return { type: "service", retryable: true };
  }

  return { type: "unknown", retryable: true };
}

async function createSessionWithRetry(options, maxRetries) {
  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const session = await client.createSession(options);
      return session;
    } catch (error) {
      lastError = error;
      const classification = classifySessionError(error);

      if (!classification.retryable) {
        console.log("Non-retryable error:", classification.type, "-", error.message);
        throw error;
      }

      if (attempt < maxRetries) {
        const delay = 1000 * Math.pow(2, attempt - 1);
        console.log("Attempt", attempt, "failed. Retrying in", delay, "ms");
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }

  throw lastError;
}

async function main() {
  try {
    const session = await createSessionWithRetry({ mode: "passive" }, 3);
    console.log("Session created:", session.sessionId);
  } catch (error) {
    console.log("All attempts failed:", error.message);
  }
}

main();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

async function withSession(options, workFn) {
  const session = await client.createSession(options);
  const sessionId = session.sessionId;

  try {
    const result = await workFn(sessionId, session);
    return result;
  } finally {
    try {
      await client.closeSession(sessionId);
      console.log("Session cleaned up:", sessionId);
    } catch (closeError) {
      console.log("Session cleanup note:", closeError.message);
    }
  }
}

async function main() {
  const data = await withSession({ mode: "passive", timeout: 600 }, async (sessionId) => {
    const response = await client.request({
      url: "https://api.example.com/data",
      method: "GET",
      sessionId: sessionId
    });

    return response.data;
  });

  console.log("Retrieved data:", data);
}

main();

const BBREClient = require("mydisctsolver-bbre");

const client = new BBREClient({ apiKey: "YOUR_API_KEY" });

const activeSessions = new Set();

async function createTrackedSession(options) {
  const session = await client.createSession(options);
  activeSessions.add(session.sessionId);
  return session;
}

async function closeTrackedSession(sessionId) {
  try {
    await client.closeSession(sessionId);
  } catch (error) {
    console.log("Close error for", sessionId, ":", error.message);
  }
  activeSessions.delete(sessionId);
}

async function cleanupAllSessions() {
  console.log("Cleaning up", activeSessions.size, "active sessions");
  const promises = [];
  for (const sessionId of activeSessions) {
    promises.push(closeTrackedSession(sessionId));
  }
  await Promise.all(promises);
  console.log("All sessions cleaned up");
}

process.on("SIGINT", async () => {
  await cleanupAllSessions();
  process.exit(0);
});

process.on("SIGTERM", async () => {
  await cleanupAllSessions();
  process.exit(0);
});

async function main() {
  const session = await createTrackedSession({ mode: "passive" });
  console.log("Session created:", session.sessionId);

  const response = await client.request({
    url: "https://api.example.com/data",
    method: "GET",
    sessionId: session.sessionId
  });
  console.log("Response status:", response.statusCode);

  await closeTrackedSession(session.sessionId);
}

main();