Book a table the moment one opens

import express from 'express';
import { Outcrawl } from '@outcrawl/sdk';
import type { AgentJob } from '@outcrawl/sdk';

const oc = new Outcrawl();
const PUBLIC_URL = 'https://tables.yourapp.example'; // where Outcrawl can reach this server
const HOOKS = `/hooks/${process.env.HOOK_TOKEN ?? ''}`; // a long random token: the only credential on these paths
const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL ?? ''; // a Slack incoming webhook of yours
if ((process.env.HOOK_TOKEN ?? '').length < 24) throw new Error('Set HOOK_TOKEN to a long random string.');

const want = {
  restaurant: 'Lilia',
  page: 'https://resy.com/cities/new-york-ny/venues/lilia?date=2026-10-17&seats=4',
  date: '2026-10-17',
  partySize: 4,
  earliest: '19:00',
  latest: '21:00',
  maxDepositPerPerson: 25, // USD
};

interface Booking {
  booked: boolean;
  time?: string;
  partySize?: number;
  confirmation?: string;
  depositPerPerson?: string;
  cancellationPolicy?: string;
  reason?: string;
}

const bookingSchema = {
  type: 'object',
  properties: {
    booked: { type: 'boolean' },
    time: { type: 'string', description: 'Reservation time, 24-hour HH:MM' },
    partySize: { type: 'integer' },
    confirmation: { type: 'string', description: 'Confirmation number or message' },
    depositPerPerson: { type: 'string', description: 'Deposit or charge per person, with currency, or "none"' },
    cancellationPolicy: { type: 'string' },
    reason: { type: 'string', description: 'Why nothing was booked, when nothing was' },
  },
  required: ['booked'],
};

const [profile] = await oc.profiles.list({ label: 'resy-personal' });
if (profile === undefined) throw new Error('Create the resy-personal profile and sign in to Resy with it first.');

// Checked every minute. Each check is 1 credit, changed or not.
const monitor = await oc.monitors.create({
  url: want.page,
  schedule: '* * * * *',
  label: 'table-lilia',
  judge: true,
  notify: { webhook: `${PUBLIC_URL}${HOOKS}/table-changed` },
});

let inFlight: AgentJob | undefined; // the run in flight, so two changes never book twice
let done = false;

async function tell(text: string): Promise<void> {
  console.log(text);
  if (SLACK_WEBHOOK_URL !== '') {
    await fetch(SLACK_WEBHOOK_URL, {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ text }),
    });
  }
}

const app = express();
app.use(express.json());

// 1. The monitor saw the page change. Send an agent to book.
app.post(`${HOOKS}/table-changed`, async (req, res) => {
  const change = req.body as { monitorId: string; status: string; summary?: string };
  if (done || inFlight !== undefined || change.status !== 'changed') {
    res.sendStatus(204);
    return;
  }
  inFlight = oc.agent({
    task:
      `On Resy, book a table at ${want.restaurant} for ${want.partySize} people on ${want.date}, at the earliest ` +
      `available time from ${want.earliest} to ${want.latest}. Start at ${want.page}; you are signed in. If Resy ` +
      'asks for a card to hold the table, use {{secret:card_dining}}. Do not book if no time in that window is ' +
      `free, or if the reservation needs a deposit or charge now above $${want.maxDepositPerPerson} per person: ` +
      'report why instead.',
    caps: { budget: '75.00', duration: '6m' },
    profile: profile.id,
    secrets: ['card_dining'],
    rules: ['Only use resy.com.'],
    schema: bookingSchema,
    webhook: `${PUBLIC_URL}${HOOKS}/booking-finished`,
  });
  try {
    res.status(202).json({ run: await inFlight.id() });
  } catch (error) {
    inFlight = undefined; // refused, for example every browser slot busy; the next change tries again
    throw error;
  }
});

// 2. The run finished. Check what it booked and tell you.
app.post(`${HOOKS}/booking-finished`, async (req, res) => {
  const { runId } = req.body as { runId: string };
  res.sendStatus(200);
  if (inFlight === undefined || runId !== (await inFlight.id())) return; // a repeat delivery
  inFlight = undefined;

  const run = await oc.agent.get(runId); // read the run itself, not the webhook body
  const booking = run.data as Booking | undefined;
  if (booking?.booked !== true) {
    console.log(`No table yet: ${booking?.reason ?? run.stopReason ?? run.status}`);
    return; // keep watching
  }
  done = true;
  await oc.monitors.delete(monitor.id);
  const inWindow = booking.time !== undefined && booking.time >= want.earliest && booking.time <= want.latest;
  await tell(
    `Booked ${want.restaurant}, ${want.date} at ${booking.time ?? '?'} for ${booking.partySize ?? want.partySize}. ` +
      `Confirmation ${booking.confirmation ?? 'on Resy'}. Deposit: ${booking.depositPerPerson ?? 'none'}. ` +
      `${booking.cancellationPolicy ?? ''}${inWindow ? '' : ' This is OUTSIDE your window: check it on Resy.'}`,
  );
});

app.listen(3000, () => console.log(`Watching ${want.page} as monitor ${monitor.id}`));

import os
from contextlib import asynccontextmanager

import httpx
from fastapi import FastAPI, Request, Response
from fastapi.responses import JSONResponse

from outcrawl import Outcrawl

