aisubs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AISubs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,629 @@
+<table>
+  <tr>
+    <td><img src="./dashboard/public/aisubs-mark.svg" alt="AISubs icon" width="72"></td>
+    <td>
+      <h1>AISubs</h1>
+      <strong>Connect your AI subscriptions. Use them anywhere.</strong>
+    </td>
+  </tr>
+</table>
+
+Connect once, then use your subscriptions through an SDK in your app, a local
+API, cURL, or any compatible tool.
+
+<p align="center">
+  <img src="./public/aisubs-dashboard.png" alt="AISubs dashboard showing connected accounts" width="100%" />
+</p>
+
+<p align="center">
+  <img src="./public/aisubs-chatgpt-account.png" alt="AISubs ChatGPT account details showing plan, usage, and integration examples" width="33%" />
+  <img src="./public/aisubs-grok-account.png" alt="AISubs Grok account details showing plan, usage, and integration examples" width="33%" />
+  <img src="./public/aisubs-copilot-account.png" alt="AISubs GitHub Copilot account details showing credits and integration examples" width="33%" />
+</p>
+
+> AISubs keeps credentials on your computer. It collects no telemetry, analytics, request logs, or activity history.
+
+## Quick start
+
+```bash
+nubx aisubs dashboard       # Nub (recommended)
+npx aisubs dashboard        # npm
+pnpm exec aisubs dashboard  # pnpm
+bunx aisubs dashboard       # Bun
+```
+
+Click **Add account**, choose a provider, complete sign-in, and give the
+account a local name such as `personal` or `work`.
+
+## The idea
+
+1. Connect a provider account and give it a local name, such as `personal`.
+2. Ask AISubs which models and request format that account supports.
+3. Send the provider-native request through that account.
+
+One provider can have many accounts:
+
+```text
+ChatGPT / personal
+ChatGPT / work
+Claude  / team
+```
+
+AISubs never silently switches accounts. Your application chooses the account
+for each request.
+
+## Providers
+
+| Provider       | ID             | Sign-in                | Request format              |
+| -------------- | -------------- | ---------------------- | --------------------------- |
+| ChatGPT        | `chatgpt`      | Browser or device code | Responses                   |
+| Claude         | `claude`       | Browser                | Anthropic Messages          |
+| GitHub Copilot | `copilot`      | Device code            | Read from the model catalog |
+| Grok           | `grok`         | Device code            | Read from the model catalog |
+| OpenCode Go    | `opencode-go`  | API key                | Read from the model catalog |
+| OpenCode Zen   | `opencode-zen` | API key                | Read from the model catalog |
+
+Provider model lists and protocols can change. Discover models at runtime and
+pin the AISubs version your application has tested.
+
+## Fastest start: direct Node.js
+
+This is the simplest integration. It needs no local server and no AISubs API
+key.
+
+### 1. Create AISubs once
+
+```js
+// subscriptions.js
+import { chatGptProvider, createSubscriptionAuth } from "aisubs";
+
+export const subscriptions = createSubscriptionAuth({
+  providers: [chatGptProvider()],
+});
+```
+
+By default, credentials are stored at `~/.aisubs/credentials.json`.
+
+Keep this object in trusted backend code. Do not send it to a browser.
+
+### 2. Connect an account
+
+```js
+import { subscriptions } from "./subscriptions.js";
+
+const account = subscriptions.account("chatgpt", "personal");
+
+if (!(await account.status()).authenticated) {
+  const login = await account.signIn();
+
+  if (login.prompt.mode === "browser") {
+    console.log("Open:", login.prompt.authorizationUri);
+  }
+  if (login.prompt.mode === "device") {
+    console.log("Open:", login.prompt.verificationUri);
+    console.log("Code:", login.prompt.userCode);
+  }
+
+  await login.wait();
+}
+```
+
+### 3. Discover a model and send a request
+
+This example selects the first available ChatGPT model, so it does not depend
+on a model ID that may change:
+
+```js
+const catalog = await account.getModels();
+if (!catalog) throw new Error("This provider does not expose models");
+console.log(
+  "Available model IDs:",
+  catalog.models.map((item) => item.id),
+);
+
+const modelId = catalog.models.find((item) => item.selectable !== false)?.id;
+if (!modelId) throw new Error("No ChatGPT model is available");
+console.log("Using model:", modelId);
+
+const response = await account.proxy("responses", {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify({
+    model: modelId,
+    store: false,
+    stream: true,
+    input: "Hello from AISubs",
+  }),
+});
+
+if (!response.ok) throw new Error(await response.text());
+if (response.body) {
+  for await (const chunk of response.body) process.stdout.write(Buffer.from(chunk));
+}
+```
+
+Here, `modelId` is the exact ID returned by `account.getModels()`. Model IDs
+belong to the connected provider account and can change, so list them first
+instead of copying a fixed ID from documentation.
+
+`store: false` is a request option for the Responses API; it is unrelated to
+AISubs credential storage and keeps response storage disabled. `stream: true`
+asks for incremental output, which is why the example reads `response.body` in
+chunks. Keep both options for ChatGPT subscription Responses requests.
+
+AISubs refreshes expired credentials automatically and retries a provider `401`
+once.
+
+<details>
+<summary><strong>Use another provider</strong></summary>
+
+Add its provider factory when creating AISubs:
+
+```js
+import {
+  chatGptProvider,
+  claudeProvider,
+  copilotProvider,
+  createSubscriptionAuth,
+  grokProvider,
+  openCodeGoProvider,
+  openCodeZenProvider,
+} from "aisubs";
+
+const subscriptions = createSubscriptionAuth({
+  providers: [
+    chatGptProvider(),
+    claudeProvider(),
+    copilotProvider(),
+    grokProvider(),
+    openCodeGoProvider(),
+    openCodeZenProvider(),
+  ],
+});
+```
+
+To use a different file, pass a custom store:
+
+```js
+import { chatGptProvider, createSubscriptionAuth, FileCredentialStore } from "aisubs";
+
+const subscriptions = createSubscriptionAuth({
+  store: new FileCredentialStore("./data/aisubs-credentials.json"),
+  providers: [chatGptProvider()],
+});
+```
+
+Then select the account by provider ID:
+
+```js
+const claude = subscriptions.account("claude", "team");
+const copilot = subscriptions.account("copilot", "github");
+const grok = subscriptions.account("grok", "personal");
+const go = subscriptions.account("opencode-go", "team");
+const zen = subscriptions.account("opencode-zen", "lab");
+```
+
+OpenCode uses an API key:
+
+```js
+const login = await go.signIn({ apiKey: process.env.OPENCODE_API_KEY });
+await login.wait();
+```
+
+For ChatGPT on a headless machine, use `signIn({ mode: "device" })`. Copilot
+also accepts `enterpriseDomain` for a supported GitHub Enterprise Cloud domain.
+
+Provider request paths are:
+
+| Model catalog endpoint | `account.proxy()` path            |
+| ---------------------- | --------------------------------- |
+| `responses`            | `responses`                       |
+| `chat/completions`     | `chat/completions`                |
+| `messages`             | `messages`                        |
+| `models/MODEL_ID`      | `models/MODEL_ID:generateContent` |
+
+Use `account.getModels()` first for Copilot, Grok, and OpenCode because one
+provider can expose more than one request format.
+
+</details>
+
+<details>
+<summary><strong>Read account, usage, and model information</strong></summary>
+
+```js
+const details = await account.details();
+
+console.log(details.session); // connection state and safe account identity
+console.log(details.credential); // expiry and refresh state, never token values
+console.log(details.usage); // limits and reset information, or null
+console.log(details.models); // available models, or null
+```
+
+Useful methods:
+
+| Method                       | Purpose                                                |
+| ---------------------------- | ------------------------------------------------------ |
+| `account.status()`           | Check whether the account is connected                 |
+| `account.signIn(options?)`   | Start a browser, device-code, or API-key login         |
+| `account.signOut()`          | Remove this account's locally stored credentials       |
+| `account.getModels()`        | Get the provider's current model catalog               |
+| `account.getUsage()`         | Get current plan usage, if supported                   |
+| `account.details()`          | Get safe session, credential, usage, and model data    |
+| `account.fetch(url, init?)`  | Make an authorized request to an allowed provider URL  |
+| `account.proxy(path, init?)` | Make a provider-native request without handling tokens |
+
+`details()`, `getUsage()`, and `getModels()` never return access or refresh
+tokens. `getAccessToken()` exists for advanced backend integrations; keep its
+result secret and prefer `fetch()` or `proxy()` when possible.
+
+</details>
+
+<details>
+<summary><strong>Use multiple accounts</strong></summary>
+
+```js
+const personal = subscriptions.account("chatgpt", "personal");
+const work = subscriptions.account("chatgpt", "work");
+
+const selected = user.isWorkAccount ? work : personal;
+const response = await selected.proxy("responses", requestOptions);
+```
+
+Account names are 1–128 characters and cannot contain control characters.
+Each account has separate credentials, refresh state, usage, and model data.
+
+</details>
+
+## Dashboard
+
+### Requirements and installation
+
+- [Node.js 24 or newer](https://nodejs.org/en/download/).
+- A terminal and a browser for provider sign-in.
+- [Nub 0.6 or newer](https://nubjs.com/docs/install) is recommended. It is not
+  required; [pnpm](https://pnpm.io/installation),
+  [npm](https://docs.npmjs.com/cli/install/), and
+  [Bun](https://bun.sh/docs/installation) also work.
+- An API key for OpenCode Go or OpenCode Zen; the other providers use browser
+  or device-code sign-in.
+
+Install AISubs in your project:
+
+```bash
+nub install aisubs       # Nub (recommended)
+npm install aisubs       # npm
+pnpm add aisubs          # pnpm
+bun add aisubs           # Bun
+```
+
+Use the dashboard when you want to connect accounts without writing login UI:
+
+```bash
+nubx aisubs dashboard       # Nub (recommended)
+npx aisubs dashboard        # npm
+pnpm exec aisubs dashboard  # pnpm
+bunx aisubs dashboard       # Bun
+```
+
+Then click **Add account**, choose a provider, finish sign-in, and choose a
+local account name. The dashboard shows safe account details, usage, models,
+and copy-ready integration examples.
+
+By default, AISubs uses Node.js 24 or newer, listens on
+`127.0.0.1:4319`, and stores credentials at `~/.aisubs/credentials.json`.
+
+To use another directory, choose an available port, or prevent the browser
+from opening:
+
+```bash
+nubx aisubs dashboard \
+  --data-dir ./data/aisubs \
+  --port 0 \
+  --no-open
+```
+
+Use the equivalent `npx`, `pnpm exec`, or `bunx` command if you use npm, pnpm,
+or Bun.
+
+The dashboard prints the secure link when `--no-open` is used. Credentials stay
+on your computer; do not commit the data directory or expose the dashboard to
+the network.
+
+Use `AISUBS_DATA_DIR` or `--data-dir` to choose another data directory. Use
+`--port 0` for an available port and `--no-open` to print the secure link
+without opening a browser.
+
+## Local HTTP bridge
+
+Use the bridge for an existing SDK, Python, cURL, or another program that
+cannot import AISubs:
+
+```bash
+nubx aisubs dashboard       # Nub (recommended)
+npx aisubs dashboard        # npm
+pnpm exec aisubs dashboard  # pnpm
+bunx aisubs dashboard       # Bun
+export AISUBS_API_KEY="the-control-key-printed-by-aisubs"
+```
+
+The base URL chooses the provider and account. Append the provider's request
+path shown by `getModels()` or the dashboard:
+
+```text
+http://127.0.0.1:4319/aisubs/chatgpt/personal/responses
+http://127.0.0.1:4319/aisubs/claude/team/messages
+http://127.0.0.1:4319/aisubs/grok/personal/chat/completions
+```
+
+The account name is URL-decoded by AISubs, so URL-encode names containing
+spaces or other URL characters. AISubs removes the control key before sending
+the request to a provider.
+
+<details>
+<summary><strong>Vercel AI SDK</strong></summary>
+
+For a `responses` model:
+
+```bash
+nub install ai @ai-sdk/openai
+```
+
+```js
+import { createOpenAI } from "@ai-sdk/openai";
+import { streamText } from "ai";
+
+const provider = createOpenAI({
+  baseURL: "http://127.0.0.1:4319/aisubs/chatgpt/personal",
+  apiKey: process.env.AISUBS_API_KEY,
+});
+
+const result = streamText({
+  model: provider.responses("MODEL_ID"),
+  prompt: "Hello",
+  providerOptions: { openai: { store: false } },
+});
+
+for await (const text of result.textStream) process.stdout.write(text);
+```
+
+For `chat/completions`, use `@ai-sdk/openai-compatible`. For `messages`, use
+`@ai-sdk/anthropic`. For OpenCode Zen Gemini, use the model-specific
+`models/MODEL_ID:generateContent` URL shown in the dashboard.
+
+</details>
+
+<details>
+<summary><strong>TanStack AI</strong></summary>
+
+TanStack AI can use AISubs through its OpenAI-compatible adapter:
+
+```bash
+nub install @tanstack/ai @tanstack/ai-openai       # Nub (recommended)
+npm install @tanstack/ai @tanstack/ai-openai       # npm
+pnpm add @tanstack/ai @tanstack/ai-openai          # pnpm
+bun add @tanstack/ai @tanstack/ai-openai           # Bun
+```
+
+```ts
+import { chat } from "@tanstack/ai";
+import { openaiCompatibleText } from "@tanstack/ai-openai/compatible";
+
+const stream = chat({
+  adapter: openaiCompatibleText("MODEL_ID", {
+    baseURL: "http://127.0.0.1:4319/aisubs/grok/personal",
+    apiKey: process.env.AISUBS_API_KEY!,
+  }),
+  messages: [{ role: "user", content: "Hello" }],
+});
+
+for await (const chunk of stream) {
+  if (chunk.type === "TEXT_MESSAGE_CONTENT") process.stdout.write(chunk.delta);
+}
+```
+
+Use the equivalent `npm install`, `pnpm add`, or `bun add` command if you use
+another package manager. Replace the provider, account, and model with values
+from your dashboard.
+
+</details>
+
+<details>
+<summary><strong>OpenAI, Anthropic, Python, or cURL</strong></summary>
+
+OpenAI Responses:
+
+```bash
+nub install openai
+```
+
+```js
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  baseURL: "http://127.0.0.1:4319/aisubs/chatgpt/personal",
+  apiKey: process.env.AISUBS_API_KEY,
+});
+
+const stream = await client.responses.create({
+  model: "MODEL_ID",
+  store: false,
+  stream: true,
+  input: "Hello",
+});
+
+for await (const event of stream) console.log(event);
+```
+
+Anthropic Messages uses `@anthropic-ai/sdk` with this base URL:
+
+```text
+http://127.0.0.1:4319/aisubs/claude/team
+```
+
+Chat Completions with LiteLLM:
+
+```bash
+pip install litellm
+```
+
+```python
+import os
+from litellm import completion
+
+response = completion(
+    model="openai/MODEL_ID",
+    api_base="http://127.0.0.1:4319/aisubs/grok/personal",
+    api_key=os.environ["AISUBS_API_KEY"],
+    messages=[{"role": "user", "content": "Hello"}],
+    stream=True,
+)
+
+for event in response:
+    print(event)
+```
+
+cURL:
+
+```bash
+curl "http://127.0.0.1:4319/aisubs/chatgpt/personal/responses" \
+  -H "Authorization: Bearer $AISUBS_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model":"MODEL_ID","store":false,"stream":true,"input":"Hello"}'
+```
+
+For Messages, use `x-api-key: $AISUBS_API_KEY` and
+`anthropic-version: 2023-06-01`.
+
+</details>
+
+<details>
+<summary><strong>Run a server from Node.js</strong></summary>
+
+HTTP bridge without the dashboard:
+
+```js
+import { randomBytes } from "node:crypto";
+import { chatGptProvider, createSubscriptionAuth, FileCredentialStore } from "aisubs";
+import { createSubscriptionAuthServer } from "aisubs/http";
+
+const auth = createSubscriptionAuth({
+  store: new FileCredentialStore("./data/aisubs-credentials.json"),
+  providers: [chatGptProvider()],
+});
+
+const server = await createSubscriptionAuthServer({
+  auth,
+  apiKey: randomBytes(24).toString("hex"),
+  port: 4319,
+});
+
+console.log(server.url);
+// await server.close();
+```
+
+Dashboard inside a Node.js application:
+
+```js
+import { createSubscriptionAuthDashboardServer } from "aisubs/dashboard";
+
+const dashboard = await createSubscriptionAuthDashboardServer({ auth });
+console.log(dashboard.bootstrapUrl);
+// await dashboard.close();
+```
+
+Both servers bind only to localhost. The programmatic HTTP server requires its
+API key; the dashboard also provides a one-time browser link.
+
+</details>
+
+<details>
+<summary><strong>Local HTTP API</strong></summary>
+
+```text
+GET    /health
+GET    /v1/providers
+GET    /v1/auth
+GET    /v1/auth/:provider
+GET    /v1/auth/:provider/accounts
+POST   /v1/auth/:provider/login
+GET    /v1/logins/:loginId
+DELETE /v1/logins/:loginId
+GET    /v1/auth/:provider/details?account=work
+DELETE /v1/auth/:provider?account=work
+POST   /v1/fetch/:provider
+GET    /v1/usage/:provider?account=work
+GET    /v1/models/:provider?account=work
+*      /aisubs/:provider/:account/*
+```
+
+The dashboard's `/bootstrap` link is one-time. Other routes require the
+control API key or dashboard session cookie. Login responses return an attempt
+ID; poll `/v1/logins/:loginId` until it is complete, failed, or cancelled.
+
+</details>
+
+<details>
+<summary><strong>Storage and security</strong></summary>
+
+- Default credentials: `~/.aisubs/credentials.json`.
+- Override the directory with `AISUBS_DATA_DIR` or `--data-dir`.
+- `FileCredentialStore` creates private directories/files and uses file locks.
+- `MemoryCredentialStore` is available for tests and temporary processes.
+- Usage is cached for 15 seconds; model catalogs are cached for five minutes.
+- Sign-in, refresh, and sign-out clear the affected metadata cache.
+- Provider credentials are added only after host allowlist validation.
+- Local auth and control-key headers are removed before forwarding.
+- Account APIs return safe summaries, never token values.
+- Never expose provider credentials or `AISUBS_API_KEY` in browser code.
+
+</details>
+
+<details>
+<summary><strong>Local development</strong></summary>
+
+From the package directory, run:
+
+```bash
+nub run dev
+```
+
+Equivalent commands are `pnpm dev`, `npm run dev`, and `bun run dev`. Nub is
+recommended, but it is not required. The command builds the package once,
+watches backend and dashboard changes, and opens the local dashboard. Pass
+`-- --no-open` to keep the browser closed.
+
+</details>
+
+<details>
+<summary><strong>Maintainer pre-publish check</strong></summary>
+
+```bash
+nub run check
+nub pack --dry-run
+```
+
+With another package manager, use `pnpm check` / `pnpm pack`,
+`npm run check` / `npm pack --dry-run`, or `bun run check` / `bun pm pack`.
+
+Confirm that the package contains `dist`, `examples`, `public`, `README.md`,
+`LICENSE`, and the README logo asset. Test at least one real account for every
+provider your release claims to support.
+
+Runnable examples:
+
+- [`examples/direct.mjs`](./examples/direct.mjs)
+- [`examples/server.mjs`](./examples/server.mjs)
+
+</details>
+
+## Contributing and bug reports
+
+Please read [`CONTRIBUTING.md`](./CONTRIBUTING.md) before opening an issue or
+pull request. To report a reproducible bug, use the
+[Bug report form](./.github/ISSUE_TEMPLATE/bug_report.yml) and include the
+version, environment, steps to reproduce, expected and actual behavior, and
+sanitized error output where relevant.
+
+## License
+
+AISubs is licensed under the [MIT License](./LICENSE).

package/dashboard/public/aisubs-mark.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 56">
+  <rect width="56" height="56" rx="14" fill="#e5e5e5"/>
+  <path
+    fill="#0f0f0f"
+    fill-rule="evenodd"
+    d="M11.25 25.12C11.34 24.55 11.74 22.98 12 22.38C12.26 21.77 12.21 21.23 13.38 20.12C14.54 19.02 20.49 14.16 21.75 13.12C23.01 12.09 23.27 11.86 23.88 11.5C24.48 11.14 26.18 10.34 26.75 10.12C27.32 9.91 28.1 9.79 28.62 9.75C29.15 9.71 30.61 9.71 31.12 9.75C31.64 9.79 32.41 9.96 32.88 10.12C33.34 10.29 34.45 10.72 35 11.12C35.55 11.53 37.01 12.81 37.5 13.5C37.99 14.19 38.9 16.16 39.12 16.88C39.35 17.59 39.08 19.04 39.38 19.5C39.67 19.96 41.15 20.38 41.62 20.75C42.1 21.12 43.05 22.19 43.38 22.62C43.7 23.06 44.16 23.8 44.38 24.38C44.59 24.95 45.03 26.77 45.12 27.38C45.22 27.98 45.2 28.84 45.12 29.38C45.05 29.91 44.78 31.23 44.5 31.88C44.22 32.52 44.1 33.46 42.75 34.75C41.4 36.04 34.78 41.47 33.25 42.62C31.72 43.78 30.59 44.12 30 44.38C29.41 44.63 28.93 44.7 28.38 44.75C27.82 44.8 26.18 44.91 25.38 44.75C24.57 44.59 22.41 43.83 21.62 43.38C20.84 42.92 19.4 41.65 18.88 41C18.35 40.35 17.5 38.77 17.25 38C17 37.23 17.04 35.15 16.75 34.62C16.46 34.1 15.29 33.94 14.88 33.62C14.46 33.31 13.6 32.44 13.25 32C12.9 31.57 12.24 30.59 12 30C11.76 29.41 11.34 27.71 11.25 27.12C11.16 26.54 11.16 25.7 11.25 25.12Z
+      M14.75 25.75C14.72 26.45 15.12 28.27 15.38 28.88C15.63 29.48 16.61 30.5 16.88 30.75C17.14 31 17.48 31.14 17.62 31C17.77 30.86 17.95 29.95 18.12 29.62C18.3 29.3 18.66 28.71 19.12 28.25C19.59 27.79 20.7 26.75 22 25.75C23.3 24.75 28.65 20.73 30 19.88C31.35 19.02 32.56 18.79 33.25 18.62C33.94 18.46 35.48 18.68 35.75 18.5C36.02 18.32 35.74 17.59 35.5 17.12C35.26 16.66 34.2 15.06 33.75 14.62C33.3 14.19 32.34 13.66 31.75 13.5C31.16 13.34 29.49 13.21 28.88 13.25C28.26 13.29 28.07 12.88 26.62 13.88C25.18 14.87 18.2 20.41 16.88 21.5C15.55 22.59 15.88 22.49 15.62 23C15.37 23.51 14.78 25.05 14.75 25.75Z
+      M20.75 32C20.68 32.16 20.5 32.23 20.75 32.25C21 32.27 22.38 32.24 22.88 32.12C23.37 32.01 23.63 32.13 24.88 31.25C26.12 30.36 32.06 25.73 33.25 24.75C34.44 23.77 34.51 23.45 34.75 23.12C34.99 22.8 35.35 22.14 35.25 22C35.15 21.86 34.31 21.89 33.88 22C33.44 22.11 32.98 21.96 31.62 22.88C30.27 23.79 23.86 28.66 22.62 29.62C21.39 30.59 21.6 30.59 21.38 30.88C21.15 31.16 20.82 31.84 20.75 32Z
+      M20.5 35.75C20.16 36.11 21.05 37.84 21.38 38.38C21.7 38.91 22.71 39.91 23.25 40.25C23.79 40.59 25.32 41.13 25.88 41.25C26.43 41.37 27.45 41.3 27.88 41.25C28.3 41.2 29.05 40.99 29.38 40.88C29.7 40.76 29.41 41.16 30.62 40.25C31.84 39.34 38.34 34.2 39.5 33.25C40.66 32.3 40.04 32.69 40.25 32.38C40.46 32.06 41.09 31.02 41.25 30.62C41.41 30.23 41.62 29.68 41.62 29.12C41.62 28.57 41.43 26.6 41.25 26C41.07 25.4 40.44 24.48 40.12 24.12C39.81 23.77 38.9 22.93 38.62 23C38.35 23.07 38.2 24.25 37.88 24.75C37.55 25.25 37.18 26.02 35.88 27.12C34.57 28.23 28.39 33.01 27 34C25.61 34.99 25.03 35.16 24.25 35.38C23.47 35.59 20.84 35.39 20.5 35.75Z"
+  />
+</svg>

package/dist/account-key.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderId, Session } from "./types.js";
+export declare function nextAccountKey(sessions: readonly Session[], provider: ProviderId): string;

package/dist/account-key.js

@@ -0,0 +1,11 @@
+export function nextAccountKey(sessions, provider) {
+    const used = new Set(sessions
+        .filter((session) => session.provider === provider && session.authenticated)
+        .map((session) => session.accountKey));
+    if (!used.has("default"))
+        return "default";
+    let index = 2;
+    while (used.has(`account-${index}`))
+        index += 1;
+    return `account-${index}`;
+}