Capabilities

// Basic creation
const session = await client.sessions.create();

// With browser mode
const session = await client.sessions.create({
  browserMode: 'normal',
});

// With uploaded extensions
const session = await client.sessions.create({
  browserMode: 'normal',
  extensionIds: ['ext_11ff6ce20fb0'],
});

// With authenticated upstream proxy
const session = await client.sessions.create({
  proxy: {
    type: 'external',
    server: 'http://192.168.1.1:8080',
    username: 'user',
    password: 'pass',
  },
});

// Available browser modes:
// - 'normal': Chrome in standard browser container
// - 'light': lightweight browser mode

const context = await client.contexts.create({
  metadata: { userId: '1001' },
});

const session = await client.sessions.create({
  context: { id: context.id, mode: 'readWrite' },
});

// The SDK also accepts 'read_write', 'readOnly', and 'read_only'
// and normalizes them to the API payload format.

const result = await client.sessions.list();
console.log(`Total: ${result.pagination.totalCount}`);
console.log(`Active: ${result.pagination.activeCount}`);

for (const session of result) {
  console.log(`${session.id}: ${session.status}`);
}

const activeSessions = await client.sessions.list({ status: 'active' });
console.log(`Found ${activeSessions.length} active sessions`);

await client.sessions.delete({ sessionId: 'session-id' });

// Or use the session object helper
await session.close();

const session = await client.sessions.create({
  downloads: { enabled: true },
});

const downloads = await client.sessions.downloads.list(session.id);
console.log(downloads.summary.count);

const fileBuffer = await client.sessions.downloads.get(session.id, 'download-id');
const archiveBuffer = await client.sessions.downloads.archive(session.id);

await client.sessions.downloads.delete(session.id);

const session = await client.sessions.create({
  recording: { persistent: true },
});

const context = await client.contexts.create({
  metadata: { owner: 'demo' },
});

const contexts = await client.contexts.list({
  status: 'available',
  limit: 20,
});

const details = await client.contexts.get(context.id);
console.log(details.status);

await client.contexts.forceRelease(context.id);
await client.contexts.delete(context.id);

const extension = await client.extensions.upload('/absolute/path/to/extension.zip', {
  name: 'demo-extension',
});

const extensions = await client.extensions.list({ limit: 10 });
for (const item of extensions) {
  console.log(item.id, item.name);
}

const details = await client.extensions.get(extension.id);
await client.extensions.delete(extension.id);

import {
  APIError,
  AuthenticationError,
  ContextLockedError,
  ContextNotFoundError,
  NetworkError,
  TimeoutError,
} from 'lexmount';

try {
  await client.sessions.create({
    context: { id: 'ctx_123', mode: 'readWrite' },
  });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid credentials');
  } else if (error instanceof ContextNotFoundError) {
    console.error('Context not found');
  } else if (error instanceof ContextLockedError) {
    console.error(error.activeSessionId, error.retryAfter);
  } else if (error instanceof TimeoutError || error instanceof NetworkError) {
    console.error('Temporary connectivity issue');
  } else if (error instanceof APIError) {
    console.error(error.statusCode);
  } else {
    throw error;
  }
}

import { disableLogging, enableLogging, setLogLevel } from 'lexmount';

setLogLevel('DEBUG');
enableLogging('INFO');
disableLogging();