@modelprofile.com/authswitch 3.3.0 → 5.0.0

package/dist_ts/claudehttp.d.ts

@@ -0,0 +1,39 @@
+/** A fixed, local diagnostic. Nothing a service sent (a body, a header) and no request header ever becomes one. */
+export declare class ClaudeRequestError extends Error {
+}
+/** How every Claude lookup reports a login the service does not accept (HTTP 401, or a refresh grant it rejected). */
+export declare const CLAUDE_LOGIN_REJECTED = "Login expired or was rejected. Log in again with Claude Code and save it.";
+/** The service did not accept the login. */
+export declare class ClaudeLoginRejectedError extends ClaudeRequestError {
+    constructor();
+}
+/** The service refused a request for too many requests. That says nothing about the account's usage or login. */
+export declare class ClaudeRateLimitError extends ClaudeRequestError {
+    readonly retryAt: string | null;
+    constructor(subjectArg: string, retryAt: string | null);
+}
+export interface IClaudeRequest {
+    url: string;
+    method: 'GET' | 'POST';
+    headers: Record<string, string>;
+    body?: string;
+    /** What diagnostics call the service: `Claude account` reads `The Claude account service could not be reached.` */
+    subject: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    /** Whether an error status's JSON body is read for the caller, such as an OAuth error code; otherwise it is discarded. */
+    readErrorBody?: boolean;
+    /** The clock a `Retry-After` delay is counted from. */
+    now: () => number;
+}
+export interface IClaudeResponse {
+    status: number;
+    /** The JSON object the service answered with; null for an empty body, a body that is not a JSON object, or an unread one. */
+    body: Record<string, unknown> | null;
+}
+/**
+ * One request to a Claude account service, shaped like Claude Code's own but naming authswitch in its User-Agent:
+ * redirects refused, bounded in time and in size, and cancelled with the caller's signal. A rate limit is reported as
+ * `ClaudeRateLimitError`; every other status is the caller's to interpret.
+ */
+export declare const claudeRequest: (fetcherArg: typeof fetch, requestArg: IClaudeRequest) => Promise<IClaudeResponse>;

package/dist_ts/claudehttp.js

