u-chan-secrets 4.0.0 → 5.0.0

package/dist/core/login-filler.js

@@ -6,6 +6,7 @@ const CHALLENGE_CSS = 'iframe[src*="recaptcha"], iframe[src*="hcaptcha"], iframe
 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();
+const failed = (reason, code = 'unsupported_form') => ({ status: 'failed', reason, code });
 /**
  * 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.
@@ -15,7 +16,7 @@ async function guard(what, fn) {
         return await fn();
     }
     catch {
-        throw new UserFacingError(`failed to ${what}`);
+        throw new UserFacingError(`failed to ${what}`, 'unsupported_form');
     }
 }
 /**
@@ -31,14 +32,9 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
         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}` };
+        return failed('unexpected login host');
     };
-    await page.goto(entry.loginUrl, { waitUntil: 'load', timeout });
+    await guard('open approved login page', () => page.goto(entry.loginUrl, { waitUntil: 'domcontentloaded', timeout }));
     const hostFail = badHost();
     if (hostFail)
         return hostFail;
@@ -47,6 +43,8 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
     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 needsHuman = async () => await visible(page.locator(CHALLENGE_CSS)).isVisible()
+        || await visible(page.getByText(/(?:use|enter|verify|sign in with) (?:your |a )?passkey|check your (?:phone|device)|approve (?:this |the )?sign.?in/i)).isVisible();
     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(() => {
@@ -56,12 +54,14 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
     const afterWaitHost = badHost();
     if (afterWaitHost)
         return afterWaitHost;
+    if (await needsHuman())
+        return failed(NEEDS_YOU, 'needs_human');
+    if (!hasUser && !hasPass && await otpBox.isVisible())
+        return failed(NEEDS_YOU, 'needs_human');
     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 };
+        return failed('username field not found');
     const creds = await getCreds();
     // Each action: sync host check, then only the action itself (no awaits in between).
     const submit = async (h) => {
@@ -73,7 +73,7 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
     };
     const userH = await handleOf(userBox);
     if (!userH)
-        return { status: 'failed', reason: 'username field not found' };
+        return failed('username field not found');
     let passH = hasPass ? await handleOf(passBox) : null;
     let submitH = await handleOf(submitBox);
     let fail;
@@ -81,11 +81,11 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
     // 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' };
+            return failed('the page asks for a 2FA code but the Bitwarden item has no TOTP', 'needs_human');
         const code = await freshTotpCode(creds.totp);
         const otpH = await handleOf(otpBox);
         if (!otpH)
-            return { status: 'failed', reason: '2FA field not found' };
+            return failed('2FA field not found');
         const f = badHost();
         if (f)
             return f;
@@ -117,12 +117,12 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
             await passBox.waitFor({ state: 'visible', timeout });
         }
         catch {
-            return { status: 'failed', reason: 'password field did not appear' };
+            return await needsHuman() ? failed(NEEDS_YOU, 'needs_human') : failed('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' };
+            return failed('password field did not appear');
         if ((fail = badHost()))
             return fail;
         await guard('fill password field', () => passH.fill(creds.password, { timeout }));
@@ -137,20 +137,19 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
     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(() => { });
+    await page.waitForLoadState('domcontentloaded', { timeout: Math.min(timeout, 3000) }).catch(() => { });
     if ((fail = badHost()))
         return fail;
-    if (await visible(page.locator(CHALLENGE_CSS)).isVisible())
-        return { status: 'failed', reason: NEEDS_YOU };
+    if (await needsHuman())
+        return failed(NEEDS_YOU, 'needs_human');
     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 };
+        return failed(reason, otpFilled ? 'needs_human' : 'authentication_unconfirmed');
     }
     // Separate 2FA step after the password.
     if (await otpBox.isVisible()) {
         if (otpFilled)
-            return { status: 'failed', reason: '2FA code rejected (wrong TOTP in Bitwarden?)' };
+            return failed('2FA code rejected (wrong TOTP in Bitwarden?)', 'needs_human');
         const otpSubmitH = await handleOf(submitBox);
         if ((fail = await fillOtp()))
             return fail;
@@ -159,12 +158,13 @@ export async function fillLogin(page, entry, getCreds, opts = {}) {
         await otpBox.waitFor({ state: 'hidden', timeout }).catch(() => {
             // Timeout: the check below decides.
         });
-        await page.waitForLoadState('load', { timeout }).catch(() => { });
-        await page.waitForLoadState('networkidle', { timeout }).catch(() => { });
+        await page.waitForLoadState('domcontentloaded', { timeout: Math.min(timeout, 3000) }).catch(() => { });
         if ((fail = badHost()))
             return fail;
         if (await otpBox.isVisible())
-            return { status: 'failed', reason: '2FA code rejected (wrong TOTP in Bitwarden?)' };
+            return failed('2FA code rejected (wrong TOTP in Bitwarden?)', 'needs_human');
+        if (await needsHuman())
+            return failed(NEEDS_YOU, 'needs_human');
     }
     return { status: 'logged_in' };
 }

package/dist/core/login-success.js

@@ -0,0 +1,24 @@
+import { setTimeout as delay } from 'node:timers/promises';
+/** Poll only approved evidence; page values and browser errors never become public diagnostics. */
+export async function waitForLoginSuccess(page, success, hostCheck, signal, timeoutMs = 15000) {
+    const deadline = Date.now() + timeoutMs;
+    try {
+        do {
+            signal?.throwIfAborted();
+            if (!hostCheck(page.url()))
+                return false;
+            const matched = 'url' in success ? page.url() === success.url : await page.locator(success.selector).first().isVisible();
+            if (matched && hostCheck(page.url()))
+                return true;
+            if (Date.now() >= deadline)
+                return false;
+            await delay(Math.min(100, Math.max(0, deadline - Date.now())), undefined, { signal });
+        } while (Date.now() <= deadline);
+        return false;
+    }
+    catch {
+        if (signal?.aborted)
+            signal.throwIfAborted();
+        return false;
+    }
+}

