mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-18 16:08:56 +00:00
* 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
116 lines
4.7 KiB
TypeScript
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);
|
|
}
|