Cancel every subscription you forgot about

import { writeFile } from 'node:fs/promises';
import { stdin, stdout } from 'node:process';
import { createInterface } from 'node:readline/promises';
import { setTimeout as sleep } from 'node:timers/promises';
import { ConcurrencyLimitError, Outcrawl, QuotaExceededError } from '@outcrawl/sdk';
import type { AgentRequest } from '@outcrawl/sdk';

const oc = new Outcrawl();

// One row per subscription. Each profile is already signed in to that site.
const services = [
  { name: 'The New York Times', site: 'nytimes.com', start: 'https://myaccount.nytimes.com/seg/subscription', profile: 'subs-nytimes' },
  { name: 'Audible', site: 'audible.com', start: 'https://www.audible.com/account/overview', profile: 'subs-audible' },
  { name: 'Adobe Creative Cloud', site: 'adobe.com', start: 'https://account.adobe.com/plans', profile: 'subs-adobe' },
  { name: 'Headspace', site: 'headspace.com', start: 'https://www.headspace.com/subscriptions', profile: 'subs-headspace' },
];

// Runs at once. Keep it below your plan's browser count (Free 2, Builder 5, Pro 25, Scale 100).
const MAX_AT_ONCE = 2;

interface Walkthrough {
  active: boolean;
  plan?: string;
  price?: string;
  renewsOn?: string;
  path: string[];
  offersDeclined?: string[];
  finalButton?: string;
  feeToCancel?: string;
  blocker?: string;
}

interface Cancellation {
  cancelled: boolean;
  accessEndsOn?: string;
  confirmation?: string;
  leftForYou?: string;
}

const walkthroughSchema = {
  type: 'object',
  properties: {
    active: { type: 'boolean', description: 'Whether this account has an active paid subscription' },
    plan: { type: 'string' },
    price: { type: 'string', description: 'Price per billing period, with currency' },
    renewsOn: { type: 'string', description: 'Next renewal date, YYYY-MM-DD' },
    path: { type: 'array', items: { type: 'string' }, description: 'Each screen passed, in order' },
    offersDeclined: { type: 'array', items: { type: 'string' } },
    finalButton: { type: 'string', description: 'Exact label of the button that ends the subscription' },
    feeToCancel: { type: 'string', description: 'Any fee for cancelling now, with currency, or "none"' },
    blocker: { type: 'string', description: 'What stopped you before the final screen, if anything' },
  },
  required: ['active', 'path'],
};

const cancellationSchema = {
  type: 'object',
  properties: {
    cancelled: { type: 'boolean' },
    accessEndsOn: { type: 'string', description: 'Last day of access, YYYY-MM-DD' },
    confirmation: { type: 'string', description: 'Confirmation message or number shown' },
    leftForYou: { type: 'string', description: 'What a person still has to do, if not cancelled' },
  },
  required: ['cancelled'],
};

// Submit a run and answer its id, waiting for a free browser slot instead of failing.
async function start(request: AgentRequest): Promise<string> {
  for (;;) {
    try {
      return (await oc.agent(request).submitted).id;
    } catch (error) {
      if (error instanceof ConcurrencyLimitError) {
        await sleep(20_000); // no Retry-After: a slot frees when one of your runs ends
      } else if (error instanceof QuotaExceededError && error.ceiling === 'requests_per_minute') {
        await sleep(error.retryAfterSeconds * 1000); // the error says how long to wait
      } else {
        throw error; // out of monthly credits, or a bad request: retrying cannot help
      }
    }
  }
}

// Run `work` over every item, at most `size` at a time.
async function inPool<T, R>(items: readonly T[], size: number, work: (item: T) => Promise<R>): Promise<R[]> {
  const results: R[] = new Array<R>(items.length);
  let next = 0;
  const worker = async () => {
    while (next < items.length) {
      const index = next++;
      results[index] = await work(items[index] as T);
    }
  };
  await Promise.all(Array.from({ length: Math.min(size, items.length) }, worker));
  return results;
}

const profiles = await oc.profiles.list({ label: 'subs-*' });
const profileIds = new Map(profiles.map((profile) => [profile.label, profile.id]));
for (const service of services) {
  if (!profileIds.has(service.profile)) throw new Error(`No profile labelled ${service.profile}`);
}

// Pass 1: walk each cancellation flow up to its last screen, and stop there.
const walkthroughs = await inPool(services, MAX_AT_ONCE, async (service) => {
  const run = await oc.agent.job(await start({
    task:
      `You are signed in to ${service.name}. Starting at ${service.start}, find how to cancel the subscription ` +
      'on this account and work through the cancellation flow. Answer any survey with "I no longer use it" and ' +
      'decline every retention offer, discount, downgrade and pause. Stop on the final screen, the one whose ' +
      'button would end the subscription, and do not press that button. If there is no active subscription, say so.',
    caps: { budget: '150.00', duration: '10m' },
    profile: profileIds.get(service.profile),
    rules: [`Only use ${service.site}.`],
    schema: walkthroughSchema,
  })).settled();
  return { service, walkthrough: run.data as Walkthrough | undefined, credits: run.credits };
});

