agl 40.4.0 → 40.5.0

package/ts_authswitch/testsupport.ts

@@ -1,4 +1,5 @@
 import * as plugins from './plugins.js';
+import { authSwitchApiKeyVerifier } from './authority-apikeys.js';
 import { AuthSwitchAuthorityDaemon, type IAuthSwitchAuthorityDaemonOptions } from './classes.authoritydaemon.js';
 import { AuthSwitchOpenAiProvider } from './classes.openaiprovider.js';
 import { ClaudeAccountStatus } from './classes.claudestatus.js';
@@ -107,9 +108,9 @@ export interface IAuthSwitchFixtureUsage {
 }
 
 /**
- * Anthropic's profile, usage and token endpoints for exactly the fixture tokens it knows, its model list for the
- * fixture API keys it issued, and ChatGPT's `wham/usage` for the fixture ChatGPT logins; every other request fails with
- * an error, so nothing a test starts reaches a real provider.
+ * Anthropic's profile, usage and token endpoints for exactly the fixture tokens it knows, Anthropic's and OpenAI's
+ * model lists for the fixture API keys it issued, and ChatGPT's `wham/usage` for the fixture ChatGPT logins; every
+ * other request fails with an error, so nothing a test starts reaches a real provider.
  */
 export class AuthSwitchFakeClaudeProvider {
   /** Access token -> the account name it belongs to. */
@@ -138,6 +139,27 @@ export class AuthSwitchFakeClaudeProvider {
     return apiKey;
   }
 
+  /**
+   * The OpenAI API keys OpenAI accepts -> the account name each was issued for, and whether it may read the model list
+   * (a restricted key without that permission may not); delete one to revoke it.
+   */
+  public readonly openAiApiKeys = new Map<string, { name: string; modelRead: boolean }>();
+  /** While true, OpenAI's model list answers 503. */
+  public openAiModelsDown = false;
+  public openAiModelListCalls = 0;
+
+  /**
+   * Issues `name`'s OpenAI API key, which OpenAI accepts from then on, and answers it: `sk-proj-fixture-<name>`, a
+   * project key's prefix, so the authority tells it from an Anthropic key as it would a real one. `modelRead: false`
+   * issues a restricted key that may not read the model list.
+   */
+  public issueOpenAiApiKey(name: string, options: { modelRead?: boolean } = {}): string {
+    assertFixtureName(name);
+    const apiKey = `sk-proj-fixture-${name}`;
+    this.openAiApiKeys.set(apiKey, { name, modelRead: options.modelRead ?? true });
+    return apiKey;
+  }
+
   /** Accepts the access token of `name`'s login at `generation`, and its refresh token for the next generation. */
   public know(name: string, generation: number): void {
     assertFixtureName(name);
@@ -168,6 +190,33 @@ export class AuthSwitchFakeClaudeProvider {
       }
       return Response.json({ data: [], has_more: false });
     }
+    if (url === 'https://api.openai.com/v1/models') {
+      // The model list of an OpenAI API key, which the authority reads to learn whether OpenAI accepts a key.
+      this.openAiModelListCalls++;
+      if (this.openAiModelsDown) {
+        return Response.json({ error: { message: 'overloaded', type: 'server_error' } }, { status: 503 });
+      }
+      const headers = new Headers(init?.headers);
+      // Only the request the authority's verifier sends is a fixture request: anything else is answered as malformed.
+      if ((init?.method ?? 'GET') !== 'GET' || init?.redirect !== 'error' || headers.has('x-api-key')
+        || headers.has('openai-organization') || headers.has('openai-project')) {
+        return Response.json({ error: { message: 'not a fixture request', type: 'invalid_request_error' } },
+          { status: 400 });
+      }
+      const presented = (headers.get('authorization') ?? '').replace(/^Bearer /, '');
+      const issued = this.openAiApiKeys.get(presented);
+      if (!issued) {
+        // OpenAI quotes the key it refused (masked); the fake quotes it whole, so a test proves nothing repeats it.
+        return Response.json({ error: { message: `Incorrect API key provided: ${presented}`,
+          type: 'invalid_request_error', param: null, code: 'invalid_api_key' } }, { status: 401 });
+      }
+      if (!issued.modelRead) {
+        return Response.json({ error: { message: 'You have insufficient permissions for this operation. Missing scopes:'
+          + ' api.model.read.', type: 'invalid_request_error', param: null, code: null } }, { status: 403 });
+      }
+      return Response.json({ object: 'list', data: [{ id: 'gpt-fixture', object: 'model', created: 1_700_000_000,
+        owned_by: 'openai' }] });
+    }
     if (url === 'https://api.anthropic.com/api/oauth/usage') {
       const token = (new Headers(init?.headers).get('Authorization') ?? '').replace(/^Bearer /, '');
       const name = this.accessTokens.get(token);
@@ -395,7 +444,7 @@ export const authSwitchSeedClaudeAccount = async (daemon: AuthSwitchAuthorityDae
   } else {
     const account: IStoredAuthorityAccount = { id: accountId, providerId: 'anthropic', issuer: 'anthropic',
       subject: identity.accountUuid, workspaceId: identity.organizationUuid, label: name,
-      email: identity.emailAddress, plan: 'max', primaryGrantId: loginId, maxUsagePercent: null, reserveLiftUntil: null, lapsesAt: null, removed: false, revision: 1,
+      email: identity.emailAddress, plan: 'max', primaryGrantId: loginId, maxUsagePercent: null, reserveLiftUntil: null, lapsesAt: null, spendLimitMicroUsd: null, keyHint: null, removed: false, revision: 1,
       statusObservedAt: now, updateId };
     await database.changeAccountAndGrant(updateId, accountId, loginId, () => ({ account, grant }));
   }
@@ -418,8 +467,8 @@ export const authSwitchSeedClaudeAccount = async (daemon: AuthSwitchAuthorityDae
  * It serves the management and runtime sockets exactly as the installed authority does, with the Claude native
  * authority on a fixture host home, container homes confined to `homesDirectory` and Claude sign-ins made in
  * `claudeSignInDirectory`. Its OpenAI provider, its
- * Claude usage reads and its checks of an Anthropic API key go to the fake provider, which refuses everything that is
- * not a fixture request, and no Claude Code process is ever seen running on a home.
+ * Claude usage reads and its checks of an Anthropic or OpenAI API key go to the fake provider, which refuses everything
+ * that is not a fixture request, and no Claude Code process is ever seen running on a home.
  */
 export class AuthSwitchTestAuthority {
   private stopping: Promise<void> | null = null;
@@ -468,9 +517,7 @@ export class AuthSwitchTestAuthority {
         dataDirectory: plugins.path.join(directory, 'db'), socketPath: databaseSocketPath,
         authoritySocketPath, runtimeSocketPath,
         broker: { provider: new AuthSwitchOpenAiProvider({ fetch: provider.fetch }), secrets: plainCodec, proactive: false,
-          verifyAnthropicApiKey: async (apiKey, signal) => {
-            await plugins.flexAnthropic.listAnthropicApiKeyModels({ apiKey }, { signal, fetch: provider.fetch });
-          } },
+          verifyApiKey: authSwitchApiKeyVerifier(provider.fetch) },
         ...claude.options,
         codexNative: { home: new CodexNativeHome({ codexHome: codexHost.codexHome, executable: codexHost.binary,
           scope: codexHost.scope }), secrets: plainCodec },
@@ -663,7 +710,7 @@ export class AuthSwitchTestAuthority {
     await database.changeAccountAndGrant(updateId, account.accountId, account.loginId, () => ({
       account: { id: account.accountId, providerId: 'anthropic', issuer: 'anthropic', subject: identity.accountUuid,
         workspaceId: identity.organizationUuid, label: name, email: identity.emailAddress, plan: 'max',
-        primaryGrantId: account.loginId, maxUsagePercent: null, reserveLiftUntil: null, lapsesAt: null, removed: false, revision: 1, statusObservedAt: now, updateId },
+        primaryGrantId: account.loginId, maxUsagePercent: null, reserveLiftUntil: null, lapsesAt: null, spendLimitMicroUsd: null, keyHint: null, removed: false, revision: 1, statusObservedAt: now, updateId },
       grant: { id: account.loginId, accountId: account.accountId, providerId: 'anthropic', purpose: 'claude_host_native',
         audience: 'claude-code-host', state: 'native', owner: 'claude_native', grantGeneration: 1, authorizationGeneration: 1,
         revision: 1, ciphertext: null, accessExpiresAt: null, attemptId: null, retryAt: null, retryCount: 0,
@@ -701,7 +748,7 @@ export class AuthSwitchTestAuthority {
     const identity = authSwitchFixtureOpenAiIdentity(name);
     return { id: accountId, providerId: 'openai', issuer: 'openai', subject: identity.userId,
       workspaceId: identity.chatgptAccountId, label: name, email: identity.email, plan: 'pro', primaryGrantId: loginId,
-      maxUsagePercent: null, reserveLiftUntil: null, lapsesAt: null, removed: false, revision: 1, statusObservedAt: now, updateId };
+      maxUsagePercent: null, reserveLiftUntil: null, lapsesAt: null, spendLimitMicroUsd: null, keyHint: null, removed: false, revision: 1, statusObservedAt: now, updateId };
   }
 
   /**

package/ts_authswitch/ts_migration/0011_account_api_key_fields.ts

@@ -0,0 +1,20 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * Gives every account recorded before API keys carried a spend limit the two members the account record now states.
+ *
+ * An API key account may carry a monthly spend limit (`spendLimitMicroUsd`) and names how its key ends (`keyHint`);
+ * the record states each, or `null` for none. Every account recorded earlier has neither: it gains
+ * `spendLimitMicroUsd: null` and `keyHint: null` -- an Anthropic key held from before keeps no hint, since its key is
+ * sealed -- and nothing else about it changes, neither its revision nor its update id, since no one changed the
+ * account. A record that already carries a member keeps it exactly as it is, which is what makes an interrupted run
+ * safe to repeat.
+ */
+export const addAccountApiKeyFields = async (db: plugins.nosqldb.SmartdataDb): Promise<void> => {
+  const accounts = db.mongoDb.collection('authswitch_authority_accounts');
+  for (const member of ['spendLimitMicroUsd', 'keyHint'] as const) {
+    const missing = { [member]: { $exists: false } };
+    if (!await accounts.findOne(missing)) continue;
+    await accounts.updateMany(missing, { $set: { [member]: null } });
+  }
+};

package/ts_authswitch/ts_migration/index.ts

@@ -9,6 +9,7 @@ import { addAccountMaxUsage } from './0007_account_max_usage.js';
 import { addAccountLapse } from './0008_account_lapse.js';
 import { addAccountReserveLift } from './0009_account_reserve_lift.js';
 import { prepareCodexHostRelease } from './0010_codex_host_release.js';
+import { addAccountApiKeyFields } from './0011_account_api_key_fields.js';
 
 /**
  * Runs on every start of an existing store, in this fixed order. Each module recognises the published shapes it
@@ -25,4 +26,5 @@ export const runAuthorityMigrations = async (db: plugins.nosqldb.SmartdataDb): P
   await addAccountLapse(db);
   await addAccountReserveLift(db);
   await prepareCodexHostRelease(db);
+  await addAccountApiKeyFields(db);
 };

package/ts_interfaces/functions.authorityscope.ts

@@ -147,10 +147,10 @@ export const findAuthorityDaemonLogin = (
 };
 
 /**
- * The login AGL's inference proxy binds for an account, and its purpose, like `findAuthorityDaemonLogin`: a
- * ChatGPT account's daemon-held `openai_managed` login, or an Anthropic account's daemon-held login -- a Claude
- * sign-in (`claude_host_native`), the one that can back a binding when the account holds several, or an API key
- * (`anthropic_api_key`).
+ * The login AGL's inference proxy binds for an account, and its purpose, like `findAuthorityDaemonLogin`: an OpenAI
+ * account's daemon-held login -- a ChatGPT sign-in (`openai_managed`) or an API key (`openai_api_key`) -- or an
+ * Anthropic account's daemon-held login -- a Claude sign-in (`claude_host_native`), the one that can back a binding
+ * when the account holds several, or an API key (`anthropic_api_key`).
  */
 export const findAuthorityGatewayLogin = (
   projectionArg: IControllerAuthorityProjection,
@@ -159,17 +159,37 @@ export const findAuthorityGatewayLogin = (
   const snapshot = projectionArg.snapshot;
   const account = snapshot?.accounts.find((accountArg) => accountArg.id === accountIdArg);
   if (!snapshot || !account || account.removed) return 'no_account';
-  if (account.providerId !== 'anthropic') return findAuthorityDaemonLogin(projectionArg, accountIdArg);
+  if (account.providerId !== 'anthropic') {
+    const managed = findAuthorityDaemonLogin(projectionArg, accountIdArg);
+    return managed !== 'no_login' ? managed : snapshot.logins.find((loginArg) => loginArg.accountId === accountIdArg
+      && loginArg.purpose === 'openai_api_key' && loginArg.owner === 'daemon') ?? 'no_login';
+  }
   const logins = snapshot.logins.filter((loginArg) => loginArg.accountId === accountIdArg
     && (loginArg.purpose === 'claude_host_native' || loginArg.purpose === 'anthropic_api_key')
     && loginArg.owner === 'daemon');
   return logins.find((loginArg) => loginArg.capabilities.canBind) ?? logins[0] ?? 'no_login';
 };
 
+/**
+ * The login an API key's answers are reported on (`authswitch.authority.usage.spend`): the key's live gateway login, or
+ * once the key was removed the login it had, as the projection publishes removed accounts and their logins too; the
+ * accounts service records a removed key's spend. `undefined` when the projection names no API-key login of the account.
+ */
+export const findAuthorityApiKeyLogin = (
+  projectionArg: IControllerAuthorityProjection,
+  accountIdArg: string,
+): TControllerAccountLogin | undefined => {
+  const isKeyLogin = (loginArg: TControllerAccountLogin) => loginArg.accountId === accountIdArg && loginArg.owner === 'daemon'
+    && (loginArg.purpose === 'anthropic_api_key' || loginArg.purpose === 'openai_api_key');
+  const live = findAuthorityGatewayLogin(projectionArg, accountIdArg);
+  if (typeof live !== 'string') return isKeyLogin(live) ? live : undefined;
+  return projectionArg.snapshot?.logins.filter(isKeyLogin).at(-1);
+};
+
 /**
  * A pool of AGL's inference proxy: its provider, and what its accounts authenticate with -- a subscription sign-in
- * (a ChatGPT or a Claude account), or an Anthropic API key. Claude Code runs on the Claude subscription pool, Flex's
- * Claude models only on the API-key pool.
+ * (a ChatGPT or a Claude account), or an API key of the provider. Claude Code runs on the Claude subscription pool,
+ * Flex's Claude models only on the Anthropic API-key pool.
  */
 export interface IInferencePool {
   provider: 'openai' | 'anthropic';
@@ -179,7 +199,7 @@ export interface IInferencePool {
 /**
  * The pool of AGL's inference proxy an account serves in, or `undefined` for none: an account whose gateway login
  * (`findAuthorityGatewayLogin`) the authority holds ready, can bind and keeps in no tool's home -- a ChatGPT account
- * this host's Codex does not run on, a Claude account, or an Anthropic API key.
+ * this host's Codex does not run on, a Claude account, or an Anthropic or OpenAI API key.
  */
 export const findInferencePool = (
   projectionArg: IControllerAuthorityProjection,
@@ -197,6 +217,9 @@ export const findInferencePool = (
   if (account.providerId === 'anthropic' && login.purpose === 'anthropic_api_key') {
     return { provider: 'anthropic', credential: 'api_key' };
   }
+  if (account.providerId === 'openai' && login.purpose === 'openai_api_key') {
+    return { provider: 'openai', credential: 'api_key' };
+  }
   return undefined;
 };
 
@@ -230,6 +253,18 @@ export const isFlexAuthorityConnectionId = (valueArg: unknown): valueArg is stri
  */
 export const flexClaudePoolConnectionId = 'flex:proxy:anthropic';
 
+/**
+ * Whether an account serves in the Claude pool Flex's Claude models run on: an Anthropic API key in the proxy's
+ * Anthropic API-key pool (`findInferencePool`). An OpenAI key serves the OpenAI API-key pool, which Flex does not use.
+ */
+export const isFlexClaudePoolMember = (
+  projectionArg: IControllerAuthorityProjection,
+  accountIdArg: string,
+): boolean => {
+  const pool = findInferencePool(projectionArg, accountIdArg);
+  return pool?.provider === 'anthropic' && pool.credential === 'api_key';
+};
+
 /** Whether a value is a Flex connection id: an authority account's, or the Claude pool's. */
 export const isFlexConnectionId = (valueArg: unknown): valueArg is string =>
   valueArg === flexClaudePoolConnectionId || isFlexAuthorityConnectionId(valueArg);

package/ts_interfaces/interfaces.ts

@@ -5,7 +5,7 @@ import type {
   TControllerBrowserPaintAvailability,
   TControllerBrowserPaintTermination,
 } from './browserpaint.js';
-export const controllerProtocolVersion = 43 as const;
+export const controllerProtocolVersion = 44 as const;
 export const controllerUpgradeManagementVersion = 2 as const;
 export const controllerPackageName = 'agl' as const;
 /** The systemd user unit `agl service install` writes; a controller it runs reports it in its status. */

package/ts_interfaces/plugins.ts

@@ -2,9 +2,12 @@ import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
 import type * as browserRuntime from '@push.rocks/smartbrowser/runtime';
 // The account-management contract on its own. Its own doc comment declares it credential-free and
 // safe for browser code, while the package root is Node-only, so the browser-facing interfaces take
-// the subpath rather than the root export. It is a leaf that imports nothing, so the rules it
-// publishes -- the account label rule -- are taken from it as values rather than restated.
+// the subpath rather than the root export. Besides types it imports only the model id rule, itself a
+// leaf, so the rules it publishes -- the account label rule -- are taken from it as values rather than
+// restated.
 import * as authswitchAuthority from '../ts_authswitch/authority-contract.js';
+// An API key's monthly spend: the spend limit rule and dollar amounts, a leaf that imports nothing.
+import * as authswitchSpend from '../ts_authswitch/authority-spend.js';
 import type {
   AuthenticationResponseJSON,
   PublicKeyCredentialCreationOptionsJSON,
@@ -14,7 +17,7 @@ import type {
 
 export { typedrequestInterfaces };
 export type { browserRuntime };
-export { authswitchAuthority };
+export { authswitchAuthority, authswitchSpend };
 
 export type {
   AuthenticationResponseJSON,

package/ts_interfaces/requests.accounts.ts

@@ -97,6 +97,8 @@ export type TControllerAccountNativeAssignment = plugins.authswitchAuthority.IAu
 export type TControllerAccountOperation = plugins.authswitchAuthority.IAuthSwitchOperation;
 export type TControllerAccountPreuse = plugins.authswitchAuthority.IAuthSwitchPreuseOperation;
 export type TControllerAccountUsage = plugins.authswitchAuthority.IAuthSwitchUsageSnapshot;
+/** An API key's month, the reading of an API key account's usage (`kind: 'spend'`). */
+export type TControllerAccountSpendReading = plugins.authswitchAuthority.IAuthSwitchSpendReading;
 /** A re-check of a Claude login: the usage held once its read finished, and how that read went. */
 export type TControllerAccountUsageRecheck = plugins.authswitchAuthority.IAuthSwitchUsageRecheck;
 export type TControllerAccountsDoctorPage = plugins.authswitchAuthority.IAuthSwitchDoctorPage;
@@ -187,6 +189,52 @@ export interface IReq_ControllerAccountsMaxUsage extends plugins.typedrequestInt
   response: { answer: TControllerAccountsAnswer<TControllerAccount> };
 }
 
+/** The providers whose API keys the Accounts screen adds as accounts. */
+export type TControllerApiKeyProvider = plugins.authswitchAuthority.TAuthSwitchApiKeyProvider;
+
+/**
+ * The spend limit rule, as the accounts service publishes and applies it: a whole number of cents from
+ * `controllerSpendLimitRange.min` to `.max`, in micro-dollars. A view checks a value with it before it offers the
+ * change, and the service refuses any other value with `invalid_input`.
+ */
+export const isControllerSpendLimitMicroUsd = plugins.authswitchSpend.isAuthSwitchSpendLimitMicroUsd;
+/** The range of a spend limit, in micro-dollars. */
+export const controllerSpendLimitRange = plugins.authswitchSpend.authSwitchSpendLimitRange;
+
+/** The longest API key the accounts service holds, in characters; a longer value is refused before it is sent. */
+export const controllerApiKeyMaxLength = 512;
+
+/**
+ * Adds an Anthropic or OpenAI API key as an account, with an optional label and monthly spend limit
+ * (`isControllerSpendLimitMicroUsd`). The accounts service asks the provider whether it accepts the key before it holds
+ * it, and answers why when it does not (`api_key_unverified`, `invalid_input`). The key is never answered, logged or
+ * audited; the account names it only by how it ends (`keyHint`). The answer arrives only once the controller's own
+ * projection shows the account; it can take up to 35 seconds, the provider's answer included.
+ */
+export interface IReq_ControllerAccountsApiKeyAdd extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_ControllerAccountsApiKeyAdd
+> {
+  method: 'controller.accounts.apikey.add';
+  request: { providerId: TControllerApiKeyProvider; apiKey: string; label?: string; spendLimitMicroUsd?: number };
+  response: { answer: TControllerAccountsAnswer<{ account: TControllerAccount; loginId: string }> };
+}
+
+/**
+ * Sets an API key account's monthly spend limit, or clears it with `null`: at the limit AGL's inference proxy places
+ * nothing more on the key until the month ends (UTC). `expectedRevision` is the revision the view showed, so a change of
+ * an account that changed meanwhile is refused as `account_changed`, and a value that breaks the rule, or an account on
+ * a sign-in, as `invalid_input`, both by the service. The answer arrives only once the projection shows the result.
+ */
+export interface IReq_ControllerAccountsSpendLimit extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_ControllerAccountsSpendLimit
+> {
+  method: 'controller.accounts.spendlimit';
+  request: { accountId: string; expectedRevision: number; spendLimitMicroUsd: number | null };
+  response: { answer: TControllerAccountsAnswer<TControllerAccount> };
+}
+
 /** Duration validation shared with the authority; no implicit duration is supplied. */
 export const isControllerReserveLiftHours = plugins.authswitchAuthority.isAuthSwitchReserveLiftHours;
 

package/ts_interfaces/requests.ts

@@ -29,6 +29,8 @@ import type {
   IReq_ControllerAccountsRename,
   IReq_ControllerAccountsMaxUsage,
   IReq_ControllerAccountsReserveLift,
+  IReq_ControllerAccountsApiKeyAdd,
+  IReq_ControllerAccountsSpendLimit,
   IReq_ControllerAccountsSnapshot,
   IReq_ControllerAccountsUsageGet,
   IReq_ControllerAccountsUsageRecheck,
@@ -399,6 +401,8 @@ export type TControllerRequest =
   | IReq_ControllerAccountsRename
   | IReq_ControllerAccountsMaxUsage
   | IReq_ControllerAccountsReserveLift
+  | IReq_ControllerAccountsApiKeyAdd
+  | IReq_ControllerAccountsSpendLimit
   | IReq_ControllerAccountsRemove
   | IReq_ControllerAccountsAdd
   | IReq_ControllerAccountsReauth

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'agl',
-  version: '40.4.0',
+  version: '40.5.0',
   description: 'Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions'
 }

package/ts_web/accounts.plugins.ts

@@ -11,5 +11,7 @@ import * as authswitchUsageWindows from '../ts_authswitch/authority-usagewindows
 import * as authswitchUsageLimit from '../ts_authswitch/authority-usagelimit.js';
 // A Claude account's subscription facts and payment problem, in the words the authswitch command line uses; types only behind it.
 import * as authswitchSubscription from '../ts_authswitch/authority-subscription.js';
+// An API key's month: the spend limit rule and dollar amounts, as the command line states them; it imports nothing.
+import * as authswitchSpend from '../ts_authswitch/authority-spend.js';
 
-export { authswitchPreuseText, authswitchSubscription, authswitchUsageLimit, authswitchUsageWindows };
+export { authswitchPreuseText, authswitchSpend, authswitchSubscription, authswitchUsageLimit, authswitchUsageWindows };

package/ts_web/accounts.templates.ts

@@ -1,10 +1,11 @@
 import * as plugins from './plugins.js';
-import type {
-  IAccountActionSlot,
-  IAccountFact,
-  IAccountRow,
-  IAccountsSummary,
-  TAccountsTone,
+import {
+  spendAttentionPercent,
+  type IAccountActionSlot,
+  type IAccountFact,
+  type IAccountRow,
+  type IAccountsSummary,
+  type TAccountsTone,
 } from './classes.accountsreadmodel.js';
 
 /**
@@ -95,7 +96,10 @@ export const renderSlots = (
   `;
 };
 
-/** An account as one line of the list: mark, name and who uses it, its tightest window, its one status. */
+/**
+ * An account as one line of the list: mark, name and who uses it, its tightest window -- a key's month, which without a
+ * limit has its spend and no bar -- and its one status.
+ */
 export const renderListRow = (
   rowArg: IAccountRow,
   openArg: (rowArg: IAccountRow) => void,
@@ -113,8 +117,9 @@ export const renderListRow = (
         ${meter
           ? plugins.deesElement.html`
               <span class="meterText"><span>${meter.label}</span><span class="meterValue">${meter.valueText}</span></span>
-              <dees-meter .size=${'sm'} .value=${meter.percent} .threshold=${meter.threshold} .tone=${meterTone(meter.tone)}
-                .label=${meter.label} .valueText=${meter.valueText}></dees-meter>`
+              ${meter.percent === null ? '' : plugins.deesElement.html`<dees-meter .size=${'sm'} .value=${meter.percent}
+                .threshold=${meter.threshold} .tone=${meterTone(meter.tone)} .label=${meter.label}
+                .valueText=${meter.valueText}></dees-meter>`}`
           : plugins.deesElement.html`<span class="meterText"><span>No reading</span><span class="meterValue">—</span></span>`}
       </span>
       <dees-badge data-status .type=${badgeType(rowArg.pill.tone)} .text=${rowArg.pill.text}></dees-badge>
@@ -144,17 +149,21 @@ export const renderSummary = (summaryArg: IAccountsSummary): plugins.deesElement
   </div>
 `;
 
-/** An account's usage windows, each with its reset, ticked at its maximum; or why there is no reading. */
+/**
+ * An account's usage windows, each with its reset, ticked at its maximum; or why there is no reading. A key's month
+ * wants attention from `spendAttentionPercent` of its limit, with no tick: a key has no maximum usage.
+ */
 export const renderUsageMeters = (rowArg: IAccountRow, emptyArg: string): plugins.deesElement.TemplateResult => {
   const meters = rowArg.usage?.meters ?? [];
   const threshold = rowArg.maxUsagePercent !== null && rowArg.maxUsagePercent < 100 ? rowArg.maxUsagePercent : null;
+  const attentionAt = rowArg.apiKey ? spendAttentionPercent : threshold;
   return plugins.deesElement.html`
     <mp-usage-meters class=${rowArg.usage?.current === false ? 'stale' : ''} data-usage-meters
       .windows=${meters.map((meterArg) => ({
         label: meterArg.label,
         percent: meterArg.percent,
         resetText: meterArg.resetText,
-        tone: meterTone(meterArg.percent >= 100 ? 'neutral' : threshold !== null && meterArg.percent >= threshold
+        tone: meterTone(meterArg.percent >= 100 ? 'neutral' : attentionAt !== null && meterArg.percent >= attentionAt
           ? 'attention' : 'positive'),
       }))}
       .threshold=${threshold}