u-chan-secrets 5.0.0 → 5.1.0

package/dist/client/update-package.js

@@ -0,0 +1,166 @@
+import { execFile } from 'node:child_process';
+import { createServer } from 'node:net';
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join } from 'node:path';
+import { homedir } from 'node:os';
+import { z } from 'zod';
+import { NpmPackageVerifier } from '../service/update/verifier.js';
+import { boundedRegistryFetch } from '../service/update/network.js';
+import { artifactIntegrity, inspectRelease } from '../service/update/release.js';
+import { atomicJson, boundedJson, noLinks } from '../service/update/journal.js';
+import { readBootIdentity } from '../service/update/files.js';
+import { idSchema, identitySchema, sameIdentity } from '../service/update/protocol.js';
+import { isElevated, configureCodex } from './codex-setup.js';
+import { configureClaude } from './claude-setup.js';
+import { configureWindowsCommand } from './windows-command.js';
+import { loadConfig } from '../core/config.js';
+import { defaultEndpoint } from '../ipc/endpoint.js';
+const checkpointSchema = z.strictObject({ id: idSchema, target: identitySchema });
+const desktopCheckpointSchema = z.strictObject({ stageId: idSchema, target: identitySchema, backup: z.string().regex(/^u-chan-secrets-[A-Za-z0-9.+-]+\.tgz$/) });
+export async function acquireDesktopLock(directory) {
+    const name = process.platform === 'win32' ? '\\\\.\\pipe\\u-chan-update-' + createHash('sha256').update(directory.toLowerCase()).digest('hex') : join(directory, 'update.sock');
+    const server = createServer(socket => socket.destroy());
+    return new Promise((resolve, reject) => {
+        server.once('error', (error) => error.code === 'EADDRINUSE' ? resolve(null) : reject(error));
+        server.listen({ path: name, exclusive: true }, () => resolve(() => new Promise((done, fail) => server.close(error => error ? fail(error) : done()))));
+    });
+}
+export async function verifyDesktopFiles(program, tarball) {
+    for (const [relative, bytes] of inspectRelease(tarball).files) {
+        const path = join(program, relative);
+        await noLinks(path);
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.size !== bytes.length || !(await readFile(path)).equals(bytes))
+            throw new Error('desktop_artifact_mismatch');
+    }
+}
+/** npm runs only as the desktop user. No caller artifact reaches the privileged service. */
+export function desktopUpdateAdapter(env = process.env) {
+    const state = join(env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'), 'u-chan-secrets');
+    let program = '', stage = '', artifact, npmEntry = '';
+    async function npm(args) {
+        if (await isElevated())
+            throw new Error('normal_desktop_user_required');
+        if (!npmEntry) {
+            for (const candidate of [join(dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js'), join(dirname(process.execPath), '../lib/node_modules/npm/bin/npm-cli.js')]) {
+                try {
+                    await noLinks(candidate);
+                    if ((await lstat(candidate)).isFile()) {
+                        npmEntry = candidate;
+                        break;
+                    }
+                }
+                catch { }
+            }
+            if (!npmEntry)
+                throw new Error('trusted_npm_unavailable');
+        }
+        return new Promise((resolve, reject) => execFile(process.execPath, [npmEntry, ...args], { env, windowsHide: true, timeout: 120000, maxBuffer: 1024 * 1024 }, (error, stdout) => error ? reject(new Error('desktop_npm_failed')) : resolve(stdout.trim())));
+    }
+    async function installed() {
+        if (!program) {
+            const root = await npm(['root', '--global', '--loglevel=error']);
+            if (!isAbsolute(root) || /[\r\n]/.test(root))
+                throw new Error('invalid_npm_root');
+            program = join(root, 'u-chan-secrets');
+            await noLinks(program);
+        }
+        return program;
+    }
+    return {
+        identity: async () => readBootIdentity(await installed()),
+        acquire: async () => { if (await isElevated())
+            throw new Error('normal_desktop_user_required'); await noLinks(state); await mkdir(state, { recursive: true, mode: 0o700 }); return acquireDesktopLock(state); },
+        checkpoint: async (value) => {
+            const path = join(state, 'update-checkpoint.json');
+            if (value) {
+                await atomicJson(path, checkpointSchema.parse(value));
+                return value;
+            }
+            try {
+                return checkpointSchema.parse(await boundedJson(path));
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return null;
+                throw error;
+            }
+        },
+        recover: async (target) => {
+            const saved = desktopCheckpointSchema.parse(await boundedJson(join(state, 'desktop-update.json')));
+            if (!sameIdentity(saved.target, target))
+                throw new Error('desktop_recovery_target_mismatch');
+            const backup = join(state, '#0 backup', 'update-' + saved.stageId, 'before', saved.backup);
+            await noLinks(backup);
+            const stat = await lstat(backup);
+            if (!stat.isFile() || !stat.size)
+                throw new Error('desktop_recovery_backup_missing');
+            const verified = await new NpmPackageVerifier({ fetcher: boundedRegistryFetch }).verify(target.version);
+            if (!verified.ok || !verified.tarball || artifactIntegrity(verified.tarball) !== target.integrity)
+                throw new Error('desktop_recovery_verification_failed');
+            await verifyDesktopFiles(await installed(), verified.tarball);
+            await atomicJson(join(program, 'release.json'), target);
+            return readBootIdentity(program);
+        },
+        prepare: async (target) => {
+            const result = await new NpmPackageVerifier({ fetcher: boundedRegistryFetch }).verify(target.version);
+            if (!result.ok || !result.tarball || artifactIntegrity(result.tarball) !== target.integrity)
+                throw new Error('desktop_release_verification_failed');
+            const manifest = inspectRelease(result.tarball);
+            if (manifest.version !== target.version)
+                throw new Error('desktop_version_mismatch');
+            artifact = result.tarball;
+            const stageId = randomUUID();
+            stage = join(state, '#0 backup', 'update-' + stageId);
+            await noLinks(stage);
+            await mkdir(join(stage, 'before'), { recursive: true, mode: 0o700 });
+            const packed = JSON.parse(await npm(['pack', await installed(), '--ignore-scripts', '--pack-destination', join(stage, 'before'), '--json']));
+            if (!Array.isArray(packed) || packed.length !== 1 || !/^u-chan-secrets-[A-Za-z0-9.+-]+\.tgz$/.test(packed[0]?.filename))
+                throw new Error('desktop_backup_failed');
+            const backup = join(stage, 'before', packed[0].filename);
+            await noLinks(backup);
+            if (!(await lstat(backup)).isFile())
+                throw new Error('desktop_backup_failed');
+            await writeFile(join(stage, 'target.tgz'), artifact, { flag: 'wx', mode: 0o600 });
+            await atomicJson(join(stage, 'target.json'), target);
+            await atomicJson(join(state, 'desktop-update.json'), { stageId, target, backup: packed[0].filename });
+        },
+        install: async (target) => {
+            if (!artifact || !stage)
+                throw new Error('desktop_not_prepared');
+            const path = join(stage, 'target.tgz');
+            await noLinks(path);
+            if ((await lstat(path)).size > 32 * 1024 * 1024)
+                throw new Error('desktop_artifact_too_large');
+            const bytes = await readFile(path);
+            if (artifactIntegrity(bytes) !== target.integrity || !bytes.equals(artifact))
+                throw new Error('desktop_artifact_changed');
+            await npm(['install', '--global', '--ignore-scripts', '--no-audit', '--no-fund', path]);
+            await verifyDesktopFiles(await installed(), bytes);
+            await atomicJson(join(program, 'release.json'), target);
+            const identity = await readBootIdentity(program);
+            if (!sameIdentity(identity, target))
+                throw new Error('desktop_identity_mismatch');
+            return identity;
+        },
+        repair: async () => {
+            if (await isElevated())
+                return false;
+            const config = loadConfig(env, process.platform), common = { apply: false, replaceExisting: false, browser: config.browser, endpoint: config.cdpEndpoint, ipcEndpoint: defaultEndpoint(env, process.platform), nodePath: process.execPath, entryPath: join(await installed(), 'dist/index.js') };
+            const claudeDir = env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
+            const handlers = [(apply) => configureCodex({ ...common, apply, replaceExisting: apply, configDir: env.CODEX_HOME ?? join(homedir(), '.codex') }), (apply) => configureClaude({ ...common, apply, replaceExisting: apply, configDir: claudeDir, configPath: env.CLAUDE_CONFIG_DIR ? join(claudeDir, '.claude.json') : join(homedir(), '.claude.json') })];
+            let ready = (await configureWindowsCommand(true, env.PATH ?? env.Path ?? '')).ready;
+            for (const configure of handlers) {
+                const before = await configure(false);
+                if (before.state === 'needs_update') {
+                    const repaired = await configure(true);
+                    ready = repaired.state === 'ready' && ready;
+                }
+                else if (!['ready', 'missing'].includes(before.state))
+                    ready = false;
+            }
+            return ready;
+        },
+    };
+}

package/dist/client/update.js

@@ -0,0 +1,138 @@
+import { performance } from 'node:perf_hooks';
+import { observedIdentitySchema, planSchema, publicJobSchema, sameIdentity, planDecision, terminal } from '../service/update/protocol.js';
+export async function runCoordinatedUpdate(options, d) {
+    const now = d.now ?? (() => performance.now()), sleep = d.sleep ?? (ms => new Promise(r => setTimeout(r, ms))), start = now();
+    let release = null, serviceChanged = false, lastPhase = '', lastPrinted = -1;
+    const progress = (phase) => { const seconds = Math.floor((now() - start) / 1000); if (phase !== lastPhase || seconds - lastPrinted >= 5) {
+        d.progress(phase, seconds);
+        lastPhase = phase;
+        lastPrinted = seconds;
+    } };
+    const failure = (message) => ({ ok: false, message });
+    const capabilities = async () => { const r = await d.client.capabilities(); if (!r.ok)
+        throw new Error(); return JSON.parse(r.message); };
+    try {
+        progress('checking');
+        const initial = await capabilities();
+        if (initial.protocol !== 3 || !initial.features?.includes('coordinated_update') || !d.client.planUpdate || !d.client.beginUpdate || !d.client.updateStatus || !d.client.activateUpdate || !d.client.confirmUpdateReady)
+            return failure('coordinated updater bootstrap required; install the matching trusted service first');
+        const response = await d.client.planUpdate();
+        if (!response.ok)
+            return response;
+        const plan = planSchema.parse(JSON.parse(response.message));
+        let desktop = observedIdentitySchema.parse(await d.desktop.identity()), desktopDecision = planDecision(desktop, plan.target);
+        if (options.checkOnly)
+            return { ok: true, message: JSON.stringify({ ...plan, desktop, desktopDecision, readOnly: true }) };
+        if (plan.platform !== 'win32')
+            return failure('coordinated application requires Windows; no components changed');
+        if (!plan.compatible || ['local_ahead', 'identity_unknown'].includes(plan.decision) || desktopDecision === 'local_ahead' || (desktopDecision === 'identity_unknown' && !d.desktop.recover))
+            return failure((plan.reason ?? 'local build identity is unknown or ahead') + '; no components changed');
+        release = await d.desktop.acquire();
+        if (!release)
+            return failure('another desktop update is running; reconnect after it finishes');
+        let desktopRecovered = false;
+        if (desktopDecision === 'identity_unknown') {
+            try {
+                desktop = observedIdentitySchema.parse(await d.desktop.recover(plan.target));
+                desktopDecision = planDecision(desktop, plan.target);
+            }
+            catch {
+                return failure('desktop identity unknown; restore the retained desktop package or perform a trusted desktop reinstall');
+            }
+            if (desktopDecision !== 'up_to_date')
+                return failure('desktop recovery did not establish target identity');
+            desktopRecovered = true;
+        }
+        let job = plan.activeJob ?? undefined;
+        const checkpoint = await d.desktop.checkpoint?.();
+        if (!job && checkpoint && sameIdentity(checkpoint.target, plan.target)) {
+            const r = await d.client.updateStatus(checkpoint.id);
+            if (r.ok) {
+                const saved = publicJobSchema.parse(JSON.parse(r.message));
+                if (sameIdentity(saved.target, plan.target) && saved.phase !== 'failed')
+                    job = saved;
+            }
+        }
+        const desktopNeeded = desktopDecision === 'update_required';
+        if (desktopNeeded) {
+            progress('preparing_desktop');
+            await d.desktop.prepare(plan.target);
+        }
+        if (!job && plan.decision === 'update_required') {
+            progress('preparing_service');
+            const result = await d.client.beginUpdate(plan.target);
+            if (!result.ok)
+                return result;
+            job = publicJobSchema.parse(JSON.parse(result.message));
+            await d.desktop.checkpoint?.({ id: job.id, target: plan.target });
+        }
+        if (job) {
+            await d.desktop.checkpoint?.({ id: job.id, target: plan.target });
+            while (now() - start < 15 * 60 * 1000) {
+                if (!sameIdentity(job.target, plan.target))
+                    return failure('update transaction target changed; no further work dispatched');
+                progress(job.phase);
+                if (job.phase === 'service_ready') {
+                    serviceChanged = true;
+                    break;
+                }
+                if (terminal(job.phase))
+                    return failure('service update ' + job.phase + '; retained recovery program and transaction ' + job.id);
+                if (job.phase === 'ready_to_apply') {
+                    const r = await d.client.activateUpdate(job.id);
+                    if (!r.ok)
+                        return r;
+                }
+                if (job.phase === 'waiting_for_service' || job.phase === 'rolling_back') {
+                    try {
+                        const cap = await capabilities(), expected = job.phase === 'rolling_back' ? job.source : job.target;
+                        if (cap.release && sameIdentity(cap.release, expected))
+                            await d.client.confirmUpdateReady(job.id);
+                    }
+                    catch { }
+                }
+                await sleep(1000);
+                try {
+                    const r = await d.client.updateStatus(job.id);
+                    if (r.ok)
+                        job = publicJobSchema.parse(JSON.parse(r.message));
+                }
+                catch { }
+            }
+            if (job.phase !== 'service_ready')
+                return failure('update still in progress; run u-chan update to reconnect to transaction ' + job.id);
+        }
+        let finalDesktop = desktop;
+        if (desktopNeeded) {
+            progress('updating_desktop');
+            try {
+                finalDesktop = await d.desktop.install(plan.target);
+            }
+            catch {
+                return failure('partial update: service verified; desktop installation failed. Run u-chan update to resume; desktop rollback package retained');
+            }
+        }
+        const cap = await capabilities();
+        if (!cap.release || !sameIdentity(cap.release, plan.target) || !sameIdentity(finalDesktop, plan.target))
+            return failure('partial update: component identities do not match the verified target; retry update or inspect retained recovery copies');
+        let registrationsReady = true;
+        if ((desktopNeeded || desktopRecovered) && d.desktop.repair)
+            registrationsReady = await d.desktop.repair().catch(() => false);
+        progress('complete');
+        let vault = 'unknown';
+        try {
+            const state = await d.client.status?.();
+            const match = state?.message.match(/\bvault: (unlocked|locked|unauthenticated|unavailable)\b/);
+            if (match)
+                vault = match[1];
+        }
+        catch { }
+        return { ok: true, message: JSON.stringify({ status: 'complete', desktop: finalDesktop, service: cap.release, serviceTransactionObserved: serviceChanged, vault, agentSessionRestartRequired: desktopNeeded || desktopRecovered, manualSetupRequired: !registrationsReady, rollbackRetained: serviceChanged || desktopNeeded || desktopRecovered }) };
+    }
+    catch {
+        return failure(serviceChanged ? 'partial update; service ready, finish desktop verification before claiming completion' : 'update check or preparation failed; inspect transaction status before retrying');
+    }
+    finally {
+        await release?.().catch(() => { });
+    }
+}

package/dist/client/windows-command.js

@@ -0,0 +1,54 @@
+import { lstat, mkdir, readFile, rename, realpath } from 'node:fs/promises';
+import { delimiter, join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+/** Let PowerShell resolve the npm .cmd launcher without changing execution policy or loading a profile. */
+export async function configureWindowsCommand(apply, searchPath) {
+    const result = (ready, message) => ({ ready, changed: false, message });
+    try {
+        for (const entry of searchPath.split(delimiter).filter(Boolean)) {
+            const directory = resolve(entry.replace(/^"|"$/g, ''));
+            const script = join(directory, 'u-chan.ps1'), command = join(directory, 'u-chan.cmd');
+            const exists = async (file) => {
+                try {
+                    return await lstat(file);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return undefined;
+                    throw error;
+                }
+            };
+            const ps = await exists(script), cmd = await exists(command);
+            if (!ps && !cmd)
+                continue;
+            if (!cmd?.isFile() || cmd.isSymbolicLink() || (ps && (!ps.isFile() || ps.isSymbolicLink()))) {
+                return result(false, 'Custom or redirected u-chan launcher preserved; use u-chan.cmd unlock.');
+            }
+            const batch = await readFile(command, 'utf8');
+            if (!batch.includes('"%dp0%\\node_modules\\u-chan-secrets\\dist\\cli.js" %*')) {
+                return result(false, 'Unrecognized u-chan launcher preserved; inspect command installation manually.');
+            }
+            if (!ps)
+                return result(true, 'PowerShell can use the u-chan.cmd launcher as u-chan.');
+            const source = await readFile(script, 'utf8');
+            if (!source.startsWith('#!/usr/bin/env pwsh') || !source.includes('"$basedir/node_modules/u-chan-secrets/dist/cli.js" $args') || !source.trimEnd().endsWith('exit $ret')) {
+                return result(false, 'Custom PowerShell launcher preserved; use u-chan.cmd unlock.');
+            }
+            if (!apply)
+                return result(false, 'Run u-chan.cmd setup --apply to make u-chan work without PowerShell scripts.');
+            if ((await realpath(directory)).toLowerCase() !== directory.toLowerCase())
+                throw new Error('Redirected launcher directory.');
+            const backupDirectory = join(directory, '#0 backup');
+            await mkdir(backupDirectory, { recursive: true });
+            if ((await lstat(backupDirectory)).isSymbolicLink() || (await realpath(backupDirectory)).toLowerCase() !== backupDirectory.toLowerCase())
+                throw new Error('Redirected backup directory.');
+            const backupPath = join(backupDirectory, `u-chan-${randomUUID()}.ps1`);
+            await rename(script, backupPath);
+            return { ready: true, changed: true, backupPath, message: 'PowerShell now uses u-chan.cmd as u-chan; original .ps1 launcher retained in #0 backup.' };
+        }
+        return result(true, 'No npm u-chan launcher found on PATH; source checkout commands remain unchanged.');
+    }
+    catch {
+        return result(false, 'Could not configure the PowerShell command; use u-chan.cmd unlock and inspect launcher permissions.');
+    }
+}

package/dist/core/browser.js

@@ -1,4 +1,3 @@
-import { execFile } from 'node:child_process';
 import { chromium } from 'playwright';
 import { UserFacingError } from './types.js';
 import { isHostAllowed } from './allowlist.js';
@@ -22,10 +21,6 @@ async function restrictPageNavigation(page, allowed, signal) {
     await session.send('Network.setBypassServiceWorker', { bypass: true });
     await session.send('Fetch.enable', { patterns: [{ resourceType: 'Document', requestStage: 'Request' }] });
 }
-/** 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;

package/dist/core/config.js

@@ -12,6 +12,7 @@ export function serviceConfig(env, platform) {
     return {
         home,
         allowlistPath: path.join(home, 'allowlist.json'),
+        discordAllowlistPath: path.join(home, 'discord-allowlist.json'),
         auditPath: path.join(home, 'audit.log'),
         settingsPath: path.join(home, 'settings.json'),
         bwDataDir: path.join(home, 'bw-data'),

package/dist/core/doctor.js

@@ -108,6 +108,10 @@ export async function runDoctor(d) {
         add('uac', elevation, 'Windows administrator prompt policy checked.', 'Set UAC to Always notify in Windows settings.');
     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.');
+    if (service?.discordPolicy !== undefined)
+        add('discord_policy', state(service.discordPolicy), 'Protected Discord connection policy checked.', 'Repair Discord connection state from a trusted administrator terminal; never include tokens in policy JSON.');
+    if (service?.discordBroker !== undefined)
+        add('discord_broker', service.discordBroker === 'available' ? 'pass' : 'unknown', service.discordBroker === 'available' ? 'Discord broker source support available; native rendering and active-session ownership require separate verification.' : 'Discord broker requires Windows and complete protected review.', 'Use an upgraded Windows service with the complete protected review helper.', false);
     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')
@@ -117,7 +121,7 @@ export async function runDoctor(d) {
     const kindMismatch = d.browser && (service?.browserKind === 'chrome' || service?.browserKind === 'edge') && service.browserKind !== d.browser;
     if (d.browserIdentity)
         add('browser_identity', kindMismatch ? 'fail' : identity, `Dedicated ${label} process, owner and profile checked.`, 'Check the selected browser, dedicated profile and occupied endpoint; close only the previous dedicated U-Chan instance before switching.');
-    add('playwright', playwright, 'Playwright shared-browser configuration checked.', 'Configure Playwright MCP with --cdp-endpoint and restart the AI session.', playwright !== 'unknown');
+    add('playwright', playwright, 'Playwright shared-browser configuration checked.', 'Configure Playwright MCP with --cdp-endpoint (u-chan setup --apply --replace-existing) and restart the AI session.', playwright !== 'unknown');
     return { version: 1, checks, ...(d.browser ? { browser: d.browser, observedBrowser: service?.browserKind === 'edge' || service?.browserKind === 'chrome' ? service.browserKind : 'unknown' } : {}) };
 }
 export async function observeCdpBrowser(endpoint) {

package/dist/core/vault.js

@@ -1,6 +1,7 @@
 import { execFile } from 'node:child_process';
 import { UserFacingError } from './types.js';
 import { redact } from './redact.js';
+import { snowflake, tokenFieldSchema } from '../discord/policy.js';
 /**
  * Default exec: runs bw directly, never through a shell (item names come from the AI).
  * On Windows this requires the native bw.exe (e.g. `winget install Bitwarden.CLI`),
@@ -28,6 +29,7 @@ export class BitwardenVault {
     idleLockMs;
     now;
     sessionKey = '';
+    authorizationVersion = 0;
     lastUse = 0;
     constructor(opts) {
         this.dataDir = opts.dataDir;
@@ -37,10 +39,14 @@ export class BitwardenVault {
     }
     /** Returns the in-memory session, dropping it if the idle timeout elapsed. */
     session() {
-        if (this.sessionKey && this.now() - this.lastUse > this.idleLockMs)
+        if (this.sessionKey && this.now() - this.lastUse > this.idleLockMs) {
             this.sessionKey = '';
+            this.authorizationVersion++;
+        }
         return this.sessionKey;
     }
+    /** In-process authorization generation; never a credential or an IPC capability. */
+    authorizationEpoch() { this.session(); return this.authorizationVersion; }
     run(args, session, extra = {}, signal) {
         const env = { ...process.env, BW_NOINTERACTION: 'true', BITWARDENCLI_APPDATA_DIR: this.dataDir, ...extra };
         delete env.BW_SESSION;
@@ -72,6 +78,7 @@ export class BitwardenVault {
         if (!key)
             return false; // keep any previous session until a new one succeeds
         this.sessionKey = key;
+        this.authorizationVersion++;
         this.lastUse = this.now();
         return true;
     }
@@ -79,6 +86,7 @@ export class BitwardenVault {
         return this.unlock(password);
     }
     async lock() {
+        this.authorizationVersion++;
         const session = this.sessionKey;
         this.sessionKey = '';
         try {
@@ -104,7 +112,7 @@ export class BitwardenVault {
             return 'unavailable';
         }
     }
-    async getLogin(item, signal) {
+    async getItem(item, signal, quiet = false) {
         const session = this.session();
         if (!session)
             throw new UserFacingError((await this.status(signal)) === 'unauthenticated' ? LOGIN_MSG : UNLOCK_MSG);
@@ -135,16 +143,113 @@ export class BitwardenVault {
             }
             if (err.includes('you are not logged in'))
                 throw new UserFacingError(LOGIN_MSG);
-            console.error(`bw failed (exit ${r.code}): ${redact(r.stderr.trim(), [session])}`);
+            if (!quiet)
+                console.error(`bw failed (exit ${r.code}): ${redact(r.stderr.trim(), [session])}`);
             throw new UserFacingError(`bw failed (exit ${r.code})`);
         }
-        let login;
         try {
-            login = JSON.parse(r.stdout).login;
+            const value = JSON.parse(r.stdout);
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                throw new Error();
+            return value;
         }
         catch {
             throw new UserFacingError('unexpected bw output');
         }
+    }
+    /** Protected discovery only: return scoped setup metadata, never note contents or token values. */
+    async getDiscordSetup(item, signal) {
+        const session = this.session();
+        if (!session)
+            throw new UserFacingError(UNLOCK_MSG);
+        try {
+            const result = await this.run(['sync'], session, {}, signal);
+            if (result.code !== 0)
+                throw new Error();
+        }
+        catch {
+            throw new UserFacingError('Bitwarden vault sync failed; check the private vault connection');
+        }
+        if (this.sessionKey !== session)
+            throw new UserFacingError(UNLOCK_MSG);
+        const data = await this.getItem(item, signal, true);
+        if (typeof data.id !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(data.id))
+            throw new UserFacingError('vault item has no stable item ID');
+        const normalize = (value) => value.toLowerCase().replace(/[ _-]/g, '');
+        const guildKeys = new Set(['guildid', 'serverid', 'discordguildid', 'discordserverid']);
+        const tokenKeys = new Set(['token', 'bottoken', 'discordtoken', 'discordbottoken']);
+        const guildIds = new Set(), fields = [];
+        const addGuild = (value) => {
+            if (typeof value !== 'string')
+                throw new UserFacingError('vault item has invalid Discord server metadata');
+            const id = value.trim().replace(/^[`"']|[`"']$/g, '');
+            if (!snowflake.safeParse(id).success)
+                throw new UserFacingError('vault item has invalid Discord server metadata');
+            guildIds.add(id);
+        };
+        const password = data.login?.password;
+        if (typeof password === 'string' && password)
+            fields.push({ kind: 'password' });
+        for (const field of Array.isArray(data.fields) ? data.fields : []) {
+            if (!field || typeof field !== 'object' || typeof field.name !== 'string')
+                continue;
+            const key = normalize(field.name);
+            if (guildKeys.has(key))
+                addGuild(field.value);
+            if (tokenKeys.has(key) && field.type === 1 && typeof field.value === 'string' && field.value)
+                fields.push(tokenFieldSchema.parse({ kind: 'hidden', name: field.name }));
+        }
+        if (typeof data.notes === 'string') {
+            for (const line of data.notes.split(/\r?\n/)) {
+                const match = /^\s*(?:[-*#]\s*)?([a-z _-]+)\s*[:=]\s*(.*?)\s*$/i.exec(line);
+                if (match && guildKeys.has(normalize(match[1].trim())))
+                    addGuild(match[2]);
+            }
+            try {
+                const object = JSON.parse(data.notes);
+                if (object && typeof object === 'object' && !Array.isArray(object))
+                    for (const [key, value] of Object.entries(object))
+                        if (guildKeys.has(normalize(key)))
+                            addGuild(value);
+            }
+            catch (e) {
+                if (e instanceof UserFacingError)
+                    throw e;
+            }
+        }
+        if (guildIds.size !== 1)
+            throw new UserFacingError('vault item does not contain one unambiguous labeled Discord server ID');
+        if (fields.length !== 1)
+            throw new UserFacingError('vault item does not contain one unambiguous password or named hidden bot-token field');
+        signal?.throwIfAborted();
+        this.lastUse = this.now();
+        return { item: data.id, guildId: [...guildIds][0], field: fields[0] };
+    }
+    /** Privileged service only. Never expose this method through IPC or MCP. */
+    async getToken(item, field, signal) {
+        const parsed = tokenFieldSchema.safeParse(field);
+        if (!parsed.success)
+            throw new UserFacingError('invalid token field');
+        const data = await this.getItem(item, signal, true);
+        let token;
+        if (field.kind === 'password')
+            token = data.login?.password;
+        else {
+            const fields = Array.isArray(data.fields) ? data.fields.filter(f => f && typeof f === 'object' && f.name === field.name) : [];
+            if (fields.length !== 1 || fields[0].type !== 1)
+                throw new UserFacingError('token field is missing or ambiguous');
+            token = fields[0].value;
+        }
+        if (typeof token !== 'string' || !token || token.length > 4096 || /[\s\p{Cc}\p{Cf}]/u.test(token))
+            throw new UserFacingError('token field is missing or invalid');
+        signal?.throwIfAborted();
+        this.lastUse = this.now();
+        return token;
+    }
+    async getLogin(item, signal) {
+        const data = await this.getItem(item, signal);
+        let login;
+        login = data.login;
         if (typeof login?.username !== 'string' || typeof login?.password !== 'string' || !login.username || !login.password) {
             throw new UserFacingError('item has no username/password');
         }