@rndmjoker/proton-mcp 0.4.4

package/dist/credentials/keyring.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Credentials in the operating system's keyring.
+ *
+ * @napi-rs/keyring is an optional dependency. On a platform without a prebuilt
+ * binary the install does not fail, this store simply becomes unavailable and
+ * the others remain. So the import has to be dynamic and its failure has to be
+ * an ordinary outcome rather than a crash.
+ *
+ * Every call here can block: a locked keyring opens a dialog, and the underlying
+ * calls are synchronous. Callers must treat this store as potentially
+ * unresponsive, see probeKeyring in availability.ts.
+ */
+import type { CredentialStore, Credentials } from './store.js';
+/** Identifies our entries in the keyring. */
+export declare const SERVICE_NAME = "proton-mcp";
+/** The account under which the Bridge credentials are stored. */
+export declare const ACCOUNT_NAME = "bridge";
+/** Minimal shape of what @napi-rs/keyring provides. */
+interface KeyringEntry {
+    setPassword(password: string): void;
+    getPassword(): string | null;
+    deletePassword(): boolean;
+}
+interface KeyringModule {
+    Entry: new (service: string, account: string) => KeyringEntry;
+}
+/**
+ * Loads the keyring module, or reports that it is not there.
+ *
+ * The result is cached, including the negative one: a missing optional
+ * dependency does not appear halfway through a session.
+ */
+export declare function loadKeyringModule(): Promise<KeyringModule | undefined>;
+/** For tests, which must not depend on what is installed here. */
+export declare function _setKeyringModule(module: KeyringModule | undefined): void;
+/** Resets the cache. For tests. */
+export declare function _resetKeyringModule(): void;
+export declare class KeyringStore implements CredentialStore {
+    #private;
+    private readonly service;
+    private readonly account;
+    readonly kind: 'keyring';
+    constructor(service?: string, account?: string);
+    load(): Promise<Credentials | undefined>;
+    save(credentials: Credentials): Promise<void>;
+    clear(): Promise<void>;
+}
+export {};

package/dist/credentials/keyring.js

@@ -0,0 +1,97 @@
+/**
+ * Credentials in the operating system's keyring.
+ *
+ * @napi-rs/keyring is an optional dependency. On a platform without a prebuilt
+ * binary the install does not fail, this store simply becomes unavailable and
+ * the others remain. So the import has to be dynamic and its failure has to be
+ * an ordinary outcome rather than a crash.
+ *
+ * Every call here can block: a locked keyring opens a dialog, and the underlying
+ * calls are synchronous. Callers must treat this store as potentially
+ * unresponsive, see probeKeyring in availability.ts.
+ */
+import { BridgeError } from '../bridge/errors.js';
+/** Identifies our entries in the keyring. */
+export const SERVICE_NAME = 'proton-mcp';
+/** The account under which the Bridge credentials are stored. */
+export const ACCOUNT_NAME = 'bridge';
+let cached = undefined;
+/**
+ * Loads the keyring module, or reports that it is not there.
+ *
+ * The result is cached, including the negative one: a missing optional
+ * dependency does not appear halfway through a session.
+ */
+export async function loadKeyringModule() {
+    if (cached !== undefined)
+        return cached ?? undefined;
+    try {
+        const module = (await import('@napi-rs/keyring'));
+        cached = module;
+        return module;
+    }
+    catch {
+        cached = null;
+        return undefined;
+    }
+}
+/** For tests, which must not depend on what is installed here. */
+export function _setKeyringModule(module) {
+    cached = module ?? null;
+}
+/** Resets the cache. For tests. */
+export function _resetKeyringModule() {
+    cached = undefined;
+}
+export class KeyringStore {
+    service;
+    account;
+    kind = 'keyring';
+    constructor(service = SERVICE_NAME, account = ACCOUNT_NAME) {
+        this.service = service;
+        this.account = account;
+    }
+    async #entry() {
+        const module = await loadKeyringModule();
+        if (!module) {
+            throw new BridgeError('The system keyring is not available in this installation. The optional dependency ' +
+                '@napi-rs/keyring has no prebuilt binary for this platform. Choose a different place ' +
+                'to keep the credentials.');
+        }
+        return new module.Entry(this.service, this.account);
+    }
+    async load() {
+        const entry = await this.#entry();
+        const raw = entry.getPassword();
+        if (!raw)
+            return undefined;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!parsed.user || !parsed.pass)
+                return undefined;
+            return { user: parsed.user, pass: parsed.pass };
+        }
+        catch {
+            // Someone or something wrote a value we cannot read. Treating it as
+            // absent lets the user simply sign in again.
+            return undefined;
+        }
+    }
+    async save(credentials) {
+        const entry = await this.#entry();
+        // Both values go into one entry: the keyring stores a single secret per
+        // account, and splitting them across two accounts would make a partial
+        // state possible.
+        entry.setPassword(JSON.stringify({ user: credentials.user, pass: credentials.pass }));
+    }
+    async clear() {
+        const entry = await this.#entry();
+        try {
+            entry.deletePassword();
+        }
+        catch {
+            // Nothing stored is the outcome we wanted anyway.
+        }
+    }
+}
+//# sourceMappingURL=keyring.js.map