walkthroughs.forEach(({ service, walkthrough }, index) => {
  if (walkthrough === undefined) {
    console.log(`${index + 1}. ${service.name}: no answer, cancel this one yourself`);
  } else if (!walkthrough.active) {
    console.log(`${index + 1}. ${service.name}: no active subscription`);
  } else {
    console.log(
      `${index + 1}. ${service.name}: ${walkthrough.plan ?? '?'} at ${walkthrough.price ?? '?'}, renews ${walkthrough.renewsOn ?? '?'}. ` +
        (walkthrough.finalButton !== undefined
          ? `Fee to cancel: ${walkthrough.feeToCancel ?? 'none'}. Ready to press "${walkthrough.finalButton}".`
          : `Stopped early: ${walkthrough.blocker ?? 'no reason given'}`),
    );
  }
});

// You decide. Nothing has been cancelled yet.
const prompt = createInterface({ input: stdin, output: stdout });
const answer = await prompt.question('Cancel which? Numbers separated by commas, "all", or Enter for none: ');
prompt.close();

const ready = walkthroughs.filter(({ walkthrough }) => walkthrough?.active === true && walkthrough.finalButton !== undefined);
const approved =
  answer.trim() === 'all'
    ? ready
    : answer
        .split(',')
        .map((part) => walkthroughs[Number(part.trim()) - 1])
        .filter((row): row is (typeof walkthroughs)[number] => row !== undefined && ready.includes(row));

// Pass 2: only the ones you approved, following the path pass 1 found.
const cancellations = await inPool(approved, MAX_AT_ONCE, async ({ service, walkthrough }) => {
  const steps = walkthrough as Walkthrough;
  const run = await oc.agent.job(await start({
    task:
      `You are signed in to ${service.name}. I have approved cancelling this subscription. Last time you reached ` +
      `the final screen this way: ${steps.path.join(' > ')}. Decline every retention offer again, then press ` +
      `"${steps.finalButton}" on the final screen. The fee to cancel I approved is: ${steps.feeToCancel ?? 'none'}. ` +
      'If the final screen shows a different fee, do not press it. Report the confirmation. If anything stops you (a sign-in, a ' +
      'cancellation that must be done by phone or chat, a page that changed), stop and say exactly what is left for me to do.',
    caps: { budget: '100.00', duration: '10m' },
    profile: profileIds.get(service.profile),
    rules: [`Only use ${service.site}.`],
    schema: cancellationSchema,
  })).settled();
  const result = run.data as Cancellation | undefined;
  return { service: service.name, ...(result ?? { cancelled: false, leftForYou: `Run ended ${run.stopReason ?? run.status}; see ${run.replayUrl ?? 'the console'}` }) };
});

console.table(cancellations);
await writeFile('cancellations.json', JSON.stringify({ walkthroughs, cancellations }, null, 2));

import asyncio
import json

from outcrawl import ConcurrencyLimitError, Outcrawl, QuotaExceededError

# One row per subscription. Each profile is already signed in to that site.
SERVICES = [
    {"name": "The New York Times", "site": "nytimes.com", "start": "https://myaccount.nytimes.com/seg/subscription", "profile": "subs-nytimes"},
    {"name": "Audible", "site": "audible.com", "start": "https://www.audible.com/account/overview", "profile": "subs-audible"},
    {"name": "Adobe Creative Cloud", "site": "adobe.com", "start": "https://account.adobe.com/plans", "profile": "subs-adobe"},
    {"name": "Headspace", "site": "headspace.com", "start": "https://www.headspace.com/subscriptions", "profile": "subs-headspace"},
]

# Runs at once. Keep it below your plan's browser count (Free 2, Builder 5, Pro 25, Scale 100).
MAX_AT_ONCE = 2

WALKTHROUGH_SCHEMA = {
    "type": "object",
    "properties": {
        "active": {"type": "boolean", "description": "Whether this account has an active paid subscription"},
        "plan": {"type": "string"},
        "price": {"type": "string", "description": "Price per billing period, with currency"},
        "renewsOn": {"type": "string", "description": "Next renewal date, YYYY-MM-DD"},
        "path": {"type": "array", "items": {"type": "string"}, "description": "Each screen passed, in order"},
        "offersDeclined": {"type": "array", "items": {"type": "string"}},
        "finalButton": {"type": "string", "description": "Exact label of the button that ends the subscription"},
        "feeToCancel": {"type": "string", "description": 'Any fee for cancelling now, with currency, or "none"'},
        "blocker": {"type": "string", "description": "What stopped you before the final screen, if anything"},
    },
    "required": ["active", "path"],
}

CANCELLATION_SCHEMA = {
    "type": "object",
    "properties": {
        "cancelled": {"type": "boolean"},
        "accessEndsOn": {"type": "string", "description": "Last day of access, YYYY-MM-DD"},
        "confirmation": {"type": "string", "description": "Confirmation message or number shown"},
        "leftForYou": {"type": "string", "description": "What a person still has to do, if not cancelled"},
    },
    "required": ["cancelled"],
}


