dsh-subscriptions 0.1.0

package/lib/auth/rpc.js

@@ -0,0 +1,386 @@
+/**
+ * The `subscriptions-auth` host RPC endpoints the web Settings page drives.
+ * They are mounted as exact POST Fetch routes on the shared `/api` channel
+ * (`/api/subscriptions-auth.<endpoint>`) and registered only when a host
+ * `connection` service exists (the web profile); headless compositions load
+ * the plugin without it. All business outcomes are returned as RpcResult
+ * values; handlers never throw.
+ */
+import { AttachmentId } from '@deepseek-ai/dsh-attachment';
+import { PROVIDER_IDS } from './store.js';
+import { EXTERNAL_USAGE_SOURCES } from '../providers/external-usage-controller.js';
+/**
+ * Endpoint-name prefix under the shared `/api` channel: endpoint `status`
+ * is served at `/api/subscriptions-auth.status`. The browser half calls
+ * `rpc.call('/api', 'subscriptions-auth.status', payload)`.
+ */
+export const SUBSCRIPTIONS_AUTH_PREFIX = 'subscriptions-auth.';
+/**
+ * Every endpoint {@link dispatch} answers; each gets one exact Fetch route.
+ * Kept in one place so the route table and the switch cannot drift apart.
+ */
+export const SUBSCRIPTIONS_AUTH_ENDPOINTS = [
+    'providerSettings', 'setProviderSettings',
+    'status', 'login', 'manual', 'cancel', 'logout', 'setDefault', 'usage',
+    'externalStatus', 'externalUsage',
+    'cursorStatus', 'cursorLogin', 'cursorCancel', 'cursorLogout', 'cursorUsage', 'cursorModels',
+    'cursorSettings', 'cursorSetSettings',
+    'image', 'video',
+    'speed', 'setSpeed',
+    'modelDefaults', 'setModelDefault',
+];
+/** Media types the attachment store accepts (ImageMediaType). */
+const IMAGE_MEDIA_TYPES = ['image/png', 'image/jpeg', 'image/webp', 'image/gif'];
+/** Bare MP4 file names the `video` endpoint accepts (no path separators). */
+const VIDEO_NAME_PATTERN = /^[\w.-]+\.mp4$/;
+/** Payload carried no usable provider id — an RPC client bug, not a server failure. */
+export class BadRequest extends Error {
+}
+function readEnvelope(body) {
+    if (typeof body !== 'object' || body === null)
+        return undefined;
+    const record = body;
+    if (record.type !== 'client-request' || typeof record.rpcId !== 'string' || typeof record.method !== 'string')
+        return undefined;
+    return { type: 'client-request', rpcId: record.rpcId, method: record.method, payload: record.payload };
+}
+function serverResponse(rpcId, result) {
+    return Response.json({ type: 'server-response', rpcId, result });
+}
+/**
+ * Wrap one endpoint's RPC handler as an exact Fetch route: decode the
+ * `client-request` envelope the browser rpc caller posts, run the handler,
+ * and answer with the matching `server-response` envelope — the same wire
+ * contract the dedicated-channel bridge used to apply, reproduced here so
+ * `rpc.call('/api', 'subscriptions-auth.<endpoint>', payload)` keeps working
+ * unchanged on the browser side.
+ */
+function fetchRouteFor(endpoint, handler) {
+    const method = `${SUBSCRIPTIONS_AUTH_PREFIX}${endpoint}`;
+    return {
+        path: `/api/${method}`,
+        methods: ['POST'],
+        requestBody: 'buffered',
+        fetch: async (request) => {
+            if (request.headers.get('content-type')?.split(';', 1)[0]?.trim().toLowerCase() !== 'application/json') {
+                return new Response('content type must be application/json', { status: 415 });
+            }
+            let body;
+            try {
+                body = await request.json();
+            }
+            catch {
+                return new Response('body is not JSON', { status: 400 });
+            }
+            const envelope = readEnvelope(body);
+            if (envelope === undefined) {
+                const rawId = body?.rpcId;
+                return serverResponse(typeof rawId === 'string' ? rawId : 'invalid-request', {
+                    ok: false,
+                    error: { code: 'gateway/bad-request', message: 'invalid client-request message', details: { issues: [] } },
+                });
+            }
+            if (envelope.method !== method) {
+                return serverResponse(envelope.rpcId, {
+                    ok: false,
+                    error: {
+                        code: 'gateway/bad-request',
+                        message: `method ${JSON.stringify(envelope.method)} does not match endpoint ${JSON.stringify(method)}`,
+                        details: { issues: [] },
+                    },
+                });
+            }
+            return serverResponse(envelope.rpcId, await handler(endpoint, envelope.payload, request.signal));
+        },
+    };
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function failure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof BadRequest) {
+        // The issues array is zod-shaped upstream; this channel validates by hand.
+        return { ok: false, error: { code: 'bad-request', message, details: { issues: [] } } };
+    }
+    return { ok: false, error: { code: 'internal', message, details: {} } };
+}
+function readProvider(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        throw new BadRequest('payload must be an object');
+    const provider = payload.provider;
+    if (typeof provider !== 'string' || !PROVIDER_IDS.includes(provider)) {
+        throw new BadRequest(`payload.provider must be one of ${PROVIDER_IDS.join(', ')}`);
+    }
+    return provider;
+}
+function readString(payload, field) {
+    const value = payload[field];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new BadRequest(`payload.${field} must be a non-empty string`);
+    }
+    return value;
+}
+/** Validate the `setModelDefault` endpoint's payload. */
+function readModelDefaultInput(payload) {
+    const provider = readProvider(payload);
+    const model = readString(payload, 'model');
+    const record = payload;
+    let effort;
+    if (record.effort !== undefined) {
+        if (typeof record.effort !== 'string' || record.effort.length === 0) {
+            throw new BadRequest('payload.effort must be a non-empty string when present');
+        }
+        effort = record.effort;
+    }
+    return {
+        provider,
+        model,
+        ...(effort === undefined ? {} : { effort }),
+    };
+}
+/** Validate the optional Claude login method. */
+function readLoginMethod(payload, provider) {
+    const method = payload.method;
+    if (method === undefined)
+        return undefined;
+    if (provider !== 'claude')
+        throw new BadRequest('payload.method is only valid for claude');
+    if (method !== 'oauth' && method !== 'keychain') {
+        throw new BadRequest('payload.method must be "oauth" or "keychain"');
+    }
+    return method;
+}
+/** Validate the `setSpeed` endpoint's tier. */
+function readSpeedTier(payload) {
+    const tier = payload.tier;
+    if (tier !== 'standard' && tier !== 'fast') {
+        throw new BadRequest('payload.tier must be "standard" or "fast"');
+    }
+    return tier;
+}
+/** Validate the `image` endpoint's payload into a full attachment reference. */
+function readImageRef(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        throw new BadRequest('payload must be an object');
+    const record = payload;
+    const attachmentId = record.attachmentId;
+    if (typeof attachmentId !== 'string' || attachmentId.length === 0) {
+        throw new BadRequest('payload.attachmentId must be a non-empty string');
+    }
+    const mediaType = record.mediaType;
+    if (typeof mediaType !== 'string' || !IMAGE_MEDIA_TYPES.includes(mediaType)) {
+        throw new BadRequest(`payload.mediaType must be one of ${IMAGE_MEDIA_TYPES.join(', ')}`);
+    }
+    for (const field of ['bytes', 'width', 'height']) {
+        const value = record[field];
+        if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
+            throw new BadRequest(`payload.${field} must be a positive integer`);
+        }
+    }
+    const name = record.name;
+    if (name !== undefined && typeof name !== 'string') {
+        throw new BadRequest('payload.name must be a string when present');
+    }
+    return {
+        attachmentId: AttachmentId(attachmentId),
+        mediaType: mediaType,
+        bytes: record.bytes,
+        width: record.width,
+        height: record.height,
+        ...name === undefined ? {} : { name: name },
+    };
+}
+/**
+ * Validate the `video` endpoint's payload into a bare file name. Rejecting
+ * anything with a path separator (the pattern allows none) pins every read
+ * inside the plugin's videos directory.
+ */
+function readVideoName(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        throw new BadRequest('payload must be an object');
+    const name = payload.name;
+    if (typeof name !== 'string' || !VIDEO_NAME_PATTERN.test(name)) {
+        throw new BadRequest('payload.name must be a bare .mp4 file name');
+    }
+    return name;
+}
+/** Validate the usage/model catalog endpoints' optional force flag. */
+function readForce(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return false;
+    const force = payload.force;
+    if (force === undefined)
+        return false;
+    if (typeof force !== 'boolean')
+        throw new BadRequest('payload.force must be a boolean when present');
+    return force;
+}
+/** Validate the session id both speed endpoints carry. */
+function readSessionId(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        throw new BadRequest('payload must be an object');
+    return readString(payload, 'sessionId');
+}
+async function dispatch(controller, speed, modelDefaults, endpoint, payload, signal, providerSettings, externalUsage, cursor) {
+    switch (endpoint) {
+        case 'providerSettings':
+            if (!providerSettings)
+                throw new BadRequest('provider settings are unavailable');
+            return ok(await providerSettings.get(readProvider(payload), readForce(payload)));
+        case 'setProviderSettings': {
+            if (!providerSettings)
+                throw new BadRequest('provider settings are unavailable');
+            const provider = readProvider(payload);
+            await providerSettings.set(provider, payload.settings);
+            return ok({ ok: true });
+        }
+        case 'status': {
+            // One provider's failure (a corrupt store entry, a broken flow) must not
+            // blind the whole page: it degrades to an error detail on that provider
+            // while the others still report their real status.
+            const entries = await Promise.all(PROVIDER_IDS.map(async (provider) => [provider, await controller.status(provider).catch((error) => ({
+                    busy: false,
+                    accounts: [],
+                    detail: error instanceof Error ? error.message : String(error),
+                }))]));
+            return ok({ providers: Object.fromEntries(entries) });
+        }
+        case 'login': {
+            const provider = readProvider(payload);
+            return ok(await controller.login(provider, readLoginMethod(payload, provider)));
+        }
+        case 'manual': {
+            const provider = readProvider(payload);
+            await controller.manual(provider, readString(payload, 'input'));
+            return ok({ ok: true });
+        }
+        case 'cancel':
+            await controller.cancel(readProvider(payload));
+            return ok({ ok: true });
+        case 'logout': {
+            const provider = readProvider(payload);
+            await controller.logout(provider, readString(payload, 'account'));
+            return ok({ ok: true });
+        }
+        case 'setDefault': {
+            const provider = readProvider(payload);
+            await controller.setDefault(provider, readString(payload, 'account'));
+            return ok({ ok: true });
+        }
+        case 'usage': {
+            const provider = readProvider(payload);
+            return ok(await controller.usage(provider, readString(payload, 'account'), signal, readForce(payload)));
+        }
+        case 'externalStatus':
+            if (!externalUsage)
+                throw new BadRequest('external usage is unavailable');
+            return ok(await externalUsage.status());
+        case 'externalUsage': {
+            if (!externalUsage)
+                throw new BadRequest('external usage is unavailable');
+            const source = readString(payload, 'source');
+            if (!EXTERNAL_USAGE_SOURCES.includes(source)) {
+                throw new BadRequest(`payload.source must be one of ${EXTERNAL_USAGE_SOURCES.join(', ')}`);
+            }
+            return ok(await externalUsage.usage(source, signal));
+        }
+        case 'cursorStatus':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            return ok(await cursor.status());
+        case 'cursorLogin':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            return ok(await cursor.login());
+        case 'cursorCancel':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            await cursor.cancel();
+            return ok({ ok: true });
+        case 'cursorLogout':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            await cursor.logout();
+            return ok({ ok: true });
+        case 'cursorUsage':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            return ok(await cursor.usage(signal));
+        case 'cursorModels':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            return ok(await cursor.models(readForce(payload), signal));
+        case 'cursorSettings':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            return ok(await cursor.settings(readForce(payload), signal));
+        case 'cursorSetSettings':
+            if (!cursor)
+                throw new BadRequest('Cursor account is unavailable');
+            if (payload === null || typeof payload !== 'object')
+                throw new BadRequest('payload must be an object');
+            await cursor.setSettings(payload.settings);
+            return ok({ ok: true });
+        case 'image':
+            return ok(await controller.readImage(readImageRef(payload), signal));
+        case 'video':
+            return ok(await controller.readVideo(readVideoName(payload), signal));
+        case 'speed':
+            return ok(await speed.speed(readSessionId(payload)));
+        case 'setSpeed':
+            await speed.setSpeed(readSessionId(payload), readSpeedTier(payload));
+            return ok({ ok: true });
+        case 'modelDefaults': {
+            if (modelDefaults === undefined)
+                throw new BadRequest('model defaults are unavailable');
+            return ok(await modelDefaults.catalog(readForce(payload)));
+        }
+        case 'setModelDefault':
+            if (modelDefaults === undefined)
+                throw new BadRequest('model defaults are unavailable');
+            {
+                const input = readModelDefaultInput(payload);
+                await modelDefaults.set(input.provider, input.model, input.effort);
+            }
+            return ok({ ok: true });
+        default:
+            throw new BadRequest(`unknown /subscriptions-auth endpoint "${endpoint}"`);
+    }
+}
+/**
+ * Register the `/subscriptions-auth` RPC channel when a host connection exists.
+ * @param ctx - the plugin context (headless profiles have no `connection`).
+ * @param controller - the auth operations backing the endpoints.
+ * @param speed - the per-session speed-tier state backing the Speed toggle.
+ * @param modelDefaults - optional per-model default-effort state backing `modelDefaults`/`setModelDefault`.
+ */
+export function registerAuthRpc(ctx, controller, speed, modelDefaults = undefined, providerSettings = undefined, externalUsage = undefined, cursor = undefined) {
+    // `connection` is not in this plugin's inject list (headless compositions
+    // lack it), so its startup order is unconstrained: defer registration until
+    // the service exists instead of probing once at apply time.
+    //
+    // Exact Fetch routes under `/api` rather than a dedicated `rpc.handle`
+    // channel: since dsh 0.1.5 the connection plugin no longer injects
+    // `webServer` itself, and `rpc.handle` resolves `webServer` through the
+    // connection plugin's own fiber, so every dedicated channel registration
+    // throws `cannot get property "webServer" without inject`. The `/api`
+    // route is mounted by the connection plugin (with its own webServer scope)
+    // and applies the same trust fence and browser authentication, so exact
+    // routes below it work on both dsh lines.
+    ctx.inject(['connection'], (ctx) => {
+        const connection = ctx.get('connection');
+        const handler = async (endpoint, payload, signal) => {
+            try {
+                return await dispatch(controller, speed, modelDefaults, endpoint, payload, signal, providerSettings, externalUsage, cursor);
+            }
+            catch (error) {
+                return failure(error);
+            }
+        };
+        const register = connection.fetch.register;
+        for (const endpoint of SUBSCRIPTIONS_AUTH_ENDPOINTS) {
+            ctx.effect(() => register(fetchRouteFor(endpoint, handler)), `dsh-subscriptions: /api/${SUBSCRIPTIONS_AUTH_PREFIX}${endpoint} route`);
+        }
+    });
+}