package/dist/credentials/keyring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring.js","sourceRoot":"","sources":["../../src/credentials/keyring.ts"],"names":[],"mappings":"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"}

package/dist/credentials/plain-file.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Credentials in an unencrypted file.
+ *
+ * A fully supported option, not a leftover. It is the only one that never
+ * prompts for anything and can be written by a script, which is what makes it
+ * the choice for automated setups. The price is stated plainly: file permissions
+ * are all that protect it.
+ *
+ * This is also the format the server already reads on startup, so an existing
+ * setup keeps working.
+ */
+import type { CredentialStore, Credentials } from './store.js';
+export declare class PlainFileStore implements CredentialStore {
+    private readonly path;
+    /** Where warnings go. stderr, never stdout, which carries the protocol. */
+    private readonly notify;
+    readonly kind: 'plain-file';
+    constructor(path?: string, 
+    /** Where warnings go. stderr, never stdout, which carries the protocol. */
+    notify?: (message: string) => void);
+    load(): Promise<Credentials | undefined>;
+    save(credentials: Credentials): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/credentials/plain-file.js

@@ -0,0 +1,78 @@
+/**
+ * Credentials in an unencrypted file.
+ *
+ * A fully supported option, not a leftover. It is the only one that never
+ * prompts for anything and can be written by a script, which is what makes it
+ * the choice for automated setups. The price is stated plainly: file permissions
+ * are all that protect it.
+ *
+ * This is also the format the server already reads on startup, so an existing
+ * setup keeps working.
+ */
+import { readFile, writeFile, unlink, mkdir, stat, chmod } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { platform } from 'node:os';
+import { credentialsPath, parseEnvFile, permissionWarning } from '../config.js';
+export class PlainFileStore {
+    path;
+    notify;
+    kind = 'plain-file';
+    constructor(path = credentialsPath(), 
+    /** Where warnings go. stderr, never stdout, which carries the protocol. */
+    notify = () => undefined) {
+        this.path = path;
+        this.notify = notify;
+    }
+    async load() {
+        let content;
+        try {
+            content = await readFile(this.path, 'utf8');
+        }
+        catch {
+            return undefined;
+        }
+        if (platform() !== 'win32') {
+            try {
+                const warning = permissionWarning((await stat(this.path)).mode);
+                if (warning)
+                    this.notify(`${this.path}: ${warning}`);
+            }
+            catch {
+                // Failing to stat a file we just read is not worth reporting.
+            }
+        }
+        const values = parseEnvFile(content);
+        const user = values.BRIDGE_USER?.trim();
+        const pass = values.BRIDGE_PASS;
+        if (!user || !pass)
+            return undefined;
+        return { user, pass };
+    }
+    async save(credentials) {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        // Keep the shape a person can read and edit, since being editable by hand is
+        // half the point of this option.
+        const content = [
+            '# Proton Mail Bridge credentials for proton-mcp.',
+            '#',
+            '# BRIDGE_PASS is the password the Bridge generates, NOT your Proton account',
+            '# password. This file is unencrypted: its permissions are what protect it.',
+            `BRIDGE_USER=${credentials.user}`,
+            `BRIDGE_PASS=${credentials.pass}`,
+            '',
+        ].join('\n');
+        await writeFile(this.path, content, { mode: 0o600 });
+        // writeFile only applies the mode when it creates the file, so an existing
+        // one with loose permissions would silently keep them.
+        await chmod(this.path, 0o600);
+    }
+    async clear() {
+        try {
+            await unlink(this.path);
+        }
+        catch {
+            // Already gone is the outcome we wanted.
+        }
+    }
+}
+//# sourceMappingURL=plain-file.js.map

package/dist/credentials/plain-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-file.js","sourceRoot":"","sources":["../../src/credentials/plain-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAClF,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAE/E,MAAM,OAAO,cAAc;IAIN,IAAI;IAEJ,MAAM;IALhB,IAAI,GAAG,YAAqB,CAAA;IAErC,YACmB,IAAI,GAAW,eAAe,EAAE;IACjD,2EAA2E;IAC1D,MAAM,GAA8B,GAAG,EAAE,CAAC,SAAS;oBAFnD,IAAI;sBAEJ,MAAM;IACtB,CAAC;IAEJ,KAAK,CAAC,IAAI;QACR,IAAI,OAAe,CAAA;QACnB,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAC7C,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAA;QAClB,CAAC;QAED,IAAI,QAAQ,EAAE,KAAK,OAAO,EAAE,CAAC;YAC3B,IAAI,CAAC;gBACH,MAAM,OAAO,GAAG,iBAAiB,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;gBAC/D,IAAI,OAAO;oBAAE,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC,CAAA;YACtD,CAAC;YAAC,MAAM,CAAC;gBACP,8DAA8D;YAChE,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAA;QACpC,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,EAAE,IAAI,EAAE,CAAA;QACvC,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAA;QAC/B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAA;QACpC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;IACvB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,WAAwB;QACjC,MAAM,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;QAEjE,6EAA6E;QAC7E,iCAAiC;QACjC,MAAM,OAAO,GAAG;YACd,kDAAkD;YAClD,GAAG;YACH,6EAA6E;YAC7E,4EAA4E;YAC5E,eAAe,WAAW,CAAC,IAAI,EAAE;YACjC,eAAe,WAAW,CAAC,IAAI,EAAE;YACjC,EAAE;SACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAEZ,MAAM,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;QACpD,2EAA2E;QAC3E,uDAAuD;QACvD,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAC/B,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,yCAAyC;QAC3C,CAAC;IACH,CAAC;CACF"}

package/dist/credentials/probe-keyring.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Probes the system keyring, meant to be run as a child process.
+ *
+ * It lives in its own process for one reason: a locked keyring opens a dialog
+ * and the underlying calls are synchronous, so the probe may never return.
+ * A hanging process can be killed, a hanging call cannot.
+ *
+ * The result goes back over IPC. Nothing is written to stdout or stderr, because
+ * the parent speaks the MCP protocol over stdout.
+ */
+export {};

package/dist/credentials/probe-keyring.js

@@ -0,0 +1,57 @@
+/**
+ * Probes the system keyring, meant to be run as a child process.
+ *
+ * It lives in its own process for one reason: a locked keyring opens a dialog
+ * and the underlying calls are synchronous, so the probe may never return.
+ * A hanging process can be killed, a hanging call cannot.
+ *
+ * The result goes back over IPC. Nothing is written to stdout or stderr, because
+ * the parent speaks the MCP protocol over stdout.
+ */
+import { KeyringStore, loadKeyringModule } from './keyring.js';
+const SERVICE = 'proton-mcp-selftest';
+const ACCOUNT = 'availability-probe';
+function report(result) {
+    process.send?.(result);
+    // Exit right away. A keyring binding may keep handles open that would
+    // otherwise hold the process alive.
+    process.exit(0);
+}
+async function main() {
+    const module = await loadKeyringModule();
+    if (!module) {
+        report({
+            ok: false,
+            reason: 'the optional dependency @napi-rs/keyring is not installed, or has no prebuilt binary for ' +
+                'this platform.',
+        });
+        return;
+    }
+    // A separate service name, so the probe never touches the real entry.
+    const store = new KeyringStore(SERVICE, ACCOUNT);
+    const value = { user: 'probe', pass: `probe-${process.pid}` };
+    try {
+        const t0 = process.hrtime.bigint();
+        await store.save(value);
+        const writeMs = Number(process.hrtime.bigint() - t0) / 1e6;
+        const t1 = process.hrtime.bigint();
+        const readBack = await store.load();
+        const readMs = Number(process.hrtime.bigint() - t1) / 1e6;
+        // Clean up before reporting, so a failure below cannot leave the entry
+        // behind.
+        await store.clear();
+        if (readBack?.pass !== value.pass) {
+            report({
+                ok: false,
+                reason: 'the keyring accepted a value but returned something else when read back.',
+            });
+            return;
+        }
+        report({ ok: true, writeMs, readMs });
+    }
+    catch (error) {
+        report({ ok: false, reason: error?.message ?? String(error) });
+    }
+}
+void main();
+//# sourceMappingURL=probe-keyring.js.map

package/dist/credentials/probe-keyring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe-keyring.js","sourceRoot":"","sources":["../../src/credentials/probe-keyring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAG9D,MAAM,OAAO,GAAG,qBAAqB,CAAA;AACrC,MAAM,OAAO,GAAG,oBAAoB,CAAA;AAEpC,SAAS,MAAM,CAAC,MAAmB;IACjC,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAA;IACtB,sEAAsE;IACtE,oCAAoC;IACpC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACjB,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,MAAM,MAAM,GAAG,MAAM,iBAAiB,EAAE,CAAA;IACxC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,CAAC;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EACJ,2FAA2F;gBAC3F,gBAAgB;SACnB,CAAC,CAAA;QACF,OAAM;IACR,CAAC;IAED,sEAAsE;IACtE,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IAChD,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,OAAO,CAAC,GAAG,EAAE,EAAE,CAAA;IAE7D,IAAI,CAAC;QACH,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAA;QAClC,MAAM,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACvB,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAA;QAE1D,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAA;QAClC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,EAAE,CAAA;QACnC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAA;QAEzD,uEAAuE;QACvE,UAAU;QACV,MAAM,KAAK,CAAC,KAAK,EAAE,CAAA;QAEnB,IAAI,QAAQ,EAAE,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;YAClC,MAAM,CAAC;gBACL,EAAE,EAAE,KAAK;gBACT,MAAM,EAAE,0EAA0E;aACnF,CAAC,CAAA;YACF,OAAM;QACR,CAAC;QAED,MAAM,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAA;IACvC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAG,KAAe,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAC3E,CAAC;AACH,CAAC;AAED,KAAK,IAAI,EAAE,CAAA"}

package/dist/credentials/session.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Credentials held in memory only.
+ *
+ * The safest option and the least convenient: nothing reaches the disk, and
+ * nothing survives the process. For most clients that means signing in again
+ * for every conversation, because they start the server anew each time.
+ */
+import type { CredentialStore, Credentials } from './store.js';
+export declare class SessionStore implements CredentialStore {
+    #private;
+    readonly kind: 'session';
+    load(): Promise<Credentials | undefined>;
+    save(credentials: Credentials): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/credentials/session.js

@@ -0,0 +1,21 @@
+/**
+ * Credentials held in memory only.
+ *
+ * The safest option and the least convenient: nothing reaches the disk, and
+ * nothing survives the process. For most clients that means signing in again
+ * for every conversation, because they start the server anew each time.
+ */
+export class SessionStore {
+    kind = 'session';
+    #held;
+    async load() {
+        return this.#held;
+    }
+    async save(credentials) {
+        this.#held = { user: credentials.user, pass: credentials.pass };
+    }
+    async clear() {
+        this.#held = undefined;
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/credentials/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/credentials/session.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,OAAO,YAAY;IACd,IAAI,GAAG,SAAkB,CAAA;IAClC,KAAK,CAAyB;IAE9B,KAAK,CAAC,IAAI;QACR,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,WAAwB;QACjC,IAAI,CAAC,KAAK,GAAG,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAA;IACjE,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,KAAK,GAAG,SAAS,CAAA;IACxB,CAAC;CACF"}

package/dist/credentials/store.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Where the Bridge credentials live.
+ *
+ * The user chooses, because the trade-off is theirs to make. All four options
+ * are fully supported: none of them is a second-class fallback, and none is
+ * presented as the obvious answer. What differs is which drawback you accept.
+ *
+ * Each option therefore states both sides plus who it is actually for, and one
+ * factual property that makes them comparable without prose: what ends up on
+ * disk.
+ *
+ * One property shapes the whole module: reading from a system keyring can
+ * **block**. A locked KWallet or GNOME Keyring opens a dialog, and the calls in
+ * @napi-rs/keyring are synchronous, so there is no way to abandon one from the
+ * same thread. Anything that touches a keyring therefore has to assume it may
+ * never return, which is why the availability probe runs in a child process.
+ */
+export interface Credentials {
+    user: string;
+    pass: string;
+}
+/** The ways credentials can be kept. */
+export type StoreKind = 'keyring' | 'session' | 'encrypted-file' | 'plain-file';
+export interface CredentialStore {
+    readonly kind: StoreKind;
+    /** Returns the credentials, or undefined when none are stored. */
+    load(): Promise<Credentials | undefined>;
+    save(credentials: Credentials): Promise<void>;
+    /** Removes what is stored. Succeeds even when nothing was there. */
+    clear(): Promise<void>;
+    /**
+     * Whether something is stored, without unlocking it.
+     *
+     * Only the encrypted file implements this, and it is the reason the method
+     * exists: it is the one store that can hold credentials the server cannot
+     * read on its own. The interface has to tell "nothing stored" from "stored
+     * but locked", because the first calls for the full sign-in form and the
+     * second only for a master password.
+     */
+    exists?(): Promise<boolean>;
+}
+/**
+ * What lands on disk. The one property that makes the options comparable
+ * without reading three paragraphs.
+ */
+export type DiskExposure = 
+/** Nothing at all. */
+'none'
+/** Encrypted with a key that is not stored anywhere. */
+ | 'encrypted'
+/** Protected by the operating system, readable by your account. */
+ | 'os-protected'
+/** Readable by anything that can read your files. */
+ | 'plaintext';
+/** What the user is told about an option before choosing it. */
+export interface StoreDescription {
+    kind: StoreKind;
+    title: string;
+    /** One sentence on what it does. */
+    summary: string;
+    /** What it is good at. */
+    benefit: string;
+    /** What it costs. Every option has something. */
+    cost: string;
+    /** Who should pick this one. */
+    bestFor: string;
+    exposure: DiskExposure;
+    /** How often you have to type something to use the server. */
+    prompts: 'never' | 'once per server start' | 'occasionally';
+}
+export declare const EXPOSURE_LABELS: Record<DiskExposure, string>;
+export declare const STORE_DESCRIPTIONS: Record<StoreKind, StoreDescription>;
+/**
+ * The order options are presented in: least exposed first.
+ *
+ * Not a ranking of quality. It puts the security-relevant difference in front,
+ * so that choosing convenience is a conscious step down the list rather than
+ * something that happens by accident.
+ */
+export declare const PRESENTATION_ORDER: StoreKind[];

package/dist/credentials/store.js

@@ -0,0 +1,94 @@
+/**
+ * Where the Bridge credentials live.
+ *
+ * The user chooses, because the trade-off is theirs to make. All four options
+ * are fully supported: none of them is a second-class fallback, and none is
+ * presented as the obvious answer. What differs is which drawback you accept.
+ *
+ * Each option therefore states both sides plus who it is actually for, and one
+ * factual property that makes them comparable without prose: what ends up on
+ * disk.
+ *
+ * One property shapes the whole module: reading from a system keyring can
+ * **block**. A locked KWallet or GNOME Keyring opens a dialog, and the calls in
+ * @napi-rs/keyring are synchronous, so there is no way to abandon one from the
+ * same thread. Anything that touches a keyring therefore has to assume it may
+ * never return, which is why the availability probe runs in a child process.
+ */
+export const EXPOSURE_LABELS = {
+    none: 'nothing on disk',
+    encrypted: 'encrypted on disk',
+    'os-protected': 'on disk, protected by the operating system',
+    plaintext: 'unencrypted on disk',
+};
+export const STORE_DESCRIPTIONS = {
+    keyring: {
+        kind: 'keyring',
+        title: 'System keyring',
+        summary: 'The password goes where the operating system keeps your other passwords: Credential Manager ' +
+            'on Windows, Keychain on macOS, GNOME Keyring or KWallet on Linux.',
+        benefit: 'Nothing to type after the first sign-in, and the password is protected by the same mechanism ' +
+            'as the rest of your logins. It is also the only option where the secret is not simply a file ' +
+            'you could accidentally copy into a backup or a shared folder.',
+        cost: 'Needs a running keyring service, which a container, a plain SSH session or WSL usually lacks. ' +
+            'On macOS the permission is tied to the code hash of the node binary, so after a Node update ' +
+            'the system asks for your login password again. Reading it can also block if the keyring is ' +
+            'locked.',
+        bestFor: 'A desktop machine you use yourself. This is the ordinary case.',
+        exposure: 'os-protected',
+        prompts: 'occasionally',
+    },
+    'encrypted-file': {
+        kind: 'encrypted-file',
+        title: 'Encrypted file',
+        summary: 'The password is encrypted with a master password of your choosing and written into your user ' +
+            'directory.',
+        benefit: 'Works everywhere, with no system service and no graphical session, so it is the one option ' +
+            'that behaves identically on every platform. Even if someone copies the file, it is useless ' +
+            'without your master password.',
+        cost: 'You type the master password every time the server starts. Forget it and the stored password ' +
+            'is gone for good, since nothing anywhere can decrypt it. And a master password you can ' +
+            'remember is usually weaker than one the operating system would have generated.',
+        bestFor: 'Servers, containers, headless machines, and anyone who would rather type something than ' +
+            'depend on a system service.',
+        exposure: 'encrypted',
+        prompts: 'once per server start',
+    },
+    session: {
+        kind: 'session',
+        title: 'This session only',
+        summary: 'Nothing is stored. The password is held in memory and forgotten when the server stops.',
+        benefit: 'Nothing to find, on disk or elsewhere. A stolen laptop, a backup or a misplaced file cannot ' +
+            'give the password away, because there is nothing to give away.',
+        cost: 'You sign in again whenever the server starts, which for most clients means every new ' +
+            'conversation. In practice this is the option people abandon after a few days.',
+        bestFor: 'A shared or untrusted machine, a one-off look at a mailbox, or anyone who genuinely wants ' +
+            'nothing left behind.',
+        exposure: 'none',
+        prompts: 'once per server start',
+    },
+    'plain-file': {
+        kind: 'plain-file',
+        title: 'Plain file',
+        summary: 'The password sits unencrypted in a file in your user directory, readable only by your ' +
+            'account.',
+        benefit: 'The simplest thing that works. No service, no master password, no prompts ever, and you can ' +
+            'read and edit it with any text editor, which makes it the easiest to script and to debug.',
+        cost: 'Anything that can read your files can read the password: a backup tool, a synchronised ' +
+            'folder, another program running as you, or anyone who gets hold of the disk. File ' +
+            'permissions are the only thing protecting it.',
+        bestFor: 'Automation and scripted setups where no one can type a password, on a machine you control ' +
+            'and whose backups you trust.',
+        exposure: 'plaintext',
+        prompts: 'never',
+    },
+};
+/**
+ * The order options are presented in: least exposed first.
+ *
+ * Not a ranking of quality. It puts the security-relevant difference in front,
+ * so that choosing convenience is a conscious step down the list rather than
+ * something that happens by accident.
+ */
+export const PRESENTATION_ORDER = ['session', 'keyring', 'encrypted-file', 'plain-file'];
+//# sourceMappingURL=store.js.map

package/dist/credentials/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/credentials/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AA4DH,MAAM,CAAC,MAAM,eAAe,GAAiC;IAC3D,IAAI,EAAE,iBAAiB;IACvB,SAAS,EAAE,mBAAmB;IAC9B,cAAc,EAAE,4CAA4C;IAC5D,SAAS,EAAE,qBAAqB;CACjC,CAAA;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAwC;IACrE,OAAO,EAAE;QACP,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,gBAAgB;QACvB,OAAO,EACL,8FAA8F;YAC9F,mEAAmE;QACrE,OAAO,EACL,+FAA+F;YAC/F,+FAA+F;YAC/F,+DAA+D;QACjE,IAAI,EACF,gGAAgG;YAChG,8FAA8F;YAC9F,6FAA6F;YAC7F,SAAS;QACX,OAAO,EAAE,gEAAgE;QACzE,QAAQ,EAAE,cAAc;QACxB,OAAO,EAAE,cAAc;KACxB;IACD,gBAAgB,EAAE;QAChB,IAAI,EAAE,gBAAgB;QACtB,KAAK,EAAE,gBAAgB;QACvB,OAAO,EACL,+FAA+F;YAC/F,YAAY;QACd,OAAO,EACL,6FAA6F;YAC7F,6FAA6F;YAC7F,+BAA+B;QACjC,IAAI,EACF,+FAA+F;YAC/F,yFAAyF;YACzF,gFAAgF;QAClF,OAAO,EACL,0FAA0F;YAC1F,6BAA6B;QAC/B,QAAQ,EAAE,WAAW;QACrB,OAAO,EAAE,uBAAuB;KACjC;IACD,OAAO,EAAE;QACP,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,mBAAmB;QAC1B,OAAO,EAAE,wFAAwF;QACjG,OAAO,EACL,8FAA8F;YAC9F,gEAAgE;QAClE,IAAI,EACF,uFAAuF;YACvF,+EAA+E;QACjF,OAAO,EACL,4FAA4F;YAC5F,sBAAsB;QACxB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,uBAAuB;KACjC;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,YAAY;QAClB,KAAK,EAAE,YAAY;QACnB,OAAO,EACL,wFAAwF;YACxF,UAAU;QACZ,OAAO,EACL,8FAA8F;YAC9F,2FAA2F;QAC7F,IAAI,EACF,yFAAyF;YACzF,oFAAoF;YACpF,+CAA+C;QACjD,OAAO,EACL,4FAA4F;YAC5F,8BAA8B;QAChC,QAAQ,EAAE,WAAW;QACrB,OAAO,EAAE,OAAO;KACjB;CACF,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAA"}

package/dist/in-flight.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bookkeeping for tool calls that are still running.
+ *
+ * Background: a stdio server learns that its client is gone by its input
+ * stream ending. If it exits right away it cuts off calls that are still in
+ * progress and their answer is lost. If it waits forever it hangs whenever a
+ * call never returns.
+ *
+ * Hence: keep count, and wait for a bounded grace period on shutdown.
+ */
+/** How many calls are currently running. For tests and diagnostics only. */
+export declare function inFlightCount(): number;
+/**
+ * Wraps a tool call so that shutdown waits for it.
+ *
+ * The counter is also released on failure. Otherwise a single failed call
+ * would keep the server from ever shutting down.
+ *
+ * Also the one place every tool call passes through, so it is where the status
+ * page gets its record of what is running and what happened. Only the tool name
+ * is passed on, never the arguments: see activity.ts for why.
+ */
+export declare function track<T>(fn: () => Promise<T>, tool?: string): Promise<T>;
+/**
+ * Waits until no call is running any more, but at most `maxMs`.
+ *
+ * Returns true when things really went quiet and false when the deadline
+ * passed. The return value lets the caller record that it gave up instead of
+ * hiding it.
+ */
+export declare function waitForIdle(maxMs?: number): Promise<boolean>;
+/** Resets the state. For tests only. */
+export declare function _reset(): void;