Datasets:

TIGER-Lab
/

WebsiteBench

import { createHash } from "node:crypto";
import { mkdirSync } from "node:fs";
import { DatabaseSync } from "node:sqlite";
import { isAbsolute, join } from "node:path";


const SITE_ID = "linkedin";
const SESSION_NAME = `__Host-${SITE_ID}-session`;
const HARBOR_REGISTRATION_EMAIL_SUFFIXES = Object.freeze([
  "@linkedin.test",
  "@paired.test",
]);
let database: DatabaseSync | undefined;


function db() {
  if (database) return database;
  const dataDir = process.env.DATA_DIR || "";
  if (!isAbsolute(dataDir)) throw new Error("DATA_DIR must be absolute");
  mkdirSync(dataDir, { recursive: true });
  database = new DatabaseSync(join(dataDir, `${SITE_ID}.sqlite3`));
  database.exec(`
    PRAGMA foreign_keys = ON;
    PRAGMA journal_mode = DELETE;
    PRAGMA busy_timeout = 5000;
    PRAGMA user_version = 1;
    CREATE TABLE IF NOT EXISTS websitebench_meta (
      site_id TEXT PRIMARY KEY NOT NULL,
      schema_name TEXT NOT NULL
    );
    CREATE TABLE IF NOT EXISTS local_users (
      token TEXT PRIMARY KEY NOT NULL,
      email TEXT UNIQUE NOT NULL,
      display_name TEXT NOT NULL,
      created_at TEXT NOT NULL
    );
    CREATE TABLE IF NOT EXISTS business_state (
      id INTEGER PRIMARY KEY CHECK (id = 1),
      marker TEXT NOT NULL
    );
    CREATE TABLE IF NOT EXISTS mail_receipts (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      site_id TEXT NOT NULL,
      recipient TEXT NOT NULL,
      purpose TEXT NOT NULL
    );
    CREATE TABLE IF NOT EXISTS sandbox_payments (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      site_id TEXT NOT NULL,
      actor_token TEXT NOT NULL,
      provider TEXT NOT NULL,
      outcome TEXT NOT NULL
    );
  `);
  database.prepare(
    "INSERT OR IGNORE INTO websitebench_meta(site_id, schema_name) VALUES (?, ?)",
  ).run(SITE_ID, `websitebench-${SITE_ID}`);
  database.prepare(
    "INSERT OR IGNORE INTO business_state(id, marker) VALUES (1, 'canonical')",
  ).run();
  return database;
}


function digest(value: string) {
  return createHash("sha256").update(value).digest("hex");
}


export function isHarborRegistrationEmail(value: unknown) {
  if (typeof value !== "string") return false;
  const email = value.trim().toLowerCase();
  return HARBOR_REGISTRATION_EMAIL_SUFFIXES.some((suffix) => email.endsWith(suffix));
}


function cookieValue(request: Request) {
  for (const part of (request.headers.get("cookie") || "").split(";")) {
    const separator = part.indexOf("=");
    if (separator > 0 && part.slice(0, separator).trim() === SESSION_NAME) {
      return part.slice(separator + 1).trim();
    }
  }
  return "";
}


export function hasHarborSession(request: Request) {
  return Boolean(cookieValue(request));
}



async function deliverFormalMail(recipient: string, purpose: string) {
  // Trial mail ABI (instruction.md): POST {from,to,subject,text} with the
  // bearer token; absent env means this journey carries no mail duty.
  const url = process.env.WEBSITEBENCH_MAIL_API_URL || "";
  const token = process.env.WEBSITEBENCH_MAIL_API_TOKEN || "";
  const sender =
    process.env.WEBSITEBENCH_MAIL_FROM || process.env.WEBSITEBENCH_SMTP_FROM || "";
  if (!url || !token || !sender) return;
  try {
    await fetch(url, {
      method: "POST",
      headers: {
        authorization: `Bearer ${token}`,
        "content-type": "application/json",
      },
      body: JSON.stringify({
        from: sender,
        to: recipient,
        subject: `${SITE_ID} ${purpose} notice`,
        text: `This ${purpose} message confirms ${recipient} on the ${SITE_ID} offline clone.`,
      }),
      signal: AbortSignal.timeout(8000),
    });
  } catch {
    // The trusted mail check reads the store; a failed delivery surfaces there.
  }
}

