@agentproto/browser-profiles 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1946 @@
+import { ToolError } from '@agentproto/tool';
+import { existsSync, readFileSync, rmSync, readdirSync, mkdirSync, writeFileSync, appendFileSync, statSync, chmodSync, renameSync, mkdtempSync, copyFileSync } from 'fs';
+import { platform, homedir, tmpdir } from 'os';
+import path, { join, dirname } from 'path';
+import { z } from 'zod';
+import { execFileSync } from 'child_process';
+import { createDecipheriv, createHash, randomUUID, pbkdf2Sync } from 'crypto';
+import { browserCookieSchema, assertSpawnArgsSafe } from '@agentproto/driver-browser';
+
+/**
+ * @agentproto/browser-profiles
+ * Browser session and profile model: descriptors, Chrome profile discovery, camofox sessions, and the injection seams.
+ */
+
+var SESSION_SOURCE_UNKNOWN_CODE = "browser-profiles:unknown-source";
+var SESSION_SOURCE_DUPLICATE_CODE = "browser-profiles:duplicate-source";
+var SESSION_DESCRIPTOR_INVALID_CODE = "browser-profiles:invalid-descriptor";
+var SessionSourceUnknownError = class extends ToolError {
+  kind;
+  registered;
+  constructor(kind, registered) {
+    super({
+      code: SESSION_SOURCE_UNKNOWN_CODE,
+      message: `no session source registered for kind "${kind}"; registered: ${registered.length ? registered.join(", ") : "none"}. Register one with registry.register({ kind, materialize }) before resolving the session.`
+    });
+    this.name = "SessionSourceUnknownError";
+    this.kind = kind;
+    this.registered = registered;
+  }
+};
+var SessionSourceDuplicateError = class extends ToolError {
+  kind;
+  constructor(kind) {
+    super({
+      code: SESSION_SOURCE_DUPLICATE_CODE,
+      message: `a session source for kind "${kind}" is already registered`
+    });
+    this.name = "SessionSourceDuplicateError";
+    this.kind = kind;
+  }
+};
+var SessionDescriptorInvalidError = class extends ToolError {
+  issues;
+  constructor(issues) {
+    super({
+      code: SESSION_DESCRIPTOR_INVALID_CODE,
+      message: `not a valid session descriptor: ${issues.join("; ")}`
+    });
+    this.name = "SessionDescriptorInvalidError";
+    this.issues = issues;
+  }
+};
+function isSessionSourceUnknownError(value) {
+  return value instanceof SessionSourceUnknownError;
+}
+var SESSION_SOURCE_RESERVED_CODE = "browser-profiles:reserved-source";
+var ACCOUNT_SWITCHER_MISSING_CODE = "browser-profiles:account-switcher-missing";
+var CHROME_IDENTITY_CODE = "browser-profiles:chrome-identity";
+var SESSION_RESOLVE_CODE = "browser-profiles:resolve";
+var SessionSourceReservedError = class extends ToolError {
+  kind;
+  constructor(kind) {
+    super({
+      code: SESSION_SOURCE_RESERVED_CODE,
+      message: `"${kind}" is a built-in strategy kind and cannot be registered as a session source`
+    });
+    this.name = "SessionSourceReservedError";
+    this.kind = kind;
+  }
+};
+var AccountSwitcherMissingError = class extends ToolError {
+  constructor(platform2) {
+    super({
+      code: ACCOUNT_SWITCHER_MISSING_CODE,
+      message: `the session pins a sub-account on "${platform2}" but no accountSwitcher hook was provided; refusing to continue, since acting as the wrong account is worse than failing`
+    });
+    this.name = "AccountSwitcherMissingError";
+  }
+};
+var ChromeIdentityError = class extends ToolError {
+  constructor(message) {
+    super({ code: CHROME_IDENTITY_CODE, message });
+    this.name = "ChromeIdentityError";
+  }
+};
+var SessionResolveError = class extends ToolError {
+  constructor(message, cause) {
+    super({ code: SESSION_RESOLVE_CODE, message, ...cause !== void 0 ? { cause } : {} });
+    this.name = "SessionResolveError";
+  }
+};
+
+// src/known.ts
+function isKnown(k) {
+  return "known" in k;
+}
+function knownOr(k, fallback) {
+  return isKnown(k) ? k.known : fallback;
+}
+
+// src/cookie.ts
+function domainMatches(domain, domains) {
+  const h = String(domain ?? "").replace(/^\./, "").toLowerCase();
+  return domains.some((d) => h === d || h.endsWith(`.${d}`));
+}
+function toSessionCookie(c) {
+  const o = {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path || "/"
+  };
+  if (c.httpOnly != null) o.httpOnly = c.httpOnly;
+  if (c.secure != null) o.secure = c.secure;
+  if (c.sameSite) o.sameSite = String(c.sameSite);
+  const exp = c.expires ?? c.expirationDate;
+  if (!c.session && exp) o.expires = Math.floor(exp);
+  return o;
+}
+function dedupeCookies(cookies) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const c of cookies) seen.set(`${c.name}|${c.domain}|${c.path}`, c);
+  return [...seen.values()];
+}
+
+// src/auth-signals.ts
+var norm = (d) => d.replace(/^\./, "").toLowerCase();
+var hostMatches = (host, domain) => host === domain || host.endsWith(`.${domain}`);
+function createAuthSignalRegistry(initial = []) {
+  const signals = /* @__PURE__ */ new Map();
+  const registry = {
+    register(signal) {
+      signals.set(norm(signal.domain), signal);
+    },
+    knownDomains: () => [...signals.keys()],
+    isKnownDomain: (domain) => signals.has(norm(domain)),
+    canonicalDomain(domain) {
+      const d = norm(domain);
+      if (signals.has(d)) return d;
+      for (const s of signals.values()) {
+        if (s.aliases?.some((a) => norm(a) === d)) return norm(s.domain);
+      }
+      return d;
+    },
+    equivalentDomains(domain) {
+      const d = norm(domain);
+      const canon = registry.canonicalDomain(d);
+      const s = signals.get(canon);
+      const all = [canon, ...(s?.aliases ?? []).map(norm)];
+      return [...new Set(all)].filter((x) => x !== d);
+    },
+    hostBelongsTo(host, domain) {
+      const h = norm(host);
+      const s = signals.get(norm(domain));
+      const names = [norm(domain), ...(s?.aliases ?? []).map(norm)];
+      return names.some((n) => hostMatches(h, n));
+    },
+    isAuthed(domain, cookies, nowMs) {
+      const s = signals.get(norm(domain));
+      if (!s) return false;
+      const mine = cookies.filter((c) => registry.hostBelongsTo(c.host, domain));
+      if (s.detect) return s.detect(mine, nowMs);
+      const names = s.cookieNames ?? [];
+      return mine.some((c) => names.includes(c.name) && (c.expiresUnix === void 0 || c.expiresUnix > nowMs / 1e3));
+    }
+  };
+  for (const s of initial) registry.register(s);
+  return registry;
+}
+var defaultAuthSignalRegistry = createAuthSignalRegistry();
+function chromeUserDataDir(home = homedir()) {
+  switch (platform()) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "Google", "Chrome");
+    case "win32":
+      return join(process.env.LOCALAPPDATA ?? join(home, "AppData", "Local"), "Google", "Chrome", "User Data");
+    default:
+      return join(home, ".config", "google-chrome");
+  }
+}
+function chromeLocalStatePath(home = homedir()) {
+  return join(chromeUserDataDir(home), "Local State");
+}
+var str = (v) => typeof v === "string" ? v : void 0;
+function parseLocalState(text) {
+  const parsed = JSON.parse(text);
+  const cache = parsed.profile?.info_cache ?? {};
+  return {
+    profiles: Object.entries(cache).map(([directory, info]) => ({
+      directory,
+      name: str(info.name),
+      userName: str(info.user_name),
+      gaiaName: str(info.gaia_name),
+      activeTime: info.active_time ?? info.last_active_time
+    })),
+    lastUsed: str(parsed.profile?.last_used) ?? null
+  };
+}
+function readLocalState(chromeRoot) {
+  const file = join(chromeRoot, "Local State");
+  if (!existsSync(file)) return { profiles: [], lastUsed: null };
+  try {
+    return parseLocalState(readFileSync(file, "utf8"));
+  } catch {
+    return { profiles: [], lastUsed: null };
+  }
+}
+function chromeTimeToIso(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return "";
+  let unixMs;
+  if (raw > 1e16) {
+    unixMs = Math.floor(raw / 1e3) - 116444736e5;
+  } else if (raw > 1e12) {
+    unixMs = raw;
+  } else if (raw > 1e9) {
+    unixMs = raw * 1e3;
+  } else {
+    return "";
+  }
+  if (unixMs <= 0 || unixMs > Date.now() + 864e5) return "";
+  return new Date(unixMs).toISOString();
+}
+var BUILTIN_STRATEGY_KINDS = ["chrome-cookie", "stored-credential", "authed-storageState"];
+var BUILTIN_INJECT_FROM = ["chrome-profile", "file", "camofox-native"];
+function isBuiltinStrategyKind(kind) {
+  return BUILTIN_STRATEGY_KINDS.includes(kind);
+}
+var isChromeCookieStrategy = (s) => s.kind === "chrome-cookie";
+var isStoredCredentialStrategy = (s) => s.kind === "stored-credential";
+var isOwnedStorageStateStrategy = (s) => s.kind === "authed-storageState";
+var isSourceStrategy = (s) => !isBuiltinStrategyKind(s.kind);
+var isChromeProfileInject = (i) => i.from === "chrome-profile";
+var isFileInject = (i) => i.from === "file";
+var isCamofoxNativeInject = (i) => i.from === "camofox-native";
+var isSourceInject = (i) => !BUILTIN_INJECT_FROM.includes(i.from);
+var accountSchema = z.object({ platform: z.string(), userId: z.string() }).loose();
+var chromeProfileInjectSchema = z.object({
+  from: z.literal("chrome-profile"),
+  domains: z.array(z.string()),
+  profile: z.string(),
+  account: accountSchema.optional()
+}).loose();
+var fileInjectSchema = z.object({ from: z.literal("file"), domains: z.array(z.string()), path: z.string() }).loose();
+var camofoxNativeInjectSchema = z.object({ from: z.literal("camofox-native") }).loose();
+var sourceInjectSchema = z.object({ from: z.string().min(1), domains: z.array(z.string()), sessionRef: z.string() }).loose();
+var sessionInjectSchema = z.union([
+  chromeProfileInjectSchema,
+  fileInjectSchema,
+  camofoxNativeInjectSchema,
+  sourceInjectSchema
+]);
+var chromeCookieStrategySchema = z.object({
+  kind: z.literal("chrome-cookie"),
+  domains: z.array(z.string()),
+  profile: z.string(),
+  profileName: z.string().optional(),
+  profileEmail: z.string().optional(),
+  account: accountSchema.optional()
+}).loose();
+var storedCredentialStrategySchema = z.object({ kind: z.literal("stored-credential"), platform: z.string(), account: z.string() }).loose();
+var ownedStorageStateStrategySchema = z.object({ kind: z.literal("authed-storageState"), storageStatePath: z.string(), capturedAt: z.string().optional() }).loose();
+var sourceStrategySchema = z.object({ kind: z.string().min(1), domains: z.array(z.string()), sessionRef: z.string() }).loose();
+var strategySchema = z.union([
+  chromeCookieStrategySchema,
+  storedCredentialStrategySchema,
+  ownedStorageStateStrategySchema,
+  sourceStrategySchema
+]);
+var sessionIdentitySchema = z.object({
+  profile: z.string().optional(),
+  account: z.string().optional(),
+  platform: z.string().optional(),
+  profileName: z.string().optional(),
+  profileEmail: z.string().optional()
+}).loose();
+var authStatusSchema = z.enum(["authenticated", "auth-wall", "stale", "unknown"]);
+var sessionDescriptorSchema = z.object({
+  id: z.string().min(1),
+  backend: z.enum(["camofox", "chrome"]),
+  identity: sessionIdentitySchema.optional(),
+  inject: sessionInjectSchema.optional(),
+  strategies: z.array(strategySchema).optional(),
+  base: z.string().optional(),
+  url: z.string().optional(),
+  savedAt: z.string().optional(),
+  lastVerifiedAt: z.string().optional(),
+  lastAuthStatus: authStatusSchema.optional(),
+  lastCookieRefreshAt: z.string().optional()
+}).loose();
+function parseSessionDescriptor(json) {
+  const result = sessionDescriptorSchema.safeParse(json);
+  if (!result.success) {
+    throw new SessionDescriptorInvalidError(
+      result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+    );
+  }
+  return json;
+}
+function ownedStorageStatePath(id) {
+  const safeId = id.replace(/[^\w.-]/g, "_");
+  return join(process.env["CAMOFOX_PROFILES_DIR"] ?? join(homedir(), ".agentproto", "camofox-profiles"), `${safeId}.json`);
+}
+function injectKindOf(from) {
+  if (from === "chrome-profile" || from === "file") return "chrome-cookie";
+  if (from === "camofox-native") return "authed-storageState";
+  return from;
+}
+function injectFromOf(kind) {
+  if (kind === "chrome-cookie") return "chrome-profile";
+  if (kind === "authed-storageState") return "camofox-native";
+  if (kind === "stored-credential") return void 0;
+  return kind;
+}
+function chromeCookieStrategyOf(inject, identity) {
+  return {
+    kind: "chrome-cookie",
+    domains: inject.domains,
+    profile: inject.profile,
+    ...identity?.profileName ? { profileName: identity.profileName } : {},
+    ...identity?.profileEmail ? { profileEmail: identity.profileEmail } : {},
+    ...inject.account ? { account: inject.account } : {}
+  };
+}
+function deriveStrategies(raw, opts) {
+  const out = [];
+  const inject = raw.inject;
+  if (inject) {
+    if (isChromeProfileInject(inject)) {
+      out.push(chromeCookieStrategyOf(inject, raw.identity));
+    } else if (isFileInject(inject)) {
+      out.push({
+        kind: "chrome-cookie",
+        domains: inject.domains,
+        profile: raw.identity?.profile ?? "",
+        ...raw.identity?.profileName ? { profileName: raw.identity.profileName } : {},
+        ...raw.identity?.profileEmail ? { profileEmail: raw.identity.profileEmail } : {}
+      });
+    } else if (isCamofoxNativeInject(inject)) {
+      out.push({ kind: "authed-storageState", storageStatePath: ownedStorageStatePath(raw.id) });
+    } else {
+      out.push({ kind: inject.from, domains: inject.domains, sessionRef: inject.sessionRef });
+    }
+  }
+  const platform2 = raw.identity?.platform;
+  const account = raw.identity?.account;
+  if (platform2 && account && opts.credentials?.some((c) => c.platform === platform2 && c.account === account)) {
+    out.push({ kind: "stored-credential", platform: platform2, account });
+  }
+  return out;
+}
+function normalizeDescriptor(raw, opts = {}) {
+  if (raw.strategies && raw.strategies.length > 0) return raw;
+  const strategies = deriveStrategies(raw, opts);
+  return strategies.length > 0 ? { ...raw, strategies } : raw;
+}
+function selectResolutionStrategy(desc) {
+  const strategies = desc.strategies;
+  if (!strategies || strategies.length === 0) return void 0;
+  if (desc.lastAuthStatus !== "auth-wall") {
+    const owned = strategies.find(isOwnedStorageStateStrategy);
+    if (owned) return owned;
+  }
+  const chrome = strategies.find(isChromeCookieStrategy);
+  if (chrome) return chrome;
+  return strategies.find(isSourceStrategy);
+}
+function resolveInjectFromStrategies(desc) {
+  const sel = selectResolutionStrategy(desc);
+  if (!sel) return desc.inject;
+  if (isOwnedStorageStateStrategy(sel)) return { from: "camofox-native" };
+  if (isChromeCookieStrategy(sel)) {
+    if (desc.inject && isFileInject(desc.inject)) return desc.inject;
+    return {
+      from: "chrome-profile",
+      domains: sel.domains,
+      profile: sel.profile,
+      ...sel.account ? { account: sel.account } : {}
+    };
+  }
+  if (isSourceStrategy(sel)) return { from: sel.kind, domains: sel.domains, sessionRef: sel.sessionRef };
+  return desc.inject;
+}
+var COOKIE_STALE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function cookieFreshness(desc, now, ttlMs = COOKIE_STALE_TTL_MS) {
+  const eff = resolveInjectFromStrategies(desc);
+  if (eff && (isChromeProfileInject(eff) || isFileInject(eff))) return "fresh";
+  const stamp = desc.lastCookieRefreshAt;
+  if (!stamp) return "unknown";
+  const t = Date.parse(stamp);
+  if (Number.isNaN(t)) return "unknown";
+  return now - t <= ttlMs ? "fresh" : "stale";
+}
+function priorChromeStrategy(prev) {
+  const v2 = prev?.strategies?.find(isChromeCookieStrategy);
+  if (v2) return v2;
+  if (prev?.inject && isChromeProfileInject(prev.inject)) return chromeCookieStrategyOf(prev.inject, prev.identity);
+  return void 0;
+}
+function buildOwnedSessionDescriptor(input) {
+  const { id, platform: platform2, reuseBase, account, url, now, prev } = input;
+  const chrome = priorChromeStrategy(prev);
+  const strategies = [
+    ...chrome ? [chrome] : [],
+    { kind: "authed-storageState", storageStatePath: ownedStorageStatePath(id), capturedAt: now },
+    ...account ? [{ kind: "stored-credential", platform: platform2, account }] : []
+  ];
+  return {
+    id,
+    backend: "camofox",
+    identity: {
+      platform: platform2,
+      ...account ? { account } : {},
+      ...prev?.identity?.profile ? { profile: prev.identity.profile } : {},
+      ...prev?.identity?.profileName ? { profileName: prev.identity.profileName } : {},
+      ...prev?.identity?.profileEmail ? { profileEmail: prev.identity.profileEmail } : {}
+    },
+    inject: { from: "camofox-native" },
+    base: reuseBase,
+    savedAt: now,
+    strategies,
+    ...url ? { url } : {}
+  };
+}
+function fileSessionStore(dir, opts = {}) {
+  const fileFor = (id) => join(dir, `${id.replace(/[^\w.-]/g, "_")}.json`);
+  const normalizeOpts = () => opts.credentials ? { credentials: opts.credentials() } : {};
+  const read = (path5) => normalizeDescriptor(parseSessionDescriptor(JSON.parse(readFileSync(path5, "utf8"))), normalizeOpts());
+  return {
+    async save(desc) {
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+      writeFileSync(fileFor(desc.id), JSON.stringify(desc, null, 2), { mode: 384 });
+    },
+    async load(id) {
+      try {
+        return read(fileFor(id));
+      } catch {
+        return null;
+      }
+    },
+    async list() {
+      if (!existsSync(dir)) return [];
+      const out = [];
+      for (const f of readdirSync(dir).filter((name) => name.endsWith(".json"))) {
+        try {
+          out.push(read(join(dir, f)));
+        } catch {
+        }
+      }
+      return out;
+    },
+    async remove(id) {
+      rmSync(fileFor(id), { force: true });
+    }
+  };
+}
+function compositeSessionStore(readStores, writeStore) {
+  const requireWrite = () => {
+    if (!writeStore) throw new Error("compositeSessionStore is read-only (no writeStore)");
+    return writeStore;
+  };
+  return {
+    async save(desc) {
+      await requireWrite().save(desc);
+    },
+    async load(id) {
+      for (const s of readStores) {
+        const d = await s.load(id);
+        if (d) return d;
+      }
+      return null;
+    },
+    async list() {
+      const seen = /* @__PURE__ */ new Map();
+      for (const s of readStores) {
+        for (const d of await s.list()) if (!seen.has(d.id)) seen.set(d.id, d);
+      }
+      return [...seen.values()];
+    },
+    async remove(id) {
+      await requireWrite().remove(id);
+    }
+  };
+}
+
+// src/session-sources.ts
+function createSessionSourceRegistry(initial = []) {
+  const sources = /* @__PURE__ */ new Map();
+  const registry = {
+    register(source) {
+      if (isBuiltinStrategyKind(source.kind) || source.kind === "chrome-profile" || source.kind === "file" || source.kind === "camofox-native") {
+        throw new SessionSourceReservedError(source.kind);
+      }
+      if (sources.has(source.kind)) throw new SessionSourceDuplicateError(source.kind);
+      sources.set(source.kind, source);
+    },
+    list: () => [...sources.values()],
+    has: (kind) => sources.has(kind),
+    resolve(kind) {
+      const found = sources.get(kind);
+      if (!found) throw new SessionSourceUnknownError(kind, [...sources.keys()]);
+      return found;
+    },
+    materialize: (kind, ref) => registry.resolve(kind).materialize(ref)
+  };
+  for (const s of initial) registry.register(s);
+  return registry;
+}
+function metaToDescriptor(kind, m) {
+  return {
+    id: m.ref,
+    backend: "camofox",
+    ...m.identity ? { identity: m.identity } : {},
+    inject: { from: kind, sessionRef: m.ref, domains: m.domains },
+    ...m.url ? { url: m.url } : {}
+  };
+}
+function catalogSessionStore(kind, catalog) {
+  return {
+    async save() {
+      throw new Error(`the "${kind}" catalog store is read-only; capture sessions in the managing system`);
+    },
+    async load(id) {
+      const m = await catalog.get(id);
+      return m ? metaToDescriptor(kind, m) : null;
+    },
+    async list() {
+      return (await catalog.list()).map((m) => metaToDescriptor(kind, m));
+    },
+    async remove() {
+      throw new Error(`the "${kind}" catalog store is read-only; manage sessions in the managing system`);
+    }
+  };
+}
+var SQLITE_MAX_BUFFER = 256 * 1024 * 1024;
+var CHROME_EPOCH_TO_UNIX_S = 11644473600;
+function profileDirs(chromeRoot) {
+  if (!existsSync(chromeRoot)) return [];
+  return readdirSync(chromeRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => name === "Default" || /^Profile \d+$/.test(name)).filter((name) => existsSync(path.join(chromeRoot, name, "Cookies")));
+}
+function defaultChromeRoot() {
+  if (platform() !== "darwin") {
+    throw new Error("local browser sessions currently support macOS only; pass { chromeRoot } for other platforms.");
+  }
+  return path.join(homedir(), "Library", "Application Support", "Google", "Chrome");
+}
+function chromeUserDataRoot(opts = {}) {
+  return opts.chromeRoot ?? defaultChromeRoot();
+}
+function deriveKey(password) {
+  return pbkdf2Sync(password, "saltysalt", 1003, 16, "sha1");
+}
+function readSafeStorageKey() {
+  const pw = execFileSync("security", ["find-generic-password", "-wa", "Chrome", "-s", "Chrome Safe Storage"]).toString().trim();
+  return deriveKey(pw);
+}
+function decryptChromeValue(hex, key) {
+  const buf = Buffer.from(hex, "hex");
+  if (buf.subarray(0, 3).toString() !== "v10") return buf.toString("utf8");
+  const ct = buf.subarray(3);
+  const d = createDecipheriv("aes-128-cbc", key, Buffer.alloc(16, " "));
+  d.setAutoPadding(true);
+  let pt = Buffer.concat([d.update(ct), d.final()]);
+  if (pt.length >= 32) {
+    const headPrintable = [...pt.subarray(0, 32)].every((b) => b >= 32 && b < 127);
+    const tail = pt.subarray(32).toString("utf8");
+    if (!headPrintable && /^[\x20-\x7e]*$/.test(tail)) pt = pt.subarray(32);
+  }
+  return pt.toString("utf8");
+}
+function safeStorageKey(password) {
+  return deriveKey(password);
+}
+var errText = (e) => e instanceof Error ? e.message : String(e);
+function withCookiesCopy(profileDir, prefix, fn) {
+  const tmpDir = mkdtempSync(path.join(tmpdir(), prefix));
+  try {
+    const db = path.join(tmpDir, "Cookies");
+    copyFileSync(path.join(profileDir, "Cookies"), db);
+    return fn(db);
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+var sqlite = (db, args) => execFileSync("sqlite3", [db, ...args], { maxBuffer: SQLITE_MAX_BUFFER, stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+function countCookies(profileDir) {
+  try {
+    return { known: withCookiesCopy(profileDir, "bp-ct-", (db) => Number(sqlite(db, ["SELECT count(*) FROM cookies;"]))) };
+  } catch (e) {
+    return { unknown: errText(e) };
+  }
+}
+function countCookiesByDomain(profileDir, domains) {
+  try {
+    const hosts = withCookiesCopy(
+      profileDir,
+      "bp-cd-",
+      (db) => sqlite(db, ["SELECT host_key FROM cookies;"]).split("\n").filter(Boolean).map((h) => h.replace(/^\./, "").toLowerCase())
+    );
+    const counts = Object.fromEntries(domains.map((d) => [d, 0]));
+    for (const host of hosts) {
+      for (const d of domains) if (host === d || host.endsWith(`.${d}`)) counts[d] = (counts[d] ?? 0) + 1;
+    }
+    return { known: counts };
+  } catch (e) {
+    return { unknown: errText(e) };
+  }
+}
+function profileLoggedInDomains(profileDir, registry = defaultAuthSignalRegistry, extraDomains = []) {
+  try {
+    const hosts = withCookiesCopy(
+      profileDir,
+      "bp-host-",
+      (db) => sqlite(db, ["SELECT DISTINCT host_key FROM cookies;"]).split("\n").map((h) => h.replace(/^\./, "").toLowerCase())
+    );
+    const of = [.../* @__PURE__ */ new Set([...registry.knownDomains(), ...extraDomains])];
+    const found = /* @__PURE__ */ new Set();
+    for (const host of hosts) {
+      for (const domain of of) if (registry.hostBelongsTo(host, domain)) found.add(domain);
+    }
+    return { known: [...found].sort() };
+  } catch (e) {
+    return { unknown: errText(e) };
+  }
+}
+function profileAuthedDomains(profileDir, registry = defaultAuthSignalRegistry, nowMs = Date.now()) {
+  try {
+    const rows = withCookiesCopy(
+      profileDir,
+      "bp-auth-",
+      (db) => sqlite(db, ["SELECT host_key, name, expires_utc FROM cookies;"]).split("\n")
+    );
+    const metas = [];
+    for (const row of rows) {
+      const [hostRaw, name, expiresRaw] = row.split("|");
+      if (!hostRaw || !name) continue;
+      const exp = Number(expiresRaw);
+      metas.push({
+        name,
+        host: hostRaw.replace(/^\./, "").toLowerCase(),
+        expiresUnix: !Number.isFinite(exp) || exp === 0 ? void 0 : exp / 1e6 - CHROME_EPOCH_TO_UNIX_S
+      });
+    }
+    const found = registry.knownDomains().filter((d) => registry.isAuthed(d, metas, nowMs));
+    return { known: found.sort() };
+  } catch (e) {
+    return { unknown: errText(e) };
+  }
+}
+function scanChromeIdentities(opts = {}) {
+  const chromeRoot = opts.chromeRoot ?? defaultChromeRoot();
+  const registry = opts.authSignals ?? defaultAuthSignalRegistry;
+  const { profiles, lastUsed } = readLocalState(chromeRoot);
+  const info = new Map(profiles.map((p) => [p.directory, p]));
+  return profileDirs(chromeRoot).map((profile) => {
+    const dir = path.join(chromeRoot, profile);
+    const meta = info.get(profile);
+    return {
+      profile,
+      name: meta?.name ?? null,
+      email: meta?.userName ?? null,
+      gaiaName: meta?.gaiaName ?? null,
+      lastUsed: profile === lastUsed,
+      cookieCount: knownOr(countCookies(dir), 0),
+      domainsLoggedIn: knownOr(profileLoggedInDomains(dir, registry, opts.extraDomains), []),
+      domainsAuthed: profileAuthedDomains(dir, registry)
+    };
+  });
+}
+function decryptChromeCookies(profileDir, domains, key) {
+  return withCookiesCopy(profileDir, "bp-ck-", (db) => {
+    const rows = sqlite(db, [
+      "-separator",
+      "	",
+      "SELECT name, host_key, path, hex(encrypted_value), is_secure, is_httponly, expires_utc FROM cookies;"
+    ]).split("\n").filter(Boolean);
+    const jar = [];
+    for (const line of rows) {
+      const [name, host, cpath, hex, secure, httpOnly, expires] = line.split("	");
+      if (!host || !domainMatches(host, domains)) continue;
+      let value;
+      try {
+        value = decryptChromeValue(hex ?? "", key);
+      } catch {
+        continue;
+      }
+      if (!value) continue;
+      const exp = Number(expires);
+      const expiresUnix = exp > 0 ? Math.floor(exp / 1e6 - CHROME_EPOCH_TO_UNIX_S) : void 0;
+      jar.push({
+        name: name ?? "",
+        value,
+        domain: host,
+        path: cpath || "/",
+        secure: secure === "1",
+        httpOnly: httpOnly === "1",
+        ...expiresUnix && expiresUnix > 0 ? { expires: expiresUnix } : {}
+      });
+    }
+    return jar;
+  });
+}
+function createLocalBrowserSession(opts = {}) {
+  const chromeRoot = opts.chromeRoot ?? defaultChromeRoot();
+  const registry = opts.authSignals ?? defaultAuthSignalRegistry;
+  const getKey = opts.safeStoragePassword ? () => deriveKey(opts.safeStoragePassword()) : readSafeStorageKey;
+  const domainsFor = (domain) => {
+    const d = domain.replace(/^\./, "").toLowerCase();
+    const aliases = opts.domainAliases ? opts.domainAliases[d] ?? [] : registry.equivalentDomains(d);
+    return [d, ...aliases];
+  };
+  return {
+    async getDecryptedForDomain(domain, profile) {
+      const domains = domainsFor(domain);
+      const key = getKey();
+      const profiles = profile ? [profile] : profileDirs(chromeRoot);
+      for (const p of profiles) {
+        const dir = path.join(chromeRoot, p);
+        if (!existsSync(path.join(dir, "Cookies"))) continue;
+        const cookies = decryptChromeCookies(dir, domains, key);
+        if (cookies.length > 0) return { cookies, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      return null;
+    },
+    listProfiles() {
+      return profileDirs(chromeRoot).map((profile) => ({ profile, cookieCount: countCookies(path.join(chromeRoot, profile)) }));
+    }
+  };
+}
+
+// src/chrome-identity.ts
+function domainAuthSignal(domain, found, registry = defaultAuthSignalRegistry) {
+  if (!isKnown(found.domainsAuthed)) return "unknown";
+  if (!registry.isKnownDomain(domain)) return "unknown";
+  return found.domainsAuthed.known.includes(registry.canonicalDomain(domain)) ? "authed" : "not-authed";
+}
+function wantDomains(inject, registry) {
+  return [...new Set(inject.domains.map((d) => registry.canonicalDomain(d)))];
+}
+function chromeIdentityLabel(s) {
+  const who = s.name ?? s.email ?? "?";
+  const email = s.email && s.email !== s.name ? ` (${s.email})` : "";
+  const dir = s.name && s.name !== s.profile ? ` [${s.profile}]` : "";
+  return `"${who}"${email}${dir}`;
+}
+function scanFor(inject, opts) {
+  return opts.scan ?? scanChromeIdentities({
+    ...opts.scanOptions,
+    ...opts.authSignals ? { authSignals: opts.authSignals } : {},
+    extraDomains: inject.domains
+  });
+}
+function resolveChromeProfile(inject, identity, opts = {}) {
+  if (!isChromeProfileInject(inject)) return void 0;
+  const registry = opts.authSignals ?? defaultAuthSignalRegistry;
+  const ids = opts.scan ?? scanChromeIdentities({ ...opts.scanOptions, authSignals: registry });
+  const pinned = inject.profile;
+  const want = wantDomains(inject, registry);
+  const authed = (s) => {
+    const da = s.domainsAuthed;
+    return isKnown(da) && want.some((d) => da.known.includes(d));
+  };
+  const pin = ids.find((s) => s.profile === pinned);
+  if (pin && authed(pin)) return pinned;
+  const email = identity?.account;
+  if (email) {
+    const sameAccount = ids.find((s) => s.email === email && authed(s));
+    if (sameAccount) return sameAccount.profile;
+  }
+  return pinned;
+}
+function verifyChromeIdentity(inject, identity, opts = {}) {
+  if (!isChromeProfileInject(inject)) return;
+  const registry = opts.authSignals ?? defaultAuthSignalRegistry;
+  const target = inject.profile ?? identity?.profile;
+  if (!target) return;
+  const ids = scanFor(inject, opts);
+  const found = ids.find((s) => s.profile === target);
+  if (!found) {
+    const avail = ids.map((s) => `${s.profile} (${s.name ?? s.email ?? "?"})`).join(", ");
+    throw new ChromeIdentityError(`chrome profile "${target}" not found; available: ${avail || "none"}`);
+  }
+  if (identity?.account && found.email && found.email !== identity.account) {
+    opts.warn?.(`profile "${target}" is now ${found.email}, session was pinned to ${identity.account}; using the live account`);
+  }
+  const want = wantDomains(inject, registry);
+  if (!isKnown(found.domainsAuthed)) {
+    throw new ChromeIdentityError(
+      `couldn't read ${chromeIdentityLabel(found)}'s cookie store, so a live ${want.join("/")} login can't be confirmed (${found.domainsAuthed.unknown}). Chrome may be holding the Cookies DB lock: fully quit and reopen Chrome, then retry. This is NOT "not logged in".`
+    );
+  }
+  const signals = want.map((d) => domainAuthSignal(d, found, registry));
+  if (signals.includes("authed")) return;
+  if (signals.includes("not-authed")) {
+    const authedProfiles = ids.filter((s) => {
+      const da = s.domainsAuthed;
+      return isKnown(da) && want.some((d) => da.known.includes(d));
+    });
+    const hint = authedProfiles.length ? ` A valid ${want.join("/")} login IS present in: ${authedProfiles.map(chromeIdentityLabel).join(", ")}; re-login to ${want.join("/")} in ${chromeIdentityLabel(found)}, or re-pin this session to "${authedProfiles[0].profile}".` : ` No profile is logged into ${want.join("/")}; log in first.`;
+    throw new ChromeIdentityError(`${chromeIdentityLabel(found)} has no valid ${want.join("/")} login (only stale crumbs).${hint}`);
+  }
+  const hasAnyCookie = want.some((d) => found.domainsLoggedIn.includes(d));
+  if (!hasAnyCookie) {
+    throw new ChromeIdentityError(
+      `${chromeIdentityLabel(found)} carries no cookies at all for ${want.join("/")}; no auth signal is registered for it (register a detector on the AuthSignalRegistry for a real check), and Chrome's on-disk cookie store holds nothing for it either. If you ARE logged in, Chrome may still be buffering the cookie in memory: fully quit and reopen Chrome, then retry.`
+    );
+  }
+  opts.warn?.(
+    `no auth signal registered for ${want.join("/")}; cannot confirm a live login, proceeding on cookie presence only`
+  );
+}
+function describeSessionAuth(inject, identity, opts = {}) {
+  if (!isChromeProfileInject(inject)) {
+    return {
+      state: "not-checked",
+      message: `not checked: the "${inject.from}" transport carries no live auth-cookie guard (only "chrome-profile" sessions are inspected); a resolvable session is the only signal available here`
+    };
+  }
+  const registry = opts.authSignals ?? defaultAuthSignalRegistry;
+  const target = inject.profile ?? identity?.profile;
+  if (!target) return { state: "not-checked", message: "not checked: no profile pinned to verify against" };
+  const ids = scanFor(inject, opts);
+  const preScan = ids.find((s) => s.profile === target);
+  if (preScan && !isKnown(preScan.domainsAuthed)) {
+    return {
+      state: "unknown",
+      message: `unknown: couldn't read ${chromeIdentityLabel(preScan)}'s cookie store (${preScan.domainsAuthed.unknown}); Chrome may hold the DB lock, quit and reopen it. Not "not logged in".`
+    };
+  }
+  try {
+    verifyChromeIdentity(inject, identity, { ...opts, scan: ids });
+  } catch (e) {
+    return { state: "not-authed", message: e instanceof Error ? e.message : String(e) };
+  }
+  const found = ids.find((s) => s.profile === target);
+  const want = wantDomains(inject, registry);
+  if (want.some((d) => domainAuthSignal(d, found, registry) === "authed")) {
+    return {
+      state: "authed",
+      message: `profile present and logged in: live ${want.join("/")} auth cookie confirmed in ${chromeIdentityLabel(found)}`
+    };
+  }
+  return {
+    state: "unknown",
+    message: `unknown: no auth signal registered for ${want.join("/")}; proceeding on cookie presence only, not a verified login`
+  };
+}
+function assertChromeLaunchDirSafe(userDataDir, providerId) {
+  assertSpawnArgsSafe([`--user-data-dir=${userDataDir}`], providerId);
+}
+function camofoxStatePath() {
+  return process.env["CAMOFOX_TABS_STATE"] ?? join(homedir(), ".agentproto", "camofox-tabs.json");
+}
+function defaultCamofoxBase() {
+  return (process.env["CAMOFOX_URL"] || `http://localhost:${process.env["CAMOFOX_PORT"] || "9377"}`).replace(/\/$/, "");
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function readState(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState(file, s) {
+  if (!existsSync(dirname(file))) mkdirSync(dirname(file), { recursive: true, mode: 448 });
+  writeFileSync(file, JSON.stringify(s, null, 2), { mode: 384 });
+}
+async function openSession(opts) {
+  const base = (opts.base || defaultCamofoxBase()).replace(/\/$/, "");
+  const userId = opts.userId;
+  const stateFile = opts.stateFile ?? camofoxStatePath();
+  const doFetch = opts.fetch ?? fetch;
+  const settleMs = opts.settleMs ?? 2500;
+  const rest = async (method, path5, body) => {
+    const res = await doFetch(`${base}${path5}`, {
+      method,
+      headers: { "content-type": "application/json" },
+      ...body ? { body: JSON.stringify(body) } : {}
+    });
+    const t = await res.text();
+    if (!res.ok) throw new Error(`${method} ${path5} -> ${res.status}: ${t.slice(0, 160)}`);
+    return t ? JSON.parse(t) : {};
+  };
+  if (opts.injectCookies !== false) {
+    await rest("POST", `/sessions/${encodeURIComponent(userId)}/cookies`, {
+      cookies: opts.cookies ? [...opts.cookies] : [],
+      sessionKey: userId
+    });
+  }
+  const state = readState(stateFile);
+  let tabId = "";
+  let listed = [];
+  try {
+    const l = await rest("GET", `/tabs?userId=${encodeURIComponent(userId)}`);
+    const tabs = l["tabs"] ?? l;
+    listed = Array.isArray(tabs) ? tabs : [];
+  } catch {
+  }
+  const ids = new Set(listed.map((t) => t.tabId ?? t.id));
+  const remembered = state[userId];
+  const first = listed[0];
+  if (remembered && ids.has(remembered)) {
+    tabId = remembered;
+  } else if (first) {
+    tabId = first.tabId ?? first.id ?? "";
+  } else {
+    const tab = await rest("POST", "/tabs", {
+      userId,
+      sessionKey: userId,
+      ...opts.storageState ? { storageState: opts.storageState } : opts.url ? { url: opts.url } : {},
+      ...opts.keepAlive ? { keepAlive: true } : {}
+    });
+    tabId = String(tab["tabId"] ?? tab["id"] ?? "");
+    if (opts.storageState && opts.url) {
+      await rest("POST", `/tabs/${encodeURIComponent(tabId)}/navigate`, {
+        userId,
+        url: opts.url,
+        waitUntil: "domcontentloaded",
+        timeout: 15e3
+      });
+    }
+  }
+  state[userId] = tabId;
+  writeState(stateFile, state);
+  const evaluate = async (expression) => {
+    const r = await rest("POST", `/tabs/${encodeURIComponent(tabId)}/evaluate`, { userId, expression });
+    return r["result"] ?? r["value"];
+  };
+  const goto = async (u, waitUntil = "domcontentloaded") => {
+    await rest("POST", `/tabs/${encodeURIComponent(tabId)}/navigate`, { userId, url: u, waitUntil });
+    if (settleMs > 0) await sleep(settleMs);
+  };
+  const screenshot = async (o = {}) => {
+    const format = o.format ?? "jpeg";
+    const qs = new URLSearchParams({ userId, format });
+    if (o.selector) qs.set("selector", o.selector);
+    if (o.quality != null) qs.set("quality", String(o.quality));
+    const res = await doFetch(`${base}/tabs/${encodeURIComponent(tabId)}/screenshot?${qs.toString()}`);
+    if (!res.ok) throw new Error(`screenshot -> ${res.status}: ${(await res.text()).slice(0, 160)}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    const isPng = buf.length > 8 && buf[0] === 137 && buf[1] === 80;
+    const isJpeg = buf.length > 2 && buf[0] === 255 && buf[1] === 216;
+    const mimeType = isPng ? "image/png" : isJpeg ? "image/jpeg" : format === "png" ? "image/png" : "image/jpeg";
+    return { imageBase64: buf.toString("base64"), mimeType };
+  };
+  const rawGet = (p) => evaluate(
+    `(async()=>{try{const r=await fetch(${JSON.stringify(p)},{headers:{accept:"application/json","x-requested-with":"XMLHttpRequest"},credentials:"include"});let b=null;try{b=await r.json()}catch{}return{status:r.status,body:b}}catch(e){return{status:-1,error:String(e)}}})()`
+  );
+  const refresh = async () => {
+    if (!opts.refreshUrl) return false;
+    const r = await evaluate(
+      `(async()=>{try{const r=await fetch(${JSON.stringify(opts.refreshUrl)},{method:"POST",credentials:"include",headers:{accept:"application/json"}});return{status:r.status}}catch(e){return{status:-1}}})()`
+    );
+    return r?.status === 200;
+  };
+  const apiRaw = async (p) => {
+    let r = await rawGet(p);
+    if (r?.status === 401 && await refresh()) r = await rawGet(p);
+    return r;
+  };
+  const api = async (p) => {
+    const r = await apiRaw(p);
+    if (!r || r.status < 200 || r.status >= 300) throw new Error(`GET ${p} -> ${r?.status}`);
+    return r.body;
+  };
+  if (opts.url) await goto(opts.url);
+  return {
+    tabId,
+    userId,
+    api,
+    apiRaw,
+    evaluate,
+    screenshot,
+    goto,
+    click: async (selector) => {
+      await rest("POST", `/tabs/${encodeURIComponent(tabId)}/click`, { userId, selector });
+    },
+    type: async (selector, text) => {
+      await rest("POST", `/tabs/${encodeURIComponent(tabId)}/type`, { userId, selector, text });
+    },
+    press: async (key) => {
+      await rest("POST", `/tabs/${encodeURIComponent(tabId)}/press`, { userId, key });
+    },
+    startNetCapture: async (urlPattern, max) => {
+      await rest("POST", `/tabs/${encodeURIComponent(tabId)}/capture`, {
+        userId,
+        sessionKey: userId,
+        ...urlPattern ? { urlPattern } : {},
+        ...max ? { max } : {}
+      });
+    },
+    readNetCapture: async () => {
+      const r = await rest("GET", `/tabs/${encodeURIComponent(tabId)}/capture?userId=${encodeURIComponent(userId)}`);
+      const reqs = r["requests"];
+      return Array.isArray(reqs) ? reqs : [];
+    },
+    close: async () => {
+      try {
+        await rest("DELETE", `/tabs/${encodeURIComponent(tabId)}?userId=${encodeURIComponent(userId)}`);
+      } catch {
+      }
+      const s = readState(stateFile);
+      delete s[userId];
+      writeState(stateFile, s);
+    }
+  };
+}
+var rawCookieSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+  domain: z.string(),
+  path: z.string().optional(),
+  httpOnly: z.boolean().optional(),
+  secure: z.boolean().optional(),
+  sameSite: z.string().optional(),
+  expires: z.number().optional(),
+  expirationDate: z.number().optional(),
+  session: z.boolean().optional()
+}).loose();
+var rawCookieFileSchema = z.union([
+  z.array(rawCookieSchema),
+  z.object({ cookies: z.array(rawCookieSchema).optional() }).loose()
+]);
+function gatherFromFile(path5, domains) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path5, "utf8"));
+  } catch {
+    throw new SessionResolveError(`cookie file "${path5}" is not valid JSON`);
+  }
+  const parsed = rawCookieFileSchema.safeParse(raw);
+  if (!parsed.success) throw new SessionResolveError(`cookie file "${path5}" does not hold a cookie jar`);
+  const arr = Array.isArray(parsed.data) ? parsed.data : parsed.data.cookies ?? [];
+  return dedupeCookies(arr.filter((c) => domainMatches(c.domain, domains)).map(toSessionCookie));
+}
+async function gatherFromChromeProfile(args, deps) {
+  if (!args.profile) {
+    const avail = scanChromeIdentities({ ...deps.local, ...deps.authSignals ? { authSignals: deps.authSignals } : {} }).map((s) => `${s.profile} (${s.name ?? s.email ?? "?"})`).join(", ");
+    throw new SessionResolveError(
+      `chrome-profile source needs an explicit "profile" (multiple accounts exist); pick one: ${avail || "none"}`
+    );
+  }
+  const provider = createLocalBrowserSession({
+    ...deps.local,
+    ...deps.authSignals ? { authSignals: deps.authSignals } : {}
+  });
+  const out = [];
+  for (const domain of args.domains) {
+    const payload = await provider.getDecryptedForDomain(domain, args.profile);
+    for (const c of payload?.cookies ?? []) out.push(c);
+  }
+  const jar = dedupeCookies(out);
+  if (!args.account) return jar;
+  if (!deps.accountSwitcher) throw new AccountSwitcherMissingError(args.account.platform);
+  return deps.accountSwitcher(args.account.platform, jar, args.account.userId);
+}
+async function gatherCookiesForStrategy(strategy, desc, deps = {}) {
+  if (!isChromeCookieStrategy(strategy)) {
+    throw new SessionResolveError(`no cookies to gather for "${strategy.kind}" source`);
+  }
+  if (desc.inject && isFileInject(desc.inject)) return gatherFromFile(desc.inject.path, desc.inject.domains);
+  return gatherFromChromeProfile(
+    {
+      domains: strategy.domains,
+      profile: strategy.profile,
+      ...strategy.account ? { account: strategy.account } : {}
+    },
+    deps
+  );
+}
+async function gatherCookies(inject, deps = {}) {
+  if (isFileInject(inject)) return gatherFromFile(inject.path, inject.domains);
+  if (isChromeProfileInject(inject)) return gatherFromChromeProfile(inject, deps);
+  throw new SessionResolveError(`no cookies to gather for "${inject.from}" source`);
+}
+async function resolveSession(desc, deps = {}) {
+  const open = deps.openCamofox ?? openSession;
+  const sources = deps.sources ?? createSessionSourceRegistry();
+  const registry = deps.authSignals ?? defaultAuthSignalRegistry;
+  if (desc.backend === "chrome") {
+    const profile = desc.identity?.profile;
+    const driver = profile && deps.driverFor ? await deps.driverFor(profile) : deps.driver;
+    if (!driver) {
+      const hint = profile ? `deps.driverFor("${profile}") or deps.driver` : `deps.driver (or set identity.profile plus deps.driverFor for multi-account)`;
+      throw new SessionResolveError(`session "${desc.id}": backend "chrome" needs a live BrowserDriver: ${hint}`);
+    }
+    return { backend: "chrome", driver };
+  }
+  const selected = selectResolutionStrategy(desc);
+  const kind = selected?.kind ?? (desc.inject ? injectKindOf(desc.inject.from) : void 0);
+  if (!kind) throw new SessionResolveError(`session "${desc.id}": backend "camofox" needs inject{ from, domains }`);
+  const openWith = async (extra) => ({
+    backend: "camofox",
+    session: await open({
+      userId: desc.id,
+      ...desc.base ? { base: desc.base } : {},
+      ...desc.url ? { url: desc.url } : {},
+      ...extra
+    })
+  });
+  if (kind === "authed-storageState") {
+    const profilePath = ownedStorageStatePath(desc.id);
+    return openWith({
+      injectCookies: false,
+      ...existsSync(profilePath) ? { storageState: profilePath } : {},
+      keepAlive: true
+    });
+  }
+  if (kind === "chrome-cookie") return resolveChromeCookie(desc, selected, deps, openWith, registry);
+  const ref = selected && isSourceStrategy(selected) ? { sessionRef: selected.sessionRef, domains: selected.domains } : desc.inject && isSourceInject(desc.inject) ? { sessionRef: desc.inject.sessionRef, domains: desc.inject.domains } : void 0;
+  if (!ref) throw new SessionResolveError(`session "${desc.id}": "${kind}" source carries no sessionRef/domains`);
+  const cookies = await sources.materialize(kind, ref);
+  if (cookies.length === 0) {
+    throw new SessionResolveError(
+      `session "${desc.id}": the "${kind}" source returned no cookies for ${ref.domains.join("/")} (ref "${ref.sessionRef}"): revoked, expired, or not granted`
+    );
+  }
+  return openWith({ cookies: dedupeCookies(cookies), injectCookies: true, keepAlive: true });
+}
+async function resolveChromeCookie(desc, selected, deps, openWith, registry) {
+  if (desc.inject && isFileInject(desc.inject)) {
+    const cookies2 = await gatherCookies(desc.inject, deps);
+    return openWith({ cookies: cookies2, injectCookies: true, keepAlive: true });
+  }
+  const chromeStrat = selected && isChromeCookieStrategy(selected) ? selected : desc.inject && isChromeProfileInject(desc.inject) ? chromeCookieStrategyOf(desc.inject, desc.identity) : void 0;
+  if (!chromeStrat) throw new SessionResolveError(`session "${desc.id}": backend "camofox" needs inject{ from, domains }`);
+  const baseInject = {
+    from: "chrome-profile",
+    domains: chromeStrat.domains,
+    profile: chromeStrat.profile,
+    ...chromeStrat.account ? { account: chromeStrat.account } : {}
+  };
+  const chromeOpts = {
+    authSignals: registry,
+    ...deps.local ? { scanOptions: deps.local } : {},
+    ...deps.warn ? { warn: deps.warn } : {}
+  };
+  const healed = resolveChromeProfile(baseInject, desc.identity, chromeOpts);
+  const inject = healed && healed !== baseInject.profile ? { ...baseInject, profile: healed } : baseInject;
+  if (inject !== baseInject) {
+    deps.warn?.(
+      `"${desc.id}": pinned profile "${chromeStrat.profile}" has no live ${inject.domains.join("/")} login; healed to "${inject.profile}" (same account)`
+    );
+  }
+  verifyChromeIdentity(inject, desc.identity, chromeOpts);
+  const healedStrat = inject.profile !== chromeStrat.profile ? { ...chromeStrat, profile: inject.profile } : chromeStrat;
+  const cookies = await gatherCookiesForStrategy(healedStrat, desc, deps);
+  if (cookies.length === 0) {
+    throw new SessionResolveError(
+      `session "${desc.id}": no cookies for ${healedStrat.domains.join("/")} in profile "${healedStrat.profile || "(any)"}": not logged in, or wrong profile`
+    );
+  }
+  return openWith({ cookies, injectCookies: true, keepAlive: true });
+}
+var GRANT_DOMAIN_INVALID_CODE = "browser-profiles:grant-domain-invalid";
+var CONSENT_REQUIRED_CODE = "browser:consent_required";
+var CONSENT_FLAGS_REQUIRED_CODE = "browser-profiles:consent-flags-required";
+var CONSENT_DECLINED_CODE = "browser-profiles:consent-declined";
+var SINK_ACK_REQUIRED_CODE = "browser-profiles:sink-ack-required";
+var AGENT_GRANT_REFUSED_CODE = "browser-profiles:agent-grant-refused";
+var FULL_PROFILE_REFUSED_CODE = "browser-profiles:full-profile-refused";
+var LEDGER_RECORD_INVALID_CODE = "browser-profiles:ledger-record-invalid";
+var GRANT_STORE_INVALID_CODE = "browser-profiles:grant-store-invalid";
+var DOMAIN_HINT = {
+  empty: "a grant needs at least one explicit domain",
+  wildcard: "wildcards are not grantable; name each registrable domain (a grant already covers its subdomains)",
+  "leading-dot": "write the domain without a leading dot",
+  "bare-tld": "a bare TLD is not a registrable domain",
+  "public-suffix": "a public suffix is shared by unrelated sites and cannot be granted",
+  invalid: "expected a lowercase host such as github.com (ASCII or punycode, at least two labels)"
+};
+var GrantDomainError = class extends ToolError {
+  reason;
+  domain;
+  constructor(reason, domain) {
+    super({
+      code: GRANT_DOMAIN_INVALID_CODE,
+      message: `${domain === void 0 ? "domain list" : `"${domain}"`} rejected (${reason}): ${DOMAIN_HINT[reason]}`
+    });
+    this.name = "GrantDomainError";
+    this.reason = reason;
+    this.domain = domain;
+  }
+};
+var ConsentRequiredError = class extends ToolError {
+  constructor(message = "no active grant covers this request") {
+    super({ code: CONSENT_REQUIRED_CODE, message });
+    this.name = "ConsentRequiredError";
+  }
+};
+var NonInteractiveConsentError = class extends ToolError {
+  missing;
+  constructor(missing) {
+    super({
+      code: CONSENT_FLAGS_REQUIRED_CODE,
+      message: `non-interactive import refused: pass ${missing.join(" and ")}. There is no default of "all domains"; name each domain and confirm with --yes.`
+    });
+    this.name = "NonInteractiveConsentError";
+    this.missing = missing;
+  }
+};
+var ConsentDeclinedError = class extends ToolError {
+  constructor(what) {
+    super({ code: CONSENT_DECLINED_CODE, message: `consent declined: ${what}` });
+    this.name = "ConsentDeclinedError";
+  }
+};
+var SinkAckRequiredError = class extends ToolError {
+  sinkId;
+  constructor(sinkId) {
+    super({
+      code: SINK_ACK_REQUIRED_CODE,
+      message: `remote sink "${sinkId}" needs an explicit human acknowledgement (its id and operator) before any session material is sent`
+    });
+    this.name = "SinkAckRequiredError";
+    this.sinkId = sinkId;
+  }
+};
+var AgentGrantRefusedError = class extends ToolError {
+  attempt;
+  constructor(attempt) {
+    super({
+      code: AGENT_GRANT_REFUSED_CODE,
+      message: `refused: an agent cannot ${attempt}. Ask the user; they widen access through the operator channel, and only a human decision counts.`
+    });
+    this.name = "AgentGrantRefusedError";
+    this.attempt = attempt;
+  }
+};
+var FullProfileGrantError = class extends ToolError {
+  constructor(message) {
+    super({ code: FULL_PROFILE_REFUSED_CODE, message });
+    this.name = "FullProfileGrantError";
+  }
+};
+var LedgerRecordInvalidError = class extends ToolError {
+  issues;
+  constructor(issues) {
+    super({ code: LEDGER_RECORD_INVALID_CODE, message: `invalid consent ledger record: ${issues.join("; ")}` });
+    this.name = "LedgerRecordInvalidError";
+    this.issues = issues;
+  }
+};
+var GrantStoreInvalidError = class extends ToolError {
+  constructor(message) {
+    super({ code: GRANT_STORE_INVALID_CODE, message });
+    this.name = "GrantStoreInvalidError";
+  }
+};
+
+// src/consent/domains.ts
+var GRANT_DOMAIN_PATTERN = /^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+([a-z]{2,63}|xn--[a-z0-9-]{1,59})$/;
+var PUBLIC_SUFFIXES = /* @__PURE__ */ new Set([
+  "co.uk",
+  "org.uk",
+  "ac.uk",
+  "gov.uk",
+  "me.uk",
+  "ltd.uk",
+  "plc.uk",
+  "net.uk",
+  "sch.uk",
+  "com.au",
+  "net.au",
+  "org.au",
+  "edu.au",
+  "gov.au",
+  "id.au",
+  "co.nz",
+  "org.nz",
+  "net.nz",
+  "govt.nz",
+  "co.jp",
+  "ne.jp",
+  "or.jp",
+  "ac.jp",
+  "go.jp",
+  "co.kr",
+  "or.kr",
+  "go.kr",
+  "com.br",
+  "net.br",
+  "org.br",
+  "gov.br",
+  "com.cn",
+  "net.cn",
+  "org.cn",
+  "gov.cn",
+  "com.mx",
+  "com.ar",
+  "com.tr",
+  "com.tw",
+  "com.hk",
+  "com.sg",
+  "com.my",
+  "com.ph",
+  "com.vn",
+  "co.in",
+  "net.in",
+  "org.in",
+  "gov.in",
+  "co.id",
+  "co.th",
+  "co.il",
+  "co.za",
+  "com.ua",
+  "com.pl",
+  "com.es",
+  "com.pt",
+  "github.io",
+  "gitlab.io",
+  "herokuapp.com",
+  "appspot.com",
+  "vercel.app",
+  "netlify.app",
+  "pages.dev",
+  "workers.dev",
+  "web.app",
+  "firebaseapp.com",
+  "blogspot.com",
+  "cloudfront.net",
+  "azurewebsites.net",
+  "s3.amazonaws.com",
+  "fly.dev",
+  "onrender.com",
+  "ngrok.io",
+  "trycloudflare.com"
+]);
+function isKnownPublicSuffix(domain) {
+  return PUBLIC_SUFFIXES.has(domain);
+}
+function validateGrantDomains(input, policy = {}) {
+  if (input.length === 0) throw new GrantDomainError("empty");
+  const out = [];
+  for (const raw of input) {
+    if (typeof raw !== "string" || raw.length === 0) throw new GrantDomainError("invalid", String(raw));
+    if (raw.includes("*")) throw new GrantDomainError("wildcard", raw);
+    if (raw.startsWith(".")) throw new GrantDomainError("leading-dot", raw);
+    const domain = raw.toLowerCase();
+    if (!domain.includes(".")) throw new GrantDomainError("bare-tld", raw);
+    if (domain.length > 253 || !GRANT_DOMAIN_PATTERN.test(domain)) throw new GrantDomainError("invalid", raw);
+    if (isKnownPublicSuffix(domain) || policy.isPublicSuffix?.(domain) === true) {
+      throw new GrantDomainError("public-suffix", raw);
+    }
+    if (!out.includes(domain)) out.push(domain);
+  }
+  return out;
+}
+function hostCoveredBy(host, domain) {
+  const h = host.replace(/^\./, "").toLowerCase();
+  return h === domain || h.endsWith(`.${domain}`);
+}
+function defaultConsentLedgerPath(home = homedir()) {
+  return join(home, ".agentproto", "bureau", "consent.jsonl");
+}
+var domainSchema = z.string().max(253).regex(GRANT_DOMAIN_PATTERN);
+var sha256Schema = z.string().regex(/^[0-9a-f]{64}$/);
+var idSchema = z.string().min(1);
+var ledgerEventSchema = z.enum(["grant", "refresh", "revoke", "sink-ack", "deny"]);
+var ledgerActorSchema = z.object({
+  kind: z.enum(["human", "agent", "system"]),
+  via: z.string().optional(),
+  deviceId: idSchema.optional()
+}).strict();
+var ledgerRecordSchema = z.object({
+  seq: z.number().int().min(0),
+  at: z.iso.datetime({ offset: true }),
+  event: ledgerEventSchema,
+  actor: ledgerActorSchema,
+  grantId: idSchema.optional(),
+  sessionId: idSchema.optional(),
+  domains: z.array(domainSchema).optional(),
+  fullProfile: z.literal(true).optional(),
+  cookieCount: z.number().int().min(0).optional(),
+  nameHashes: z.array(sha256Schema).optional(),
+  sinkId: z.string().optional(),
+  derived: z.object({
+    local: z.enum(["deleted", "none"]),
+    remote: z.enum(["confirmed", "unavailable", "failed", "not-applicable"])
+  }).strict().optional(),
+  reason: z.string().max(500).optional(),
+  prev: sha256Schema.optional()
+}).strict().superRefine((r, ctx) => {
+  const need = (field) => {
+    if (r[field] === void 0) ctx.addIssue({ code: "custom", message: `${r.event} needs ${field}`, path: [field] });
+  };
+  if (r.actor.kind === "agent" && (r.event === "grant" || r.event === "sink-ack")) {
+    ctx.addIssue({ code: "custom", message: "an agent cannot grant or acknowledge a sink (C7)", path: ["actor", "kind"] });
+  }
+  if (r.event === "grant") {
+    need("grantId");
+    need("sessionId");
+    need("cookieCount");
+    if (r.domains === void 0 === (r.fullProfile === void 0)) {
+      ctx.addIssue({ code: "custom", message: "a grant record has exactly one of domains or fullProfile", path: ["domains"] });
+    }
+    if (r.domains !== void 0 && r.domains.length === 0) {
+      ctx.addIssue({ code: "custom", message: "domains must not be empty", path: ["domains"] });
+    }
+  }
+  if (r.event === "refresh") {
+    need("grantId");
+    need("domains");
+    need("cookieCount");
+    if (r.domains !== void 0 && r.domains.length === 0) {
+      ctx.addIssue({ code: "custom", message: "domains must not be empty", path: ["domains"] });
+    }
+  }
+  if (r.event === "revoke") {
+    need("grantId");
+    need("derived");
+  }
+  if (r.event === "sink-ack") {
+    need("grantId");
+    need("sinkId");
+    if (r.actor.kind !== "human") ctx.addIssue({ code: "custom", message: "a sink-ack is a human act", path: ["actor", "kind"] });
+  }
+  if (r.event === "deny") need("reason");
+});
+function cookieNameHash(grantId, cookieName) {
+  return createHash("sha256").update(grantId).update("\0").update(cookieName).digest("hex");
+}
+var sha256 = (text) => createHash("sha256").update(text).digest("hex");
+var isPosix = process.platform !== "win32";
+function createConsentLedger(opts = {}) {
+  const path5 = opts.path ?? defaultConsentLedgerPath();
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const lines = () => {
+    if (!existsSync(path5)) return [];
+    return readFileSync(path5, "utf8").split("\n").filter((line) => line.length > 0);
+  };
+  return {
+    path: path5,
+    append(entry) {
+      const existing = lines();
+      const last = existing[existing.length - 1];
+      const candidate = {
+        ...entry,
+        seq: existing.length,
+        at: now().toISOString(),
+        ...last !== void 0 ? { prev: sha256(last) } : {}
+      };
+      const parsed = ledgerRecordSchema.safeParse(candidate);
+      if (!parsed.success) {
+        throw new LedgerRecordInvalidError(parsed.error.issues.map((i) => `${i.path.join(".") || "(record)"}: ${i.message}`));
+      }
+      const line = JSON.stringify(candidate);
+      mkdirSync(dirname(path5), { recursive: true, mode: 448 });
+      appendFileSync(path5, `${line}
+`, { mode: 384 });
+      if (isPosix && (statSync(path5).mode & 63) !== 0) chmodSync(path5, 384);
+      return parsed.data;
+    },
+    read() {
+      return lines().map((line) => ledgerRecordSchema.parse(JSON.parse(line)));
+    },
+    verifyChain() {
+      const rows = lines();
+      let prevLine;
+      for (const [i, line] of rows.entries()) {
+        const rec = ledgerRecordSchema.safeParse(JSON.parse(line));
+        if (!rec.success || rec.data.seq !== i) return false;
+        if (prevLine !== void 0 && rec.data.prev !== sha256(prevLine)) return false;
+        prevLine = line;
+      }
+      return true;
+    }
+  };
+}
+var grantSinkSchema = z.union([
+  z.object({ kind: z.literal("local") }).strict(),
+  z.object({ kind: z.literal("remote"), providerId: z.string(), ackSeq: z.number().int().min(0) }).strict()
+]);
+var grantSchema = z.object({
+  id: z.string().min(1),
+  sessionId: z.string().min(1),
+  deviceId: z.string().min(1).optional(),
+  source: z.object({ kind: z.enum(["chrome", "firefox", "file", "native-login"]), profile: z.string().min(1) }).strict(),
+  domains: z.array(z.string().max(253).regex(GRANT_DOMAIN_PATTERN)).min(1).optional(),
+  fullProfile: z.literal(true).optional(),
+  sinks: z.array(grantSinkSchema).min(1),
+  grantedAt: z.iso.datetime({ offset: true }),
+  grantedVia: z.enum(["interactive", "flag"]),
+  expiresAt: z.iso.datetime({ offset: true }).optional(),
+  cookieCount: z.number().int().min(0),
+  revokedAt: z.iso.datetime({ offset: true }).optional()
+}).strict().superRefine((g, ctx) => {
+  if (g.domains === void 0 === (g.fullProfile === void 0)) {
+    ctx.addIssue({ code: "custom", message: "a grant has exactly one of domains or fullProfile", path: ["domains"] });
+  }
+  if (g.fullProfile && g.sinks.some((s) => s.kind !== "local")) {
+    ctx.addIssue({ code: "custom", message: "a full-profile grant cannot include a remote sink (C3)", path: ["sinks"] });
+  }
+});
+function isGrantActive(grant, now = /* @__PURE__ */ new Date()) {
+  if (grant.revokedAt !== void 0) return false;
+  return grant.expiresAt === void 0 || Date.parse(grant.expiresAt) > now.getTime();
+}
+function grantServesDevice(grant, deviceId) {
+  return grant.deviceId === void 0 || grant.deviceId === deviceId;
+}
+function memoryGrantStore(initial = []) {
+  const map = new Map(initial.map((g) => [g.id, structuredClone(g)]));
+  return {
+    list: () => [...map.values()].map((g) => structuredClone(g)),
+    get: (id) => {
+      const g = map.get(id);
+      return g ? structuredClone(g) : void 0;
+    },
+    put: (grant) => void map.set(grant.id, structuredClone(grant))
+  };
+}
+function defaultGrantStorePath(home = homedir()) {
+  return join(home, ".agentproto", "bureau", "grants.json");
+}
+var isPosix2 = process.platform !== "win32";
+function fileGrantStore(path5 = defaultGrantStorePath()) {
+  const load = () => {
+    if (!existsSync(path5)) return [];
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(path5, "utf8"));
+    } catch {
+      throw new GrantStoreInvalidError(`grants file ${path5} is not valid JSON`);
+    }
+    const parsed = z.object({ version: z.literal(1), grants: z.array(grantSchema) }).safeParse(raw);
+    if (!parsed.success) throw new GrantStoreInvalidError(`grants file ${path5} does not hold a grant list`);
+    return parsed.data.grants;
+  };
+  return {
+    list: load,
+    get: (id) => load().find((g) => g.id === id),
+    put(grant) {
+      const checked = grantSchema.parse(grant);
+      const all = load().filter((g) => g.id !== checked.id);
+      all.push(checked);
+      mkdirSync(dirname(path5), { recursive: true, mode: 448 });
+      const tmp = `${path5}.tmp`;
+      writeFileSync(tmp, JSON.stringify({ version: 1, grants: all }, null, 2), { mode: 384 });
+      renameSync(tmp, path5);
+      if (isPosix2 && (statSync(path5).mode & 63) !== 0) chmodSync(path5, 384);
+    }
+  };
+}
+function localChromePort(opts) {
+  const dirFor = (profile) => {
+    if (!profileDirs(opts.chromeRoot).includes(profile)) {
+      throw new ChromeIdentityError(`Chrome profile "${profile}" not found under the given user-data dir`);
+    }
+    return path.join(opts.chromeRoot, profile);
+  };
+  return {
+    countByDomain: (profile, domains) => countCookiesByDomain(dirFor(profile), domains),
+    countAll: (profile) => countCookies(dirFor(profile)),
+    readCookies(profile, domains) {
+      const key = opts.safeStoragePassword ? safeStorageKey(opts.safeStoragePassword()) : readSafeStorageKey();
+      return decryptChromeCookies(dirFor(profile), domains, key);
+    }
+  };
+}
+var FULL_PROFILE_WARNING = "WARNING: full-profile grant. Every cookie in this Chrome profile becomes usable by this device, for every site, not just the ones you know. It stays on this machine (local sink only). Prefer naming domains with --domains. Revoke it any time; the grant and the revoke are in the consent ledger.";
+var jarSchema = z.object({ version: z.literal(1), cookies: z.array(browserCookieSchema) });
+var SAME_SITE = { strict: "Strict", lax: "Lax", none: "None" };
+function toBrowserCookie(c) {
+  const sameSite = c.sameSite ? SAME_SITE[c.sameSite.toLowerCase()] : void 0;
+  return {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path ?? "/",
+    ...c.expires !== void 0 && c.expires > 0 ? { expires: c.expires } : {},
+    ...c.httpOnly !== void 0 ? { httpOnly: c.httpOnly } : {},
+    ...c.secure !== void 0 ? { secure: c.secure } : {},
+    ...sameSite ? { sameSite } : {}
+  };
+}
+var isPosix3 = process.platform !== "win32";
+var HUMAN = { kind: "human" };
+var SYSTEM = { kind: "system" };
+function createConsentHost(opts) {
+  const { grants, ledger, store, chrome } = opts;
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const newId = opts.newId ?? (() => `grant_${randomUUID()}`);
+  const jarPath = (grantId) => path.join(opts.jarDir, `${grantId.replace(/[^\w.-]/g, "_")}.json`);
+  const devicePaired = (g) => g.deviceId === void 0 || opts.isDevicePaired === void 0 || opts.isDevicePaired(g.deviceId);
+  const usable = (g, deviceId) => isGrantActive(g, now()) && devicePaired(g) && grantServesDevice(g, deviceId);
+  const writeJar = (grantId, cookies) => {
+    mkdirSync(opts.jarDir, { recursive: true, mode: 448 });
+    const file = jarPath(grantId);
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: 1, cookies }), { mode: 384 });
+    renameSync(tmp, file);
+    if (isPosix3 && (statSync(file).mode & 63) !== 0) chmodSync(file, 384);
+  };
+  const readJar = (grantId) => {
+    const file = jarPath(grantId);
+    if (!existsSync(file)) return [];
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      return [];
+    }
+    const parsed = jarSchema.safeParse(raw);
+    return parsed.success ? parsed.data.cookies : [];
+  };
+  const nameHashes = (grantId, cookies) => [...new Set(cookies.map((c) => c.name))].map((n) => cookieNameHash(grantId, n));
+  const syncDescriptor = async (sessionId) => {
+    const active = grants.list().filter((g) => g.sessionId === sessionId && g.domains !== void 0 && isGrantActive(g, now()) && existsSync(jarPath(g.id))).sort((a, b) => a.grantedAt.localeCompare(b.grantedAt));
+    const prev = await store.load(sessionId);
+    const latest = active[active.length - 1];
+    if (!latest || !latest.domains) {
+      if (prev?.inject && isFileInject(prev.inject) && path.dirname(prev.inject.path) === opts.jarDir) await store.remove(sessionId);
+      return;
+    }
+    const desc = {
+      ...prev ?? { id: sessionId, backend: "camofox" },
+      identity: { ...prev?.identity ?? {}, profile: latest.source.profile },
+      inject: { from: "file", domains: latest.domains, path: jarPath(latest.id) },
+      savedAt: now().toISOString()
+    };
+    await store.save(desc);
+  };
+  const refuseAgent = (attempt, ctx) => {
+    const named = ctx.domains && ctx.domains.length > 0 ? ` (${ctx.domains.join(", ")})` : "";
+    ledger.append({
+      event: "deny",
+      actor: ctx.actor,
+      ...ctx.grantId ? { grantId: ctx.grantId } : {},
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+      reason: `agent attempted to ${attempt}${named}`.slice(0, 500)
+    });
+    throw new AgentGrantRefusedError(attempt);
+  };
+  const guardHuman = (actor, attempt, ctx) => {
+    const a = actor ?? HUMAN;
+    if (a.kind === "agent") refuseAgent(attempt, { actor: a, sessionId: ctx.sessionId, ...ctx.domains ? { domains: ctx.domains } : {} });
+    return a;
+  };
+  return {
+    async importFromChrome(req) {
+      const actor = guardHuman(req.actor, "grant access to a Chrome profile", { sessionId: req.sessionId, ...req.domains ? { domains: req.domains } : {} });
+      const named = req.domains ?? [];
+      if (!opts.prompt) {
+        const missing = [];
+        if (named.length === 0) missing.push("--domains");
+        if (req.yes !== true) missing.push("--yes");
+        if (missing.length > 0) throw new NonInteractiveConsentError(missing);
+      }
+      const domains = validateGrantDomains(named, opts.domainPolicy);
+      const scan = chrome.countByDomain(req.profile, domains);
+      const presence = "known" in scan ? scan.known : void 0;
+      if (req.yes !== true && opts.prompt) {
+        for (const domain of domains) {
+          const ok = await opts.prompt.confirm({
+            kind: "domain",
+            domain,
+            profile: req.profile,
+            presentCount: presence?.[domain],
+            ...req.deviceId ? { deviceId: req.deviceId } : {}
+          });
+          if (!ok) throw new ConsentDeclinedError(`domain ${domain}`);
+        }
+      }
+      const remoteSinks = [];
+      const sinks = [];
+      for (const s of req.sinks ?? [{ kind: "local" }]) {
+        if (s.kind === "local") {
+          if (!sinks.some((x) => x.kind === "local")) sinks.push({ kind: "local" });
+          continue;
+        }
+        let acked = s.acknowledged === true;
+        if (!acked && opts.prompt) acked = await opts.prompt.confirm({ kind: "sink", providerId: s.providerId, sessionId: req.sessionId });
+        if (!acked) throw new SinkAckRequiredError(s.providerId);
+        remoteSinks.push({ providerId: s.providerId });
+      }
+      if (sinks.length === 0 && remoteSinks.length === 0) sinks.push({ kind: "local" });
+      const cookies = chrome.readCookies(req.profile, domains).map(toBrowserCookie);
+      const id = newId();
+      const via = req.yes === true ? "flag" : "interactive";
+      const grantActor = { ...actor, via, ...req.deviceId ? { deviceId: req.deviceId } : {} };
+      ledger.append({
+        event: "grant",
+        actor: grantActor,
+        grantId: id,
+        sessionId: req.sessionId,
+        domains,
+        cookieCount: cookies.length,
+        nameHashes: nameHashes(id, cookies)
+      });
+      writeJar(id, cookies);
+      for (const r of remoteSinks) {
+        const row = ledger.append({ event: "sink-ack", actor: grantActor, grantId: id, sessionId: req.sessionId, sinkId: r.providerId });
+        sinks.push({ kind: "remote", providerId: r.providerId, ackSeq: row.seq });
+      }
+      const grant = {
+        id,
+        sessionId: req.sessionId,
+        ...req.deviceId ? { deviceId: req.deviceId } : {},
+        source: { kind: "chrome", profile: req.profile },
+        domains,
+        sinks,
+        grantedAt: now().toISOString(),
+        grantedVia: via,
+        ...req.expiresAt ? { expiresAt: req.expiresAt } : {},
+        cookieCount: cookies.length
+      };
+      grants.put(grant);
+      await syncDescriptor(req.sessionId);
+      const warnings = presence ? domains.filter((d) => (presence[d] ?? 0) === 0).map((d) => `no cookies found for ${d} in profile ${req.profile}`) : ["presence scan failed; the import may hold fewer cookies than expected"];
+      return { grant, presence, warnings };
+    },
+    async grantFullProfile(req) {
+      const actor = guardHuman(req.actor, "grant a full Chrome profile", { sessionId: req.sessionId });
+      if (!opts.prompt && req.yes !== true) throw new NonInteractiveConsentError(["--full-profile", "--yes"]);
+      if (req.yes !== true && opts.prompt) {
+        const ok = await opts.prompt.confirm({
+          kind: "full-profile",
+          profile: req.profile,
+          warning: FULL_PROFILE_WARNING,
+          ...req.deviceId ? { deviceId: req.deviceId } : {}
+        });
+        if (!ok) throw new ConsentDeclinedError(`full profile ${req.profile}`);
+      }
+      const count = chrome.countAll(req.profile);
+      const cookieCount = "known" in count ? count.known : 0;
+      const id = newId();
+      const via = req.yes === true ? "flag" : "interactive";
+      ledger.append({
+        event: "grant",
+        actor: { ...actor, via, ...req.deviceId ? { deviceId: req.deviceId } : {} },
+        grantId: id,
+        sessionId: req.sessionId,
+        fullProfile: true,
+        cookieCount
+      });
+      const grant = {
+        id,
+        sessionId: req.sessionId,
+        ...req.deviceId ? { deviceId: req.deviceId } : {},
+        source: { kind: "chrome", profile: req.profile },
+        fullProfile: true,
+        sinks: [{ kind: "local" }],
+        grantedAt: now().toISOString(),
+        grantedVia: via,
+        ...req.expiresAt ? { expiresAt: req.expiresAt } : {},
+        cookieCount
+      };
+      grants.put(grant);
+      const warnings = "known" in count ? [] : ["cookie count unavailable; recorded as 0"];
+      return { grant, warning: FULL_PROFILE_WARNING, warnings };
+    },
+    async refresh(grantId, o = {}) {
+      const actor = o.actor ?? SYSTEM;
+      const grant = grants.get(grantId);
+      if (!grant || !usable(grant, actor.deviceId) || !grant.domains) throw new ConsentRequiredError();
+      const cookies = chrome.readCookies(grant.source.profile, grant.domains).map(toBrowserCookie);
+      ledger.append({
+        event: "refresh",
+        actor,
+        grantId,
+        sessionId: grant.sessionId,
+        domains: grant.domains,
+        cookieCount: cookies.length,
+        nameHashes: nameHashes(grantId, cookies)
+      });
+      writeJar(grantId, cookies);
+      const next = { ...grant, cookieCount: cookies.length };
+      grants.put(next);
+      await syncDescriptor(grant.sessionId);
+      return { grant: next, cookieCount: cookies.length };
+    },
+    async revoke(grantId, o = {}) {
+      const actor = o.actor ?? HUMAN;
+      const grant = grants.get(grantId);
+      if (!grant) throw new ConsentRequiredError(`no grant "${grantId}"`);
+      if (grant.revokedAt !== void 0) return { grant, derived: { local: "none", remote: "not-applicable" } };
+      const hadJar = existsSync(jarPath(grantId));
+      rmSync(jarPath(grantId), { force: true });
+      const extra = opts.deleteExtraDerived ? await opts.deleteExtraDerived(grant) : false;
+      const hasRemote = grant.sinks.some((s) => s.kind === "remote");
+      const remote = !hasRemote ? "not-applicable" : opts.revokeRemote ? await opts.revokeRemote(grant) : "unavailable";
+      const derived = { local: hadJar || extra ? "deleted" : "none", remote };
+      const revoked = { ...grant, revokedAt: now().toISOString() };
+      grants.put(revoked);
+      await syncDescriptor(grant.sessionId);
+      ledger.append({ event: "revoke", actor, grantId, sessionId: grant.sessionId, derived });
+      return { grant: revoked, derived };
+    },
+    fullProfileProof(sel) {
+      const match = (g) => g.fullProfile === true && (sel.grantId === void 0 || g.id === sel.grantId) && (sel.sessionId === void 0 || g.sessionId === sel.sessionId) && (sel.profile === void 0 || g.source.profile === sel.profile) && usable(g, sel.deviceId);
+      const found = grants.list().find(match);
+      if (!found) {
+        throw new FullProfileGrantError(
+          "no active full-profile grant covers this request. --full-profile needs an explicit, recorded grant (run the full-profile consent first)."
+        );
+      }
+      return {
+        grantId: found.id,
+        isActive: () => {
+          const g = grants.get(found.id);
+          return g !== void 0 && g.fullProfile === true && usable(g, sel.deviceId);
+        }
+      };
+    },
+    // Serves domain grants only. A full-profile grant is honored through `fullProfileProof`, never as injected cookies.
+    cookieSourceFor(scope = {}) {
+      return ({ providerId, profile }) => {
+        const out = [];
+        for (const g of grants.list()) {
+          if (g.sessionId !== profile || !g.domains || !usable(g, scope.deviceId)) continue;
+          const servesProvider = g.sinks.some((s) => s.kind === "local" || s.providerId === providerId);
+          if (!servesProvider) continue;
+          const allowed = g.domains;
+          out.push(...readJar(g.id).filter((c) => allowed.some((d) => hostCoveredBy(c.domain, d))));
+        }
+        return out;
+      };
+    },
+    assertCovered({ sessionId, host, deviceId }) {
+      const hit = grants.list().find((g) => g.sessionId === sessionId && g.domains?.some((d) => hostCoveredBy(host, d)) === true && usable(g, deviceId));
+      if (!hit) throw new ConsentRequiredError(`no active grant covers ${host} for this device`);
+      return hit;
+    },
+    refuseAgent,
+    getGrant: (id) => grants.get(id),
+    listGrants: () => grants.list()
+  };
+}
+
+// src/consent/agent.ts
+function createAgentConsentSurface(host, who = {}) {
+  const actor = {
+    kind: "agent",
+    ...who.via ? { via: who.via } : {},
+    ...who.deviceId ? { deviceId: who.deviceId } : {}
+  };
+  const own = (grantId) => {
+    const g = host.getGrant(grantId);
+    if (!g || !grantServesDevice(g, who.deviceId)) throw new ConsentRequiredError();
+    return g;
+  };
+  const sameSet = (a, b) => {
+    const left = new Set(a.map((x) => x.toLowerCase()));
+    const right = new Set(b.map((x) => x.toLowerCase()));
+    return left.size === right.size && [...left].every((x) => right.has(x));
+  };
+  return {
+    async sync(input) {
+      const grant = own(input.grantId);
+      const base = { actor, grantId: grant.id, sessionId: grant.sessionId };
+      if (input.profile !== void 0 && input.profile !== grant.source.profile) {
+        host.refuseAgent("change the Chrome profile of a grant", base);
+      }
+      if (input.domains !== void 0 && !sameSet(input.domains, grant.domains ?? [])) {
+        host.refuseAgent("add a domain to a grant", { ...base, domains: input.domains });
+      }
+      const { cookieCount } = await host.refresh(grant.id, { actor });
+      return { grantId: grant.id, cookieCount };
+    },
+    async revoke(grantId) {
+      own(grantId);
+      await host.revoke(grantId, { actor });
+    },
+    async grant(input) {
+      return host.refuseAgent("grant access to a Chrome profile", {
+        actor,
+        sessionId: input.sessionId,
+        ...input.domains ? { domains: input.domains } : {}
+      });
+    },
+    async addSink(input) {
+      const g = own(input.grantId);
+      return host.refuseAgent("add a sink to a grant", { actor, grantId: g.id, sessionId: g.sessionId });
+    }
+  };
+}
+var NATIVE_LOGIN_RECOMMENDATION = "Sign in natively instead: run the native-login flow in the Bureau browser. It needs no access to your Chrome profile, Keychain or Full Disk Access.";
+var errCode = (e) => typeof e === "object" && e !== null && "code" in e && typeof e.code === "string" ? e.code : void 0;
+function classify(e, binary, what) {
+  const code = errCode(e);
+  if (code === "EPERM" || code === "EACCES") {
+    return {
+      failure: "full-disk-access",
+      detail: `${what} was blocked (${code}). Full Disk Access is missing for "${binary}".`,
+      fix: `System Settings > Privacy & Security > Full Disk Access: enable "${binary}", then restart it.`
+    };
+  }
+  if (code === "ENOENT") {
+    return { failure: "missing", detail: `${what} does not exist.`, fix: "Check the Chrome profile name (Default, Profile 1) and that Chrome is installed." };
+  }
+  return { failure: "unreadable", detail: `${what} could not be read (${code ?? "unknown error"}).` };
+}
+function runDoctor(opts) {
+  const { port } = opts;
+  const checks = [];
+  try {
+    const state = parseLocalState(port.readLocalState());
+    checks.push({ id: "local-state", status: "ok", detail: `Local State readable, ${state.profiles.length} profile(s) listed.` });
+  } catch (e) {
+    checks.push({ id: "local-state", status: "fail", ...classify(e, port.binary, "Local State") });
+  }
+  try {
+    port.copyCookiesDb(opts.profile);
+    checks.push({ id: "cookies-db", status: "ok", detail: `Cookies db of "${opts.profile}" is copyable.` });
+  } catch (e) {
+    checks.push({ id: "cookies-db", status: "fail", ...classify(e, port.binary, `Cookies db of "${opts.profile}"`) });
+  }
+  if (opts.checkKeychain === true && port.probeKeychain) {
+    try {
+      port.probeKeychain();
+      checks.push({ id: "keychain", status: "ok", detail: "Keychain returned the Safe Storage key (value not shown)." });
+    } catch {
+      checks.push({
+        id: "keychain",
+        status: "fail",
+        failure: "keychain-denied",
+        detail: "The Keychain did not release the Safe Storage key.",
+        fix: "Approve the Keychain prompt for this run, or use native login."
+      });
+    }
+  } else {
+    checks.push({ id: "keychain", status: "skipped", detail: "Keychain not touched. Pass the explicit keychain check to probe it." });
+  }
+  const ok = checks.every((c) => c.status !== "fail");
+  return { ok, checks, ...ok ? {} : { recommendation: NATIVE_LOGIN_RECOMMENDATION } };
+}
+function localDoctorPort(opts) {
+  return {
+    binary: opts.binary ?? process.execPath,
+    readLocalState: () => readFileSync(path.join(opts.chromeRoot, "Local State"), "utf8"),
+    copyCookiesDb(profile) {
+      const dir = mkdtempSync(path.join(tmpdir(), "bp-doctor-"));
+      try {
+        copyFileSync(path.join(opts.chromeRoot, profile, "Cookies"), path.join(dir, "Cookies"));
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    },
+    ...opts.probeKeychain ? { probeKeychain: opts.probeKeychain } : {}
+  };
+}
+
+export { ACCOUNT_SWITCHER_MISSING_CODE, AGENT_GRANT_REFUSED_CODE, AccountSwitcherMissingError, AgentGrantRefusedError, BUILTIN_INJECT_FROM, BUILTIN_STRATEGY_KINDS, CHROME_IDENTITY_CODE, CONSENT_DECLINED_CODE, CONSENT_FLAGS_REQUIRED_CODE, CONSENT_REQUIRED_CODE, COOKIE_STALE_TTL_MS, ChromeIdentityError, ConsentDeclinedError, ConsentRequiredError, FULL_PROFILE_REFUSED_CODE, FULL_PROFILE_WARNING, FullProfileGrantError, GRANT_DOMAIN_INVALID_CODE, GRANT_DOMAIN_PATTERN, GRANT_STORE_INVALID_CODE, GrantDomainError, GrantStoreInvalidError, LEDGER_RECORD_INVALID_CODE, LedgerRecordInvalidError, NonInteractiveConsentError, SESSION_DESCRIPTOR_INVALID_CODE, SESSION_RESOLVE_CODE, SESSION_SOURCE_DUPLICATE_CODE, SESSION_SOURCE_RESERVED_CODE, SESSION_SOURCE_UNKNOWN_CODE, SINK_ACK_REQUIRED_CODE, SessionDescriptorInvalidError, SessionResolveError, SessionSourceDuplicateError, SessionSourceReservedError, SessionSourceUnknownError, SinkAckRequiredError, assertChromeLaunchDirSafe, authStatusSchema, buildOwnedSessionDescriptor, camofoxStatePath, catalogSessionStore, chromeCookieStrategyOf, chromeIdentityLabel, chromeLocalStatePath, chromeTimeToIso, chromeUserDataDir, chromeUserDataRoot, compositeSessionStore, cookieFreshness, cookieNameHash, countCookies, countCookiesByDomain, createAgentConsentSurface, createAuthSignalRegistry, createConsentHost, createConsentLedger, createLocalBrowserSession, createSessionSourceRegistry, decryptChromeCookies, decryptChromeValue, dedupeCookies, defaultAuthSignalRegistry, defaultCamofoxBase, defaultConsentLedgerPath, defaultGrantStorePath, describeSessionAuth, domainAuthSignal, domainMatches, fileGrantStore, fileSessionStore, gatherCookies, gatherCookiesForStrategy, grantSchema, grantServesDevice, hostCoveredBy, injectFromOf, injectKindOf, isBuiltinStrategyKind, isCamofoxNativeInject, isChromeCookieStrategy, isChromeProfileInject, isFileInject, isGrantActive, isKnown, isKnownPublicSuffix, isOwnedStorageStateStrategy, isSessionSourceUnknownError, isSourceInject, isSourceStrategy, isStoredCredentialStrategy, knownOr, ledgerActorSchema, ledgerEventSchema, ledgerRecordSchema, localChromePort, localDoctorPort, memoryGrantStore, normalizeDescriptor, openSession, ownedStorageStatePath, parseLocalState, parseSessionDescriptor, priorChromeStrategy, profileAuthedDomains, profileDirs, profileLoggedInDomains, readLocalState, readSafeStorageKey, resolveChromeProfile, resolveInjectFromStrategies, resolveSession, runDoctor, safeStorageKey, scanChromeIdentities, selectResolutionStrategy, sessionDescriptorSchema, sessionIdentitySchema, sessionInjectSchema, strategySchema, toSessionCookie, validateGrantDomains, verifyChromeIdentity };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map