@@ -0,0 +1,83 @@
+import { commitinfo } from './00_commitinfo_data.js';
+import { credentialRecord } from './classes.credentialstore.js';
+import { retryAtFrom } from './ratelimit.js';
+/** A fixed, local diagnostic. Nothing a service sent (a body, a header) and no request header ever becomes one. */
+export class ClaudeRequestError extends Error {
+}
+/** How every Claude lookup reports a login the service does not accept (HTTP 401, or a refresh grant it rejected). */
+export const CLAUDE_LOGIN_REJECTED = 'Login expired or was rejected. Log in again with Claude Code and save it.';
+/** The service did not accept the login. */
+export class ClaudeLoginRejectedError extends ClaudeRequestError {
+    constructor() { super(CLAUDE_LOGIN_REJECTED); }
+}
+/** The service refused a request for too many requests. That says nothing about the account's usage or login. */
+export class ClaudeRateLimitError extends ClaudeRequestError {
+    retryAt;
+    constructor(subjectArg, retryAt) {
+        super(`The ${subjectArg} service is rate limiting requests (HTTP 429); try again later.`);
+        this.retryAt = retryAt;
+    }
+}
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+/** The body as a JSON object, read to at most 1 MiB; null when it is empty or not a JSON object. */
+const jsonBody = async (responseArg, subjectArg) => {
+    const reader = responseArg.body?.getReader();
+    if (!reader)
+        return null;
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            size += part.value.byteLength;
+            if (size > MAX_RESPONSE_BYTES) {
+                await reader.cancel();
+                throw new ClaudeRequestError(`The ${subjectArg} response is too large.`);
+            }
+            chunks.push(part.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    try {
+        return credentialRecord(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * One request to a Claude account service, shaped like Claude Code's own but naming authswitch in its User-Agent:
+ * redirects refused, bounded in time and in size, and cancelled with the caller's signal. A rate limit is reported as
+ * `ClaudeRateLimitError`; every other status is the caller's to interpret.
+ */
+export const claudeRequest = async (fetcherArg, requestArg) => {
+    const timeout = AbortSignal.timeout(requestArg.timeoutMs);
+    const signal = requestArg.signal ? AbortSignal.any([requestArg.signal, timeout]) : timeout;
+    try {
+        const response = await fetcherArg(requestArg.url, {
+            method: requestArg.method, redirect: 'error', signal, body: requestArg.body,
+            headers: { ...requestArg.headers, 'User-Agent': `authswitch/${commitinfo.version}` },
+        });
+        if (response.status === 429) {
+            await response.body?.cancel();
+            throw new ClaudeRateLimitError(requestArg.subject, retryAtFrom(response.headers.get('retry-after'), requestArg.now()));
+        }
+        if (!response.ok && !requestArg.readErrorBody) {
+            await response.body?.cancel();
+            return { status: response.status, body: null };
+        }
+        return { status: response.status, body: await jsonBody(response, requestArg.subject) };
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw new ClaudeRequestError(`The ${requestArg.subject} request ${timeout.aborted ? 'timed out' : 'was cancelled'}.`);
+        if (error instanceof ClaudeRequestError)
+            throw error;
+        throw new ClaudeRequestError(`The ${requestArg.subject} service could not be reached.`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cliargs.d.ts

@@ -0,0 +1,36 @@
+/** A command line a command cannot run with. The command prints the message and exits with status 2. */
+export declare class UsageError extends Error {
+}
+export interface ICommandArgsSpec {
+    /** Options that take a value: `--name value` or `--name=value`. */
+    values: readonly string[];
+    /** Options that take none. */
+    flags: readonly string[];
+    maxPositionals: number;
+    /** The message for an unknown option or one positional too many. */
+    usage: string;
+}
+export interface ICommandArgs {
+    /** Each given value option's value, by option name. */
+    values: ReadonlyMap<string, string>;
+    flags: ReadonlySet<string>;
+    positionals: readonly string[];
+}
+/**
+ * A command's own arguments: value options, flags and positionals. Every option is accepted at most once, and a value
+ * is taken as it is, even when it starts with `-`, so a prompt can itself contain an option.
+ */
+export declare const parseCommandArgs: (argsArg: readonly string[], specArg: ICommandArgsSpec) => ICommandArgs;
+/**
+ * A duration option in milliseconds: whole seconds (`120`), or a number with a unit (`90s`, `2m`, `1h`, `1d`),
+ * within the bounds. Every unit the bounds message can name is accepted, so a value the message suggests parses.
+ */
+export declare const parseDurationOption: (nameArg: string, valueArg: string, boundsArg: {
+    minMs: number;
+    maxMs: number;
+}) => number;
+/** A whole-number option within the bounds. */
+export declare const parseIntegerOption: (nameArg: string, valueArg: string, boundsArg: {
+    min: number;
+    max: number;
+}) => number;

package/dist_ts/cliargs.js

@@ -0,0 +1,60 @@
+import { duration } from './accounts.js';
+/** A command line a command cannot run with. The command prints the message and exits with status 2. */
+export class UsageError extends Error {
+}
+/**
+ * A command's own arguments: value options, flags and positionals. Every option is accepted at most once, and a value
+ * is taken as it is, even when it starts with `-`, so a prompt can itself contain an option.
+ */
+export const parseCommandArgs = (argsArg, specArg) => {
+    const values = new Map();
+    const flags = new Set();
+    const positionals = [];
+    for (let index = 0; index < argsArg.length; index++) {
+        const argument = argsArg[index];
+        const separator = argument.startsWith('--') ? argument.indexOf('=') : -1;
+        const name = separator < 0 ? argument : argument.slice(0, separator);
+        if (specArg.values.includes(name)) {
+            if (values.has(name))
+                throw new UsageError(`Use ${name} only once.`);
+            const value = separator < 0 ? argsArg[++index] : argument.slice(separator + 1);
+            if (value === undefined)
+                throw new UsageError(`${name} requires a value.`);
+            values.set(name, value);
+        }
+        else if (separator < 0 && specArg.flags.includes(argument)) {
+            if (flags.has(argument))
+                throw new UsageError(`Use ${argument} only once.`);
+            flags.add(argument);
+        }
+        else if (argument.startsWith('-') || positionals.length >= specArg.maxPositionals) {
+            throw new UsageError(specArg.usage);
+        }
+        else
+            positionals.push(argument);
+    }
+    return { values, flags, positionals };
+};
+const DURATION_UNITS = { '': 1000, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+/**
+ * A duration option in milliseconds: whole seconds (`120`), or a number with a unit (`90s`, `2m`, `1h`, `1d`),
+ * within the bounds. Every unit the bounds message can name is accepted, so a value the message suggests parses.
+ */
+export const parseDurationOption = (nameArg, valueArg, boundsArg) => {
+    const match = /^(\d{1,7})([smhd]?)$/.exec(valueArg);
+    if (!match)
+        throw new UsageError(`${nameArg} takes a duration such as 120, 90s or 2m.`);
+    const milliseconds = Number(match[1]) * DURATION_UNITS[match[2]];
+    if (milliseconds < boundsArg.minMs || milliseconds > boundsArg.maxMs) {
+        throw new UsageError(`${nameArg} must be from ${duration(boundsArg.minMs / 1000)} to ${duration(boundsArg.maxMs / 1000)}.`);
+    }
+    return milliseconds;
+};
+/** A whole-number option within the bounds. */
+export const parseIntegerOption = (nameArg, valueArg, boundsArg) => {
+    const value = /^\d{1,6}$/.test(valueArg) ? Number(valueArg) : Number.NaN;
+    if (!(value >= boundsArg.min && value <= boundsArg.max))
+        throw new UsageError(`${nameArg} takes a whole number from ${boundsArg.min} to ${boundsArg.max}.`);
+    return value;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/consoletable.d.ts

@@ -0,0 +1,21 @@
+import * as plugins from './plugins.js';
+export declare const consoleWidth: () => number;
+export declare const consoleHeading: (textArg: string) => void;
+/**
+ * One note line beneath a table: dim, wrapped to the terminal, continuation lines under the prefix.
+ *
+ * Table cells wrap themselves (`overflow: 'wrap'` below), so a note is the only text a view writes that could run
+ * past the terminal. Words stay whole: one longer than the remaining width keeps its own line rather than being cut,
+ * so an account id or a URL stays selectable.
+ */
+export declare const consoleNote: (textArg: string, prefixArg?: string) => void;
+/**
+ * One table implementation for every command, including the label-per-line fallback on narrow terminals.
+ *
+ * `groupsArg` is smartconsole's optional visual grouping: a divider between runs of consecutive rows with
+ * different keys, and a colour line along the left edge per run. Keys are identities, never display labels,
+ * and the caller orders the rows so that every group is one run. Below 40 columns the fallback separates
+ * divider runs with one dim rule line; it has no left edge, so it draws no colour line, and it repeats a
+ * spanning cell on every row it covers. A column's `render` content is what both layouts show.
+ */
+export declare const consoleTable: <TRow>(outArg: plugins.smartconsole.SmartConsole, rowsArg: TRow[], columnsArg: plugins.smartconsole.IBackendTableColumn<TRow>[], groupsArg?: NoInfer<plugins.smartconsole.IBackendTableGroups<TRow>>) => Promise<void>;

package/dist_ts/consoletable.js

@@ -0,0 +1,63 @@
+import * as plugins from './plugins.js';
+import { bold, dim } from './formatting.js';
+export const consoleWidth = () => process.stdout.columns ?? 100;
+export const consoleHeading = (textArg) => { process.stdout.write(`\n${bold(textArg)}\n`); };
+/**
+ * One note line beneath a table: dim, wrapped to the terminal, continuation lines under the prefix.
+ *
+ * Table cells wrap themselves (`overflow: 'wrap'` below), so a note is the only text a view writes that could run
+ * past the terminal. Words stay whole: one longer than the remaining width keeps its own line rather than being cut,
+ * so an account id or a URL stays selectable.
+ */
+export const consoleNote = (textArg, prefixArg = '') => {
+    const words = textArg.split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return;
+    const width = consoleWidth();
+    const indent = ' '.repeat(prefixArg.length);
+    const lines = [];
+    let line = `${prefixArg}${words[0]}`;
+    for (const word of words.slice(1)) {
+        if (line.length + 1 + word.length > width) {
+            lines.push(line);
+            line = `${indent}${word}`;
+        }
+        else
+            line += ` ${word}`;
+    }
+    lines.push(line);
+    for (const written of lines)
+        process.stdout.write(`${dim(written)}\n`);
+};
+/**
+ * One table implementation for every command, including the label-per-line fallback on narrow terminals.
+ *
+ * `groupsArg` is smartconsole's optional visual grouping: a divider between runs of consecutive rows with
+ * different keys, and a colour line along the left edge per run. Keys are identities, never display labels,
+ * and the caller orders the rows so that every group is one run. Below 40 columns the fallback separates
+ * divider runs with one dim rule line; it has no left edge, so it draws no colour line, and it repeats a
+ * spanning cell on every row it covers. A column's `render` content is what both layouts show.
+ */
+export const consoleTable = async (outArg, rowsArg, columnsArg, groupsArg) => {
+    if (!rowsArg.length)
+        return;
+    const width = consoleWidth();
+    if (width < 40) {
+        // smartconsole's run semantics: null and undefined are the same key.
+        const dividerKeys = rowsArg.map(row => groupsArg?.divider?.(row) ?? null);
+        const rule = `  ${dim('─'.repeat(Math.max(1, width - 4)))}\n\n`;
+        const content = (column, row) => column.render
+            ? plugins.smartconsole.color.plain(column.render(row)) : String(column.value(row) ?? 'Unavailable');
+        rowsArg.forEach((row, index) => {
+            if (index > 0 && dividerKeys[index] !== dividerKeys[index - 1])
+                process.stdout.write(rule);
+            process.stdout.write(columnsArg.map(column => `  ${column.title}: ${content(column, row).replace(/\n/g, '\n    ')}`).join('\n') + '\n\n');
+        });
+        return;
+    }
+    await outArg.table(rowsArg, {
+        columns: columnsArg, overflow: 'wrap', groups: groupsArg,
+        theme: { header: { bold: true, foreground: 'cyan' }, border: { dim: true } },
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/helpers.d.ts

@@ -17,6 +17,8 @@ import type { IRemoteControlEnrollment, TEnrollmentState } from './interfaces.js
  * content or the new one, never a partial write.
  */
 export declare const writeSecretFileAtomically: (destinationPathArg: string, contentArg: string) => void;
+/** A Node system error's code, for the distinctions the callers make (`EEXIST`, `ENOENT`, `ELOCKED`, `ERELEASED`). */
+export declare const errorCode: (errorArg: unknown) => string | undefined;
 /**
  * Blocks the calling thread for `millisecondsArg`.
  *
@@ -26,6 +28,11 @@ export declare const writeSecretFileAtomically: (destinationPathArg: string, con
  * and the callers bound both the count and the duration.
  */
 export declare const pauseSynchronously: (millisecondsArg: number) => void;
+/**
+ * Waits `millisecondsArg` without blocking the thread. An aborted signal rejects the wait with its reason and clears
+ * the timer at once, so an abandoned wait never keeps the process alive.
+ */
+export declare const pause: (millisecondsArg: number, signalArg?: AbortSignal) => Promise<void>;
 /**
  * Trims third-party process output down to something safe to put in an error
  * message: one line, length-capped, and never empty.

package/dist_ts/helpers.js

@@ -48,6 +48,8 @@ export const writeSecretFileAtomically = (destinationPathArg, contentArg) => {
     }
     plugins.fs.chmodSync(destinationPathArg, 0o600);
 };
+/** A Node system error's code, for the distinctions the callers make (`EEXIST`, `ENOENT`, `ELOCKED`, `ERELEASED`). */
+export const errorCode = (errorArg) => errorArg?.code;
 /**
  * Blocks the calling thread for `millisecondsArg`.
  *
@@ -59,6 +61,19 @@ export const writeSecretFileAtomically = (destinationPathArg, contentArg) => {
 export const pauseSynchronously = (millisecondsArg) => {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, millisecondsArg);
 };
+/**
+ * Waits `millisecondsArg` without blocking the thread. An aborted signal rejects the wait with its reason and clears
+ * the timer at once, so an abandoned wait never keeps the process alive.
+ */
+export const pause = (millisecondsArg, signalArg) => new Promise((resolve, reject) => {
+    if (signalArg?.aborted) {
+        reject(signalArg.reason);
+        return;
+    }
+    const abort = () => { clearTimeout(timer); reject(signalArg.reason); };
+    const timer = setTimeout(() => { signalArg?.removeEventListener('abort', abort); resolve(); }, Math.max(0, millisecondsArg));
+    signalArg?.addEventListener('abort', abort, { once: true });
+});
 /**
  * Trims third-party process output down to something safe to put in an error
  * message: one line, length-capped, and never empty.
@@ -100,4 +115,4 @@ export const describeCodexFailure = (binaryArg, stdoutArg, stderrArg, spawnError
     }
     return summariseProcessOutput(stdoutArg, stderrArg, spawnErrorArg);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -20,4 +20,7 @@ export * from './classes.cli.js';
 export * from './classes.login.js';
 export * from './classes.operations.js';
 export * from './classes.service.js';
+export * from './classes.watch.js';
+export * from './classes.watchlock.js';
+export * from './watchpolicy.js';
 export declare const runCli: (argvArg?: string[]) => Promise<void>;

package/dist_ts/index.js

@@ -20,9 +20,12 @@ export * from './classes.cli.js';
 export * from './classes.login.js';
 export * from './classes.operations.js';
 export * from './classes.service.js';
+export * from './classes.watch.js';
+export * from './classes.watchlock.js';
+export * from './watchpolicy.js';
 import { AuthSwitchCli } from './classes.cli.js';
 export const runCli = async (argvArg = process.argv.slice(2)) => {
     const exitCode = await new AuthSwitchCli().run(argvArg);
     process.exitCode = exitCode;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUM7QUFFckMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxLQUFLLEVBQUUsVUFBb0IsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQWlCLEVBQUU7SUFDdkYsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLGFBQWEsRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN4RCxPQUFPLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztBQUM5QixDQUFDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxLQUFLLEVBQUUsVUFBb0IsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQWlCLEVBQUU7SUFDdkYsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLGFBQWEsRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN4RCxPQUFPLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztBQUM5QixDQUFDLENBQUMifQ==

package/dist_ts/interfaces.harness.d.ts

@@ -60,8 +60,9 @@ export interface IHarnessProcessControl {
  * A live credential that no longer holds the account the last switch activated.
  *
  * Authswitch records the hash of what it wrote, in its own store. A different hash with the same
- * account is that account's own token refresh; a different account is what a running instance
- * writing its in-memory login back looks like.
+ * account is that account's own token refresh; a different account means the login changed outside
+ * authswitch -- a new native login, or, for a harness that does not pick up swaps live, a running
+ * instance writing its in-memory login back.
  */
 export interface IHarnessCredentialDrift {
     slotId?: string;
@@ -101,6 +102,14 @@ export interface IHarnessAccountStatus {
     problems: string[];
     /** Optional structured data for shared presentation; never parse the display facts. */
     summary?: IHarnessStatusSummary;
+    /**
+     * Set when the provider refused a lookup for too many requests (HTTP 429). It says nothing about the account's
+     * usage: callers back off, never read it as an exhausted or expired login. `retryAt` is when the provider asked to
+     * be tried again (ISO 8601 UTC), or null when it did not say.
+     */
+    rateLimit?: {
+        retryAt: string | null;
+    };
 }
 export interface IHarnessStatusFact {
     label: string;
@@ -137,17 +146,18 @@ export interface IAccountType {
     plan: string;
     source: 'live' | 'stored';
 }
+/** Live billing information only. Never infer these fields from a plan or entitlement expiry. Dates are ISO 8601 UTC. */
+export interface IHarnessBilling {
+    hasActiveSubscription?: boolean;
+    autoRenew?: boolean;
+    renewsAt?: string;
+    cancelsAt?: string;
+    expiresAt?: string;
+}
 export interface IHarnessStatusSummary {
     /** A plan name does not imply an active billing status. */
     subscription?: IAccountType;
-    /** Live billing information only. Never infer these fields from a plan or entitlement expiry. */
-    billing?: {
-        hasActiveSubscription?: boolean;
-        autoRenew?: boolean;
-        renewsAt?: string;
-        cancelsAt?: string;
-        expiresAt?: string;
-    };
+    billing?: IHarnessBilling;
     /** Missing windows are unknown, not unused. Times are ISO 8601 UTC. */
     usageWindows?: IHarnessUsageWindow[];
     resets?: {
@@ -164,10 +174,24 @@ export interface IHarnessOutcome {
     lines: string[];
     problems: string[];
 }
-/** A read-only status lookup. */
+/**
+ * A caller's status-reading session, such as one `authswitch watch`. Within it an adapter may reuse a lookup whose
+ * answer rarely changes (a Claude profile) instead of repeating it on every read; outside a session every lookup is live.
+ */
+export interface IHarnessStatusSession {
+    /**
+     * The value `lookupArg` resolved to under `keyArg` less than `maxAgeMsArg` ago, otherwise the lookup's fresh result,
+     * which is then remembered. A rejected lookup is never remembered. Keys belong to the adapter that uses them, which
+     * prefixes them with its own id, so a key always names values of one type.
+     */
+    reuse<T>(keyArg: string, maxAgeMsArg: number, lookupArg: () => Promise<T>): Promise<T>;
+}
+/** One status lookup; see `IAuthHarness.readAccountStatus` for what it may and may not change. */
 export interface IHarnessStatusOptions {
     /** Cancels the lookup's requests; an adapter still bounds each request with its own timeout. */
     signal?: AbortSignal;
+    /** The session the read belongs to, when the caller reads the same accounts repeatedly. */
+    session?: IHarnessStatusSession;
 }
 /** A single text-only inference request. Credentials remain inside the adapter. */
 export interface IHarnessPreuseOptions {
@@ -191,6 +215,31 @@ export interface IAuthHarness {
     readState(): THarnessResult<IHarnessState>;
     /** Running instances of this harness, when the adapter owns their lifecycle. */
     readonly processes?: IHarnessProcessControl;
+    /**
+     * Whether running instances pick up a credential swap by themselves, on their next request.
+     *
+     * Such a harness is never offered a stop before a switch, and its outcomes carry no restart advice;
+     * an explicit stop request is still honoured through `processes`. Absent means running instances keep
+     * the login they loaded until they are restarted.
+     */
+    readonly liveSwap?: boolean;
+    /**
+     * Set when this harness's provider never reports renewal or cancellation dates, as a lower-case clause
+     * that completes "<label>: ...". Views then explain the missing dates once instead of per account.
+     */
+    readonly renewalUnavailableReason?: string;
+    /**
+     * Whether `authswitch watch` may switch this harness's login by itself when the active account runs out: every
+     * saved account's usage can be read, and a switch needs no session of the user's stopped. A helper process the
+     * adapter manages itself may still be restarted by its own switch -- Codex' app-server is, because its
+     * credential file cannot be rewritten underneath it. Absent means the watch never switches this harness.
+     */
+    readonly autoSwitch?: boolean;
+    /**
+     * The account's live status. It must never activate, switch or clear a login. It may renew the tokens of the
+     * saved copy it reads when the provider leaves it no other way to answer -- the Claude Code adapter does, for
+     * saved and inactive logins only, under its store's lock -- and must leave the active login's credential alone.
+     */
     readAccountStatus(accountIdArg: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
     readonly loginProviders?: IHarnessLoginProvider[];
     beginLogin?(options: IHarnessLoginOptions): Promise<IHarnessLoginHandle>;

package/dist_ts/interfaces.list.d.ts

@@ -1,4 +1,4 @@
-import type { IAccountType, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
+import type { IAccountType, IHarnessAccount, IHarnessAccountStatus, IHarnessBilling, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 /** Credential-free, versioned output of list --json. Missing status fields stay omitted. */
 export interface IAccountList {
     schemaVersion: 2;
@@ -39,6 +39,8 @@ export interface IAccountLimitRow {
     isActive: boolean;
     /** The adapter's plan name (`max`, `pro`), sanitised but not display-formatted; null when none is known or the row names no account. */
     accountType: IAccountType | null;
+    /** The account's live billing fields as its provider reported them (ISO UTC dates); null when none were reported or the row names no account. */
+    billing: IHarnessBilling | null;
     /** The provider's own window name, or null when no limit data is available. */
     limitType: string | null;
     scope: 'account' | 'feature' | null;

package/dist_ts/plugins.d.ts

@@ -8,6 +8,13 @@ export { childProcess, crypto, fs, os, path };
 export type { DatabaseSync };
 /** SQLite is needed only when accessing a Codex state database, not when hosting account APIs. */
 export declare const loadSqlite: () => typeof import("node:sqlite");
+import type * as properLockfile from 'proper-lockfile';
+export type TProperLockfile = typeof properLockfile;
+/**
+ * Claude Code's own lock library, loaded on first use: it installs process exit hooks when it loads, which a
+ * process that never changes a Claude Code login (such as a host embedding the account service) does not need.
+ */
+export declare const loadProperLockfile: () => Promise<TProperLockfile>;
 import * as smartconsole from '@push.rocks/smartconsole';
 export { smartconsole };
 import * as flexModels from '@modelprofile.com/flexharness-models';

package/dist_ts/plugins.js

@@ -9,6 +9,11 @@ export { childProcess, crypto, fs, os, path };
 const nativeRequire = createRequire(import.meta.url);
 /** SQLite is needed only when accessing a Codex state database, not when hosting account APIs. */
 export const loadSqlite = () => nativeRequire('node:sqlite');
+/**
+ * Claude Code's own lock library, loaded on first use: it installs process exit hooks when it loads, which a
+ * process that never changes a Claude Code login (such as a host embedding the account service) does not need.
+ */
+export const loadProperLockfile = () => import('proper-lockfile');
 // @push.rocks modules
 import * as smartconsole from '@push.rocks/smartconsole';
 export { smartconsole };
@@ -18,4 +23,4 @@ import * as flexOpenAi from '@modelprofile.com/flexharness-providers/openai';
 import * as flexAuth from '@modelprofile.com/flexharness-providers/auth';
 import * as flexAccounts from '@modelprofile.com/flexharness-providers/accounts';
 export { flexModels, flexOpenAi, flexAuth, flexAccounts };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUc1QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDO0FBRTlDLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ3JELGtHQUFrRztBQUNsRyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsR0FBaUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQztBQUUzRixzQkFBc0I7QUFDdEIsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLENBQUM7QUFFeEIsNEJBQTRCO0FBQzVCLE9BQU8sS0FBSyxVQUFVLE1BQU0sc0NBQXNDLENBQUM7QUFDbkUsT0FBTyxLQUFLLFVBQVUsTUFBTSxnREFBZ0QsQ0FBQztBQUM3RSxPQUFPLEtBQUssUUFBUSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3pFLE9BQU8sS0FBSyxZQUFZLE1BQU0sa0RBQWtELENBQUM7QUFDakYsT0FBTyxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUc1QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDO0FBRTlDLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ3JELGtHQUFrRztBQUNsRyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsR0FBaUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQztBQUszRjs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxHQUE2QixFQUFFLENBQUMsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUM7QUFFNUYsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDO0FBRXhCLDRCQUE0QjtBQUM1QixPQUFPLEtBQUssVUFBVSxNQUFNLHNDQUFzQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxVQUFVLE1BQU0sZ0RBQWdELENBQUM7QUFDN0UsT0FBTyxLQUFLLFFBQVEsTUFBTSw4Q0FBOEMsQ0FBQztBQUN6RSxPQUFPLEtBQUssWUFBWSxNQUFNLGtEQUFrRCxDQUFDO0FBQ2pGLE9BQU8sRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsQ0FBQyJ9

package/dist_ts/ratelimit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * When a provider that answered HTTP 429 asked to be tried again, read from its `Retry-After` header (RFC 9110: a
+ * number of seconds, or an HTTP date) and returned as ISO 8601 UTC. An absent or unreadable header is null: the
+ * provider did not say, and the caller picks its own backoff.
+ */
+export declare const retryAtFrom: (headerArg: string | null, nowArg: number) => string | null;
+/** The latest retry time several refused requests asked for; null when none of them said. */
+export declare const latestRetryAt: (retryAtsArg: readonly (string | null)[]) => string | null;

package/dist_ts/ratelimit.js

@@ -0,0 +1,13 @@
+/**
+ * When a provider that answered HTTP 429 asked to be tried again, read from its `Retry-After` header (RFC 9110: a
+ * number of seconds, or an HTTP date) and returned as ISO 8601 UTC. An absent or unreadable header is null: the
+ * provider did not say, and the caller picks its own backoff.
+ */
+export const retryAtFrom = (headerArg, nowArg) => {
+    const value = headerArg?.trim() ?? '';
+    const time = /^\d{1,9}$/.test(value) ? nowArg + Number(value) * 1000 : /^[A-Za-z]{3}, .+ GMT$/.test(value) ? Date.parse(value) : Number.NaN;
+    return Number.isFinite(time) ? new Date(time).toISOString() : null;
+};
+/** The latest retry time several refused requests asked for; null when none of them said. */
+export const latestRetryAt = (retryAtsArg) => retryAtsArg.filter((value) => value !== null).sort().at(-1) ?? null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmF0ZWxpbWl0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcmF0ZWxpbWl0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsQ0FBQyxTQUF3QixFQUFFLE1BQWMsRUFBaUIsRUFBRTtJQUNyRixNQUFNLEtBQUssR0FBRyxTQUFTLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDO0lBQ3RDLE1BQU0sSUFBSSxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7SUFDNUksT0FBTyxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ3JFLENBQUMsQ0FBQztBQUVGLDZGQUE2RjtBQUM3RixNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsQ0FBQyxXQUF1QyxFQUFpQixFQUFFLENBQ3RGLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQW1CLEVBQUUsQ0FBQyxLQUFLLEtBQUssSUFBSSxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDIn0=