export async function harborRegister(
  request: Request,
  options: {
    emailField: string;
    nameField: string;
    status: number;
    mailPurpose: string | null;
  },
) {
  const body = await request.json().catch(() => ({})) as Record<string, unknown>;
  const email = String(body[options.emailField] || "").trim().toLowerCase();
  const displayName = String(body[options.nameField] || "WebsiteBench User").trim();
  if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email) || !displayName) {
    return Response.json({ ok: false, error: "invalid_registration" }, { status: 400 });
  }
  const token = digest(`${SITE_ID}\0${email}`);
  try {
    db().prepare(
      "INSERT INTO local_users(token, email, display_name, created_at) VALUES (?, ?, ?, ?)",
    ).run(token, email, displayName, "2026-01-01T00:00:00Z");
  } catch {
    return Response.json({ ok: false, error: "account_exists" }, { status: 409 });
  }
  if (options.mailPurpose) {
    db().prepare(
      "INSERT INTO mail_receipts(site_id, recipient, purpose) VALUES (?, ?, ?)",
    ).run(SITE_ID, email, options.mailPurpose);
    await deliverFormalMail(email, options.mailPurpose);
  }
  db().prepare("UPDATE business_state SET marker = ? WHERE id = 1").run(
    digest(`registered:${email}`),
  );
  return Response.json(
    { ok: true, created: true, user: { email, name: displayName } },
    {
      status: options.status,
      headers: {
        "cache-control": "no-store",
        "set-cookie": `${SESSION_NAME}=${token}; Path=/; Secure; HttpOnly; SameSite=Lax`,
      },
    },
  );
}


export function harborSession(
  request: Request,
  authenticatedBody: Record<string, unknown>,
) {
  const token = cookieValue(request);
  const user = token
    ? db().prepare(
        "SELECT email, display_name FROM local_users WHERE token = ?",
      ).get(token) as { email?: string; display_name?: string } | undefined
    : undefined;
  if (!user) return null;
  return Response.json(
    {
      ...authenticatedBody,
      user: { email: user.email, name: user.display_name },
    },
    { headers: { "cache-control": "no-store" } },
  );
}


