@indigoai-us/hq-cli 5.345.91 → 5.345.93

package/dist/lib/capacity/sign-in.d.ts

@@ -0,0 +1,103 @@
+/**
+ * hq capacity login / accounts (US-012).
+ *
+ * Account homes, vendor login, and registry writes stay in
+ * `hq lanes accounts login`. This module decides which accounts to show,
+ * which ones are expired rather than signed out, and which registry id to
+ * keep after the first usage read. It never refreshes a token.
+ */
+import { type CapacityAccount } from "./accounts.js";
+import { type NowView } from "./ledger.js";
+export type SignInState = "signed_in" | "expired" | "signed_out" | "unknown";
+export interface RosterRow {
+    provider: string;
+    label: string;
+    organization: string | null;
+    state: SignInState;
+    reason: string | null;
+    command: string | null;
+    observedAt: string | null;
+    home: string;
+    /** True when the registry account is read for usage and is not used by lanes. */
+    usageOnly?: boolean;
+}
+/** Sentence printed for an expired Claude credential. Other commands pass through. */
+export declare function formatRefreshLine(provider: string, command: string): string;
+export declare function laneEnableCommand(provider: string, label: string): string;
+export declare class SignInUsageError extends Error {
+    constructor(message: string);
+}
+export declare function formatCredits(value: string | number | null): string;
+export declare function promptsAllowed(input: {
+    stdinTty: boolean;
+    stdoutTty: boolean;
+    json?: boolean;
+}): boolean;
+export declare function organizationSlug(name: string): string | null;
+export declare function uniqueAccountId(base: string, taken: ReadonlySet<string>): string;
+export declare function generateAccountId(randomHex: string): string;
+export declare function addAccountCommands(provider?: string): string[];
+export declare function presentAccount(account: {
+    authState?: string;
+    signedOut?: boolean;
+    reason?: string | null;
+    fixCommand?: string | null;
+    homes?: string[];
+    limits?: unknown[];
+    labels?: string[];
+}, provider: string, userHome: string): {
+    state: SignInState;
+    reason: string | null;
+    command: string | null;
+};
+export declare function rosterFrom(accounts: readonly CapacityAccount[], view: NowView, userHome: string): RosterRow[];
+export declare function formatRoster(rows: readonly RosterRow[], nowMs: number): string;
+export declare function formatLoginText(rows: readonly RosterRow[], nowMs: number, extra?: {
+    repair?: boolean;
+    provider?: string;
+}): string;
+export declare function repairSelection(rows: readonly RosterRow[], provider?: string): {
+    signedOut: RosterRow[];
+    expired: RosterRow[];
+};
+export declare function loginJson(rows: readonly RosterRow[], nowMs: number, provider?: string): unknown;
+export interface CapacityLoginRequest {
+    provider?: string;
+    account?: string;
+    repair?: boolean;
+    json?: boolean;
+    interactive: boolean;
+}
+export interface CapacityLoginDeps {
+    rows: readonly RosterRow[];
+    nowMs: number;
+    ask: (question: string) => Promise<boolean>;
+    loginAccount: (provider: string, accountId: string) => Promise<{
+        id: string;
+        home: string;
+    }>;
+    readAccount: (provider: string, accountId: string, home: string) => Promise<NowView>;
+    renameAccount: (provider: string, from: string, to: string) => void;
+    takenIds: (provider: string) => string[];
+    formatReading: (view: NowView, provider: string, label: string, home: string) => string;
+    newAccountId: () => string;
+}
+export interface CapacityLoginResult {
+    exitCode: number;
+    text: string;
+    json?: unknown;
+}
+export declare function executeCapacityLogin(request: CapacityLoginRequest, deps: CapacityLoginDeps): Promise<CapacityLoginResult>;
+export declare function organizationFor(view: NowView, provider: string, home: string): string | null;
+export declare function renameCapacityAccount(hqRoot: string, providerRaw: string, fromRaw: string, toRaw: string, options?: {
+    force?: boolean;
+}): void;
+export declare function removeCapacityAccount(hqRoot: string, providerRaw: string, idRaw: string, options?: {
+    deleteHome?: boolean;
+    force?: boolean;
+    hostname?: string;
+    homedir?: () => string;
+}): {
+    removedHome: boolean;
+};
+//# sourceMappingURL=sign-in.d.ts.map

