dsh-plugin-subscription-oauth 0.0.0-stage → 0.2.0

package/lib/http.js

@@ -0,0 +1,98 @@
+/**
+ * Outbound HTTP for the Kimi routes.
+ *
+ * The plugin respects the conventional proxy environment variables so a user
+ * behind a corporate relay can still reach `auth.kimi.com`. `NO_PROXY` is
+ * honoured, and a loopback destination is never proxied.
+ *
+ * @module dsh-plugin-subscription-oauth/http
+ */
+/** One cached dispatcher per proxy URL. */
+const agents = new Map();
+/** Hosts that always bypass a proxy. */
+const ALWAYS_DIRECT = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+/** Read the first non-empty value among the given environment names. */
+function envValue(env, ...names) {
+    for (const name of names) {
+        const value = env[name];
+        if (value !== undefined && value.trim() !== '')
+            return value.trim();
+    }
+    return undefined;
+}
+/** Whether `host` matches one `NO_PROXY` entry (exact host or dotted suffix). */
+function matchesNoProxy(host, noProxy) {
+    const target = host.toLowerCase();
+    for (const raw of noProxy.split(',')) {
+        const entry = raw.trim().toLowerCase().replace(/^\./, '');
+        if (entry === '')
+            continue;
+        if (entry === '*')
+            return true;
+        if (target === entry || target.endsWith(`.${entry}`))
+            return true;
+    }
+    return false;
+}
+/** Proxy URL that applies to `url`, or undefined for a direct connection. */
+function proxyFor(url, env) {
+    const host = url.hostname.toLowerCase();
+    if (ALWAYS_DIRECT.has(host))
+        return undefined;
+    const noProxy = envValue(env, 'NO_PROXY', 'no_proxy');
+    if (noProxy !== undefined && matchesNoProxy(host, noProxy))
+        return undefined;
+    if (url.protocol === 'https:')
+        return envValue(env, 'HTTPS_PROXY', 'https_proxy', 'ALL_PROXY', 'all_proxy');
+    return envValue(env, 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy');
+}
+/** Lazily create (and cache) the dispatcher for one proxy URL. */
+async function dispatcherFor(proxyUrl) {
+    const cached = agents.get(proxyUrl);
+    if (cached !== undefined)
+        return cached;
+    const { ProxyAgent } = await import('undici');
+    const agent = new ProxyAgent(proxyUrl);
+    agents.set(proxyUrl, agent);
+    return agent;
+}
+/** The absolute URL of a fetch input, or undefined when it cannot be parsed. */
+function requestUrl(input) {
+    try {
+        if (input instanceof URL)
+            return input;
+        if (typeof input === 'string')
+            return new URL(input);
+        return new URL(input.url);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Fetch an absolute URL, honouring the proxy environment.
+ *
+ * Falls back to a direct request when no proxy applies or when the dispatcher
+ * cannot be constructed, so a malformed proxy setting degrades to a direct
+ * attempt instead of breaking every call.
+ *
+ * @param input - absolute request URL (a `Request` is inspected for its URL).
+ * @param init - standard request options.
+ * @param env - environment to read proxy settings from.
+ * @returns the response.
+ */
+export async function proxiedFetch(input, init, env = process.env) {
+    const url = requestUrl(input);
+    if (url === undefined)
+        return fetch(input, init);
+    const proxyUrl = proxyFor(url, env);
+    if (proxyUrl === undefined)
+        return fetch(input, init);
+    try {
+        const dispatcher = await dispatcherFor(proxyUrl);
+        return await fetch(input, { ...init, dispatcher });
+    }
+    catch {
+        return fetch(input, init);
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Kimi Code, Grok (X Premium) and Google Antigravity subscription access for
+ * DeepSeek Harness.
+ *
+ * Each provider route authorizes once through its own OAuth flow (Settings →
+ * Subscriptions) and then streams over the wire that provider's subscription
+ * exposes. Tokens live below `~/.dsh/plugins/kimi-oauth/`, one provider section
+ * per route.
+ *
+ * @module dsh-plugin-subscription-oauth
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Plugin id; also the name every effect label and log line is prefixed with. */
+export declare const name = "dsh-plugin-subscription-oauth";
+/** The provider routes need the LLM runtime; everything else is optional. */
+export declare const inject: string[];
+/** Every route key this plugin accepts in configuration. */
+export declare const PROVIDER_IDS: readonly ["kimi", "grok", "antigravity", "glm"];
+/** The routes this build can actually register. */
+export declare const IMPLEMENTED_PROVIDER_IDS: readonly ["kimi", "grok", "antigravity", "glm"];
+/** One route key. */
+export type ProviderId = typeof PROVIDER_IDS[number];
+/** Plugin configuration, as accepted from `cordis.patch.yml`. */
+export interface Config {
+    /** Routes to register; defaults to every implemented provider. */
+    providers?: ProviderId[];
+    /** Register the routes at all. Defaults to true. */
+    enabled?: boolean;
+    /** OAuth host serving the Kimi Code device flow. */
+    oauthHost?: string;
+    /** Kimi Code request base; `<base>/responses` is the endpoint. */
+    apiBase?: string;
+    /** Consult each endpoint's live model list. Defaults to true. */
+    discovery?: boolean;
+    /** Abandon a stream after this much silence. Defaults to 300000. */
+    streamIdleTimeoutMs?: number;
+    /** Model the picker preselects on the Kimi Code route. */
+    defaultModel?: string;
+    /** Kimi Code model ids to publish without shipped metadata. */
+    extraModels?: string[];
+    /**
+     * Register the `auto` provider, which stands in for every enabled model across
+     * the other routes. Defaults to true.
+     */
+    auto?: boolean;
+}
+/** Configuration schema, with the config file's own defaults applied. */
+export declare const Config: z<Config>;
+/**
+ * Register every configured provider route, its credential store, and — when
+ * the host has a connection service — the Settings page's RPC routes.
+ *
+ * @param ctx - the plugin's context.
+ * @param config - validated plugin configuration.
+ */
+export declare function apply(ctx: Context, config?: Config): void;

package/lib/index.js

@@ -0,0 +1,185 @@
+/**
+ * Kimi Code, Grok (X Premium) and Google Antigravity subscription access for
+ * DeepSeek Harness.
+ *
+ * Each provider route authorizes once through its own OAuth flow (Settings →
+ * Subscriptions) and then streams over the wire that provider's subscription
+ * exposes. Tokens live below `~/.dsh/plugins/kimi-oauth/`, one provider section
+ * per route.
+ *
+ * @module dsh-plugin-subscription-oauth
+ */
+import path from 'node:path';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import z from '@deepseek-ai/schemastery';
+import { registerSubscriptionRpc } from './auth/rpc.js';
+import { SubscriptionRegistry } from './auth/registry.js';
+import { KIMI_DATA_DIR, KIMI_DEFAULT_MODEL, KIMI_STREAM_IDLE_TIMEOUT_MS, normalizeApiBase, normalizeOAuthHost, resolveApiBase, resolveOAuthHost, } from './constants.js';
+import { proxiedFetch } from './http.js';
+import { AUTO_PROVIDER_ID, createAutoProvider } from './providers/auto.js';
+import { createAntigravityProvider } from './providers/antigravity.js';
+import { createGrokProvider } from './providers/grok.js';
+import { createKimiProvider } from './providers/kimi-provider.js';
+import { createGlmProvider } from './providers/glm-provider.js';
+import { ModelPreferences } from './settings.js';
+/** Plugin id; also the name every effect label and log line is prefixed with. */
+export const name = 'dsh-plugin-subscription-oauth';
+/** The provider routes need the LLM runtime; everything else is optional. */
+export const inject = ['llm'];
+/** Every route key this plugin accepts in configuration. */
+export const PROVIDER_IDS = ['kimi', 'grok', 'antigravity', 'glm'];
+/** The routes this build can actually register. */
+export const IMPLEMENTED_PROVIDER_IDS = ['kimi', 'grok', 'antigravity', 'glm'];
+/** Configuration schema, with the config file's own defaults applied. */
+export const Config = z.object({
+    providers: z.array(z.union([...PROVIDER_IDS])).default([...IMPLEMENTED_PROVIDER_IDS]),
+    enabled: z.boolean().default(true),
+    oauthHost: z.string(),
+    apiBase: z.string(),
+    discovery: z.boolean().default(true),
+    streamIdleTimeoutMs: z.number().default(KIMI_STREAM_IDLE_TIMEOUT_MS),
+    defaultModel: z.string().default(KIMI_DEFAULT_MODEL),
+    extraModels: z.array(z.string()).default([]),
+    auto: z.boolean().default(true),
+});
+/**
+ * Register every configured provider route, its credential store, and — when
+ * the host has a connection service — the Settings page's RPC routes.
+ *
+ * @param ctx - the plugin's context.
+ * @param config - validated plugin configuration.
+ */
+export function apply(ctx, config = {}) {
+    if (config.enabled === false)
+        return;
+    const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? KIMI_STREAM_IDLE_TIMEOUT_MS;
+    if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0) {
+        throw new Error(`${name}: streamIdleTimeoutMs must be a positive finite number`);
+    }
+    const selected = new Set(config.providers ?? [...IMPLEMENTED_PROVIDER_IDS]);
+    const onWarn = (message) => {
+        ctx.logger.warn(`${name}: ${message}`);
+    };
+    const dataDir = dshHomePath(...KIMI_DATA_DIR);
+    const credentialFile = path.join(dataDir, 'auth.json');
+    const preferences = new ModelPreferences(path.join(dataDir, 'preferences.json'));
+    /** Registration handles, so a catalog change can re-announce one route. */
+    const handles = new Map();
+    const reannounce = (id) => { handles.get(id)?.replace([id]); };
+    const routes = [];
+    for (const id of selected) {
+        switch (id) {
+            case 'kimi':
+                routes.push(createKimiProvider({
+                    dataDir,
+                    credentialFile,
+                    oauthHost: normalizeOAuthHost(config.oauthHost ?? resolveOAuthHost()),
+                    apiBase: normalizeApiBase(config.apiBase ?? resolveApiBase()),
+                    discovery: config.discovery ?? true,
+                    streamIdleTimeoutMs,
+                    ...config.defaultModel === undefined ? {} : { defaultModel: config.defaultModel },
+                    ...config.extraModels === undefined ? {} : { extraModels: config.extraModels },
+                    preferences,
+                    // Resolved per request: the attachment service may start after this plugin.
+                    resolveAttachments: () => ctx.get('attachments'),
+                    onCatalogChanged: () => { reannounce('kimi'); },
+                    onWarn,
+                    fetchFn: proxiedFetch,
+                }));
+                break;
+            case 'grok':
+                routes.push(createGrokProvider({
+                    credentialFile,
+                    discovery: config.discovery ?? true,
+                    streamIdleTimeoutMs,
+                    preferences,
+                    resolveAttachments: () => ctx.get('attachments'),
+                    onCatalogChanged: () => { reannounce('grok'); },
+                    onWarn,
+                    fetchFn: proxiedFetch,
+                }));
+                break;
+            case 'antigravity':
+                routes.push(createAntigravityProvider({
+                    credentialFile,
+                    discovery: config.discovery ?? true,
+                    streamIdleTimeoutMs,
+                    preferences,
+                    resolveAttachments: () => ctx.get('attachments'),
+                    onCatalogChanged: () => { reannounce('antigravity'); },
+                    onWarn,
+                    fetchFn: proxiedFetch,
+                }));
+                break;
+            case 'glm':
+                routes.push(createGlmProvider({
+                    credentialFile,
+                    discovery: config.discovery ?? true,
+                    streamIdleTimeoutMs,
+                    preferences,
+                    resolveAttachments: () => ctx.get('attachments'),
+                    onCatalogChanged: () => { reannounce('glm'); },
+                    onWarn,
+                    fetchFn: proxiedFetch,
+                }));
+                break;
+            default:
+                // A configured route with no module yet must not silently disappear.
+                onWarn(`provider ${id} is configured but not implemented in this build`);
+                break;
+        }
+    }
+    const registry = new SubscriptionRegistry(routes);
+    // `auto` stands in for the other routes, so it is built after them and added
+    // to the same registry it reads. Its list spans routes, which is why it is a
+    // provider of its own rather than a model inside each one.
+    if (config.auto ?? true) {
+        const auto = createAutoProvider({
+            preferences,
+            registry,
+            // Auto spans every provider the harness serves — the built-in DeepSeek
+            // routes and any provider the user adds included — so it is enumerated
+            // through the runtime rather than through this plugin's own registry. The
+            // runtime is read per call, so a provider that registers later (another
+            // plugin, a route the user configures) joins the chain without a restart.
+            host: {
+                providers: () => ctx.llm.listProviders().map((entry) => ({ id: entry.id, name: entry.name })),
+                models: (provider) => ctx.llm.listModels(provider),
+                resolve: async (provider, model) => {
+                    const resolved = await ctx.llm.resolveModelInfo(provider, model);
+                    return {
+                        ...resolved.context?.contextWindow === undefined ? {} : { contextWindow: resolved.context.contextWindow },
+                        ...resolved.reasoning === undefined
+                            ? {}
+                            : { reasoningEfforts: resolved.reasoning.efforts.map((effort) => String(effort.id)) },
+                        ...resolved.inputModalities === undefined ? {} : { inputModalities: resolved.inputModalities },
+                    };
+                },
+                // Dispatch through the harness, which selects the adapter that owns the
+                // provider. Auto's own adapter is never asked to guess.
+                stream: (options) => ctx.llm.stream(options),
+            },
+            onCatalogChanged: () => { reannounce(AUTO_PROVIDER_ID); },
+            onWarn,
+        });
+        registry.register(auto);
+        routes.push(auto);
+    }
+    // Registered in the page's reading order, not construction order: the model
+    // picker groups by the order the adapters arrive, and Auto leads it.
+    for (const id of registry.ids()) {
+        const route = registry.get(id);
+        if (route === undefined)
+            continue;
+        const handle = ctx.llm.registerAdapter([route.id], route.adapter);
+        handles.set(route.id, handle);
+        ctx.effect(() => () => handle(), `${name}: ${route.id} provider route`);
+    }
+    registerSubscriptionRpc(ctx, registry);
+    // Warm each route's live catalog for an install that is already signed in.
+    for (const id of registry.ids()) {
+        void registry.discover(id, false).catch((error) => {
+            onWarn(`${id} startup discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+}

package/lib/protocol.d.ts

@@ -0,0 +1,316 @@
+/**
+ * Wire contract shared by the plugin's node half (the RPC routes) and its
+ * browser half (the Settings page).
+ *
+ * Only this module crosses the boundary: the client bundle imports the types
+ * and the channel name, and every call travels as one JSON envelope over a
+ * `POST /api/<prefix><endpoint>` route. One status document describes every
+ * provider route the plugin serves, so the page renders one card per entry.
+ *
+ * @module dsh-plugin-subscription-oauth/protocol
+ */
+/** Prefix of every RPC method this plugin serves. */
+export declare const RPC_PREFIX = "subscription-oauth.";
+/** Endpoints the Settings page may call. */
+export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload"];
+/** One endpoint name. */
+export type RpcEndpoint = typeof RPC_ENDPOINTS[number];
+/** Client → host envelope. */
+export interface RpcRequest {
+    type: 'client-request';
+    rpcId: string;
+    method: string;
+    payload: unknown;
+}
+/** Host → client envelope, carrying either the value or the failure. */
+export interface RpcResponse {
+    type: 'server-response';
+    rpcId: string;
+    result: RpcResult;
+}
+/** Discriminated result inside {@link RpcResponse}. */
+export type RpcResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: RpcError;
+};
+/** Failure detail, with the provider-neutral code when one applies. */
+export interface RpcError {
+    code: string;
+    message: string;
+    /**
+     * Carrier-owned structured detail. The Connection transport models a failure
+     * as `{code, message, details}`, so an empty object travels here rather than
+     * an absent field the client would have to repair.
+     */
+    details: Record<string, unknown>;
+}
+/**
+ * One provider-owned connection fact the manage dialog shows.
+ *
+ * The key is a stable identifier (`oauthHost`, `apiBase`, …) that the browser
+ * half localizes; the host never sends user-facing prose.
+ */
+export interface DetailRow {
+    key: string;
+    value: string;
+}
+/** How the browser should present one pending login. */
+export type LoginMode = 
+/** Open the URL in a new tab; the redirect completes the login. */
+'open-url'
+/** Show the code (and a link) while the host polls the token endpoint. */
+ | 'device-code';
+/** What the Settings page has to show to finish a login. */
+export interface LoginPrompt {
+    /** URL the user opens (or that was opened for them). */
+    readonly url: string;
+    /** Code the user confirms in the browser; device flows only. */
+    readonly userCode?: string;
+    /** Epoch milliseconds after which the attempt lapses. */
+    readonly expiresAt: number;
+    readonly mode: LoginMode;
+}
+/** One signed-in account as the page displays it. */
+export interface AccountStatus {
+    /** Account key the store is keyed by. */
+    account: string;
+    /** Display label (email, user id, or the key's digest). */
+    label: string;
+    /** Epoch milliseconds when the access token lapses. */
+    expiresAt: number;
+    /** Whether the access token is already past its expiry. */
+    expired: boolean;
+    /** Whether this account serves requests by default. */
+    isDefault: boolean;
+    /**
+     * Whether the provider refused this account's grant outright.
+     *
+     * A refresh answered with `invalid_grant` means the authorization is gone — the
+     * stored token can never be renewed — so the page asks for a new sign-in rather
+     * than reporting the account as connected.
+     */
+    needsLogin?: boolean;
+}
+/** One selectable model, as the page lists it. */
+export interface ModelSummary {
+    id: string;
+    name: string;
+    description?: string;
+    contextWindow: number;
+    inputModalities?: readonly string[];
+    defaultEffort?: string;
+    /** Whether the session model picker offers this model. */
+    visible: boolean;
+    /**
+     * Route that owns this model, when the listing spans routes.
+     *
+     * The uto provider mixes models from every route, so its rows name the
+     * owning route; a single-route catalog leaves it out.
+     */
+    source?: string;
+    /** Whether the user added this id by hand, so it can be removed again. */
+    userAdded?: boolean;
+    /**
+     * Whether this entry is fixed at the head of the list.
+     *
+     * The synthetic `auto` entry follows the user's own order, so it cannot be
+     * hidden or moved; the page renders it without those controls.
+     */
+    pinned?: boolean;
+}
+/** One metered allowance of a subscription plan. */
+export interface UsageWindow {
+    /** What the window meters, e.g. `weekly`, `5h`, `credits`. */
+    label: string;
+    /** How much of the allowance is spent, when the provider states it. */
+    usedPercent?: number;
+    /** Amount already spent, when the provider states an absolute figure. */
+    used?: number;
+    /** Total allowance, when the provider states one. */
+    limit?: number;
+    /** Epoch milliseconds when the window resets, when the provider states it. */
+    resetsAt?: number;
+}
+/** One account's plan and metered allowances. */
+export interface ProviderUsage {
+    /** Account the figures belong to. */
+    account: string;
+    /** Plan name or tier, when the provider states one. */
+    plan?: string;
+    /** Whether the plan renews on a date the provider states. */
+    renewsAt?: number;
+    /** Metered allowances, most relevant first. */
+    windows: readonly UsageWindow[];
+    /** Epoch milliseconds these figures were read. */
+    fetchedAt: number;
+    /**
+     * Whether these figures are the route's substitute rather than its own accounting.
+     *
+     * A substitute is shown when the primary source cannot answer, and it is never
+     * reused as if it were a reading: the next request asks again.
+     */
+    substitute?: boolean;
+}
+/** Result of reading one route's usage. */
+export interface UsageResult {
+    provider: string;
+    /** Usage per account the endpoint could answer for. */
+    usage: readonly ProviderUsage[];
+    /** Why an account's usage is missing, when the read failed. */
+    error?: string;
+    status: SubscriptionStatus;
+}
+/** The full state of one provider route. */
+export interface ProviderStatus {
+    /** Provider route key, e.g. `kimi`. */
+    provider: string;
+    displayName: string;
+    /** Where a user manages the underlying subscription. */
+    codeUrl?: string;
+    /** Whether at least one account is stored. */
+    loggedIn: boolean;
+    /**
+     * Whether this route signs in at all.
+     *
+     * uto has no account of its own — it delegates to routes that do — so the
+     * page hides the connect and manage controls for it.
+     */
+    connectable?: boolean;
+    /** Whether a login attempt is being polled. */
+    busy: boolean;
+    /** The pending attempt, when `busy`. */
+    pending?: LoginPrompt;
+    accounts: AccountStatus[];
+    /** Account key serving requests, when one does. */
+    activeAccount?: string;
+    /** Absolute path of the credential file, for support requests. */
+    credentialFile: string;
+    /** Whether the live model list is consulted. */
+    discovery: boolean;
+    /** Live catalog ids, when discovery has succeeded this session. */
+    discovered?: readonly string[];
+    models: readonly ModelSummary[];
+    /** Model the picker preselects. */
+    defaultModel?: string;
+    /** Last usage figures read for this route, when they were requested. */
+    usage?: readonly ProviderUsage[];
+    /** Why the last usage read failed, when it did. */
+    usageError?: string;
+    /** Provider-owned connection facts shown in the manage dialog. */
+    details: readonly DetailRow[];
+    /** Last background failure (a login that could not complete). */
+    lastError?: string;
+}
+/** Every provider route's state, in display order. */
+export interface SubscriptionStatus {
+    providers: ProviderStatus[];
+}
+/** Result of starting a login. */
+export interface LoginStart {
+    prompt: LoginPrompt;
+    status: SubscriptionStatus;
+}
+/** Result of a token refresh. */
+export interface RefreshResult {
+    account: string;
+    expiresAt: number;
+    status: SubscriptionStatus;
+}
+/** Payload fields naming one provider route and optionally one account. */
+export interface AccountRequest {
+    provider: string;
+    account?: string;
+}
+/** Payload of `setDefault`. */
+export interface SetDefaultRequest {
+    provider: string;
+    account: string;
+}
+/** Payload of `discover`. */
+export interface DiscoverRequest {
+    provider: string;
+    /** Ask the endpoint for its live model list even when one is cached. */
+    force?: boolean;
+}
+/** Payload of `setModelVisible`. */
+export interface SetModelVisibleRequest {
+    provider: string;
+    /** Model id as the catalog reports it. */
+    id: string;
+    /** Whether the session model picker should offer it. */
+    visible: boolean;
+}
+/** Payload of `addModel` and `removeModel`. */
+export interface ModelIdRequest {
+    provider: string;
+    /** Model id as the endpoint accepts it. */
+    id: string;
+}
+/** Payload of `setModelOrder`. */
+export interface SetModelOrderRequest {
+    provider: string;
+    /** Every catalog model id, in the order the user arranged them. */
+    ids: readonly string[];
+}
+/** Payload naming only a provider route. */
+export interface ProviderRequest {
+    provider: string;
+}
+/** Map an endpoint to its payload and value types. */
+export interface RpcMap {
+    status: {
+        payload: undefined;
+        value: SubscriptionStatus;
+    };
+    login: {
+        payload: AccountRequest;
+        value: LoginStart;
+    };
+    cancel: {
+        payload: ProviderRequest;
+        value: SubscriptionStatus;
+    };
+    logout: {
+        payload: AccountRequest;
+        value: SubscriptionStatus;
+    };
+    setDefault: {
+        payload: SetDefaultRequest;
+        value: SubscriptionStatus;
+    };
+    refresh: {
+        payload: AccountRequest;
+        value: RefreshResult;
+    };
+    discover: {
+        payload: DiscoverRequest;
+        value: SubscriptionStatus;
+    };
+    setModelVisible: {
+        payload: SetModelVisibleRequest;
+        value: SubscriptionStatus;
+    };
+    setModelOrder: {
+        payload: SetModelOrderRequest;
+        value: SubscriptionStatus;
+    };
+    addModel: {
+        payload: ModelIdRequest;
+        value: SubscriptionStatus;
+    };
+    removeModel: {
+        payload: ModelIdRequest;
+        value: SubscriptionStatus;
+    };
+    usage: {
+        payload: DiscoverRequest;
+        value: UsageResult;
+    };
+    reload: {
+        payload: undefined;
+        value: SubscriptionStatus;
+    };
+}

package/lib/protocol.js

@@ -0,0 +1,29 @@
+/**
+ * Wire contract shared by the plugin's node half (the RPC routes) and its
+ * browser half (the Settings page).
+ *
+ * Only this module crosses the boundary: the client bundle imports the types
+ * and the channel name, and every call travels as one JSON envelope over a
+ * `POST /api/<prefix><endpoint>` route. One status document describes every
+ * provider route the plugin serves, so the page renders one card per entry.
+ *
+ * @module dsh-plugin-subscription-oauth/protocol
+ */
+/** Prefix of every RPC method this plugin serves. */
+export const RPC_PREFIX = 'subscription-oauth.';
+/** Endpoints the Settings page may call. */
+export const RPC_ENDPOINTS = [
+    'status',
+    'login',
+    'cancel',
+    'logout',
+    'setDefault',
+    'refresh',
+    'discover',
+    'setModelVisible',
+    'setModelOrder',
+    'addModel',
+    'removeModel',
+    'usage',
+    'reload',
+];