dsh-plugin-subscriptions 0.5.1 → 0.5.3

package/lib/auth/store.js

@@ -1,16 +1,52 @@
 /**
  * On-disk OAuth session store at `~/.dsh/plugins/subscriptions/auth.json`.
  *
- * The file is a JSON object keyed by provider id. 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.
+ * 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.
  */
+import { createHash } from 'node:crypto';
 import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 /** Every provider route, in display order. */
 export const PROVIDER_IDS = ['codex', 'claude', 'grok', 'copilot'];
+/**
+ * The stable identity of one session's account: codex keys on the always
+ * present `accountId` claim, 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 function accountKeyOf(provider, session) {
+    switch (provider) {
+        case 'codex':
+            return session.accountId;
+        case 'claude':
+            return session.emailAddress ?? tokenHash(session.refreshToken);
+        case 'grok':
+            return session.account ?? tokenHash(session.refreshToken);
+        case 'copilot':
+            return session.account ?? tokenHash(session.refreshToken);
+    }
+}
+/** Short stable hash for sessions without an identity field. */
+function tokenHash(refreshToken) {
+    return `token-${createHash('sha256').update(refreshToken).digest('hex').slice(0, 16)}`;
+}
 /**
  * Absolute path of the auth store file.
  * @returns `dshHomePath('plugins', 'subscriptions', 'auth.json')`.
@@ -22,22 +58,23 @@ export function authFilePath() {
 function legacyAuthFilePath() {
     return dshHomePath('plugins', 'router', 'auth.json');
 }
-/** Check that one durable entry carries the fields every session needs. */
-function assertSessionShape(provider, value) {
+/** Check that one durable session carries the fields every session needs. */
+function assertSessionShape(provider, account, value) {
     if (typeof value !== 'object' || value === null) {
-        throw new Error(`subscriptions auth store: entry "${provider}" is not an object; fix or delete the store file`);
+        throw new Error(`subscriptions auth store: entry "${provider}/${account}" is not an object; fix or delete the store file`);
     }
     const entry = value;
     if (typeof entry.accessToken !== 'string' || entry.accessToken.length === 0
         || typeof entry.refreshToken !== 'string' || entry.refreshToken.length === 0
         || typeof entry.expiresAt !== 'number' || !Number.isFinite(entry.expiresAt)) {
-        throw new Error(`subscriptions auth store: entry "${provider}" is missing accessToken/refreshToken/expiresAt; fix or delete the store file`);
+        throw new Error(`subscriptions auth store: entry "${provider}/${account}" is missing accessToken/refreshToken/expiresAt; fix or delete the store file`);
     }
 }
 /**
  * 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.
+ * 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.
  */
@@ -67,7 +104,7 @@ export async function loadStore(path = authFilePath()) {
     }
     return parseStore(text, path);
 }
-/** Parse and validate store JSON read from `path`. */
+/** Parse, validate, and migrate store JSON read from `path`. */
 function parseStore(text, path) {
     let parsed;
     try {
@@ -79,11 +116,36 @@ function parseStore(text, path) {
     if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
         throw new Error(`subscriptions auth store at ${path} must be a JSON object keyed by provider; fix or delete the file`);
     }
-    const store = parsed;
+    const raw = parsed;
+    const store = {};
     for (const provider of PROVIDER_IDS) {
-        const entry = store[provider];
-        if (entry !== undefined)
-            assertSessionShape(provider, entry);
+        const entry = raw[provider];
+        if (entry === undefined)
+            continue;
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+            throw new Error(`subscriptions auth store: entry "${provider}" is not an object; fix or delete the store file`);
+        }
+        const record = entry;
+        if (typeof record.accessToken === 'string') {
+            // Single-account format: wrap the bare session, preserving every field.
+            assertSessionShape(provider, '(legacy)', record);
+            const session = record;
+            const key = accountKeyOf(provider, session);
+            store[provider] = { default: key, accounts: { [key]: session } };
+            continue;
+        }
+        const accounts = record.accounts;
+        if (typeof accounts !== 'object' || accounts === null || Array.isArray(accounts)) {
+            throw new Error(`subscriptions auth store: entry "${provider}" has no accounts map; fix or delete the store file`);
+        }
+        if (record.default !== undefined && typeof record.default !== 'string') {
+            throw new Error(`subscriptions auth store: entry "${provider}" default is not a string; fix or delete the store file`);
+        }
+        for (const [account, session] of Object.entries(accounts)) {
+            assertSessionShape(provider, account, session);
+        }
+        ;
+        store[provider] = record;
     }
     return store;
 }