package/dist/lib/capacity/sign-in.js

@@ -0,0 +1,517 @@
+/**
+ * hq capacity login / accounts (US-012).
+ *
+ * Account homes, vendor login, and registry writes stay in
+ * `hq lanes accounts login`. This module decides which accounts to show,
+ * which ones are expired rather than signed out, and which registry id to
+ * keep after the first usage read. It never refreshes a token.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { defaultProviderHome } from "./accounts.js";
+import { EXPIRED_REASON, claudeOpenCommand, isExpiredReason, } from "./ledger.js";
+import { effectiveAccountHome } from "../lanes/account-home.js";
+import { canonicalizeHome, loadLanesConfig, writeLanesConfig } from "../lanes/config.js";
+import { LANE_PROVIDERS, parseLaneProvider } from "../lanes/types.js";
+import { formatSpan } from "./read.js";
+/** Sentence printed for an expired Claude credential. Other commands pass through. */
+export function formatRefreshLine(provider, command) {
+    if (provider === "claude" && (command === "claude" || command.startsWith("CLAUDE_CONFIG_DIR="))) {
+        return `Open Claude Code once to refresh: ${command}`;
+    }
+    return command;
+}
+export function laneEnableCommand(provider, label) {
+    return `hq lanes accounts enable ${provider} ${label}`;
+}
+export class SignInUsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SignInUsageError";
+    }
+}
+const RESERVED_IDS = new Set(["a", "default"]);
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function formatCredits(value) {
+    if (value === null || value === "")
+        return "—";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return "—";
+        return trimDecimals(value);
+    }
+    const trimmed = value.trim();
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+        return trimDecimals(Number(trimmed));
+    return trimmed;
+}
+function trimDecimals(value) {
+    const rounded = Math.round((value + Number.EPSILON) * 100) / 100;
+    return rounded.toFixed(2).replace(/\.00$/, "").replace(/(\.\d)0$/, "$1");
+}
+export function promptsAllowed(input) {
+    return input.stdinTty && input.stdoutTty && !input.json;
+}
+export function organizationSlug(name) {
+    // A domain-shaped organization ("getindigo.ai", from an individual plan)
+    // labels the account by its first part: "getindigo".
+    const domain = /^([a-z0-9-]+)(\.[a-z0-9-]+)+$/i.exec(name.trim());
+    const source = domain ? domain[1] : name;
+    const slug = source
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+    if (!slug || !/[a-z0-9]/.test(slug) || RESERVED_IDS.has(slug))
+        return null;
+    return slug;
+}
+export function uniqueAccountId(base, taken) {
+    if (!taken.has(base) && !RESERVED_IDS.has(base))
+        return base;
+    for (let n = 2; n < 1000; n += 1) {
+        const candidate = `${base}-${n}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    throw new SignInUsageError(`No free account id near ${base}`);
+}
+export function generateAccountId(randomHex) {
+    const hex = randomHex.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 8);
+    if (hex.length < 4)
+        throw new SignInUsageError("Could not generate an account id");
+    return `acct-${hex}`;
+}
+export function addAccountCommands(provider) {
+    const providers = provider ? [parseLaneProvider(provider)] : [...LANE_PROVIDERS];
+    return providers.map((name) => `hq capacity login ${name}`);
+}
+export function presentAccount(account, provider, userHome) {
+    const label = account.labels?.find((item) => item !== "default") ?? account.labels?.[0];
+    if (account.authState === "expired" || isExpiredReason(account.reason)) {
+        const home = account.homes?.[0] ?? null;
+        return {
+            state: "expired",
+            reason: EXPIRED_REASON,
+            command: provider === "claude"
+                ? claudeOpenCommand(home ?? (label === "default" ? null : home), userHome)
+                : account.fixCommand ?? null,
+        };
+    }
+    const signedOut = account.authState === "signed_out"
+        || account.signedOut === true
+        || isSignedOutReason(account.reason);
+    if (signedOut) {
+        const reason = account.reason && !isExpiredReason(account.reason)
+            ? account.reason
+            : "signed out: credential missing";
+        return {
+            state: "signed_out",
+            reason,
+            command: account.fixCommand ?? null,
+        };
+    }
+    const hasLimits = Array.isArray(account.limits) && account.limits.length > 0;
+    if (account.authState === "ok" || hasLimits) {
+        return { state: "signed_in", reason: null, command: null };
+    }
+    return { state: "unknown", reason: null, command: null };
+}
+function isSignedOutReason(reason) {
+    if (!reason || isExpiredReason(reason))
+        return false;
+    return reason.startsWith("signed out:")
+        || reason === "unavailable: auth"
+        || reason === "unavailable: missing_scope";
+}
+export function rosterFrom(accounts, view, userHome) {
+    const defaultHome = new Map();
+    for (const account of accounts) {
+        if (account.label === "default")
+            defaultHome.set(account.provider, path.resolve(account.home));
+    }
+    const rows = [];
+    for (const account of accounts) {
+        const folded = defaultHome.get(account.provider);
+        if (account.label !== "default" && folded && path.resolve(account.home) === folded)
+            continue;
+        const group = view.providers.find((provider) => provider.provider === account.provider);
+        const match = matchAccount(group?.accounts, account);
+        const presented = match
+            ? presentAccount({ ...match, homes: [account.home], labels: [account.label] }, account.provider, userHome)
+            : { state: "unknown", reason: null, command: null };
+        rows.push({
+            provider: account.provider,
+            label: account.label,
+            organization: match?.organization ?? null,
+            state: presented.state,
+            reason: presented.reason,
+            command: presented.state === "signed_out"
+                ? presented.command ?? `hq capacity login ${account.provider} --account ${account.label}`
+                : presented.command,
+            observedAt: match?.observedAt ?? latestLimitAt(match),
+            home: account.home,
+            usageOnly: account.lanes === false,
+        });
+    }
+    return rows;
+}
+function matchAccount(accounts, account) {
+    if (!accounts)
+        return undefined;
+    const resolved = path.resolve(account.home);
+    return accounts.find((row) => row.labels.includes(account.label))
+        ?? accounts.find((row) => row.homes.some((home) => path.resolve(home) === resolved));
+}
+function latestLimitAt(account) {
+    if (!account)
+        return null;
+    let latest = "";
+    for (const limit of account.limits) {
+        if (limit.observedAt > latest)
+            latest = limit.observedAt;
+    }
+    return latest || null;
+}
+export function formatRoster(rows, nowMs) {
+    if (rows.length === 0)
+        return "No accounts.";
+    const headers = ["PROVIDER", "LABEL", "ORGANIZATION", "STATE", "LAST READING"];
+    const body = rows.map((row) => [
+        row.provider,
+        row.usageOnly ? `${row.label} (usage only)` : row.label,
+        row.organization ?? "—",
+        row.state,
+        readingAge(row.observedAt, nowMs),
+    ]);
+    const lines = [formatTable(headers, body)];
+    for (const row of rows) {
+        if (!row.usageOnly)
+            continue;
+        lines.push("", `${row.provider} ${row.label}  usage only`);
+        lines.push(laneEnableCommand(row.provider, row.label));
+    }
+    for (const row of rows) {
+        if (row.state !== "expired" && row.state !== "signed_out")
+            continue;
+        lines.push("", `${row.provider} ${row.label}`, row.reason ?? row.state);
+        if (row.command)
+            lines.push(formatRefreshLine(row.provider, row.command));
+    }
+    return lines.join("\n");
+}
+export function formatLoginText(rows, nowMs, extra) {
+    const parts = [formatRoster(rows, nowMs)];
+    if (extra?.repair) {
+        const plan = repairSelection(rows, extra.provider);
+        parts.push(formatRepairPlan(plan));
+    }
+    parts.push(["Add an account:", ...addAccountCommands(extra?.provider)].join("\n"));
+    return parts.filter((part) => part.length > 0).join("\n\n");
+}
+export function repairSelection(rows, provider) {
+    const scoped = provider ? rows.filter((row) => row.provider === provider) : rows;
+    return {
+        signedOut: scoped.filter((row) => row.state === "signed_out"),
+        expired: scoped.filter((row) => row.state === "expired"),
+    };
+}
+function formatRepairPlan(plan) {
+    const lines = [];
+    if (plan.signedOut.length === 0)
+        lines.push("No signed-out accounts to repair.");
+    else {
+        lines.push("Signed out (login again):");
+        for (const row of plan.signedOut) {
+            lines.push(row.command ?? `hq capacity login ${row.provider} --account ${row.label}`);
+        }
+    }
+    if (plan.expired.length > 0) {
+        lines.push("", "Expired (open the account; login is not repeated):");
+        for (const row of plan.expired) {
+            lines.push(`${row.provider} ${row.label}`);
+            lines.push(row.reason ?? EXPIRED_REASON);
+            if (row.command)
+                lines.push(formatRefreshLine(row.provider, row.command));
+        }
+    }
+    return lines.join("\n");
+}
+export function loginJson(rows, nowMs, provider) {
+    return {
+        accounts: rows.map((row) => ({
+            provider: row.provider,
+            label: row.label,
+            organization: row.organization,
+            state: row.state,
+            reason: row.reason,
+            command: row.command ? formatRefreshLine(row.provider, row.command) : null,
+            usageOnly: row.usageOnly === true,
+            laneCommand: row.usageOnly ? laneEnableCommand(row.provider, row.label) : null,
+            lastReadingAge: readingAge(row.observedAt, nowMs),
+        })),
+        addAccountCommands: addAccountCommands(provider),
+    };
+}
+function readingAge(observedAt, nowMs) {
+    if (!observedAt)
+        return "—";
+    const at = Date.parse(observedAt);
+    if (Number.isNaN(at))
+        return "—";
+    return `${formatSpan(Math.floor((nowMs - at) / 1000))} ago`;
+}
+function formatTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
+    const render = (row) => row.map((entry, index) => entry.padEnd(widths[index] ?? 0)).join("  ");
+    const lines = [render(headers)];
+    if (rows.length > 0)
+        lines.push(render(widths.map((width) => "-".repeat(width))));
+    lines.push(...rows.map(render));
+    return lines.join("\n");
+}
+export async function executeCapacityLogin(request, deps) {
+    if (request.provider)
+        parseLaneProvider(request.provider);
+    if (request.account && !request.provider) {
+        throw new SignInUsageError("Pass a provider before --account.");
+    }
+    if (request.account)
+        assertRegistryAccountId(request.account);
+    const providerFilter = request.provider;
+    const wantsSignIn = Boolean(request.provider || request.account || request.repair);
+    if (!request.interactive && wantsSignIn && !request.json) {
+        return { exitCode: 1, text: "sign-in needs an interactive terminal" };
+    }
+    if (!request.interactive || request.json) {
+        return {
+            exitCode: 0,
+            text: formatLoginText(deps.rows, deps.nowMs, { repair: request.repair, provider: providerFilter }),
+            json: loginJson(deps.rows, deps.nowMs, providerFilter),
+        };
+    }
+    if (request.repair) {
+        return runRepair(request, deps);
+    }
+    if (request.provider) {
+        const block = await signInOne(request.provider, request.account, deps);
+        return { exitCode: 0, text: block };
+    }
+    const lines = [formatRoster(deps.rows, deps.nowMs)];
+    for (const provider of LANE_PROVIDERS) {
+        const yes = await deps.ask(`Sign into another ${provider} account?`);
+        if (!yes)
+            continue;
+        lines.push(await signInOne(provider, undefined, deps));
+    }
+    return { exitCode: 0, text: lines.join("\n\n") };
+}
+async function runRepair(request, deps) {
+    const plan = repairSelection(deps.rows, request.provider);
+    const lines = [formatRepairPlan(plan)];
+    for (const row of plan.signedOut) {
+        if (row.label === "default" || RESERVED_IDS.has(row.label)) {
+            lines.push(`${row.provider} ${row.label}: ${defaultVendorLogin(row.provider)}`);
+            continue;
+        }
+        const logged = await deps.loginAccount(row.provider, row.label);
+        const view = await deps.readAccount(row.provider, row.label, logged.home);
+        lines.push(deps.formatReading(view, row.provider, row.label, logged.home));
+    }
+    return { exitCode: 0, text: lines.join("\n\n") };
+}
+async function signInOne(provider, account, deps) {
+    const id = account ?? deps.newAccountId();
+    const logged = await deps.loginAccount(provider, id);
+    const view = await deps.readAccount(provider, logged.id, logged.home);
+    let label = logged.id;
+    if (!account) {
+        const org = organizationFor(view, provider, logged.home);
+        const slug = org ? organizationSlug(org) : null;
+        if (slug) {
+            const taken = new Set([...deps.takenIds(provider), ...RESERVED_IDS]);
+            taken.delete(logged.id);
+            const next = uniqueAccountId(slug, taken);
+            if (next !== logged.id) {
+                deps.renameAccount(provider, logged.id, next);
+                label = next;
+            }
+        }
+    }
+    return deps.formatReading(view, provider, label, logged.home);
+}
+export function organizationFor(view, provider, home) {
+    const group = view.providers.find((item) => item.provider === provider);
+    const resolved = path.resolve(home);
+    const account = group?.accounts?.find((row) => row.homes.some((item) => path.resolve(item) === resolved));
+    return account?.organization ?? null;
+}
+export function renameCapacityAccount(hqRoot, providerRaw, fromRaw, toRaw, options = {}) {
+    const provider = parseLaneProvider(providerRaw);
+    const from = requiredId(fromRaw, "account id");
+    const to = requiredId(toRaw, "new id");
+    assertRegistryAccountId(to);
+    assertNotLiveLane(hqRoot, provider, from, options.force);
+    const config = loadLanesConfig(hqRoot);
+    const accounts = config.providers[provider].accounts;
+    const current = accounts[from];
+    if (!current)
+        throw new SignInUsageError(unknownAccount(provider, from, accounts));
+    if (from === to)
+        return;
+    if (accounts[to])
+        throw new SignInUsageError(`${provider} account ${to} already exists.`);
+    accounts[to] = current;
+    delete accounts[from];
+    if (config.providers[provider].default_account === from) {
+        config.providers[provider].default_account = to;
+    }
+    const preferred = config.providers[provider].preferred_accounts;
+    if (preferred) {
+        config.providers[provider].preferred_accounts = preferred.map((id) => (id === from ? to : id))
+            .filter((id, index, all) => all.indexOf(id) === index);
+    }
+    writeLanesConfig(hqRoot, config);
+}
+export function removeCapacityAccount(hqRoot, providerRaw, idRaw, options = {}) {
+    const provider = parseLaneProvider(providerRaw);
+    const id = requiredId(idRaw, "account id");
+    const config = loadLanesConfig(hqRoot);
+    const accounts = config.providers[provider].accounts;
+    const current = accounts[id];
+    if (!current)
+        throw new SignInUsageError(unknownAccount(provider, id, accounts));
+    assertNotLiveLane(hqRoot, provider, id, options.force);
+    const hostname = options.hostname ?? "";
+    const home = hostname
+        ? effectiveAccountHome(current, hostname).home
+        : current.home;
+    if (options.deleteHome) {
+        assertDeletableHome(provider, id, home, options.homedir ?? (() => ""), hqRoot, config);
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+    delete accounts[id];
+    if (config.providers[provider].default_account === id)
+        delete config.providers[provider].default_account;
+    if (config.providers[provider].preferred_accounts) {
+        config.providers[provider].preferred_accounts = config.providers[provider].preferred_accounts
+            ?.filter((item) => item !== id);
+    }
+    try {
+        writeLanesConfig(hqRoot, config);
+    }
+    catch (err) {
+        if (!options.deleteHome)
+            throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new SignInUsageError(`Deleted the home for ${provider} ${id}, but the registry was not updated: ${message}`);
+    }
+    return { removedHome: options.deleteHome === true };
+}
+const LIVE_LANE_STATES = new Set(["running", "queued", "blocked", "awaiting_input"]);
+function assertNotLiveLane(hqRoot, provider, id, force) {
+    if (force)
+        return;
+    const dir = path.join(hqRoot, "workspace", "lanes", "lanes");
+    if (!fs.existsSync(dir))
+        return;
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!name.endsWith(".json") || name.includes(".conflict-") || name.startsWith("."))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (parsed.provider !== provider || parsed.account !== id)
+            continue;
+        if (typeof parsed.state !== "string" || !LIVE_LANE_STATES.has(parsed.state))
+            continue;
+        const laneId = typeof parsed.lane_id === "string" ? parsed.lane_id : name.replace(/\.json$/, "");
+        throw new SignInUsageError(`Refusing to change ${provider} ${id}: lane ${laneId} is ${parsed.state}. Pass --force to change it anyway.`);
+    }
+}
+function assertDeletableHome(provider, accountId, home, homedir, hqRoot, config) {
+    const userHome = homedir();
+    if (!userHome)
+        throw new SignInUsageError("Refusing to delete an account home without a home directory.");
+    const deps = {
+        homedir: () => userHome,
+        realpathSync: (target) => fs.realpathSync(target),
+        existsSync: (target) => fs.existsSync(target),
+    };
+    const resolved = canonicalizeHome(home, deps);
+    const user = canonicalizeHome(userHome, deps);
+    if (resolved === user)
+        throw new SignInUsageError("Refusing to delete the home directory.");
+    const root = canonicalizeHome(hqRoot, deps);
+    if (resolved === root || isAncestor(resolved, root)) {
+        throw new SignInUsageError("Refusing to delete the HQ root or one of its parents.");
+    }
+    for (const name of LANE_PROVIDERS) {
+        const defaults = canonicalizeHome(defaultProviderHome(name, userHome), deps);
+        if (resolved === defaults) {
+            throw new SignInUsageError(`Refusing to delete the default ${name} home. Remove the account without --delete-home.`);
+        }
+        if (isAncestor(resolved, defaults)) {
+            throw new SignInUsageError(`Refusing to delete a parent of the default ${name} home.`);
+        }
+    }
+    const expected = canonicalizeHome(path.join(userHome, `.${provider}-${accountId}`), deps);
+    if (resolved !== expected) {
+        throw new SignInUsageError(`Refusing to delete ${home}. Only ~/.${provider}-${accountId} can be deleted.`);
+    }
+    for (const other of LANE_PROVIDERS) {
+        for (const [id, account] of Object.entries(config.providers[other].accounts)) {
+            if (!account)
+                continue;
+            if (other === provider && id === accountId)
+                continue;
+            const otherHome = canonicalizeHome(account.home, deps);
+            if (otherHome === resolved) {
+                throw new SignInUsageError(`Refusing to delete ${home}. Another account still uses that home.`);
+            }
+        }
+    }
+}
+function isAncestor(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function assertRegistryAccountId(id) {
+    if (!ID_PATTERN.test(id) || RESERVED_IDS.has(id)) {
+        throw new SignInUsageError("Account id must start with a letter or number, contain only letters, numbers, dots, underscores, or hyphens, and must not be reserved (a, default).");
+    }
+}
+function defaultVendorLogin(provider) {
+    if (provider === "claude")
+        return "claude auth login";
+    if (provider === "codex")
+        return "codex login";
+    if (provider === "grok")
+        return "grok login";
+    return `hq capacity login ${provider}`;
+}
+function requiredId(value, name) {
+    const id = value.trim();
+    if (!id || id !== value)
+        throw new SignInUsageError(`${name} must be a non-empty id`);
+    return id;
+}
+function unknownAccount(provider, id, accounts) {
+    const known = Object.keys(accounts);
+    const suffix = known.length > 0 ? ` Known: ${known.join(", ")}.` : "";
+    return `Unknown ${provider} account ${id}.${suffix}`;
+}
+//# sourceMappingURL=sign-in.js.map

package/dist/lib/capacity/widget.d.ts

@@ -0,0 +1,22 @@
+/**
+ * HTML card for `hq capacity --widget`.
+ *
+ * Renders the projected now view only. It does not read credentials, homes,
+ * or account ids. The clock and time zone are arguments so tests can pin both.
+ */
+import type { CapacityAccount } from "./accounts.js";
+import { type NowView } from "./ledger.js";
+export interface CapacityWidgetInput {
+    view?: NowView;
+    accounts?: readonly CapacityAccount[];
+    nowMs: number;
+    timeZone: string;
+    stale?: boolean;
+    /** False when collector.json says the collector is off. */
+    collectorEnabled?: boolean | null;
+    /** True when the ledger directory or now.json is missing. */
+    ledgerMissing?: boolean;
+}
+export declare function capacityWidgetTimeZone(env?: NodeJS.ProcessEnv): string;
+export declare function renderCapacityWidget(input: CapacityWidgetInput): string;
+//# sourceMappingURL=widget.d.ts.map