u-chan-secrets 0.0.0-stage → 3.0.2

package/dist/core/browser.js

@@ -0,0 +1,131 @@
+import { execFile } from 'node:child_process';
+import { chromium } from 'playwright';
+import { UserFacingError } from './types.js';
+import { abortable } from './abort.js';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Runs scripts/start-chrome.ps1 (idempotent: it exits early if the port is already open). */
+export const startChromeScript = (scriptPath) => () => new Promise((resolve, reject) => {
+    execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', scriptPath], { timeout: 30000, windowsHide: true }, (err) => (err ? reject(err) : resolve()));
+});
+/** Attaches to the user's Chrome over CDP so cookies are shared with Playwright MCP. Never closes the browser. */
+export class CdpBrowserProvider {
+    endpoint;
+    opts;
+    disconnecting;
+    browser;
+    connecting;
+    constructor(endpoint, opts = {}) {
+        this.endpoint = endpoint;
+        this.opts = opts;
+    }
+    async getBrowser(autoLaunch) {
+        if (this.browser?.isConnected())
+            return this.browser;
+        this.connecting ??= this.connect(autoLaunch)
+            .then((b) => (this.browser = b))
+            .finally(() => {
+            this.connecting = undefined;
+        });
+        return this.connecting;
+    }
+    async connect(autoLaunch) {
+        try {
+            return await chromium.connectOverCDP(this.endpoint, { timeout: 5000 });
+        }
+        catch {
+            if (!autoLaunch || !this.opts.launch)
+                throw new UserFacingError('Chrome is not running — run scripts/start-chrome.ps1');
+        }
+        const fail = () => new UserFacingError('could not start Chrome — run scripts/start-chrome.ps1');
+        await this.opts.launch().catch(() => {
+            throw fail();
+        });
+        const deadline = Date.now() + (this.opts.launchTimeoutMs ?? 15000);
+        while (Date.now() < deadline) {
+            try {
+                return await chromium.connectOverCDP(this.endpoint, { timeout: 2000 });
+            }
+            catch {
+                await sleep(300);
+            }
+        }
+        throw fail();
+    }
+    disconnect() {
+        return this.disconnecting ??= (async () => {
+            const browser = this.browser ?? await this.connecting?.catch(() => undefined);
+            this.browser = undefined;
+            // For connectOverCDP, close disconnects this transport, not the user's Chrome process.
+            await browser?.close().catch(() => { });
+        })().finally(() => { this.disconnecting = undefined; });
+    }
+    async withPage(fn, signal) {
+        const browser = await abortable(this.getBrowser(true), signal, () => this.disconnect(), b => b.close());
+        const context = browser.contexts()[0];
+        if (!context)
+            throw new UserFacingError('Chrome has no default window — open Chrome with scripts/start-chrome.ps1');
+        const page = await abortable(context.newPage(), signal, () => this.disconnect(), p => p.close());
+        page.setDefaultTimeout(5000);
+        try {
+            signal?.throwIfAborted();
+            return await abortable(fn(page), signal, () => this.disconnect());
+        }
+        finally {
+            await abortable(page.close(), signal, () => this.disconnect()).catch(() => { });
+        }
+    }
+    async withContext(fn, signal) {
+        const browser = await abortable(this.getBrowser(true), signal, () => this.disconnect(), b => b.close());
+        const context = browser.contexts()[0];
+        if (!context)
+            throw new UserFacingError('Chrome has no default window — open Chrome with scripts/start-chrome.ps1');
+        signal?.throwIfAborted();
+        return abortable(fn(context), signal, () => this.disconnect());
+    }
+    async connected() {
+        try {
+            await this.getBrowser(false);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/** Receives a session (cookies + localStorage) into the user's Chrome over CDP. */
+export class CdpSessionTarget {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    userAgent(signal) {
+        return this.provider.withPage((page) => page.evaluate(() => navigator.userAgent), signal);
+    }
+    cancel() { return this.provider.disconnect(); }
+    inject(state, signal) {
+        return this.provider.withContext(async (context) => {
+            signal?.throwIfAborted();
+            await context.addCookies(state.cookies);
+            for (const o of state.origins) {
+                signal?.throwIfAborted();
+                if (!o.localStorage.length)
+                    continue;
+                const page = await context.newPage();
+                page.setDefaultTimeout(5000);
+                try {
+                    await page.goto(o.origin, { waitUntil: 'commit' });
+                    signal?.throwIfAborted();
+                    await page.evaluate(({ origin, items }) => {
+                        if (location.origin !== origin)
+                            throw new Error('origin mismatch');
+                        for (const i of items)
+                            localStorage.setItem(i.name, i.value);
+                    }, { origin: o.origin, items: o.localStorage });
+                }
+                finally {
+                    await page.close().catch(() => { });
+                }
+            }
+        }, signal);
+    }
+}

package/dist/core/config.js

@@ -0,0 +1,33 @@
+import { join, posix, win32 } from 'node:path';
+import { homedir } from 'node:os';
+import { defaultEndpoint } from '../ipc/endpoint.js';
+/** Paths owned by the privileged service. Never read by the MCP client. */
+export function serviceConfig(env, platform) {
+    const path = platform === 'win32' ? win32 : posix;
+    const home = env.U_CHAN_HOME ??
+        (platform === 'win32'
+            ? path.join(env.ProgramData ?? 'C:\\ProgramData', 'u-chan-secrets')
+            : '/Library/Application Support/u-chan-secrets');
+    return {
+        home,
+        allowlistPath: path.join(home, 'allowlist.json'),
+        auditPath: path.join(home, 'audit.log'),
+        settingsPath: path.join(home, 'settings.json'),
+        bwDataDir: path.join(home, 'bw-data'),
+        endpoint: defaultEndpoint(env, platform),
+        programDir: path.join(home, 'program'),
+        stagingDir: path.join(home, 'staging'),
+    };
+}
+/** User-side values only (the user's Chrome). */
+export function loadConfig(env = process.env, platform = process.platform) {
+    const base = env.APPDATA ??
+        (platform === 'darwin'
+            ? join(homedir(), 'Library', 'Application Support')
+            : join(homedir(), 'AppData', 'Roaming'));
+    const home = env.U_CHAN_HOME ?? join(base, 'u-chan-secrets');
+    return {
+        chromeProfile: join(home, 'chrome-profile'),
+        cdpEndpoint: env.U_CHAN_CDP ?? 'http://127.0.0.1:9222',
+    };
+}

package/dist/core/doctor.js

@@ -0,0 +1,106 @@
+import { execFile } from 'node:child_process';
+const SHELLS = new Set(['node.exe', 'cmd.exe', 'powershell.exe', 'pwsh.exe', 'conhost.exe', 'node', 'sh', 'bash']);
+const IS_PLAYWRIGHT = /@playwright[\\/]mcp/i;
+/**
+ * Finds the AI client that launched us (first non-shell ancestor), then checks whether that
+ * client's Playwright MCP was started with --cdp-endpoint (i.e. shares our Chrome).
+ */
+export function checkPlaywrightCdp(procs, selfPid) {
+    const byPid = new Map(procs.map((p) => [p.pid, p]));
+    const ancestors = (pid) => {
+        const out = [];
+        const seen = new Set();
+        for (let p = byPid.get(byPid.get(pid)?.ppid ?? -1); p && !seen.has(p.pid); p = byPid.get(p.ppid)) {
+            seen.add(p.pid);
+            out.push(p);
+        }
+        return out;
+    };
+    const client = ancestors(selfPid).find((p) => !SHELLS.has(p.name.toLowerCase()));
+    if (!client)
+        return 'not_found';
+    const ours = procs.filter((p) => IS_PLAYWRIGHT.test(p.cmd) && ancestors(p.pid).some((a) => a.pid === client.pid));
+    if (ours.length === 0)
+        return 'not_found';
+    return ours.some((p) => p.cmd.includes('--cdp-endpoint')) ? 'ok' : 'missing';
+}
+const PS_LIST = 'Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine | ConvertTo-Json -Compress';
+/** Lists processes via PowerShell/CIM; returns 'unknown' on any failure. */
+export async function checkPlaywrightNow(selfPid = process.pid) {
+    if (process.platform !== 'win32')
+        return 'unknown';
+    try {
+        const stdout = await new Promise((resolve, reject) => execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', PS_LIST], { timeout: 15000, windowsHide: true, maxBuffer: 64 * 1024 * 1024 }, (err, out) => (err ? reject(err) : resolve(String(out)))));
+        const raw = JSON.parse(stdout);
+        const procs = raw.map((r) => ({ pid: r.ProcessId, ppid: r.ParentProcessId, name: r.Name ?? '', cmd: r.CommandLine ?? '' }));
+        return checkPlaywrightCdp(procs, selfPid);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+// Leave room for the service's full native ACL scan and IPC overhead.
+export const SERVICE_DIAGNOSTIC_TIMEOUT_MS = 25000;
+export async function bounded(probe, fallback, timeoutMs = 5000) {
+    let timer;
+    try {
+        return await Promise.race([Promise.resolve().then(probe), new Promise(resolve => { timer = setTimeout(() => resolve(fallback), timeoutMs); })]);
+    }
+    catch {
+        return fallback;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function runDoctor(d) {
+    const [registration, service, chrome, playwright] = await Promise.all([
+        bounded(d.registration, 'unknown'),
+        bounded(d.service, null, SERVICE_DIAGNOSTIC_TIMEOUT_MS),
+        bounded(d.chrome, 'unknown'),
+        bounded(d.playwright, 'unknown'),
+    ]);
+    const checks = [];
+    const add = (id, state, message, nextAction, required = true) => {
+        checks.push({ id, state, message, nextAction: state === 'pass' ? '' : nextAction, required });
+    };
+    const supported = d.platform === 'win32' || d.platform === 'darwin';
+    add('platform', supported ? 'pass' : 'fail', supported ? 'Platform is supported.' : 'Platform is unsupported.', 'Use Windows or macOS.');
+    add('registration', registration, 'Service registration checked.', 'Run u-chan install from a trusted administrator terminal.');
+    add('service', service ? 'pass' : 'fail', service ? 'Service is reachable.' : 'Service is unreachable.', 'Check service status; run u-chan install if absent.');
+    add('ipc', service ? 'pass' : 'unknown', 'Authenticated service connection checked.', 'Check the installed owner account and service.');
+    const state = (value) => value === 'pass' || value === 'fail' ? value : 'unknown';
+    add('assets', state(service?.assets), 'Private service assets checked.', 'Repair the installation from a trusted administrator terminal.');
+    add('permissions', state(service?.permissions), 'Protected service permissions checked.', 'Repair protected permissions from a trusted administrator terminal.');
+    const v = service?.vault;
+    add('vault', v === 'locked' ? 'pass' : v === 'unauthenticated' ? 'fail' : state(v), v === 'locked' ? 'Vault is locked.' : v === 'unauthenticated' ? 'Vault is not authenticated.' : 'Vault availability checked.', 'Complete Bitwarden service login during trusted setup.');
+    if (v === 'locked')
+        checks[checks.length - 1].nextAction = 'Run u-chan unlock.';
+    add('chrome', chrome, 'Dedicated Chrome CDP endpoint checked.', 'Start dedicated Chrome with the provided platform launcher.');
+    add('playwright', playwright, 'Playwright shared-browser configuration checked.', 'Configure Playwright MCP with --cdp-endpoint and restart the AI session.', playwright !== 'unknown');
+    return { version: 1, checks };
+}
+export function doctorExitCode(report) {
+    const required = report.checks.filter(c => c.required);
+    return required.some(c => c.state === 'fail') ? 1 : required.some(c => c.state === 'unknown') ? 2 : 0;
+}
+export async function commandState(file, args, passes, timeoutMs = 5000) {
+    return new Promise(resolve => {
+        execFile(file, args, { timeout: timeoutMs, windowsHide: true, maxBuffer: 65536 }, (err, stdout) => {
+            resolve(err ? 'unknown' : passes(stdout) ? 'pass' : 'fail');
+        });
+    });
+}
+export async function chromeState(endpoint) {
+    try {
+        const url = new URL('/json/version', endpoint);
+        if (!['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) || url.protocol !== 'http:')
+            return 'fail';
+        const r = await fetch(url, { signal: AbortSignal.timeout(5000), redirect: 'error' });
+        const json = await r.json();
+        return r.ok && typeof json.webSocketDebuggerUrl === 'string' ? 'pass' : 'fail';
+    }
+    catch {
+        return 'fail';
+    }
+}

package/dist/core/login-filler.js

@@ -0,0 +1,170 @@
+import { isHostAllowed } from './allowlist.js';
+import { freshTotpCode } from './totp.js';
+import { UserFacingError } from './types.js';
+export const NEEDS_YOU = 'needs you — sign in by hand this time';
+const CHALLENGE_CSS = 'iframe[src*="recaptcha"], iframe[src*="hcaptcha"], iframe[src*="challenges.cloudflare.com"], iframe[src*="arkoselabs"]';
+const USERNAME_CSS = '[autocomplete=username], [type=email], [name*=email i], [name*=user i], [id*=email i]';
+const OTP_CSS = 'input[autocomplete="one-time-code"], input[name*="otp" i], input[id*="otp" i], input[name*="2fa" i], input[name="code"], input[id="code"]';
+const visible = (l) => l.filter({ visible: true }).first();
+/**
+ * Playwright puts the filled value into its error call log, so any action that
+ * handles credentials is rethrown with a fixed message and no cause.
+ */
+async function guard(what, fn) {
+    try {
+        return await fn();
+    }
+    catch {
+        throw new UserFacingError(`failed to ${what}`);
+    }
+}
+/**
+ * Fills a login form only while the page host passes `hostCheck`. A synchronous
+ * check runs immediately before every fill/click, and fills go through element
+ * handles so a navigation after the check makes the action throw instead of
+ * landing in a different document. Outcomes and errors never contain credentials.
+ */
+export async function fillLogin(page, entry, getCreds, opts = {}) {
+    const timeout = opts.timeoutMs ?? 15000;
+    const hostCheck = opts.hostCheck ?? ((url) => isHostAllowed(entry, url));
+    const badHost = () => {
+        const url = page.url();
+        if (hostCheck(url))
+            return undefined;
+        let host = 'unknown';
+        try {
+            host = new URL(url).hostname;
+        }
+        catch { /* keep unknown */ }
+        return { status: 'failed', reason: `unexpected host ${host}` };
+    };
+    await page.goto(entry.loginUrl, { waitUntil: 'load', timeout });
+    const hostFail = badHost();
+    if (hostFail)
+        return hostFail;
+    const sel = entry.selectors;
+    const userBox = visible(page.locator(sel?.username ?? USERNAME_CSS));
+    const passBox = visible(page.locator(sel?.password ?? 'input[type=password]'));
+    const submitBox = visible(page.locator(sel?.submit ?? 'button[type=submit], input[type=submit]'));
+    const otpBox = visible(page.locator(sel?.otp ?? OTP_CSS));
+    const handleOf = async (l) => (await l.isVisible()) ? l.elementHandle({ timeout }) : null;
+    // Forms may render late; wait briefly before concluding there is none.
+    await userBox.or(passBox).first().waitFor({ state: 'visible', timeout: Math.min(timeout, 3000) }).catch(() => {
+        // No field appeared in the window: handled below as already logged in.
+    });
+    const [hasUser, hasPass] = await Promise.all([userBox.isVisible(), passBox.isVisible()]);
+    const afterWaitHost = badHost();
+    if (afterWaitHost)
+        return afterWaitHost;
+    if (!hasUser && !hasPass)
+        return { status: 'already_logged_in' };
+    if (!hasUser)
+        return { status: 'failed', reason: 'username field not found' };
+    if (await visible(page.locator(CHALLENGE_CSS)).isVisible())
+        return { status: 'failed', reason: NEEDS_YOU };
+    const creds = await getCreds();
+    // Each action: sync host check, then only the action itself (no awaits in between).
+    const submit = async (h) => {
+        const fail = badHost();
+        if (fail)
+            return fail;
+        await guard('submit', () => (h ? h.click({ timeout }) : page.keyboard.press('Enter')));
+        return undefined;
+    };
+    const userH = await handleOf(userBox);
+    if (!userH)
+        return { status: 'failed', reason: 'username field not found' };
+    let passH = hasPass ? await handleOf(passBox) : null;
+    let submitH = await handleOf(submitBox);
+    let fail;
+    let otpFilled = false;
+    // 2FA code, at most once per login so a bad seed cannot lock the account.
+    const fillOtp = async () => {
+        if (!creds.totp)
+            return { status: 'failed', reason: 'the page asks for a 2FA code but the Bitwarden item has no TOTP' };
+        const code = await freshTotpCode(creds.totp);
+        const otpH = await handleOf(otpBox);
+        if (!otpH)
+            return { status: 'failed', reason: '2FA field not found' };
+        const f = badHost();
+        if (f)
+            return f;
+        await guard('fill 2FA field', () => otpH.fill(code, { timeout }));
+        otpFilled = true;
+        return undefined;
+    };
+    // Some sites put the 2FA field in the same form as the password.
+    const fillInlineOtp = async () => ((await otpBox.isVisible()) ? fillOtp() : undefined);
+    if (passH) {
+        if ((fail = badHost()))
+            return fail;
+        await guard('fill username field', () => userH.fill(creds.username, { timeout }));
+        if ((fail = badHost()))
+            return fail;
+        await guard('fill password field', () => passH.fill(creds.password, { timeout }));
+        if ((fail = await fillInlineOtp()))
+            return fail;
+        if ((fail = await submit(submitH)))
+            return fail;
+    }
+    else {
+        if ((fail = badHost()))
+            return fail;
+        await guard('fill username field', () => userH.fill(creds.username, { timeout }));
+        if ((fail = await submit(submitH)))
+            return fail;
+        try {
+            await passBox.waitFor({ state: 'visible', timeout });
+        }
+        catch {
+            return { status: 'failed', reason: 'password field did not appear' };
+        }
+        passH = await handleOf(passBox);
+        submitH = await handleOf(submitBox); // re-measured for step 2
+        if (!passH)
+            return { status: 'failed', reason: 'password field did not appear' };
+        if ((fail = badHost()))
+            return fail;
+        await guard('fill password field', () => passH.fill(creds.password, { timeout }));
+        if ((fail = await fillInlineOtp()))
+            return fail;
+        if ((fail = await submit(submitH)))
+            return fail;
+    }
+    // Wait for the login form to go away, then judge the final page. Wait on locators, not
+    // the filled handles: SPAs often re-render the form on submit, detaching those nodes
+    // long before the app navigates away.
+    await userBox.or(passBox).first().waitFor({ state: 'hidden', timeout }).catch(() => {
+        // Timeout: the state check below decides.
+    });
+    await page.waitForLoadState('load', { timeout }).catch(() => { });
+    await page.waitForLoadState('networkidle', { timeout }).catch(() => { });
+    if ((fail = badHost()))
+        return fail;
+    if (await visible(page.locator(CHALLENGE_CSS)).isVisible())
+        return { status: 'failed', reason: NEEDS_YOU };
+    if ((await userBox.isVisible()) || (await passBox.isVisible())) {
+        const reason = otpFilled ? 'login form still present (wrong password or 2FA code?)' : 'login form still present (wrong password?)';
+        return { status: 'failed', reason };
+    }
+    // Separate 2FA step after the password.
+    if (await otpBox.isVisible()) {
+        if (otpFilled)
+            return { status: 'failed', reason: '2FA code rejected (wrong TOTP in Bitwarden?)' };
+        const otpSubmitH = await handleOf(submitBox);
+        if ((fail = await fillOtp()))
+            return fail;
+        if ((fail = await submit(otpSubmitH)))
+            return fail;
+        await otpBox.waitFor({ state: 'hidden', timeout }).catch(() => {
+            // Timeout: the check below decides.
+        });
+        await page.waitForLoadState('load', { timeout }).catch(() => { });
+        await page.waitForLoadState('networkidle', { timeout }).catch(() => { });
+        if ((fail = badHost()))
+            return fail;
+        if (await otpBox.isVisible())
+            return { status: 'failed', reason: '2FA code rejected (wrong TOTP in Bitwarden?)' };
+    }
+    return { status: 'logged_in' };
+}

package/dist/core/policy.js

@@ -0,0 +1,36 @@
+const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+export function validOptions(v) {
+    if (!object(v) || Object.keys(v).some(k => k !== 'grant' && k !== 'success'))
+        return false;
+    if (v.grant !== undefined) {
+        const g = v.grant;
+        if (!object(g))
+            return false;
+        if (g.kind === 'timed') {
+            if (Object.keys(g).some(k => k !== 'kind' && k !== 'minutes') || !Number.isInteger(g.minutes) || g.minutes < 1 || g.minutes > 1440)
+                return false;
+        }
+        else if ((g.kind !== 'once' && g.kind !== 'permanent') || Object.keys(g).length !== 1)
+            return false;
+    }
+    if (v.success !== undefined) {
+        const s = v.success;
+        if (!object(s) || Object.keys(s).length !== 1)
+            return false;
+        if ('url' in s) {
+            if (typeof s.url !== 'string' || s.url.length > 2048)
+                return false;
+            try {
+                const u = new URL(s.url);
+                if (u.protocol !== 'https:' || u.username || u.password)
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
+        else if (typeof s.selector !== 'string' || !s.selector.trim() || s.selector.length > 1000)
+            return false;
+    }
+    return true;
+}

package/dist/core/redact.js

@@ -0,0 +1,7 @@
+export function redact(text, secrets) {
+    let out = text;
+    for (const s of secrets)
+        if (s)
+            out = out.split(s).join('[REDACTED]');
+    return out;
+}

package/dist/core/service.js

@@ -0,0 +1,167 @@
+import { buildEntry, clean, cleanSelectors, normalizeDomain, selectorsLine } from './allowlist.js';
+import { redact } from './redact.js';
+import { validOptions } from './policy.js';
+import { isHostAllowed } from './allowlist.js';
+import { GrantCoordinator } from '../service/grants.js';
+import { randomUUID } from 'node:crypto';
+import { abortable } from './abort.js';
+import { UserFacingError, } from './types.js';
+/** Normalized domain for lookups/audit; throws on unusable input. */
+function domainOf(input) {
+    const d = normalizeDomain(clean(input));
+    if (!d)
+        throw new UserFacingError('domain is empty or invalid');
+    return d;
+}
+export class CoreService {
+    deps;
+    grants;
+    constructor(deps) {
+        this.deps = deps;
+        this.grants = deps.grants ?? new GrantCoordinator(deps.allowlist);
+    }
+    /** Runs `fn`, maps errors to ToolResults (never leaking details) and audits the outcome. */
+    guarded(action, domain, secrets, fn) {
+        return this.grants.run(() => this.runGuarded(action, domain, secrets, fn));
+    }
+    async runGuarded(action, domain, secrets, fn) {
+        let result;
+        let audit;
+        try {
+            ;
+            ({ result, audit } = await fn());
+        }
+        catch (err) {
+            const message = err instanceof UserFacingError ? err.message : 'internal error';
+            if (!(err instanceof UserFacingError)) {
+                const e = err;
+                console.error(redact(String(e?.stack ?? err), secrets));
+            }
+            result = { ok: false, message, ...(err instanceof UserFacingError && err.code ? { code: err.code } : {}) };
+            audit = `failed: ${message}`;
+        }
+        if (action) {
+            try {
+                await this.deps.audit.record({ action, domain: normalizeDomain(clean(domain)) || clean(domain), result: audit });
+            }
+            catch {
+                console.error('audit write failed');
+            }
+        }
+        return result;
+    }
+    login(domain) {
+        const secrets = [];
+        return this.guarded('login', domain, secrets, async () => {
+            const entry = await this.deps.allowlist.get(domainOf(domain));
+            if (!entry)
+                throw new UserFacingError('domain is not allowlisted — use request_allow', 'grant_missing');
+            this.grants.check(entry);
+            const signal = AbortSignal.timeout(this.deps.loginTimeoutMs ?? 60000);
+            const within = async (work) => {
+                try {
+                    return await abortable(work, signal, async () => { await this.deps.login.cancel?.(); });
+                }
+                catch (e) {
+                    if (signal.aborted)
+                        throw new UserFacingError('login timed out; retry if needed', 'login_timeout');
+                    throw e;
+                }
+            };
+            const status = await within(this.deps.vault.status(signal));
+            if (status !== 'unlocked')
+                throw new UserFacingError(status === 'locked' ? 'vault locked — run u-chan unlock' : status === 'unauthenticated' ? 'complete Bitwarden service login during setup' : 'Bitwarden is unavailable', status === 'locked' ? 'vault_locked' : status === 'unauthenticated' ? 'vault_unauthenticated' : 'vault_unavailable');
+            if (this.deps.login.preflight)
+                await within(this.deps.login.preflight(signal));
+            signal.throwIfAborted();
+            await this.grants.reserve(entry.domain);
+            const getCreds = async () => {
+                this.grants.check(entry, true);
+                const c = await within(this.deps.vault.getLogin(entry.item, signal));
+                secrets.push(c.username, c.password, ...(c.totp ? [c.totp] : []));
+                return c;
+            };
+            const out = await this.deps.login.run(entry, getCreds, { signal, beforeTransfer: async () => { signal.throwIfAborted(); this.grants.check(entry, true); } });
+            if (out.status === 'logged_in')
+                return { result: { ok: true, message: 'logged in' }, audit: 'ok' };
+            if (out.status === 'already_logged_in')
+                return { result: { ok: true, message: 'already logged in' }, audit: 'already' };
+            const message = out.reason ?? 'login failed';
+            return { result: { ok: false, message, ...(out.code ? { code: out.code } : {}) }, audit: `failed: ${message}` };
+        });
+    }
+    requestAllow(domain, loginUrl, item, selectors, options) {
+        return this.guarded('request_allow', domain, [], async () => {
+            if (options !== undefined && !validOptions(options))
+                throw new UserFacingError('invalid approval policy or success condition', 'invalid_policy');
+            const d = domainOf(domain);
+            const existing = await this.deps.allowlist.get(d);
+            let entry = buildEntry(d, clean(loginUrl), clean(item), existing);
+            const epoch = this.grants.epoch();
+            const grant = options?.grant ?? { kind: 'permanent' };
+            delete entry.expiresAt;
+            delete entry.remainingUses;
+            entry.grantId = randomUUID();
+            if (grant.kind === 'once')
+                entry.remainingUses = 1;
+            if (grant.kind === 'timed')
+                entry.expiresAt = new Date(this.grants.now() + grant.minutes * 60000).toISOString();
+            const sel = cleanSelectors(selectors);
+            if (sel)
+                entry = { ...entry, selectors: sel };
+            if (options?.success)
+                entry = { ...entry, success: options.success };
+            if (entry.success && 'url' in entry.success && !isHostAllowed(entry, entry.success.url))
+                throw new UserFacingError('success URL must use an approved HTTPS host', 'invalid_policy');
+            const approved = await this.deps.approver.ask('U-Chan Secrets', [
+                'Allow the AI to sign in?',
+                `Domain: ${entry.domain}`,
+                `Login URL: ${new URL(entry.loginUrl).href}`,
+                `Bitwarden item: ${entry.item}`,
+                `Hosts: ${entry.hosts.join(', ')}`,
+                ...(entry.selectors ? [selectorsLine(entry.selectors)] : []),
+                ...(entry.success ? [`Success condition: ${JSON.stringify(entry.success)}`] : []),
+                entry.remainingUses !== undefined ? 'Duration: one login attempt; a failed reserved attempt also counts.' : entry.expiresAt ? `Duration: until ${entry.expiresAt}` : 'Duration: permanent future logins.',
+                'Expiry and revocation do not log out sessions already transferred to Chrome.',
+            ]);
+            if (!approved)
+                return { result: { ok: false, message: 'denied' }, audit: 'denied' };
+            this.grants.approve(entry, epoch);
+            await this.deps.allowlist.upsert(entry);
+            return { result: { ok: true, message: 'approved' }, audit: `approved; ${grant.kind}${entry.expiresAt ? '; expires ' + entry.expiresAt : ''}` };
+        });
+    }
+    revoke(domain) {
+        return this.guarded('revoke', domain, [], async () => {
+            const removed = await this.deps.allowlist.remove(domainOf(domain));
+            return removed
+                ? { result: { ok: true, message: 'revoked' }, audit: 'ok' }
+                : { result: { ok: false, message: 'domain is not in the allowlist' }, audit: 'not found' };
+        });
+    }
+    listAllowed() {
+        return this.guarded(undefined, '', [], async () => {
+            const all = await this.deps.allowlist.list();
+            if (all.length === 0)
+                return { result: { ok: true, message: 'allowlist is empty' }, audit: '' };
+            const message = all.map((e) => {
+                let policy = e.expiresAt ? 'expires ' + e.expiresAt : e.remainingUses !== undefined ? e.remainingUses + ' attempts remaining' : 'permanent';
+                try {
+                    this.grants.check(e);
+                }
+                catch (err) {
+                    policy = err instanceof UserFacingError && err.code === 'grant_exhausted' ? 'exhausted' : 'expired';
+                }
+                return `${e.domain} — ${e.item} — ${e.hosts.join(', ')} — ${policy}`;
+            }).join('\n');
+            return { result: { ok: true, message }, audit: '' };
+        });
+    }
+    status() {
+        return this.guarded(undefined, '', [], async () => {
+            const vault = await this.deps.vault.status();
+            const message = `vault: ${vault}; mode: ${await this.deps.mode()}`;
+            return { result: { ok: vault === 'unlocked', message }, audit: '' };
+        });
+    }
+}