Files
hyperframes/packages/cli/src/auth/user.ts
T
James Russo 3e462f4277 feat(cli): use dedicated HyperFrames OAuth clients (#6687)
* feat(cli): use dedicated HyperFrames OAuth clients

* docs(cli): shorten credential store contract comment

* fix(cli): respect Windows modes in OAuth media test

* fix(cli): keep media workflows on HyperFrames OAuth

* test(cli): scope billing status assertions to wallet rows

* test(cli): align telemetry fixtures and CI auth inputs
2026-10-29 21:25:20 +00:00

116 lines
4.7 KiB
TypeScript

/**
* Persistence + display helpers for the friendly-display `user` block in
* the HyperFrames `~/.hyperframes/credentials` file.
*
* The `user` block is additive METADATA captured at login time from
* `GET /v3/users/me` — NOT a credential. It lets `auth status` (and the
* post-login "Logged in as ..." line) show a recognizable identity
* without re-hitting the API on every invocation, and keeps working when
* the API is unreachable.
*
* This file is SHARED with the Go `heygen` CLI, which writes the same
* `user` block (see `heygen-cli/internal/auth/user_store.go`). Persisting
* here goes through `readStore` / `writeStore`, which round-trip every
* unrecognized key — so saving our user block never clobbers a key the
* other CLI wrote.
*/
import { credentialPath } from "./paths.js";
import {
readStore,
writeStore,
deleteStore,
hasPreservedUnknownData,
type StoredUserInfo,
} from "./store.js";
export type { StoredUserInfo } from "./store.js";
/** True when `u` carries no friendly fields worth surfacing. */
export function isUserInfoEmpty(u: StoredUserInfo): boolean {
return !u.email && !u.first_name && !u.last_name && !u.username;
}
/**
* Most friendly name available, in priority order:
* email > "first last" > first-only > last-only > username > undefined.
* The "first-only" / "last-only" intermediates come from `combineName`,
* which returns `first || last || ""` when only one of the two is present
* (so a user with just a first name still resolves to that first name,
* not straight to username). The caller falls back to its own marker
* (e.g. "(unknown user)") on `undefined`. Mirrors `UserInfo.DisplayName()`
* in heygen-cli.
*/
export function userDisplayName(u: StoredUserInfo): string | undefined {
if (u.email) return u.email;
const name = combineName(u.first_name, u.last_name);
if (name) return name;
return u.username || undefined;
}
/**
* `"first last"` when both are present; otherwise `first || last || ""`
* (one-sided fall-through), and `""` when neither is set. The empty-string
* return is treated as falsy by `userDisplayName`, so it falls through to
* `username`.
*/
function combineName(first?: string, last?: string): string {
if (first && last) return `${first} ${last}`;
return first || last || "";
}
/**
* Persist the friendly-display block, preserving any co-located api_key /
* oauth blocks and unknown/foreign keys. An all-empty `StoredUserInfo`
* is a no-op (the caller should typically gate on `isUserInfoEmpty`
* before calling, but we guard here too so a failed probe can't blank an
* existing block by accident).
*
* A broken pre-existing file surfaces as a thrown `ErrInvalidStore` from
* `readStore` — callers treat persistence as best-effort and warn rather
* than fail the login.
*/
export async function saveUserInfo(info: StoredUserInfo, path = credentialPath()): Promise<void> {
if (isUserInfoEmpty(info)) return;
// readStore preserves co-located api_key / oauth blocks and any
// unknown/foreign keys (captured on a hidden slot), so writing back
// only attaches the user block. A legacy single-line plaintext file
// parses into { api_key }, so this upgrades it to JSON in passing.
const { credentials } = await readStore(path);
credentials.user = { ...info };
await writeStore(credentials, path);
}
/**
* Read the friendly-display block. Returns `null` when the file is absent
* or carries no `user` block (a pre-this-change login). Genuine parse
* errors propagate so the caller can warn rather than silently pretend
* the file is clean.
*/
export async function loadUserInfo(path = credentialPath()): Promise<StoredUserInfo | null> {
const { credentials, source } = await readStore(path);
if (source === "absent") return null;
if (!credentials.user || isUserInfoEmpty(credentials.user)) return null;
return credentials.user;
}
/**
* Remove the friendly-display block, leaving any co-located credential
* (and unknown/foreign keys) intact. When neither a known credential NOR
* any preserved unknown/foreign data survives, the orphaned-metadata file
* is removed entirely. A surviving unknown top-level key (a future
* credential another CLI owns) keeps the file — deleting it would clobber
* exactly the cross-CLI data the store machinery exists to preserve. A
* no-op when there is nothing to clear.
*/
export async function clearUserInfo(path = credentialPath()): Promise<void> {
const { credentials, source } = await readStore(path);
if (source === "absent" || !credentials.user) return;
delete credentials.user;
if (!credentials.api_key && !credentials.oauth && !hasPreservedUnknownData(credentials)) {
await deleteStore(path);
return;
}
await writeStore(credentials, path);
}