@trusty-squire/mcp 1.1.13-rc.8 → 1.1.13

package/dist/bot/operator-profile-pool.js

@@ -1,855 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, copyFileSync, cpSync, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, readlinkSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
-import { homedir, hostname, tmpdir } from "node:os";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { CHROME_PROFILE_DIR, processBirthIdentity, processBirthIdentityState, profilePathIdentity, profileProcessIdentity, profileProcessIdentityState, signalProfileProcess, } from "./profile.js";
-// Fixed per-namespace admission bound. These directories, rather than an
-// in-memory counter, are the authority across MCP processes. A third operator
-// start in the same namespace may wait at the provision seam, but can never
-// create a third active profile while both slots are claimed.
-const ACTIVE_SLOT_COUNT = 2;
-const UNPUBLISHED_SEED_GENERATION = "unpublished";
-const STARTUP_GRACE_MS = 30_000;
-const WARM_IDLE_TTL_MS = 6 * 60 * 60 * 1_000;
-const WARM_MAX_REUSES = 50;
-const WARM_MAX_AGE_MS = 24 * 60 * 60 * 1_000;
-const TRANSIENT_PROFILE_NAMES = new Set([
-    "SingletonLock",
-    "SingletonSocket",
-    "SingletonCookie",
-    "DevToolsActivePort",
-]);
-const TRANSIENT_PROFILE_DIRS = new Set(["Cache", "Code Cache", "GPUCache", "Crashpad"]);
-const IDENTITY_SEED_FILES = [
-    "Local State",
-    "logged-in-providers.json",
-    "provider-emails.json",
-];
-const POOLED_COOKIE_STORES = ["Default/Cookies", "Default/Network/Cookies"];
-const SQLITE_SIDECAR_SUFFIXES = ["", "-journal", "-shm", "-wal"];
-export const GOOGLE_LOGIN_COOKIE_MARKERS = ["__Secure-1PSID", "SAPISID", "SID"];
-export class OperatorProfileAcquisitionInterruptedError extends Error {
-    reason;
-    phase;
-    constructor(reason, phase = "profile") {
-        super(`operator profile acquisition ${reason === "timeout" ? "timed out" : "was cancelled"}`);
-        this.reason = reason;
-        this.phase = phase;
-        this.name = "OperatorProfileAcquisitionInterruptedError";
-    }
-}
-function defaultPoolRoot() {
-    return process.env.VITEST === "true"
-        ? join(tmpdir(), `trusty-squire-operator-profiles-test-${process.pid}`)
-        : join(homedir(), ".trusty-squire", "operator-profiles");
-}
-function poolRootForSource(sourceProfileDir, rootDir) {
-    if (rootDir !== undefined)
-        return resolve(rootDir);
-    const namespace = createHash("sha256")
-        .update(profilePathIdentity(sourceProfileDir))
-        .digest("hex")
-        .slice(0, 24);
-    return join(defaultPoolRoot(), "namespaces", namespace);
-}
-function paths(rootDir) {
-    const root = resolve(rootDir ?? defaultPoolRoot());
-    const seed = join(root, "seed");
-    return {
-        root,
-        seed,
-        generations: join(seed, "generations"),
-        current: join(seed, "current"),
-        seedLock: join(seed, ".lock"),
-        profiles: join(root, "profiles"),
-        active: join(root, "active"),
-        activeClaims: join(root, "active-claims"),
-        warm: join(root, "warm"),
-        tombstones: join(root, "tombstones"),
-    };
-}
-function ensurePrivateDir(path) {
-    mkdirSync(path, { recursive: true, mode: 0o700 });
-    chmodSync(path, 0o700);
-}
-function initializePool(p) {
-    for (const dir of [
-        p.root,
-        p.seed,
-        p.generations,
-        p.profiles,
-        p.active,
-        p.activeClaims,
-        p.warm,
-        p.tombstones,
-    ]) {
-        ensurePrivateDir(dir);
-    }
-}
-function writePrivateJson(path, value) {
-    const temporary = `${path}.tmp.${randomUUID()}`;
-    try {
-        writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
-        chmodSync(temporary, 0o600);
-        renameSync(temporary, path);
-    }
-    catch (err) {
-        rmSync(temporary, { force: true });
-        throw err;
-    }
-}
-function readJson(path) {
-    try {
-        return JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-function currentProcessIdentity() {
-    return processBirthIdentity(process.pid) ?? { pid: process.pid, start_time: "unknown" };
-}
-function processState(identity) {
-    return processBirthIdentityState(identity);
-}
-function readSeedLockOwner(path) {
-    try {
-        return lstatSync(path).isDirectory()
-            ? readJson(join(path, "owner.json"))
-            : readJson(path);
-    }
-    catch {
-        return null;
-    }
-}
-function seedLockState(path) {
-    // Valid owner records are reclaimed only when their same-host PID/start_time is
-    // confirmed stale. A matching or cross-host owner is intentionally unreclaimed:
-    // wall-clock reclaim of a plausibly-live owner cannot be fully race-free without
-    // a heavier heartbeat or fencing protocol, which was rejected as out of scope.
-    // It also cannot protect against an already-running old-version orphan like the
-    // 2026-08-15 incident; identify and kill that process by PID instead. The
-    // startup grace below applies only when no valid owner record can be read.
-    const owner = readSeedLockOwner(path);
-    if (owner !== null) {
-        if (owner.host !== hostname())
-            return "unknown";
-        return processState(owner);
-    }
-    try {
-        return Date.now() - lstatSync(path).mtimeMs >= STARTUP_GRACE_MS ? "stale" : "unknown";
-    }
-    catch (err) {
-        return err.code === "ENOENT" ? "stale" : "unknown";
-    }
-}
-function seedLockArtifacts(p, kind) {
-    const dir = kind === "claim" ? p.seed : p.tombstones;
-    const prefix = kind === "claim" ? `${basename(p.seedLock)}.claim-` : "seed-lock-";
-    try {
-        return readdirSync(dir)
-            .filter((name) => name.startsWith(prefix))
-            .map((name) => join(dir, name));
-    }
-    catch {
-        return [];
-    }
-}
-function scavengeSeedLockArtifacts(p) {
-    let retainedTombstone = false;
-    for (const tombstone of seedLockArtifacts(p, "stale")) {
-        if (seedLockState(tombstone) === "stale") {
-            rmSync(tombstone, { recursive: true, force: true });
-        }
-        else {
-            retainedTombstone = true;
-        }
-    }
-    for (const claim of seedLockArtifacts(p, "claim")) {
-        if (seedLockState(claim) === "stale")
-            rmSync(claim, { force: true });
-    }
-    return retainedTombstone;
-}
-function quarantineStaleSeedLock(p) {
-    if (seedLockState(p.seedLock) !== "stale")
-        return false;
-    const tombstone = join(p.tombstones, `seed-lock-${randomUUID()}`);
-    try {
-        renameSync(p.seedLock, tombstone);
-    }
-    catch (err) {
-        return err.code === "ENOENT";
-    }
-    if (seedLockState(tombstone) === "stale") {
-        rmSync(tombstone, { recursive: true, force: true });
-        return true;
-    }
-    return false;
-}
-function stripTransientProfileState(root) {
-    const walk = (dir) => {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            const path = join(dir, entry.name);
-            if (TRANSIENT_PROFILE_NAMES.has(entry.name) || TRANSIENT_PROFILE_DIRS.has(entry.name)) {
-                rmSync(path, { recursive: true, force: true });
-            }
-            else if (entry.isDirectory()) {
-                walk(path);
-            }
-        }
-    };
-    if (existsSync(root))
-        walk(root);
-}
-function stripPooledProfileCookies(root) {
-    for (const relative of POOLED_COOKIE_STORES) {
-        for (const suffix of SQLITE_SIDECAR_SUFFIXES) {
-            rmSync(join(root, `${relative}${suffix}`), { force: true });
-        }
-    }
-}
-function copyIdentitySeedFile(sourceRoot, destinationRoot, relative) {
-    const source = join(sourceRoot, relative);
-    try {
-        if (!lstatSync(source).isFile())
-            return;
-    }
-    catch {
-        return;
-    }
-    const destination = join(destinationRoot, relative);
-    ensurePrivateDir(dirname(destination));
-    copyFileSync(source, destination);
-    chmodSync(destination, 0o600);
-}
-// Pooled clones must never carry Google's session cookies: a clone presents
-// already-rotated-away cookie values (Google rotates them on the live
-// profile as it's used), and Google's server treats that as credential
-// replay and invalidates the whole session family — killing the user's real
-// Google session for a casual pooled run. Google identity now only flows
-// through the direct, unshared profile (operator-direct-identity.ts, gated
-// by operate_start's require_live_identity); the seed and its clones carry
-// no cookies at all.
-function copyIdentitySeed(sourceProfileDir, destination) {
-    if (!lstatSync(sourceProfileDir).isDirectory()) {
-        throw new Error(`operator login source is not a directory: ${sourceProfileDir}`);
-    }
-    ensurePrivateDir(destination);
-    for (const relative of IDENTITY_SEED_FILES) {
-        copyIdentitySeedFile(sourceProfileDir, destination, relative);
-    }
-}
-function assertProfileAcquisitionActive(control, phase = "profile") {
-    if (control.signal?.aborted === true) {
-        throw new OperatorProfileAcquisitionInterruptedError("cancelled", phase);
-    }
-    if (control.deadline !== undefined && Date.now() >= control.deadline) {
-        throw new OperatorProfileAcquisitionInterruptedError("timeout", phase);
-    }
-}
-async function waitForSeedLockRetry(control) {
-    assertProfileAcquisitionActive(control, "seed_lock");
-    const delay = control.deadline === undefined ? 25 : Math.max(0, Math.min(25, control.deadline - Date.now()));
-    await new Promise((resolveWait) => {
-        let settled = false;
-        let timer;
-        const finish = () => {
-            if (settled)
-                return;
-            settled = true;
-            if (timer !== undefined)
-                clearTimeout(timer);
-            control.signal?.removeEventListener("abort", finish);
-            resolveWait();
-        };
-        timer = setTimeout(finish, delay);
-        control.signal?.addEventListener("abort", finish, { once: true });
-        if (control.signal?.aborted === true)
-            finish();
-    });
-    assertProfileAcquisitionActive(control, "seed_lock");
-}
-async function withSeedLock(p, fn, control = {}) {
-    const token = randomUUID();
-    const owner = {
-        host: hostname(),
-        ...currentProcessIdentity(),
-        token,
-    };
-    for (;;) {
-        assertProfileAcquisitionActive(control, "seed_lock");
-        if (scavengeSeedLockArtifacts(p)) {
-            await waitForSeedLockRetry(control);
-            continue;
-        }
-        const claim = `${p.seedLock}.claim-${randomUUID()}`;
-        writeFileSync(claim, `${JSON.stringify(owner)}\n`, { mode: 0o600, flag: "wx" });
-        try {
-            linkSync(claim, p.seedLock);
-        }
-        catch (err) {
-            rmSync(claim, { force: true });
-            if (err.code !== "EEXIST")
-                throw err;
-            if (quarantineStaleSeedLock(p))
-                continue;
-            await waitForSeedLockRetry(control);
-            continue;
-        }
-        try {
-            rmSync(claim, { force: true });
-        }
-        catch (err) {
-            if (readSeedLockOwner(p.seedLock)?.token === token) {
-                rmSync(p.seedLock, { recursive: true, force: true });
-            }
-            throw err;
-        }
-        break;
-    }
-    try {
-        assertProfileAcquisitionActive(control, "seed_lock");
-        return await fn();
-    }
-    finally {
-        if (readSeedLockOwner(p.seedLock)?.token === token) {
-            rmSync(p.seedLock, { recursive: true, force: true });
-        }
-        for (const tombstone of seedLockArtifacts(p, "stale")) {
-            if (readSeedLockOwner(tombstone)?.token === token) {
-                rmSync(tombstone, { recursive: true, force: true });
-            }
-        }
-    }
-}
-function currentGeneration(p) {
-    try {
-        const target = readlinkSync(p.current);
-        const generation = basename(target);
-        return existsSync(join(p.generations, generation, "user-data")) ? generation : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function publishSeedLocked(p, sourceProfileDir) {
-    const generation = randomUUID();
-    const staging = join(p.generations, `.${generation}.tmp`);
-    const destination = join(p.generations, generation);
-    try {
-        ensurePrivateDir(staging);
-        copyIdentitySeed(sourceProfileDir, join(staging, "user-data"));
-        renameSync(staging, destination);
-        const nextLink = join(p.seed, `.current-${generation}`);
-        symlinkSync(join("generations", generation), nextLink, "dir");
-        renameSync(nextLink, p.current);
-        for (const entry of readdirSync(p.generations, { withFileTypes: true })) {
-            if (entry.name !== generation) {
-                rmSync(join(p.generations, entry.name), { recursive: true, force: true });
-            }
-        }
-        return generation;
-    }
-    catch (err) {
-        rmSync(staging, { recursive: true, force: true });
-        throw err;
-    }
-}
-export function assertOperatorProfileRuntimeSupported(platform = process.platform) {
-    if (platform !== "linux") {
-        throw new Error("operator profile leases require Linux process identity");
-    }
-}
-export function canPublishOperatorProfileSeed(proof, platform = process.platform) {
-    return (platform === "linux" &&
-        proof.provider === "google" &&
-        proof.loginStatus === "completed" &&
-        proof.closeState === "closed");
-}
-export async function publishOperatorProfileSeed(sourceProfileDir = CHROME_PROFILE_DIR, opts) {
-    if (!canPublishOperatorProfileSeed(opts.proof)) {
-        throw new Error("operator profile seed publication requires explicit completed Google login provenance and verified Linux Chrome closure");
-    }
-    const resolvedSource = profilePathIdentity(sourceProfileDir);
-    const p = paths(poolRootForSource(resolvedSource, opts.rootDir));
-    initializePool(p);
-    return await withSeedLock(p, () => publishSeedLocked(p, resolvedSource));
-}
-function profileDir(p, profileId) {
-    return join(p.profiles, profileId, "user-data");
-}
-function readLease(claimDir) {
-    const lease = readJson(join(claimDir, "lease.json"));
-    if (lease?.version !== 1 ||
-        typeof lease.lease_token !== "string" ||
-        typeof lease.profile_id !== "string" ||
-        !/^[0-9a-f-]{36}$/.test(lease.profile_id) ||
-        typeof lease.seed_generation !== "string" ||
-        typeof lease.created_at !== "number" ||
-        typeof lease.reuse_count !== "number" ||
-        (lease.disposition !== undefined && lease.disposition !== "destroy_required")) {
-        return null;
-    }
-    return lease;
-}
-function removeProfile(p, lease) {
-    rmSync(join(p.profiles, lease.profile_id), { recursive: true, force: true });
-}
-function quarantine(p, publicPath, label) {
-    const privatePath = join(p.tombstones, `${label}-${randomUUID()}`);
-    try {
-        renameSync(publicPath, privatePath);
-        return privatePath;
-    }
-    catch (err) {
-        if (["ENOENT", "EEXIST", "ENOTEMPTY"].includes(err.code ?? "")) {
-            return null;
-        }
-        throw err;
-    }
-}
-function removeSlotContainer(p, path) {
-    let privateClaim = null;
-    try {
-        if (lstatSync(path).isSymbolicLink()) {
-            privateClaim = resolve(dirname(path), readlinkSync(path));
-        }
-    }
-    catch {
-        return;
-    }
-    rmSync(path, { recursive: true, force: true });
-    if (privateClaim !== null && dirname(privateClaim) === p.activeClaims) {
-        rmSync(privateClaim, { recursive: true, force: true });
-    }
-}
-function reserveActiveSlot(p, index, sessionId, beforePublish) {
-    const ownerToken = randomUUID();
-    const privateClaim = join(p.activeClaims, randomUUID());
-    const candidate = join(p.active, `slot-${index}`);
-    ensurePrivateDir(privateClaim);
-    let published = false;
-    try {
-        const identity = currentProcessIdentity();
-        writePrivateJson(join(privateClaim, "owner.json"), {
-            host: hostname(),
-            ...identity,
-            token: ownerToken,
-            session_id: sessionId,
-        });
-        beforePublish?.();
-        try {
-            symlinkSync(relative(p.active, privateClaim), candidate, "dir");
-        }
-        catch (err) {
-            if (err.code === "EEXIST")
-                return null;
-            throw err;
-        }
-        published = true;
-        if (readJson(join(candidate, "owner.json"))?.token !== ownerToken) {
-            throw new Error("operator active-slot ownership was lost during reservation");
-        }
-        return { slotDir: candidate, ownerToken };
-    }
-    finally {
-        if (!published)
-            rmSync(privateClaim, { recursive: true, force: true });
-    }
-}
-function quarantineOwnedActiveSlot(p, slotDir, ownerToken, label) {
-    if (readJson(join(slotDir, "owner.json"))?.token !== ownerToken)
-        return null;
-    const tombstone = quarantine(p, slotDir, label);
-    if (tombstone === null)
-        return null;
-    if (readJson(join(tombstone, "owner.json"))?.token !== ownerToken) {
-        // The renamed directory is private, so retaining an ambiguity is safe.
-        return null;
-    }
-    return tombstone;
-}
-// removeProfile deletes a real, potentially large per-session Chrome profile
-// (cache/history/IndexedDB accumulated over real browsing) — a disk-bound
-// rmSync that can be genuinely slow. onRemovable, when supplied, lets the
-// caller defer that physical delete until after the seed lock (which this
-// function normally runs under, via scavengeQuarantinedActive /
-// scavengeActiveSlots) has been released, so an unrelated concurrent
-// operate_start never queues behind someone else's cleanup.
-function reapQuarantinedActive(p, tombstone, workerState = profileProcessIdentityState, signalWorker = signalProfileProcess, onRemovable) {
-    const owner = readJson(join(tombstone, "owner.json"));
-    if (owner !== null && (owner.host !== hostname() || processState(owner) !== "stale")) {
-        const slotIndex = /^active-(\d+)-/.exec(basename(tombstone))?.[1];
-        if (slotIndex === undefined)
-            return;
-        const publicSlot = join(p.active, `slot-${slotIndex}`);
-        try {
-            renameSync(tombstone, publicSlot);
-        }
-        catch {
-            // Another owner already reserved capacity. Keep this lease private and
-            // leak-safe for a later manual inspection rather than killing ambiguity.
-        }
-        return;
-    }
-    const claim = join(tombstone, "claim");
-    const lease = readLease(claim);
-    if (lease === null) {
-        removeSlotContainer(p, tombstone);
-        return;
-    }
-    const dir = profileDir(p, lease.profile_id);
-    const worker = lease.worker;
-    if (worker === undefined)
-        return;
-    const state = workerState(worker, dir);
-    if (state === "unknown")
-        return;
-    if (state === "matching") {
-        if (!signalWorker(worker, dir, "SIGKILL"))
-            return;
-        return;
-    }
-    if (onRemovable) {
-        onRemovable({ lease, finish: () => removeSlotContainer(p, tombstone) });
-    }
-    else {
-        removeProfile(p, lease);
-        removeSlotContainer(p, tombstone);
-    }
-}
-function scavengeDestroyRequired(p, workerState = profileProcessIdentityState, signalWorker = signalProfileProcess) {
-    for (const entry of readdirSync(p.tombstones)) {
-        if (!entry.startsWith("destroy-required-"))
-            continue;
-        const tombstone = join(p.tombstones, entry);
-        const lease = readLease(join(tombstone, "claim"));
-        if (lease?.disposition !== "destroy_required" || lease.worker === undefined)
-            continue;
-        const dir = profileDir(p, lease.profile_id);
-        const state = workerState(lease.worker, dir);
-        if (state === "unknown")
-            continue;
-        if (state === "matching") {
-            signalWorker(lease.worker, dir, "SIGKILL");
-            continue;
-        }
-        removeProfile(p, lease);
-        removeSlotContainer(p, tombstone);
-    }
-}
-function scavengeQuarantinedActive(p, workerState = profileProcessIdentityState, signalWorker = signalProfileProcess, onRemovable) {
-    for (const entry of readdirSync(p.tombstones)) {
-        if (!/^active-\d+-/.test(entry))
-            continue;
-        reapQuarantinedActive(p, join(p.tombstones, entry), workerState, signalWorker, onRemovable);
-    }
-}
-function scavengeActiveSlots(p, now, onRemovable) {
-    for (let index = 0; index < ACTIVE_SLOT_COUNT; index += 1) {
-        const slot = join(p.active, `slot-${index}`);
-        if (!existsSync(slot))
-            continue;
-        const owner = readJson(join(slot, "owner.json"));
-        if (owner === null) {
-            if (now - statSync(slot).mtimeMs < STARTUP_GRACE_MS)
-                continue;
-        }
-        else if (owner.host !== hostname() || processState(owner) !== "stale") {
-            continue;
-        }
-        // The public slot is only a candidate until this rename wins. No process is
-        // inspected again, signalled, or deleted while the lease remains claimable.
-        const tombstone = quarantine(p, slot, `active-${index}`);
-        if (tombstone !== null)
-            reapQuarantinedActive(p, tombstone, undefined, undefined, onRemovable);
-    }
-}
-// onRemovable defers the physical delete of an expired warm profile's real
-// (potentially large) directory to after the caller releases the seed lock —
-// see reapQuarantinedActive's comment for why.
-function scavengeWarm(p, generation, now, onRemovable) {
-    const removeQuarantinedWarm = (tombstone) => {
-        const lease = readLease(tombstone);
-        if (lease === null) {
-            rmSync(tombstone, { recursive: true, force: true });
-        }
-        else if (onRemovable) {
-            onRemovable({
-                lease,
-                finish: () => rmSync(tombstone, { recursive: true, force: true }),
-            });
-        }
-        else {
-            removeProfile(p, lease);
-            rmSync(tombstone, { recursive: true, force: true });
-        }
-    };
-    for (const entry of readdirSync(p.tombstones)) {
-        if (entry.startsWith("warm-"))
-            removeQuarantinedWarm(join(p.tombstones, entry));
-    }
-    const warm = join(p.warm, "slot-0");
-    if (!existsSync(warm))
-        return;
-    const lease = readLease(warm);
-    const expired = lease === null ||
-        lease.worker !== undefined ||
-        lease.seed_generation !== generation ||
-        lease.returned_at === undefined ||
-        now - lease.returned_at >= WARM_IDLE_TTL_MS ||
-        now - lease.created_at >= WARM_MAX_AGE_MS ||
-        lease.reuse_count >= WARM_MAX_REUSES;
-    if (!expired)
-        return;
-    const tombstone = quarantine(p, warm, "warm");
-    if (tombstone === null)
-        return;
-    removeQuarantinedWarm(tombstone);
-}
-function flushDeferredProfileRemovals(p, removals) {
-    for (const removal of removals) {
-        try {
-            removeProfile(p, removal.lease);
-            removal.finish();
-        }
-        catch { }
-    }
-}
-export class OperatorProfileLease {
-    p;
-    slotDir;
-    claimDir;
-    ownerToken;
-    descriptor;
-    now;
-    profileDir;
-    profileId;
-    seedGeneration;
-    finished = false;
-    constructor(p, slotDir, claimDir, ownerToken, descriptor, now) {
-        this.p = p;
-        this.slotDir = slotDir;
-        this.claimDir = claimDir;
-        this.ownerToken = ownerToken;
-        this.descriptor = descriptor;
-        this.now = now;
-        this.profileId = descriptor.profile_id;
-        this.seedGeneration = descriptor.seed_generation;
-        this.profileDir = profileDir(p, descriptor.profile_id);
-    }
-    bindWorker(worker) {
-        if (this.finished)
-            throw new Error("operator profile lease is already released");
-        if (worker.host !== hostname() ||
-            profilePathIdentity(worker.user_data_dir) !== profilePathIdentity(this.profileDir)) {
-            throw new Error("operator worker identity does not match its leased profile");
-        }
-        this.descriptor = { ...this.descriptor, worker };
-        writePrivateJson(join(this.claimDir, "lease.json"), this.descriptor);
-    }
-    async returnWarm(closeState) {
-        if (this.finished)
-            return;
-        if (this.descriptor.disposition === "destroy_required") {
-            if (closeState === "closed")
-                await this.destroy();
-            else
-                await this.retain(true);
-            return;
-        }
-        if (closeState !== "closed") {
-            await this.retain();
-            return;
-        }
-        const withoutWorker = { ...this.descriptor };
-        delete withoutWorker.worker;
-        this.descriptor = {
-            ...withoutWorker,
-            returned_at: this.now(),
-            reuse_count: this.descriptor.reuse_count + 1,
-        };
-        writePrivateJson(join(this.claimDir, "lease.json"), this.descriptor);
-        const current = currentGeneration(this.p);
-        const warm = join(this.p.warm, "slot-0");
-        let pooled = current === this.descriptor.seed_generation;
-        if (pooled) {
-            try {
-                renameSync(this.claimDir, warm);
-            }
-            catch (err) {
-                if (!["EEXIST", "ENOTEMPTY"].includes(err.code ?? ""))
-                    throw err;
-                pooled = false;
-            }
-        }
-        if (!pooled) {
-            this.discardOwnedSlot();
-            this.finished = true;
-            return;
-        }
-        this.releaseSlot();
-        this.finished = true;
-    }
-    async destroy() {
-        if (this.finished)
-            return;
-        this.descriptor = { ...this.descriptor, disposition: "destroy_required" };
-        writePrivateJson(join(this.claimDir, "lease.json"), this.descriptor);
-        this.discardOwnedSlot("destroy-required");
-        this.finished = true;
-    }
-    async retain(destroyRequired = false) {
-        if (this.finished)
-            return;
-        if (destroyRequired || this.descriptor.disposition === "destroy_required") {
-            this.descriptor = { ...this.descriptor, disposition: "destroy_required" };
-            writePrivateJson(join(this.claimDir, "lease.json"), this.descriptor);
-        }
-        quarantineOwnedActiveSlot(this.p, this.slotDir, this.ownerToken, this.descriptor.disposition === "destroy_required" ? "destroy-required" : "unverified-close");
-        this.finished = true;
-    }
-    discardOwnedSlot(label = "owned-active") {
-        const tombstone = quarantineOwnedActiveSlot(this.p, this.slotDir, this.ownerToken, label);
-        if (tombstone === null)
-            return;
-        const quarantinedLease = readLease(join(tombstone, "claim"));
-        if (quarantinedLease?.lease_token !== this.descriptor.lease_token) {
-            // Ownership changed or the descriptor became ambiguous. The private
-            // tombstone is no longer claimable, so retain it without deleting data.
-            return;
-        }
-        removeProfile(this.p, quarantinedLease);
-        removeSlotContainer(this.p, tombstone);
-    }
-    releaseSlot() {
-        const owner = readJson(join(this.slotDir, "owner.json"));
-        if (owner?.token === this.ownerToken)
-            removeSlotContainer(this.p, this.slotDir);
-    }
-}
-export async function acquireOperatorProfile(sessionId, opts = {}) {
-    assertOperatorProfileRuntimeSupported();
-    const sourceProfileDir = profilePathIdentity(opts.sourceProfileDir ?? CHROME_PROFILE_DIR);
-    const p = paths(poolRootForSource(sourceProfileDir, opts.rootDir));
-    const now = opts.now ?? Date.now;
-    initializePool(p);
-    scavengeDestroyRequired(p);
-    // Collected by scavengeQuarantinedActive/scavengeActiveSlots instead of
-    // physically removed inline, so the (potentially slow, disk-bound) removal
-    // of a real per-session profile directory happens after the seed lock
-    // below is released, never while it's held.
-    const reclaimedFromReservation = [];
-    const reservation = await withSeedLock(p, () => {
-        scavengeQuarantinedActive(p, undefined, undefined, (removal) => reclaimedFromReservation.push(removal));
-        scavengeActiveSlots(p, now(), (removal) => reclaimedFromReservation.push(removal));
-        for (let index = 0; index < ACTIVE_SLOT_COUNT; index += 1) {
-            const claimed = reserveActiveSlot(p, index, sessionId);
-            if (claimed !== null)
-                return claimed;
-        }
-        return null;
-    }, opts);
-    flushDeferredProfileRemovals(p, reclaimedFromReservation);
-    if (reservation === null) {
-        throw new Error("operate_start capacity reached: 2 operator sessions are active; finish one and retry");
-    }
-    const { slotDir, ownerToken } = reservation;
-    const claimDir = join(slotDir, "claim");
-    let allocatedProfileId = null;
-    // Same deferred-removal reasoning as reclaimedFromReservation above, for
-    // the expired-warm-profile case surfaced while cloning/reusing.
-    const reclaimedFromWarm = [];
-    try {
-        assertProfileAcquisitionActive(opts);
-        const acquiredDescriptor = await withSeedLock(p, () => {
-            const generation = currentGeneration(p);
-            scavengeWarm(p, generation ?? UNPUBLISHED_SEED_GENERATION, now(), (removal) => reclaimedFromWarm.push(removal));
-            const warm = join(p.warm, "slot-0");
-            let descriptor = null;
-            try {
-                renameSync(warm, claimDir);
-                descriptor = readLease(claimDir);
-            }
-            catch (err) {
-                if (err.code !== "ENOENT")
-                    throw err;
-            }
-            if (descriptor !== null) {
-                stripPooledProfileCookies(profileDir(p, descriptor.profile_id));
-                const activeDescriptor = { ...descriptor };
-                delete activeDescriptor.returned_at;
-                delete activeDescriptor.worker;
-                writePrivateJson(join(claimDir, "lease.json"), activeDescriptor);
-                return activeDescriptor;
-            }
-            rmSync(claimDir, { recursive: true, force: true });
-            const profileId = randomUUID();
-            allocatedProfileId = profileId;
-            const profileRoot = join(p.profiles, profileId);
-            ensurePrivateDir(profileRoot);
-            const userDataDir = join(profileRoot, "user-data");
-            if (generation === null) {
-                ensurePrivateDir(userDataDir);
-            }
-            else {
-                cpSync(join(p.generations, generation, "user-data"), userDataDir, {
-                    recursive: true,
-                    force: false,
-                    errorOnExist: true,
-                });
-                stripTransientProfileState(userDataDir);
-            }
-            stripPooledProfileCookies(userDataDir);
-            ensurePrivateDir(claimDir);
-            const coldDescriptor = {
-                version: 1,
-                lease_token: randomUUID(),
-                profile_id: profileId,
-                seed_generation: generation ?? UNPUBLISHED_SEED_GENERATION,
-                created_at: now(),
-                reuse_count: 0,
-            };
-            writePrivateJson(join(claimDir, "lease.json"), coldDescriptor);
-            return coldDescriptor;
-        }, opts);
-        assertProfileAcquisitionActive(opts);
-        return new OperatorProfileLease(p, slotDir, claimDir, ownerToken, acquiredDescriptor, now);
-    }
-    catch (err) {
-        const tombstone = quarantineOwnedActiveSlot(p, slotDir, ownerToken, "failed-active");
-        if (tombstone !== null) {
-            const lease = readLease(join(tombstone, "claim"));
-            let descriptorWasSafe = false;
-            if (lease !== null) {
-                removeProfile(p, lease);
-                descriptorWasSafe = true;
-            }
-            else if (allocatedProfileId !== null) {
-                rmSync(join(p.profiles, allocatedProfileId), { recursive: true, force: true });
-                descriptorWasSafe = true;
-            }
-            if (descriptorWasSafe)
-                removeSlotContainer(p, tombstone);
-        }
-        throw err;
-    }
-    finally {
-        flushDeferredProfileRemovals(p, reclaimedFromWarm);
-    }
-}
-export function localWorkerIdentity(pid, userDataDir) {
-    return profileProcessIdentity(pid, userDataDir);
-}
-export const operatorProfilePoolTest = {
-    paths,
-    poolRootForSource,
-    currentGeneration,
-    withSeedLock,
-    reserveActiveSlot,
-    scavengeQuarantinedActive,
-    scavengeDestroyRequired,
-    resetDefaultPool: () => rmSync(defaultPoolRoot(), { recursive: true, force: true }),
-};
-//# sourceMappingURL=operator-profile-pool.js.map