package/lib/auth/store.d.ts

@@ -0,0 +1,196 @@
+/**
+ * On-disk OAuth session store at `~/.dsh/plugins/subscriptions/auth.json`.
+ *
+ * The file is a JSON object keyed by provider id, each entry holding that
+ * provider's ACCOUNTS: a map of account key → session plus the default
+ * account's key. Writes are atomic (tmp file + rename) with mode 0600
+ * because they carry bearer tokens. Session shapes live here (not in the
+ * provider modules) because this file owns the durable format.
+ *
+ * Backward compatibility: entries written by single-account versions hold
+ * the session fields directly (no `accounts` wrapper); reads migrate them
+ * in memory, and the next write persists the new shape — existing logins
+ * survive the upgrade untouched.
+ */
+/** Provider routes this plugin can serve. */
+export type ProviderId = 'codex' | 'claude' | 'grok' | 'copilot' | 'antigravity';
+/** Every provider route, in display order. */
+export declare const PROVIDER_IDS: readonly ProviderId[];
+/** Stored ChatGPT/Codex subscription session. */
+export interface CodexSession {
+    accessToken: string;
+    refreshToken: string;
+    /** Epoch milliseconds at which the access token expires. */
+    expiresAt: number;
+    /** `chatgpt_account_id` claim from the id token; sent as the `chatgpt-account-id` header. */
+    accountId: string;
+    idToken?: string;
+    /** User email from the id token, when the token carried it. */
+    emailAddress?: string;
+    /** `chatgpt_plan_type` claim from the id token (e.g. `plus`, `pro`), when present. */
+    planType?: string;
+}
+/** Stored Claude Pro/Max subscription session. */
+export interface ClaudeSession {
+    accessToken: string;
+    refreshToken: string;
+    /** Epoch milliseconds at which the access token expires. */
+    expiresAt: number;
+    /** Scope string the tokens were issued with; echoed on refresh. */
+    scopes: string;
+    emailAddress?: string;
+    subscriptionType?: string;
+    /**
+     * True when this account was imported from Claude Code's own credential
+     * store (Keychain/file): only bound accounts sync refreshes back to it.
+     */
+    keychainBound?: boolean;
+}
+/** Stored Grok (X Premium / xAI) subscription session. */
+export interface GrokSession {
+    accessToken: string;
+    refreshToken: string;
+    /** Epoch milliseconds at which the access token expires. */
+    expiresAt: number;
+    /** Token endpoint from OIDC discovery; retained for refreshes. */
+    tokenEndpoint: string;
+    scopes?: string;
+    /** Display account: email, username, or subject claim from the id token. */
+    account?: string;
+}
+/**
+ * Stored GitHub Copilot subscription session. Two token generations are at
+ * play: the long-lived GitHub OAuth token from the device flow is kept in
+ * `refreshToken`, and `accessToken` carries the short-lived (~30 minutes)
+ * Copilot API token exchanged from it. A "refresh" is therefore a fresh
+ * exchange against `copilot_internal/v2/token`, not an OAuth grant.
+ */
+export interface CopilotSession {
+    /** Copilot API token; sent as the bearer on api.githubcopilot.com. */
+    accessToken: string;
+    /** Long-lived GitHub OAuth token from the device flow. */
+    refreshToken: string;
+    /** Epoch milliseconds at which the Copilot API token expires. */
+    expiresAt: number;
+    /** GitHub login name, for the status display. */
+    account?: string;
+}
+/** Stored Google OAuth session for the Antigravity v1internal API. */
+export interface AntigravitySession {
+    accessToken: string;
+    refreshToken: string;
+    /** Epoch milliseconds at which the Google access token expires. */
+    expiresAt: number;
+    /** Cloud AI Companion project required by Antigravity request envelopes. */
+    projectId: string;
+    /** Google account email, for the status display. */
+    account?: string;
+    /** Subscription tier observed during project discovery. */
+    plan?: string;
+    /** Granted Google OAuth scopes, when the token endpoint returned them. */
+    scopes?: string;
+}
+/** One provider's accounts: account key → session, plus the default account. */
+export interface ProviderAccounts<S> {
+    /** Key of the account direct (non-pool) routes serve; the first login wins. */
+    default?: string;
+    accounts: Record<string, S>;
+    /** Old keys remain bound to their migrated account, never a workspace sibling. */
+    aliases?: Record<string, string>;
+}
+/** The durable store shape: per provider, its accounts. */
+export interface SessionMap {
+    codex?: ProviderAccounts<CodexSession>;
+    claude?: ProviderAccounts<ClaudeSession>;
+    grok?: ProviderAccounts<GrokSession>;
+    copilot?: ProviderAccounts<CopilotSession>;
+    antigravity?: ProviderAccounts<AntigravitySession>;
+}
+/** Any stored session, for provider-agnostic plumbing. */
+export type StoredSession = CodexSession | ClaudeSession | GrokSession | CopilotSession | AntigravitySession;
+/** The session type one provider stores. */
+export type SessionOf<K extends ProviderId> = NonNullable<SessionMap[K]>['accounts'][string];
+/** One account entry as returned by {@link listAccounts} (default first). */
+export interface AccountEntry<S> {
+    key: string;
+    session: S;
+}
+/**
+ * The stable identity of one session's account: Codex keys on workspace AND
+ * user (email fallback, workspace-only for unidentified legacy sessions),
+ * the others on their display identity, falling
+ * back to a refresh-token hash for sessions stored before identity fields
+ * existed. Logging the same account in again lands on the same key, so a
+ * re-login updates in place instead of duplicating. (The hash fallback can
+ * miss that dedup once for a legacy session re-logged with a now-known
+ * identity — the duplicate is visible on the Settings page and can simply
+ * be logged out.)
+ * @param provider - the provider route.
+ * @param session - the session to key.
+ * @returns the account map key.
+ */
+export declare function accountKeyOf(provider: ProviderId, session: StoredSession): string;
+/**
+ * Resolve a persisted legacy account key to its canonical account identity.
+ * For Codex, a reference that matches no key or alias also resolves through
+ * a unique login email or workspace ID (see {@link resolveCodexReference}).
+ */
+export declare function resolveAccountKey(provider: ProviderId, account: string, path?: string): Promise<string>;
+/**
+ * Absolute path of the auth store file.
+ * @returns `dshHomePath('plugins', 'subscriptions', 'auth.json')`.
+ */
+export declare function authFilePath(): string;
+/**
+ * Read the whole store. A missing file is an empty store; malformed JSON or a
+ * malformed entry throws, because silently discarding tokens would strand the
+ * user without a diagnosis. Single-account entries are migrated in memory;
+ * the next write persists the new shape.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ * @returns the parsed session map.
+ */
+export declare function loadStore(path?: string): Promise<SessionMap>;
+/**
+ * List one provider's accounts, default first.
+ * @param provider - the provider route.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ * @returns the account entries in stable order (empty when logged out).
+ */
+export declare function listAccounts<K extends ProviderId>(provider: K, path?: string): Promise<AccountEntry<SessionOf<K>>[]>;
+/**
+ * Read one account's session.
+ * @param provider - the provider route.
+ * @param account - the account key; defaults to the provider's default account.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ * @returns the stored session, or `undefined` when absent.
+ */
+export declare function getAccountSession<K extends ProviderId>(provider: K, account?: string, path?: string): Promise<SessionOf<K> | undefined>;
+/**
+ * Write one account's session, preserving the others. The first account of a
+ * provider becomes its default.
+ *
+ * The session is validated before it lands: a corrupt entry written here
+ * would fail every later read of the whole store (one bad entry breaks all
+ * providers' status), so the write path must be as strict as the read path.
+ * @param provider - the provider route.
+ * @param account - the account key (see {@link accountKeyOf}).
+ * @param session - the fresh session from a login or refresh.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ * @throws when the session is missing accessToken/refreshToken/expiresAt.
+ */
+export declare function saveAccountSession<K extends ProviderId>(provider: K, account: string, session: SessionOf<K>, path?: string): Promise<void>;
+/**
+ * Delete one account's session (logout). Deleting the default moves the badge
+ * to the next remaining account.
+ * @param provider - the provider route.
+ * @param account - the account key.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ */
+export declare function deleteAccountSession(provider: ProviderId, account: string, path?: string): Promise<void>;
+/**
+ * Pin the account direct (non-pool) routes serve.
+ * @param provider - the provider route.
+ * @param account - the account key; must exist.
+ * @param path - store file path; defaults to {@link authFilePath}.
+ */
+export declare function setDefaultAccount(provider: ProviderId, account: string, path?: string): Promise<void>;