Connect an account you own

sente connect https://app.mailtrap.io/signin \
  --username "ops@yourcompany.com" \
  --password "$MAILTRAP_PASSWORD" \
  --totp-seed "$MAILTRAP_TOTP_SEED"     # optional; base32 or an otpauth:// URI

# The CLI waits for the run and exits non-zero unless it completed. If it blocked, it prints the
# live-view URL and the resume command:
#   sente run resume <runId>

sente session open <connectionId>       # → a CDP url for a browser already signed in

import { Sente } from "@sente-labs/sdk";
import { chromium } from "playwright";

const sente = new Sente({ apiKey: process.env.SENTE_API_TOKEN! });

// No identityId — the backing email identity is provisioned for this app.
const { connection, run } = await sente.connections.connect({
  appUrl: "https://app.mailtrap.io/signin",
  credentials: {
    username: "ops@yourcompany.com",
    password: process.env.MAILTRAP_PASSWORD!,
    totpSeed: process.env.MAILTRAP_TOTP_SEED,   // optional
  },
});

const settled = await sente.runs.waitForRun(run.id);   // timeout in ms, default 180000
if (settled.status === "blocked") {
  // A person opens settled.liveViewUrl, does the one step, then:
  //   await sente.runs.resume(run.id);
  throw new Error(`${settled.error?.code}: a human is needed at ${settled.liveViewUrl}`);
}
if (settled.status !== "completed") throw new Error(`connect failed: ${settled.error?.code}`);

// The account is live. Get a browser that is already signed in to it:
const session = await sente.registrations.getSession(connection.id);
const browser = await chromium.connectOverCDP(session.cdpUrl);
try {
  const context = browser.contexts()[0] ?? (await browser.newContext());
  const page = context.pages()[0] ?? (await context.newPage());
  await page.goto("https://app.mailtrap.io/inboxes");
} finally {
  await browser.close();
  await sente.registrations.closeSession(connection.id);
}

import os
from sente import Sente
from playwright.sync_api import sync_playwright

sente = Sente(api_key=os.environ["SENTE_API_TOKEN"])

# No identity_id — the backing email identity is provisioned for this app.
connection, run = sente.connections.connect(
    app_url="https://app.mailtrap.io/signin",
    username="ops@yourcompany.com",
    password=os.environ["MAILTRAP_PASSWORD"],
    totp_seed=os.environ.get("MAILTRAP_TOTP_SEED"),   # optional
)

settled = sente.runs.wait_for_run(run.id)             # timeout in SECONDS, default 180
if settled.status == "blocked":
    # A person opens settled.live_view_url, does the one step, then:
    #   sente.runs.resume(run.id)
    raise RuntimeError(f"{settled.error['code']}: a human is needed at {settled.live_view_url}")
if settled.status != "completed":
    raise RuntimeError(f"connect failed: {settled.error}")

session = sente.registrations.get_session(connection.id)
with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(session["cdpUrl"])
    try:
        context = browser.contexts[0] if browser.contexts else browser.new_context()
        page = context.pages[0] if context.pages else context.new_page()
        page.goto("https://app.mailtrap.io/inboxes")
    finally:
        browser.close()
        sente.registrations.close_session(connection.id)

# Re-connect with the same identity (rotates the vault and re-drives a login run).
sente connect https://app.mailtrap.io/signin --identity <identityRefOrId> \
  --username "ops@yourcompany.com" --password "$NEW_PASSWORD"

// Vault-only write — does NOT change the password at the app.
await sente.registrations.setCredentials(connection.id, { password: newPassword });
await sente.registrations.login(connection.id);   // verify the new credential works

sente.registrations.set_credentials(connection.id, password=new_password)
sente.registrations.login(connection.id)

sente connections                        # list what's connected
sente connection revoke <connectionId>   # disable; vault kept
sente connection delete <connectionId>   # revoke AND purge the password + TOTP seed

await sente.connections.list();
await sente.connections.revoke(connection.id);
await sente.connections.delete(connection.id);

sente.connections.list()
sente.connections.revoke(connection.id)
sente.connections.delete(connection.id)