package/dist/core/service.js

@@ -50,9 +50,11 @@ export class CoreService {
         }
         return result;
     }
-    login(domain) {
+    login(domain, browser = 'chrome') {
         const secrets = [];
         return this.guarded('login', domain, secrets, async () => {
+            if (browser !== 'chrome' && browser !== 'edge')
+                throw new UserFacingError('invalid browser selection', 'invalid_policy');
             const entry = await this.deps.allowlist.get(domainOf(domain));
             if (!entry)
                 throw new UserFacingError('domain is not allowlisted — use request_allow', 'grant_missing');
@@ -72,7 +74,7 @@ export class CoreService {
             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));
+                await within(this.deps.login.preflight(signal, browser));
             signal.throwIfAborted();
             await this.grants.reserve(entry.domain);
             const getCreds = async () => {
@@ -81,7 +83,7 @@ export class CoreService {
                 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); } });
+            const out = await this.deps.login.run(entry, getCreds, { signal, browser, 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')
@@ -122,7 +124,7 @@ export class CoreService {
                 ...(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.',
+                'Expiry and revocation do not log out sessions already transferred to the selected browser.',
             ]);
             if (!approved)
                 return { result: { ok: false, message: 'denied' }, audit: 'denied' };

package/dist/core/types.js

@@ -1,4 +1,4 @@
-export const RESULT_CODES = ['grant_missing', 'grant_expired', 'grant_exhausted', 'invalid_policy', 'unsupported_service', 'vault_locked', 'vault_unauthenticated', 'vault_unavailable', 'chrome_unavailable', 'unsupported_form', 'needs_human', 'authentication_unconfirmed', 'session_transfer_failed', 'internal_error', 'login_timeout', 'success_condition_failed'];
+export const RESULT_CODES = ['grant_missing', 'grant_expired', 'grant_exhausted', 'invalid_policy', 'unsupported_service', 'vault_locked', 'vault_unauthenticated', 'vault_unavailable', 'chrome_unavailable', 'browser_unavailable', 'destination_unconfirmed', 'unsupported_form', 'needs_human', 'authentication_unconfirmed', 'session_transfer_failed', 'internal_error', 'login_timeout', 'success_condition_failed'];
 export const isResultCode = (value) => typeof value === 'string' && RESULT_CODES.includes(value);
 /** Message is safe to return to the AI. */
 export class UserFacingError extends Error {

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { IpcClient } from './ipc/client.js';
 import { defaultEndpoint } from './ipc/endpoint.js';
 import { checkPlaywrightNow } from './core/doctor.js';
-import { loadConfig } from './core/config.js';
+import { loadConfig, resolveLoginBrowser } from './core/config.js';
 import { createMcpServer, withPlaywrightStatus } from './mcp/server.js';
 // Thin MCP client: every privileged action goes to the U-Chan service over IPC.
 // stdout is the MCP channel: log only to stderr.
@@ -13,5 +13,5 @@ try {
     version = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 }
 catch { }
-const client = new IpcClient(defaultEndpoint(process.env, process.platform));
+const client = new IpcClient(defaultEndpoint(process.env, process.platform), { browser: () => resolveLoginBrowser(process.env, process.platform) });
 await createMcpServer(withPlaywrightStatus(client, () => checkPlaywrightNow(process.pid, loadConfig(process.env, process.platform).cdpEndpoint)), version).connect(new StdioServerTransport());

package/dist/ipc/client.js

@@ -2,15 +2,18 @@ import net from 'node:net';
 import { FrameReader, encode } from './protocol.js';
 import { isResultCode } from '../core/types.js';
 import { validOptions } from '../core/policy.js';
+import { browserKind } from '../client/browser-choice.js';
 const DOWN = 'U-Chan service is not running — run u-chan install';
 /** One connection per call; the service does all privileged work. */
 export class IpcClient {
     path;
     nextId = 1;
     timeoutMs;
+    browser;
     constructor(path, opts = {}) {
         this.path = path;
         this.timeoutMs = opts.timeoutMs ?? 180000;
+        this.browser = opts.browser ?? 'chrome';
     }
     call(method, params = {}) {
         const id = this.nextId++;
@@ -45,7 +48,23 @@ export class IpcClient {
             socket.on('close', () => finish({ ok: false, message: 'U-Chan service closed the connection' }));
         });
     }
-    login(domain) { return this.call('login', { domain }); }
+    async login(domain, browser) {
+        let selected;
+        try {
+            selected = browserKind(browser ?? (typeof this.browser === 'function' ? this.browser() : this.browser));
+        }
+        catch {
+            return { ok: false, code: 'browser_unavailable', message: 'browser selection is invalid or changed; run setup and restart the AI session before login' };
+        }
+        const response = await this.capabilities();
+        try {
+            const capability = JSON.parse(response.message);
+            if (response.ok && capability.protocol === 3 && Array.isArray(capability.features) && capability.features.includes('verified_session_transfer'))
+                return this.call('login', { domain, browser: selected });
+        }
+        catch { }
+        return { ok: false, code: 'unsupported_service', message: 'verified login requires a reachable V5 service; update the installed service before login' };
+    }
     async requestAllow(domain, loginUrl, item, selectors, options) {
         if (options !== undefined) {
             if (!validOptions(options))

package/dist/ipc/server.js

@@ -20,7 +20,7 @@ const handlers = {
     capabilities: api => api.capabilities ? api.capabilities() : Promise.resolve({ ok: false, message: 'unknown method' }),
     diagnose: api => api.diagnose(),
     manage: api => api.manage(),
-    login: (api, p) => (str(p.domain) ? api.login(p.domain) : BAD),
+    login: (api, p) => (!str(p.domain) || (p.browser !== undefined && p.browser !== 'chrome' && p.browser !== 'edge') ? BAD : p.browser ? api.login(p.domain, p.browser) : api.login(p.domain)),
     request_allow: (api, p) => {
         const sel = selectorsOf(p.selectors);
         if (sel === BAD || !str(p.domain) || !str(p.loginUrl) || !str(p.item))

package/dist/mcp/server.js

@@ -14,12 +14,12 @@ const INSTRUCTIONS = [
     'U-Chan Secrets logs into websites for you without exposing passwords.',
     'Use it whenever a site needs sign-in (admin pages, dashboards, a Playwright page showing a login form).',
     'Never ask the user for a password, and never type one into a form yourself.',
-    'Flow: list_allowed -> login(domain) -> continue with the Playwright MCP tools in the same Chrome.',
+    'Flow: list_allowed -> login(domain) -> continue with the Playwright MCP tools in the same selected dedicated Chrome or Edge browser.',
     'If the domain is not allowlisted, ask the user which Bitwarden item to use, then call request_allow; the user approves it in a U-Chan window.',
     'If login fails, call status: a locked vault means the user must run u-chan unlock themselves. If login says "needs you", ask the user to sign in by hand.',
 ].join('\n');
 const PLAYWRIGHT_MSG = {
-    ok: 'shared chrome process configuration observed; active AI session ownership unverified',
+    ok: 'shared browser process configuration observed; active AI session ownership unverified',
     missing: 'missing or mismatched --cdp-endpoint (restart the AI session)',
     not_found: 'not found',
     unknown: 'unknown',
@@ -55,7 +55,7 @@ export function createMcpServer(core, version = '0.1.0') {
     const server = new McpServer({ name: 'u-chan-secrets', version }, { instructions: INSTRUCTIONS });
     server.registerTool('login', {
         description: 'Use this whenever a website needs sign-in: an admin page, a dashboard, or a Playwright page that shows a login form. ' +
-            'Signs into an allowlisted domain with Bitwarden credentials inside the U-Chan service and hands only the session to the shared Chrome; the credentials are never revealed. ' +
+            'Signs into an allowlisted domain with Bitwarden credentials inside the U-Chan service and hands only the session to the selected dedicated browser; the credentials are never revealed. ' +
             'After the result is ok, continue browsing with the Playwright MCP tools in the same browser.',
         inputSchema: { domain: z.string() },
     }, ({ domain }) => run(() => core.login(domain)));
@@ -67,6 +67,6 @@ export function createMcpServer(core, version = '0.1.0') {
     }, ({ domain, login_url, item, selectors, grant, success }) => run(() => (grant || success ? core.requestAllow(domain, login_url, item, selectors, { ...(grant ? { grant } : {}), ...(success ? { success } : {}) }) : selectors ? core.requestAllow(domain, login_url, item, selectors) : core.requestAllow(domain, login_url, item))));
     server.registerTool('revoke', { description: 'Remove a domain from the login allowlist.', inputSchema: { domain: z.string() } }, ({ domain }) => run(() => core.revoke(domain)));
     server.registerTool('list_allowed', { description: 'List allowlisted domains with their Bitwarden item and hosts. Call it to check whether a site can be logged into before login or request_allow.' }, () => run(() => core.listAllowed()));
-    server.registerTool('status', { description: 'Report Bitwarden vault lock state, approval mode and whether Playwright MCP shares the Chrome. Call it first when login fails.' }, () => run(() => core.status()));
+    server.registerTool('status', { description: 'Report Bitwarden vault lock state, approval mode and whether Playwright MCP shares the selected browser. Call it first when login fails.' }, () => run(() => core.status()));
     return server;
 }

package/dist/platform/darwin/manage-script.js

@@ -1,33 +1,33 @@
 export function buildJxaManagementScript(req) {
-    return `ObjC.import('Cocoa');
-ObjC.import('stdlib');
-var alert = $.NSAlert.alloc.init;
-alert.messageText = ${JSON.stringify(req.title)};
-alert.informativeText = ${JSON.stringify('Phrase: ' + req.phrase)};
-['Refresh','Previous','Next','Lock','Unlock','Revoke selected','Close'].forEach(function(t){ alert.addButtonWithTitle(t); });
-var view = $.NSView.alloc.initWithFrame($.NSMakeRect(0,0,640,420));
-var scroll = $.NSScrollView.alloc.initWithFrame($.NSMakeRect(0,50,640,370));
-scroll.hasVerticalScroller = true;
-var text = $.NSTextView.alloc.initWithFrame($.NSMakeRect(0,0,620,370));
-text.editable = false;
-text.string = ${JSON.stringify(req.lines.join('\n'))};
-scroll.documentView = text;
-view.addSubview(scroll);
-var domains = ${JSON.stringify(req.domains ?? [])};
-var select = $.NSPopUpButton.alloc.initWithFramePullsDown($.NSMakeRect(0,5,640,32),false);
-domains.forEach(function(d){ select.addItemWithTitle(d); });
-view.addSubview(select);
-alert.accessoryView = view;
-var response = Number(alert.runModal) - 1000;
-var actions = ['refresh','previous','next','lock','unlock','revoke','close'];
-var result = {action: actions[response] || 'close'};
-if (result.action === 'revoke') {
-  var index = Number(select.indexOfSelectedItem);
-  if (index < 0 || index >= domains.length) result.action = 'refresh';
-  else result.domain = domains[index];
-}
-$.NSFileHandle.fileHandleWithStandardOutput.writeData(
- $.NSString.alloc.initWithString(JSON.stringify(result)).dataUsingEncoding($.NSUTF8StringEncoding));
-$.exit(0);
+    return `ObjC.import('Cocoa');
+ObjC.import('stdlib');
+var alert = $.NSAlert.alloc.init;
+alert.messageText = ${JSON.stringify(req.title)};
+alert.informativeText = ${JSON.stringify('Phrase: ' + req.phrase)};
+['Refresh','Previous','Next','Lock','Unlock','Revoke selected','Close'].forEach(function(t){ alert.addButtonWithTitle(t); });
+var view = $.NSView.alloc.initWithFrame($.NSMakeRect(0,0,640,420));
+var scroll = $.NSScrollView.alloc.initWithFrame($.NSMakeRect(0,50,640,370));
+scroll.hasVerticalScroller = true;
+var text = $.NSTextView.alloc.initWithFrame($.NSMakeRect(0,0,620,370));
+text.editable = false;
+text.string = ${JSON.stringify(req.lines.join('\n'))};
+scroll.documentView = text;
+view.addSubview(scroll);
+var domains = ${JSON.stringify(req.domains ?? [])};
+var select = $.NSPopUpButton.alloc.initWithFramePullsDown($.NSMakeRect(0,5,640,32),false);
+domains.forEach(function(d){ select.addItemWithTitle(d); });
+view.addSubview(select);
+alert.accessoryView = view;
+var response = Number(alert.runModal) - 1000;
+var actions = ['refresh','previous','next','lock','unlock','revoke','close'];
+var result = {action: actions[response] || 'close'};
+if (result.action === 'revoke') {
+  var index = Number(select.indexOfSelectedItem);
+  if (index < 0 || index >= domains.length) result.action = 'refresh';
+  else result.domain = domains[index];
+}
+$.NSFileHandle.fileHandleWithStandardOutput.writeData(
+ $.NSString.alloc.initWithString(JSON.stringify(result)).dataUsingEncoding($.NSUTF8StringEncoding));
+$.exit(0);
 `;
 }

package/dist/platform/windows/desktop-browser.js

@@ -0,0 +1,14 @@
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+export function inspectDesktopBrowser(options, env = process.env) {
+    // The shared script derives the dedicated profile from the same user home as loadConfig.
+    const expected = options.profile.replace(/[\\/](?:chrome|edge)-profile$/, '');
+    return new Promise(resolve => execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+        fileURLToPath(new URL('../../../scripts/start-browser.ps1', import.meta.url)), '-Browser', options.browser, '-CheckOnly'], { env: { ...env, U_CHAN_HOME: expected, U_CHAN_CDP: options.endpoint }, timeout: 15000, windowsHide: true, maxBuffer: 65536 }, (error, stdout) => resolve(error ? 'unknown' : stdout.trim() === 'pass' ? 'pass' : stdout.trim() === 'fail' ? 'fail' : 'unknown')));
+}
+export function inspectServiceDesktopBrowser(endpoint, ownerSid, env = process.env, browser) {
+    if (!/^S-1-5-21-(?:[0-9]+-){3}[0-9]+$/.test(ownerSid))
+        return Promise.resolve('unknown');
+    return new Promise(resolve => execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File',
+        fileURLToPath(new URL('../../../scripts/start-browser.ps1', import.meta.url)), '-CheckOnly', '-DesktopOwnerSid', ownerSid, ...(browser ? ['-Browser', browser] : [])], { env: { ...env, U_CHAN_CDP: endpoint }, timeout: 15000, windowsHide: true, maxBuffer: 65536 }, (error, stdout) => resolve(error ? 'unknown' : stdout.trim() === 'pass' ? 'pass' : stdout.trim() === 'fail' ? 'fail' : 'unknown')));
+}

package/dist/platform/windows/doctor.js

@@ -5,5 +5,5 @@ export const checkWindowsUac = () => commandState('powershell.exe', ['-NoProfile
 export function checkWindowsPermissions(home) {
     const encoded = Buffer.from(home, 'utf8').toString('base64');
     const script = `$ErrorActionPreference='Stop'; $p=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}')); $root=Get-Item -LiteralPath $p -Force; if($root.Attributes -band [IO.FileAttributes]::ReparsePoint){'UNSAFE';exit}; $items=@($root)+@(Get-ChildItem -LiteralPath $p -Force -Recurse); foreach($i in $items){if($i.Attributes -band [IO.FileAttributes]::ReparsePoint){'UNSAFE';exit}; $acl=$i.GetAccessControl(); $owner=$acl.GetOwner([Security.Principal.SecurityIdentifier]).Value; if($owner -notin @('S-1-5-18','S-1-5-32-544')){'UNSAFE';exit}; foreach($ace in $acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){if($ace.AccessControlType -eq 'Allow' -and $ace.IdentityReference.Value -notin @('S-1-5-18','S-1-5-32-544')){'UNSAFE';exit}} }; 'SAFE'`;
-    return commandState('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], s => s.trim() === 'SAFE', 15000);
+    return commandState('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], s => s.trim() === 'SAFE', 60000);
 }

package/dist/service/control.js

@@ -14,7 +14,7 @@ export class ControlService {
         this.grants = d.grants ?? new GrantCoordinator(d.allowlist);
     }
     async capabilities() {
-        return { ok: true, message: JSON.stringify({ protocol: 3, features: ['doctor', 'success_conditions', 'grants'], serviceVersion: this.d.serviceVersion }) };
+        return { ok: true, message: JSON.stringify({ protocol: 3, features: ['doctor', 'success_conditions', 'grants', 'verified_session_transfer'], serviceVersion: this.d.serviceVersion }) };
     }
     async diagnose() {
         try {

package/dist/service/doctor.js

@@ -1,14 +1,14 @@
 import { lstat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { privateBrowserPath } from '../platform/runtime-assets.js';
-import { bounded, chromeState, safeCdpOrigin } from '../core/doctor.js';
+import { bounded, chromeState, observeCdpBrowser, safeCdpOrigin } from '../core/doctor.js';
 import { checkWindowsPermissions } from '../platform/windows/doctor.js';
 import { checkDarwinPermissions } from '../platform/darwin/doctor.js';
 export async function diagnoseService(home, vault, platform, cdpEndpoint) {
     const paths = [join(home, 'program', 'dist', 'service', 'main.js'), join(home, 'program', 'node_modules'),
         platform === 'win32' ? join(home, 'bin', 'node.exe') : process.execPath,
         platform === 'win32' ? join(home, 'bin', 'bw.exe') : join(home, 'bin', 'bw')];
-    const [assets, permissions, status, browser] = await Promise.all([
+    const [assets, permissions, status, browser, browserKind] = await Promise.all([
         bounded(async () => {
             await privateBrowserPath(home);
             for (const p of paths) {
@@ -18,10 +18,11 @@ export async function diagnoseService(home, vault, platform, cdpEndpoint) {
             }
             return 'pass';
         }, 'unknown'),
-        bounded(() => platform === 'win32' ? checkWindowsPermissions(home) : checkDarwinPermissions(home), 'unknown', 20000),
+        bounded(() => platform === 'win32' ? checkWindowsPermissions(home) : checkDarwinPermissions(home), 'unknown', 65000),
         bounded(() => vault.status(), 'unavailable'),
         cdpEndpoint === undefined ? undefined : bounded(() => chromeState(cdpEndpoint), 'unknown'),
+        cdpEndpoint === undefined ? undefined : observeCdpBrowser(cdpEndpoint),
     ]);
     return { assets, permissions, vault: status === 'unlocked' ? 'pass' : status === 'unavailable' ? 'unknown' : status,
-        ...(cdpEndpoint === undefined ? {} : { browser, browserEndpoint: safeCdpOrigin(cdpEndpoint) }) };
+        ...(cdpEndpoint === undefined ? {} : { browser, browserEndpoint: safeCdpOrigin(cdpEndpoint), browserKind }) };
 }

package/dist/service/isolated-login.js

@@ -3,7 +3,9 @@ import { isHostAllowed } from '../core/allowlist.js';
 import { abortable } from '../core/abort.js';
 import { filterState } from './session-transfer.js';
 import { UserFacingError } from '../core/types.js';
-/** Signs in inside a service-owned browser, then hands only the entry's session to the user's Chrome. */
+import { waitForLoginSuccess } from '../core/login-success.js';
+import { createPrivateNetwork } from './private-network.js';
+/** Signs in inside a service-owned browser, then verifies only the approved session in the user's selected browser. */
 export class IsolatedLogin {
     o;
     browser;
@@ -17,19 +19,23 @@ export class IsolatedLogin {
         else
             await this.o.target.cancel?.();
     }
-    async preflight(signal) {
-        const check = signal ? AbortSignal.any([signal, AbortSignal.timeout(5000)]) : AbortSignal.timeout(5000);
+    async preflight(signal, browser = 'chrome') {
+        const check = signal ? AbortSignal.any([signal, AbortSignal.timeout(20000)]) : AbortSignal.timeout(20000);
         try {
+            if (this.o.target.bindBrowser && !await abortable(this.o.target.bindBrowser(browser, check), check, async () => { await this.o.target.cancel?.(); }))
+                throw new Error('browser mismatch');
             await abortable(this.o.target.userAgent(check), check, async () => { await this.o.target.cancel?.(); });
         }
         catch {
-            throw new UserFacingError(signal?.aborted ? 'login timed out; retry if needed' : 'dedicated Chrome is unavailable; start its launcher', signal?.aborted ? 'login_timeout' : 'chrome_unavailable');
+            throw new UserFacingError(signal?.aborted ? 'login timed out; retry if needed' : 'selected dedicated browser is unavailable; run u-chan setup --start-browser', signal?.aborted ? 'login_timeout' : 'browser_unavailable');
         }
     }
     async run(entry, getCreds, options = {}) {
         const signal = options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(60000)]) : AbortSignal.timeout(60000);
         const hostCheck = this.o.hostCheck ?? ((url) => isHostAllowed(entry, url));
         let browser = this.browser, ctx;
+        let transferStarted = false;
+        let network;
         let closing, stopping;
         const closeBrowser = async () => {
             const current = browser;
@@ -41,16 +47,21 @@ export class IsolatedLogin {
         const stop = () => stopping ??= Promise.allSettled([
             ctx ? closeContext() : closeBrowser(),
             this.o.target.cancel?.(),
+            network?.close(),
         ]).then(() => { });
         this.cancellation = stop;
         try {
             signal.throwIfAborted();
+            if (this.o.target.bindBrowser && !await abortable(this.o.target.bindBrowser(options.browser ?? 'chrome', signal), signal, stop))
+                throw new UserFacingError('selected dedicated browser is unavailable or mismatched', 'browser_unavailable');
             const userAgent = await abortable(this.o.target.userAgent(signal), signal, stop);
             if (!browser?.isConnected()) {
                 browser = await abortable(this.o.launch(), signal, stop, b => b.close());
                 this.browser = browser;
             }
-            ctx = await abortable(browser.newContext({ userAgent }), signal, stop, c => c.close());
+            const fixtureOrigin = this.o.hostCheck && new URL(entry.loginUrl).protocol === 'http:' ? new URL(entry.loginUrl).origin : undefined;
+            network = await abortable(createPrivateNetwork(hostCheck, signal, fixtureOrigin), signal, stop, n => n.close());
+            ctx = await abortable(browser.newContext({ userAgent, serviceWorkers: 'block', proxy: network.proxy }), signal, stop, c => c.close());
             const page = await abortable(ctx.newPage(), signal, stop, p => p.close());
             const checkHost = () => {
                 if (!hostCheck(page.url()))
@@ -58,12 +69,14 @@ export class IsolatedLogin {
             };
             const outcome = await abortable(fillLogin(page, entry, getCreds, { timeoutMs: this.o.timeoutMs, hostCheck }), signal, stop);
             if (outcome.status === 'failed')
-                return { ...outcome, code: outcome.reason?.includes('needs you') ? 'needs_human' : outcome.reason?.includes('form still present') || outcome.reason?.includes('rejected') ? 'authentication_unconfirmed' : 'unsupported_form' };
+                return network.wasBlocked()
+                    ? { status: 'failed', code: 'unsupported_form', reason: 'an unapproved private-browser request was blocked; session was not transferred' }
+                    : { ...outcome, code: outcome.code ?? 'unsupported_form' };
             checkHost();
             if (entry.success) {
                 let matched = false;
                 try {
-                    matched = 'url' in entry.success ? page.url() === entry.success.url : await abortable(page.locator(entry.success.selector).first().isVisible(), signal, stop);
+                    matched = await abortable(waitForLoginSuccess(page, entry.success, hostCheck, signal, this.o.timeoutMs ?? 15000), signal, stop);
                 }
                 catch (e) {
                     if (signal.aborted)
@@ -80,19 +93,28 @@ export class IsolatedLogin {
             signal.throwIfAborted();
             await options.beforeTransfer?.();
             checkHost();
+            transferStarted = true;
             try {
                 await abortable(this.o.target.inject(state, signal), signal, stop);
             }
             catch (e) {
                 if (signal.aborted)
                     throw e;
-                return { status: 'failed', reason: 'could not hand the session to Chrome', code: 'session_transfer_failed' };
+                return { status: 'failed', reason: 'session transfer did not complete; some browser session state may already exist', code: 'session_transfer_failed' };
             }
-            return entry.success ? { status: 'logged_in' } : { status: 'unconfirmed', code: 'authentication_unconfirmed', reason: 'session state transferred to Chrome; sign-in was not confirmed; inspect the site before continuing' };
+            await options.beforeTransfer?.();
+            signal.throwIfAborted();
+            if (entry.success) {
+                const verified = this.o.target.verify ? await abortable(this.o.target.verify(entry, page.url(), signal), signal, stop) : false;
+                return verified ? { status: 'logged_in' } : { status: 'unconfirmed', code: 'destination_unconfirmed', reason: 'session state was transferred, but login was not confirmed in the selected browser; inspect the site before continuing' };
+            }
+            return { status: 'unconfirmed', code: 'authentication_unconfirmed', reason: 'session state transferred to the selected browser; sign-in was not confirmed; inspect the site before continuing' };
         }
         catch (e) {
             if (signal.aborted)
-                return { status: 'failed', code: 'login_timeout', reason: 'login cancelled or timed out; retry with fresh approval if needed' };
+                return { status: 'failed', code: 'login_timeout', reason: transferStarted ? 'login cancelled or timed out after transfer started; browser session state may already exist and login is unconfirmed' : 'login cancelled or timed out; retry with fresh approval if needed' };
+            if (transferStarted)
+                return { status: 'unconfirmed', code: 'destination_unconfirmed', reason: 'destination verification did not complete; browser session state may already exist and login is unconfirmed' };
             if (e instanceof UserFacingError && e.code === 'unsupported_form')
                 return { status: 'failed', code: e.code, reason: e.message };
             throw e;
@@ -102,6 +124,7 @@ export class IsolatedLogin {
                 await stop();
             else
                 await closeContext();
+            await network?.close();
             this.cancellation = undefined;
         }
     }

package/dist/service/main.js

@@ -25,6 +25,7 @@ import { ensureV3State } from './state.js';
 import { ManagementService } from './manage.js';
 import { privateBrowserPath } from '../platform/runtime-assets.js';
 import { safeVersion } from '../core/doctor.js';
+import { inspectServiceDesktopBrowser } from '../platform/windows/desktop-browser.js';
 export function prepareSocketEndpoint(endpoint, platform = process.platform) {
     if (platform !== 'win32') {
         const dir = dirname(endpoint);
@@ -60,9 +61,14 @@ export async function runService(platform = process.platform, env = process.env)
         const allowlist = new AllowlistStore(cfg.allowlistPath, () => stateReady ??= ensureV3State(cfg.home).catch(e => { stateReady = undefined; throw e; }));
         const grants = new GrantCoordinator(allowlist);
         const audit = new FileAuditLog(cfg.auditPath);
+        const endpoint = loadConfig(env, platform).cdpEndpoint;
+        const validateTarget = platform === 'win32' ? async (browser = 'chrome') => {
+            const owner = (await settings.get()).authorizedSid;
+            return typeof owner === 'string' && await inspectServiceDesktopBrowser(endpoint, owner, env, browser) === 'pass';
+        } : undefined;
         const login = new IsolatedLogin({
-            launch: async () => chromium.launch({ headless: true, executablePath: await privateBrowserPath(cfg.home), timeout: 15000 }),
-            target: new CdpSessionTarget(new CdpBrowserProvider(loadConfig(env, platform).cdpEndpoint)),
+            launch: async () => chromium.launch({ headless: true, executablePath: await privateBrowserPath(cfg.home), timeout: 15000, args: ['--disable-http2', '--disable-quic'] }),
+            target: new CdpSessionTarget(new CdpBrowserProvider(endpoint, { validate: validateTarget })),
         });
         const core = new CoreService({ vault, allowlist, grants, approver, audit, login, mode: () => approver.effectiveMode() });
         let currentVersion = 'unknown';
@@ -94,7 +100,7 @@ export async function runService(platform = process.platform, env = process.env)
             capabilities: () => control.capabilities(),
             diagnose: () => control.diagnose(),
             manage: () => control.manage(),
-            login: (domain) => core.login(domain),
+            login: (domain, browser) => core.login(domain, browser),
             requestAllow: (domain, loginUrl, item, selectors, options) => core.requestAllow(domain, loginUrl, item, selectors, options),
             revoke: (domain) => core.revoke(domain),
             listAllowed: () => core.listAllowed(),