async def start(oc: Outcrawl, **request) -> str:
    """Submit a run and answer its id, waiting for a free browser slot instead of failing."""
    while True:
        try:
            return (await oc.agent(**request).submitted)["id"]
        except ConcurrencyLimitError:
            await asyncio.sleep(20)  # no Retry-After: a slot frees when one of your runs ends
        except QuotaExceededError as error:
            if error.ceiling != "requests_per_minute":
                raise  # out of monthly credits: retrying cannot help
            await asyncio.sleep(error.retry_after_seconds)  # the error says how long to wait


async def main() -> None:
    async with Outcrawl() as oc:
        profiles = await oc.profiles.list(label="subs-*")
        profile_ids = {profile["label"]: profile["id"] for profile in profiles}
        for service in SERVICES:
            if service["profile"] not in profile_ids:
                raise SystemExit(f"No profile labelled {service['profile']}")
        slots = asyncio.Semaphore(MAX_AT_ONCE)

        # Pass 1: walk each cancellation flow up to its last screen, and stop there.
        async def walk(service: dict) -> dict:
            async with slots:
                run_id = await start(
                    oc,
                    task=(
                        f"You are signed in to {service['name']}. Starting at {service['start']}, find how to cancel "
                        "the subscription on this account and work through the cancellation flow. Answer any survey "
                        'with "I no longer use it" and decline every retention offer, discount, downgrade and pause. '
                        "Stop on the final screen, the one whose button would end the subscription, and do not press "
                        "that button. If there is no active subscription, say so."
                    ),
                    caps={"budget": "150.00", "duration": "10m"},
                    profile=profile_ids[service["profile"]],
                    rules=[f"Only use {service['site']}."],
                    schema=WALKTHROUGH_SCHEMA,
                )
                run = await oc.agent.job(run_id).settled()
            return {"service": service, "walkthrough": run.get("data"), "credits": run["credits"]}

        walkthroughs = await asyncio.gather(*(walk(service) for service in SERVICES))

        for number, row in enumerate(walkthroughs, start=1):
            name, steps = row["service"]["name"], row["walkthrough"]
            if steps is None:
                print(f"{number}. {name}: no answer, cancel this one yourself")
            elif not steps["active"]:
                print(f"{number}. {name}: no active subscription")
            elif steps.get("finalButton"):
                print(f"{number}. {name}: {steps.get('plan')} at {steps.get('price')}, renews {steps.get('renewsOn')}. "
                      f"Fee to cancel: {steps.get('feeToCancel', 'none')}. Ready to press \"{steps['finalButton']}\".")
            else:
                print(f"{number}. {name}: stopped early: {steps.get('blocker', 'no reason given')}")

        # You decide. Nothing has been cancelled yet.
        answer = await asyncio.to_thread(input, 'Cancel which? Numbers separated by commas, "all", or Enter for none: ')
        ready = [row for row in walkthroughs if row["walkthrough"] and row["walkthrough"]["active"] and row["walkthrough"].get("finalButton")]
        if answer.strip() == "all":
            approved = ready
        else:
            picked = {int(part) - 1 for part in answer.split(",") if part.strip().isdigit()}
            approved = [row for index, row in enumerate(walkthroughs) if index in picked and row in ready]

        # Pass 2: only the ones you approved, following the path pass 1 found.
        async def cancel(row: dict) -> dict:
            service, steps = row["service"], row["walkthrough"]
            async with slots:
                run_id = await start(
                    oc,
                    task=(
                        f"You are signed in to {service['name']}. I have approved cancelling this subscription. Last "
                        f"time you reached the final screen this way: {' > '.join(steps['path'])}. Decline every "
                        f'retention offer again, then press "{steps["finalButton"]}" on the final screen. The fee to '
                        f"cancel I approved is: {steps.get('feeToCancel', 'none')}. If the final screen shows a different "
                        "fee, do not press it. Report the confirmation. If anything stops you (a sign-in, a cancellation "
                        "that must be done by phone or chat, a page that changed), stop and say exactly what is left "
                        "for me to do."
                    ),
                    caps={"budget": "100.00", "duration": "10m"},
                    profile=profile_ids[service["profile"]],
                    rules=[f"Only use {service['site']}."],
                    schema=CANCELLATION_SCHEMA,
                )
                run = await oc.agent.job(run_id).settled()
            result = run.get("data") or {
                "cancelled": False,
                "leftForYou": f"Run ended {run.get('stopReason') or run['status']}; see {run.get('replayUrl') or 'the console'}",
            }
            return {"service": service["name"], **result}

        cancellations = await asyncio.gather(*(cancel(row) for row in approved))
        for row in cancellations:
            print(row)
        with open("cancellations.json", "w") as out:
            json.dump({"walkthroughs": walkthroughs, "cancellations": cancellations}, out, indent=2)


asyncio.run(main())