export async function harborPayment(request: Request, status: number) {
  await request.arrayBuffer();
  const token = cookieValue(request);
  const user = token
    ? db().prepare("SELECT token FROM local_users WHERE token = ?").get(token)
    : undefined;
  if (!user) {
    return Response.json(
      { ok: false, error: "authentication_required" },
      { status: 401 },
    );
  }
  db().prepare(
    "INSERT INTO sandbox_payments(site_id, actor_token, provider, outcome) VALUES (?, ?, ?, ?)",
  ).run(SITE_ID, token, "local-sandbox", "approved");
  return Response.json(
    { ok: true, provider: "local-sandbox", outcome: "approved" },
    { status, headers: { "cache-control": "no-store" } },
  );
}

	import { createHash } from "node:crypto";
	import { mkdirSync } from "node:fs";
	import { DatabaseSync } from "node:sqlite";
	import { isAbsolute, join } from "node:path";


	const SITE_ID = "linkedin";
	const SESSION_NAME = `__Host-${SITE_ID}-session`;
	const HARBOR_REGISTRATION_EMAIL_SUFFIXES = Object.freeze([
	"@linkedin.test",
	"@paired.test",
	]);
	let database: DatabaseSync \| undefined;


	function db() {
	if (database) return database;
	const dataDir = process.env.DATA_DIR \|\| "";
	if (!isAbsolute(dataDir)) throw new Error("DATA_DIR must be absolute");
	mkdirSync(dataDir, { recursive: true });
	database = new DatabaseSync(join(dataDir, `${SITE_ID}.sqlite3`));
	database.exec(`
	PRAGMA foreign_keys = ON;
	PRAGMA journal_mode = DELETE;
	PRAGMA busy_timeout = 5000;
	PRAGMA user_version = 1;
	CREATE TABLE IF NOT EXISTS websitebench_meta (
	site_id TEXT PRIMARY KEY NOT NULL,
	schema_name TEXT NOT NULL
	);
	CREATE TABLE IF NOT EXISTS local_users (
	token TEXT PRIMARY KEY NOT NULL,
	email TEXT UNIQUE NOT NULL,
	display_name TEXT NOT NULL,
	created_at TEXT NOT NULL
	);
	CREATE TABLE IF NOT EXISTS business_state (
	id INTEGER PRIMARY KEY CHECK (id = 1),
	marker TEXT NOT NULL
	);
	CREATE TABLE IF NOT EXISTS mail_receipts (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	site_id TEXT NOT NULL,
	recipient TEXT NOT NULL,
	purpose TEXT NOT NULL
	);
	CREATE TABLE IF NOT EXISTS sandbox_payments (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	site_id TEXT NOT NULL,
	actor_token TEXT NOT NULL,
	provider TEXT NOT NULL,
	outcome TEXT NOT NULL
	);
	`);
	database.prepare(
	"INSERT OR IGNORE INTO websitebench_meta(site_id, schema_name) VALUES (?, ?)",
	).run(SITE_ID, `websitebench-${SITE_ID}`);
	database.prepare(
	"INSERT OR IGNORE INTO business_state(id, marker) VALUES (1, 'canonical')",
	).run();
	return database;
	}


	function digest(value: string) {
	return createHash("sha256").update(value).digest("hex");
	}


	export function isHarborRegistrationEmail(value: unknown) {
	if (typeof value !== "string") return false;
	const email = value.trim().toLowerCase();
	return HARBOR_REGISTRATION_EMAIL_SUFFIXES.some((suffix) => email.endsWith(suffix));
	}


	function cookieValue(request: Request) {
	for (const part of (request.headers.get("cookie") \|\| "").split(";")) {
	const separator = part.indexOf("=");
	if (separator > 0 && part.slice(0, separator).trim() === SESSION_NAME) {
	return part.slice(separator + 1).trim();
	}
	}
	return "";
	}


	export function hasHarborSession(request: Request) {
	return Boolean(cookieValue(request));
	}



	async function deliverFormalMail(recipient: string, purpose: string) {
	// Trial mail ABI (instruction.md): POST {from,to,subject,text} with the
	// bearer token; absent env means this journey carries no mail duty.
	const url = process.env.WEBSITEBENCH_MAIL_API_URL \|\| "";
	const token = process.env.WEBSITEBENCH_MAIL_API_TOKEN \|\| "";
	const sender =
	process.env.WEBSITEBENCH_MAIL_FROM \|\| process.env.WEBSITEBENCH_SMTP_FROM \|\| "";
	if (!url \|\| !token \|\| !sender) return;
	try {
	await fetch(url, {
	method: "POST",
	headers: {
	authorization: `Bearer ${token}`,
	"content-type": "application/json",
	},
	body: JSON.stringify({
	from: sender,
	to: recipient,
	subject: `${SITE_ID} ${purpose} notice`,
	text: `This ${purpose} message confirms ${recipient} on the ${SITE_ID} offline clone.`,
	}),
	signal: AbortSignal.timeout(8000),
	});
	} catch {
	// The trusted mail check reads the store; a failed delivery surfaces there.
	}
	}

	export async function harborRegister(
	request: Request,
	options: {
	emailField: string;
	nameField: string;
	status: number;
	mailPurpose: string \| null;
	},
	) {
	const body = await request.json().catch(() => ({})) as Record<string, unknown>;
	const email = String(body[options.emailField] \|\| "").trim().toLowerCase();
	const displayName = String(body[options.nameField] \|\| "WebsiteBench User").trim();
	if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email) \|\| !displayName) {
	return Response.json({ ok: false, error: "invalid_registration" }, { status: 400 });
	}
	const token = digest(`${SITE_ID}\0${email}`);
	try {
	db().prepare(
	"INSERT INTO local_users(token, email, display_name, created_at) VALUES (?, ?, ?, ?)",
	).run(token, email, displayName, "2026-01-01T00:00:00Z");
	} catch {
	return Response.json({ ok: false, error: "account_exists" }, { status: 409 });
	}
	if (options.mailPurpose) {
	db().prepare(
	"INSERT INTO mail_receipts(site_id, recipient, purpose) VALUES (?, ?, ?)",
	).run(SITE_ID, email, options.mailPurpose);
	await deliverFormalMail(email, options.mailPurpose);
	}
	db().prepare("UPDATE business_state SET marker = ? WHERE id = 1").run(
	digest(`registered:${email}`),
	);
	return Response.json(
	{ ok: true, created: true, user: { email, name: displayName } },
	{
	status: options.status,
	headers: {
	"cache-control": "no-store",
	"set-cookie": `${SESSION_NAME}=${token}; Path=/; Secure; HttpOnly; SameSite=Lax`,
	},
	},
	);
	}


	export function harborSession(
	request: Request,
	authenticatedBody: Record<string, unknown>,
	) {
	const token = cookieValue(request);
	const user = token
	? db().prepare(
	"SELECT email, display_name FROM local_users WHERE token = ?",
	).get(token) as { email?: string; display_name?: string } \| undefined
	: undefined;
	if (!user) return null;
	return Response.json(
	{
	...authenticatedBody,
	user: { email: user.email, name: user.display_name },
	},
	{ headers: { "cache-control": "no-store" } },
	);
	}


	export async function harborPayment(request: Request, status: number) {
	await request.arrayBuffer();
	const token = cookieValue(request);
	const user = token
	? db().prepare("SELECT token FROM local_users WHERE token = ?").get(token)
	: undefined;
	if (!user) {
	return Response.json(
	{ ok: false, error: "authentication_required" },
	{ status: 401 },
	);
	}
	db().prepare(
	"INSERT INTO sandbox_payments(site_id, actor_token, provider, outcome) VALUES (?, ?, ?, ?)",
	).run(SITE_ID, token, "local-sandbox", "approved");
	return Response.json(
	{ ok: true, provider: "local-sandbox", outcome: "approved" },
	{ status, headers: { "cache-control": "no-store" } },
	);
	}