PUBLIC_URL = "https://tables.yourapp.example"  # where Outcrawl can reach this server
HOOK_TOKEN = os.environ.get("HOOK_TOKEN", "")  # a long random token: the only credential on these paths
if len(HOOK_TOKEN) < 24:
    raise SystemExit("Set HOOK_TOKEN to a long random string.")
HOOKS = f"/hooks/{HOOK_TOKEN}"
SLACK_WEBHOOK_URL = os.environ.get("SLACK_WEBHOOK_URL", "")  # a Slack incoming webhook of yours

WANT = {
    "restaurant": "Lilia",
    "page": "https://resy.com/cities/new-york-ny/venues/lilia?date=2026-10-17&seats=4",
    "date": "2026-10-17",
    "party_size": 4,
    "earliest": "19:00",
    "latest": "21:00",
    "max_deposit_per_person": 25,  # USD
}

BOOKING_SCHEMA = {
    "type": "object",
    "properties": {
        "booked": {"type": "boolean"},
        "time": {"type": "string", "description": "Reservation time, 24-hour HH:MM"},
        "partySize": {"type": "integer"},
        "confirmation": {"type": "string", "description": "Confirmation number or message"},
        "depositPerPerson": {"type": "string", "description": 'Deposit or charge per person, with currency, or "none"'},
        "cancellationPolicy": {"type": "string"},
        "reason": {"type": "string", "description": "Why nothing was booked, when nothing was"},
    },
    "required": ["booked"],
}

oc = Outcrawl()  # one client for the life of the server
state = {"profile": None, "monitor": None, "in_flight": None, "done": False}


@asynccontextmanager
async def lifespan(app: FastAPI):
    profiles = await oc.profiles.list(label="resy-personal")
    if not profiles:
        raise SystemExit("Create the resy-personal profile and sign in to Resy with it first.")
    state["profile"] = profiles[0]["id"]
    # Checked every minute. Each check is 1 credit, changed or not.
    monitor = await oc.monitors.create(
        url=WANT["page"],
        schedule="* * * * *",
        label="table-lilia",
        judge=True,
        notify={"webhook": f"{PUBLIC_URL}{HOOKS}/table-changed"},
    )
    state["monitor"] = monitor["id"]
    print(f"Watching {WANT['page']} as monitor {monitor['id']}")
    yield
    await oc.aclose()


app = FastAPI(lifespan=lifespan)


async def tell(text: str) -> None:
    print(text)
    if SLACK_WEBHOOK_URL:
        async with httpx.AsyncClient() as http:
            await http.post(SLACK_WEBHOOK_URL, json={"text": text})


# 1. The monitor saw the page change. Send an agent to book.
@app.post(f"{HOOKS}/table-changed")
async def table_changed(request: Request) -> Response:
    change = await request.json()
    if state["done"] or state["in_flight"] or change.get("status") != "changed":
        return Response(status_code=204)
    state["in_flight"] = "submitting"  # so two changes never book twice
    try:
        job = oc.agent(
            task=(
                f"On Resy, book a table at {WANT['restaurant']} for {WANT['party_size']} people on {WANT['date']}, "
                f"at the earliest available time from {WANT['earliest']} to {WANT['latest']}. Start at "
                f"{WANT['page']}; you are signed in. If Resy asks for a card to hold the table, use "
                "{{secret:card_dining}}. Do not book if no time in that window is free, or if the reservation needs "
                f"a deposit or charge now above ${WANT['max_deposit_per_person']} per person: report why instead."
            ),
            caps={"budget": "75.00", "duration": "6m"},
            profile=state["profile"],
            secrets=["card_dining"],
            rules=["Only use resy.com."],
            schema=BOOKING_SCHEMA,
            webhook=f"{PUBLIC_URL}{HOOKS}/booking-finished",
        )
        state["in_flight"] = await job.id()
    except Exception:
        state["in_flight"] = None  # refused, for example every browser slot busy; the next change tries again
        raise
    return JSONResponse({"run": state["in_flight"]}, status_code=202)


# 2. The run finished. Check what it booked and tell you.
@app.post(f"{HOOKS}/booking-finished")
async def booking_finished(request: Request) -> Response:
    run_id = (await request.json())["runId"]
    if run_id != state["in_flight"]:
        return Response(status_code=200)  # a repeat delivery of a run already handled
    state["in_flight"] = None

    run = await oc.agent.get(run_id)  # read the run itself, not the webhook body
    booking = run.get("data") or {}
    if not booking.get("booked"):
        print(f"No table yet: {booking.get('reason') or run.get('stopReason') or run['status']}")
        return Response(status_code=200)  # keep watching

    state["done"] = True
    await oc.monitors.delete(state["monitor"])
    time = booking.get("time", "?")
    in_window = WANT["earliest"] <= time <= WANT["latest"]
    await tell(
        f"Booked {WANT['restaurant']}, {WANT['date']} at {time} for {booking.get('partySize', WANT['party_size'])}. "
        f"Confirmation {booking.get('confirmation', 'on Resy')}. Deposit: {booking.get('depositPerPerson', 'none')}. "
        f"{booking.get('cancellationPolicy', '')}{'' if in_window else ' This is OUTSIDE your window: check it on Resy.'}"
    )
    return Response(status_code=200)


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, port=3000)