@@ -106,8 +168,8 @@ async function writeStore(store, path) {
 /**
  * One write chain per store path. Every mutation is a read-modify-write of a
  * single JSON file, and the plugin has several independent writers — a login,
- * a logout, and one token refresh per provider adapter, each on its own
- * schedule. Overlapping them unserialized costs whichever provider read the
+ * a logout, and one token refresh per provider account, each on its own
+ * schedule. Overlapping them unserialized costs whichever account read the
  * store first its entry.
  *
  * A chain is dropped once nothing is queued behind it, so the map holds an
@@ -136,38 +198,97 @@ async function serialize(path, action) {
     }
 }
 /**
- * Read one provider's session.
+ * List one provider's accounts, default first.
  * @param provider - the provider route.
  * @param path - store file path; defaults to {@link authFilePath}.
- * @returns the stored session, or `undefined` when logged out.
+ * @returns the account entries in stable order (empty when logged out).
  */
-export async function getSession(provider, path = authFilePath()) {
-    return (await loadStore(path))[provider];
+export async function listAccounts(provider, path = authFilePath()) {
+    const entry = (await loadStore(path))[provider];
+    if (entry === undefined)
+        return [];
+    const accounts = Object.entries(entry.accounts).map(([key, session]) => ({ key, session }));
+    accounts.sort((a, b) => Number(b.key === entry.default) - Number(a.key === entry.default));
+    return accounts;
 }
 /**
- * Write one provider's session, preserving the others.
+ * 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 async function getAccountSession(provider, account, path = authFilePath()) {
+    const entry = (await loadStore(path))[provider];
+    if (entry === undefined)
+        return undefined;
+    const key = account ?? entry.default;
+    if (key === undefined)
+        return undefined;
+    return entry.accounts[key];
+}
+/**
+ * Write one account's session, preserving the others. The first account of a
+ * provider becomes its default.
+ * @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}.
  */
-export async function saveSession(provider, session, path = authFilePath()) {
+export async function saveAccountSession(provider, account, session, path = authFilePath()) {
     return serialize(path, async () => {
         const store = await loadStore(path);
-        store[provider] = session;
+        const entry = store[provider];
+        store[provider] = {
+            default: entry?.default ?? account,
+            accounts: { ...entry?.accounts, [account]: session },
+        };
         await writeStore(store, path);
     });
 }
 /**
- * Delete one provider's session (logout).
+ * 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 async function deleteSession(provider, path = authFilePath()) {
+export async function deleteAccountSession(provider, account, path = authFilePath()) {
     return serialize(path, async () => {
         const store = await loadStore(path);
-        if (store[provider] === undefined)
+        const entry = store[provider];
+        if (entry === undefined || !(account in entry.accounts))
             return;
-        delete store[provider];
+        const accounts = { ...entry.accounts };
+        delete accounts[account];
+        if (Object.keys(accounts).length === 0) {
+            delete store[provider];
+        }
+        else {
+            ;
+            store[provider] = {
+                ...entry.default === account ? { default: Object.keys(accounts)[0] } : { default: entry.default },
+                accounts,
+            };
+        }
+        await writeStore(store, path);
+    });
+}
+/**
+ * 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 async function setDefaultAccount(provider, account, path = authFilePath()) {
+    return serialize(path, async () => {
+        const store = await loadStore(path);
+        const entry = store[provider];
+        if (entry === undefined || !(account in entry.accounts)) {
+            throw new Error(`no ${provider} account "${account}" is logged in`);
+        }
+        ;
+        store[provider] = { ...entry, default: account };
         await writeStore(store, path);
     });
 }

package/lib/client/SubscriptionsSection.d.ts

@@ -2,12 +2,18 @@ import type { ConnectionHandle } from '@deepseek-ai/dsh-api-remotes/client';
 import type { SubscriptionsKey } from './locales.js';
 /** Subscription provider ids, fixed by the node half's OAuth adapters. */
 export type SubscriptionProvider = 'codex' | 'claude' | 'grok' | 'copilot';
+/** One logged-in account as answered by the `status` endpoint. */
+export interface AccountStatus {
+    key: string;
+    account?: string;
+    expiresAt?: number;
+    plan?: string;
+    isDefault: boolean;
+}
 /** One provider's login state as answered by the `status` endpoint. */
 export interface ProviderStatus {
-    loggedIn: boolean;
     busy: boolean;
-    expiresAt?: number;
-    account?: string;
+    accounts: AccountStatus[];
     detail?: string;
 }
 /** One rate-limit window as answered by the `usage` endpoint. */
@@ -23,6 +29,23 @@ export interface ProviderUsage {
     windows?: UsageWindow[];
     plan?: string;
 }
+/** `proxyGet` endpoint value: the node half owns this shape (no secrets). */
+export interface ProxyConfigView {
+    enabled: boolean;
+    url: string;
+    username?: string;
+    passwordSet: boolean;
+    bypass: string[];
+    error?: string;
+}
+/** `proxyTest` endpoint value. */
+export interface ProxyTestResult {
+    ok: boolean;
+    viaProxy: boolean;
+    status?: number;
+    latencyMs?: number;
+    error?: string;
+}
 /** Injected dependencies of {@link SubscriptionsSection} (slot `inject`). */
 export interface SubscriptionsSectionInjected {
     /** Generic logical-RPC caller over the Connection transport. */