@shardflux/cli 0.22.0 → 0.23.1

package/dist/cli-proxy-hub.d.ts

@@ -40,12 +40,6 @@ export declare const HUB_INFO_FILE = "cli-proxy.json";
 /** Paths in the hub workspace. */
 export declare const HUB_DIR = "/home/user/.cli-proxy-hub";
 export declare const HUB_AUTH_DIR = "/home/user/.cli-proxy-api";
-/**
- * Each provider's active login: `{ "<provider type>": "<auth file, relative to the auth directory>" }` (0600). The one
- * login of each provider that stays enabled in the hub; every other login of that provider is kept there with
- * `"disabled": true`. Written by the CLI and by the hub's sf-agent, both under the hub's `logins.lock`.
- */
-export declare const HUB_ACTIVE_FILE = "/home/user/.cli-proxy-hub/active.json";
 export interface HubInfo {
     version: 1;
     api_url: string;
@@ -238,7 +232,7 @@ export interface EnsureResult {
     callbackReplaced: boolean;
     /** The config written now; null when the hub kept its own. */
     config: HubConfig | null;
-    /** The hub's logins, one active per provider (the others kept disabled). */
+    /** The hub's logins, each enabled or disabled as the user left it. */
     logins: HubLogin[];
 }
 /** The hub could not be made ready (exit 1, code `cli_proxy_hub`). */
@@ -254,10 +248,10 @@ export declare function ensureCliProxyHub(cloud: Shardflux | HubCloud, opts: Ens
 /**
  * A login in the hub: one auth file. Only its provider, email and state are ever shown, never its tokens.
  *
- * CLIProxyAPI spreads requests across every enabled login of a provider (round-robin, fill-first) and moves to another
- * one on a 429, so the hub keeps exactly one enabled per provider: the user's active login. Every other login of that
- * provider stays in the hub with `"disabled": true` (CLIProxyAPI 8.0.23 never uses a disabled auth file) until the
- * user makes it active (`shard cli-proxy use`).
+ * The hub is the user's own CLIProxyAPI: it routes requests across the enabled logins exactly as its config says
+ * (round-robin, fill-first, session affinity, retries), the user's routing and their choice. A login with
+ * `"disabled": true` stays in the hub and is never used (CLIProxyAPI 8.0.23); `shard cli-proxy use` switches logins on
+ * and off.
  */
 export interface HubLogin {
     /** Path relative to the auth directory. */
@@ -267,15 +261,10 @@ export interface HubLogin {
     email: string | null;
     /** The file carries `"disabled": true`. */
     disabled: boolean;
-    /** The one login of its provider that serves requests. */
+    /** It serves requests: enabled, with a provider, and the user's (not a file the retired account pool router left). */
     active: boolean;
 }
-/** Parses active.json: provider type → auth file. Anything else (missing, not JSON, other values) counts as empty. */
-export declare function parseActive(text: string | null): Record<string, string>;
-/**
- * The hub's logins, oldest first, as they are (nothing changes): `active` marks the one active.json names while it is
- * enabled. Files the retired account pool router left are not listed (they stay disabled).
- */
+/** The hub's logins, oldest first, as they are (nothing changes). Files the retired account pool router left are not listed. */
 export declare function listHubLogins(ws: HubWorkspace): Promise<HubLogin[]>;
 /** The auth file's text with `disabled` set (true) or removed (false), every other field kept; null when unchanged. */
 export declare function withDisabled(text: string, disabled: boolean): string | null;
@@ -287,22 +276,25 @@ export declare function withDisabled(text: string, disabled: boolean): string |
  * or `gone`.
  */
 export declare const SET_AUTH_SCRIPT = "set -euo pipefail\na=/home/user/.cli-proxy-api; rel=$1; want=$2\ncase \"$rel\" in ''|/*|*..*) echo \"not a path inside the auth folder\" >&2; exit 2 ;; esac\nf=\"$a/$rel\"\n[ -f \"$f\" ] || { echo gone; exit 0; }\ntmp=$(mktemp \"$(dirname \"$f\")/.writing.XXXXXX\"); trap 'rm -f \"$tmp\"' EXIT\nchmod 0600 \"$tmp\"; cat > \"$tmp\"; touch -r \"$f\" \"$tmp\"\nif [ \"$(sha256sum < \"$f\" | cut -d' ' -f1)\" != \"$want\" ]; then echo changed; exit 0; fi\nmv -f \"$tmp\" \"$f\"; trap - EXIT\necho written\n";
-/** Writes active.json atomically (0600) from standard input. */
-export declare const ACTIVE_SCRIPT = "set -euo pipefail\ndir=/home/user/.cli-proxy-hub; mkdir -p \"$dir\"; umask 077\ntmp=$(mktemp \"$dir/.active.XXXXXX\"); trap 'rm -f \"$tmp\"' EXIT\ncat > \"$tmp\"; mv -f \"$tmp\" \"$dir/active.json\"; trap - EXIT\necho written\n";
 /**
- * Keeps exactly one login enabled per provider (call it under the hub's `logins` lock, so two computers do not race):
- * `prefer[provider]` when given, else the one active.json names while it is present and enabled, else the oldest.
- * active.json records the choice first, then every other login of that provider is disabled (all other fields kept), then
- * the chosen one is enabled. Files without a `type` are left alone; the retired pool router's files are
- * disabled and never chosen. Returns the logins as they are now, oldest first (without the pool router's).
+ * Under the hub's `logins` lock: the retired account pool router's files stay disabled (they were never the user's);
+ * every other login keeps the state its owner gave it. Returns the logins as they are now, oldest first.
  */
-export declare function enforceActiveLogins(ws: HubWorkspace, prefer?: Record<string, string>): Promise<HubLogin[]>;
+export declare function settleHubLogins(ws: HubWorkspace): Promise<HubLogin[]>;
 /**
- * One login per provider on a hub that may predate it, without waking the hub: a hub that is not running is left
- * alone (it is checked again later). The forwarder on every connected computer runs this at start and every 15
- * minutes, so a hub set up before this rule stops spreading requests across logins without anyone running a command.
+ * The user's choice of which logins serve requests (`shard cli-proxy use`; call it under the hub's `logins` lock).
+ * `only[provider]` names the one login of that provider that stays enabled (it is enabled first, then the provider's
+ * other logins are disabled, so the provider is never without one); `all` enables every login of the hub, which then
+ * routes across them as its config says. Providers the choice does not name are left as they are. Returns the logins
+ * as they are now, oldest first.
  */
-export declare function enforceHubLoginsIfRunning(hub: HubCloud, workspaceId: string): Promise<'enforced' | 'asleep' | 'missing'>;
+export declare function useHubLogins(ws: HubWorkspace, choice: {
+    only?: Record<string, string>;
+    all?: boolean;
+}): Promise<HubLogin[]>;
+/** Where CLI 0.22.0 reads each provider's one login ({"<provider>": "<auth file>"}); written atomically (0600). */
+export declare const LEGACY_ACTIVE_FILE = "/home/user/.cli-proxy-hub/active.json";
+export declare const LEGACY_ACTIVE_SCRIPT = "set -euo pipefail\ndir=/home/user/.cli-proxy-hub; mkdir -p \"$dir\"; umask 077\ntmp=$(mktemp \"$dir/.active.XXXXXX\"); trap 'rm -f \"$tmp\"' EXIT\ncat > \"$tmp\"; mv -f \"$tmp\" \"$dir/active.json\"; trap - EXIT\necho written\n";
 /** Removes the router's files; prints `retired` when its hub token was there (its sf-agent then starts again without it). */
 export declare const RETIRE_POOL_SCRIPT: string;
 /** The config without the router's own client key (`api-keys`, or v8 `access.api-keys`); the text itself when absent. */

package/dist/cli-proxy-hub.js

@@ -50,12 +50,6 @@ export const HUB_INFO_FILE = 'cli-proxy.json';
 /** Paths in the hub workspace. */
 export const HUB_DIR = '/home/user/.cli-proxy-hub';
 export const HUB_AUTH_DIR = '/home/user/.cli-proxy-api';
-/**
- * Each provider's active login: `{ "<provider type>": "<auth file, relative to the auth directory>" }` (0600). The one
- * login of each provider that stays enabled in the hub; every other login of that provider is kept there with
- * `"disabled": true`. Written by the CLI and by the hub's sf-agent, both under the hub's `logins.lock`.
- */
-export const HUB_ACTIVE_FILE = `${HUB_DIR}/active.json`;
 const CALLBACK_PATH = /^\/__shardflux\/callback\/sfcb_[A-Za-z0-9_-]+\/$/;
 function callbackUrlOk(cb) {
     try {
@@ -661,8 +655,8 @@ export async function ensureCliProxyHub(cloud, opts) {
     // A hub that once ran the retired account pool router: its files go, and its sf-agent starts again without it.
     if (await retirePool(ws))
         restart = true;
-    // One login per provider serves requests: the rest stay in the hub, disabled.
-    const logins = await ws.withLock('logins', () => enforceActiveLogins(ws));
+    // The user's logins stay as they are; only the retired account pool router's files are kept disabled.
+    const logins = await ws.withLock('logins', () => settleHubLogins(ws));
     const started = await ws.sh(START_SCRIPT, [restart ? '1' : '0'], { timeoutMs: 180_000 });
     const startLines = started.stdout.trim().split('\n');
     const state = startLines.find((l) => ['running', 'started', 'restarted'].includes(l));
@@ -684,23 +678,6 @@ export async function ensureCliProxyHub(cloud, opts) {
         writeHubInfo(opts.dir, info);
     return { info, created, process: state, callbackReplaced, config, logins };
 }
-/** Parses active.json: provider type → auth file. Anything else (missing, not JSON, other values) counts as empty. */
-export function parseActive(text) {
-    let v;
-    try {
-        v = JSON.parse(text ?? '');
-    }
-    catch {
-        return {};
-    }
-    if (!v || typeof v !== 'object' || Array.isArray(v))
-        return {};
-    const out = {};
-    for (const [k, f] of Object.entries(v))
-        if (typeof f === 'string' && f)
-            out[k.toLowerCase()] = f;
-    return out;
-}
 const docOf = (text) => {
     try {
         const v = JSON.parse(text ?? '');
@@ -710,16 +687,13 @@ const docOf = (text) => {
         return null;
     }
 };
-/**
- * The hub's logins, oldest first, as they are (nothing changes): `active` marks the one active.json names while it is
- * enabled. Files the retired account pool router left are not listed (they stay disabled).
- */
+const publicLogins = (logins) => logins.filter((l) => !l.pool).map(({ file, provider, email, disabled, active }) => ({ file, provider, email, disabled, active }));
+/** The hub's logins, oldest first, as they are (nothing changes). Files the retired account pool router left are not listed. */
 export async function listHubLogins(ws) {
-    const logins = await readHubLogins(ws, parseActive(await ws.read(HUB_ACTIVE_FILE)));
-    return logins.filter((l) => !l.pool).map(({ file, provider, email, disabled, active }) => ({ file, provider, email, disabled, active }));
+    return publicLogins(await readHubLogins(ws));
 }
 /** The hub's logins, oldest first (the order authFiles lists them in). */
-async function readHubLogins(ws, stored) {
+async function readHubLogins(ws) {
     const files = await ws.authFiles();
     const texts = await Promise.all(files.map((f) => ws.read(`${HUB_AUTH_DIR}/${f}`)));
     return files.map((file, i) => {
@@ -727,10 +701,10 @@ async function readHubLogins(ws, stored) {
         const doc = docOf(text);
         const type = typeof doc?.type === 'string' && doc.type.trim() ? doc.type.trim().toLowerCase() : null;
         const email = typeof doc?.email === 'string' && doc.email ? doc.email : null;
-        // The retired pool router's files (`sfa-<account id>.json`, `"prefix": "sfa-…"`) are never a user's active login.
+        // The retired pool router's files (`sfa-<account id>.json`, `"prefix": "sfa-…"`) were never the user's logins.
         const pool = /^sfa-[^/]+\.json$/.test(file) || (typeof doc?.prefix === 'string' && doc.prefix.startsWith('sfa-'));
         const disabled = doc?.disabled === true;
-        return { file, provider: type, email, disabled, active: !pool && !disabled && type !== null && stored[type] === file, text, doc, pool };
+        return { file, provider: type, email, disabled, active: !pool && !disabled && type !== null, text, doc, pool };
     });
 }
 /** The auth file's text with `disabled` set (true) or removed (false), every other field kept; null when unchanged. */
@@ -762,13 +736,6 @@ if [ "$(sha256sum < "$f" | cut -d' ' -f1)" != "$want" ]; then echo changed; exit
 mv -f "$tmp" "$f"; trap - EXIT
 echo written
 `;
-/** Writes active.json atomically (0600) from standard input. */
-export const ACTIVE_SCRIPT = `set -euo pipefail
-dir=${HUB_DIR}; mkdir -p "$dir"; umask 077
-tmp=$(mktemp "$dir/.active.XXXXXX"); trap 'rm -f "$tmp"' EXIT
-cat > "$tmp"; mv -f "$tmp" "$dir/active.json"; trap - EXIT
-echo written
-`;
 const sha256 = (text) => createHash('sha256').update(text, 'utf8').digest('hex');
 /** Sets one login's `disabled` (true) or clears it (false), reading the file again when CLIProxyAPI changed it meanwhile. */
 async function setDisabled(ws, login, disabled) {
@@ -790,66 +757,70 @@ async function setDisabled(ws, login, disabled) {
     throw new HubError(`${login.file} kept changing in the hub while it was being ${disabled ? 'disabled' : 'enabled'}.`, 'run: shard cli-proxy import');
 }
 /**
- * Keeps exactly one login enabled per provider (call it under the hub's `logins` lock, so two computers do not race):
- * `prefer[provider]` when given, else the one active.json names while it is present and enabled, else the oldest.
- * active.json records the choice first, then every other login of that provider is disabled (all other fields kept), then
- * the chosen one is enabled. Files without a `type` are left alone; the retired pool router's files are
- * disabled and never chosen. Returns the logins as they are now, oldest first (without the pool router's).
+ * Under the hub's `logins` lock: the retired account pool router's files stay disabled (they were never the user's);
+ * every other login keeps the state its owner gave it. Returns the logins as they are now, oldest first.
  */
-export async function enforceActiveLogins(ws, prefer = {}) {
-    const storedText = await ws.read(HUB_ACTIVE_FILE);
-    const stored = parseActive(storedText);
-    const logins = await readHubLogins(ws, stored);
-    const chosen = {};
-    for (const login of logins) {
-        const p = login.provider;
-        if (p === null || login.pool || chosen[p] !== undefined)
-            continue;
-        const mine = logins.filter((l) => l.provider === p && !l.pool);
-        const wanted = prefer[p];
-        if (wanted !== undefined && !mine.some((l) => l.file === wanted))
-            throw new HubError(`The hub has no ${p} login ${wanted} any more.`, 'see the hub’s logins: shard cli-proxy');
-        const current = mine.find((l) => l.file === stored[p] && !l.disabled);
-        chosen[p] = wanted ?? current?.file ?? login.file;
-    }
-    // Record the choice first, then disable the rest, then enable the chosen login: two logins of one provider are never
-    // enabled at the same moment (CLIProxyAPI would fail over between them), at the cost of an instant with none during a
-    // switch. The hub's sf-agent keeps one enabled login per provider on every change (the one active.json names, else
-    // the oldest enabled, never enabling one), so in this order it never disables the chosen login.
-    const text = `${JSON.stringify(Object.fromEntries(Object.entries(chosen).sort(([a], [b]) => a.localeCompare(b))), null, 2)}\n`;
-    if (text !== storedText && (storedText !== null || Object.keys(chosen).length > 0)) {
-        const r = await ws.sh(ACTIVE_SCRIPT, [], { stdin: text });
-        if (r.code !== 0)
-            throw new HubError(`The hub did not record its active logins: ${r.stderr.trim().split('\n').at(-1) || `exit ${r.code}`}`, 'run: shard cli-proxy import');
-    }
+export async function settleHubLogins(ws) {
+    const logins = await readHubLogins(ws);
     for (const l of logins)
-        if (l.provider !== null && chosen[l.provider] !== l.file && !l.disabled)
+        if (l.pool && !l.disabled)
             await setDisabled(ws, l, true);
-    for (const l of logins)
-        if (l.provider !== null && chosen[l.provider] === l.file && l.disabled)
-            await setDisabled(ws, l, false);
-    return logins.filter((l) => !l.pool).map(({ file, provider, email, disabled }) => {
-        const active = provider !== null && chosen[provider] === file;
-        return { file, provider, email, disabled: provider === null ? disabled : !active, active };
-    });
+    return publicLogins(logins);
 }
 /**
- * One login per provider on a hub that may predate it, without waking the hub: a hub that is not running is left
- * alone (it is checked again later). The forwarder on every connected computer runs this at start and every 15
- * minutes, so a hub set up before this rule stops spreading requests across logins without anyone running a command.
+ * The user's choice of which logins serve requests (`shard cli-proxy use`; call it under the hub's `logins` lock).
+ * `only[provider]` names the one login of that provider that stays enabled (it is enabled first, then the provider's
+ * other logins are disabled, so the provider is never without one); `all` enables every login of the hub, which then
+ * routes across them as its config says. Providers the choice does not name are left as they are. Returns the logins
+ * as they are now, oldest first.
  */
-export async function enforceHubLoginsIfRunning(hub, workspaceId) {
-    const state = await hub.state(workspaceId);
-    if (state === null)
-        return 'missing';
-    if (state !== 'running')
-        return 'asleep';
-    const opened = await hub.open(false);
-    if (!opened || opened.ws.id !== workspaceId)
-        return 'missing';
-    await opened.ws.withLock('logins', () => enforceActiveLogins(opened.ws));
-    return 'enforced';
+export async function useHubLogins(ws, choice) {
+    const logins = await readHubLogins(ws);
+    const only = choice.only ?? {};
+    for (const [p, file] of Object.entries(only)) {
+        if (!logins.some((l) => !l.pool && l.provider === p && l.file === file))
+            throw new HubError(`The hub has no ${p} login ${file} any more.`, 'see the hub’s logins: shard cli-proxy');
+    }
+    const wanted = (l) => {
+        if (l.pool || l.provider === null)
+            return null;
+        if (only[l.provider] !== undefined)
+            return only[l.provider] === l.file;
+        return choice.all ? true : null;
+    };
+    for (const l of logins)
+        if (wanted(l) === true && l.disabled)
+            await setDisabled(ws, l, false);
+    for (const l of logins)
+        if (wanted(l) === false && !l.disabled)
+            await setDisabled(ws, l, true);
+    // Computers still on CLI 0.22.0 keep the login active.json names for each provider: it names this choice too.
+    if (Object.keys(only).length) {
+        const text = await ws.read(LEGACY_ACTIVE_FILE);
+        let stored = {};
+        try {
+            const v = JSON.parse(text ?? '');
+            if (v && typeof v === 'object' && !Array.isArray(v))
+                stored = v;
+        }
+        catch { /* none yet */ }
+        const next = `${JSON.stringify({ ...stored, ...only }, null, 2)}\n`;
+        if (next !== text) {
+            const r = await ws.sh(LEGACY_ACTIVE_SCRIPT, [], { stdin: next });
+            if (r.code !== 0)
+                throw new HubError(`The hub did not record the choice: ${r.stderr.trim().split('\n').at(-1) || `exit ${r.code}`}`, 'run: shard cli-proxy use <email>');
+        }
+    }
+    return listHubLogins(ws);
 }
+/** Where CLI 0.22.0 reads each provider's one login ({"<provider>": "<auth file>"}); written atomically (0600). */
+export const LEGACY_ACTIVE_FILE = `${HUB_DIR}/active.json`;
+export const LEGACY_ACTIVE_SCRIPT = `set -euo pipefail
+dir=${HUB_DIR}; mkdir -p "$dir"; umask 077
+tmp=$(mktemp "$dir/.active.XXXXXX"); trap 'rm -f "$tmp"' EXIT
+cat > "$tmp"; mv -f "$tmp" "$dir/active.json"; trap - EXIT
+echo written
+`;
 /** What the retired account pool router kept in the hub (codex-connector 5 with pooled accounts). */
 const POOL_LEFTOVERS = ['api-token', 'api-url', 'pool.json', 'pool-creds.json', 'pool-status.json', 'pool-client.key', 'pool.lock'];
 /** Removes the router's files; prints `retired` when its hub token was there (its sf-agent then starts again without it). */

package/dist/cli-proxy.d.ts

@@ -213,14 +213,9 @@ export interface HubAccount {
     disabled: boolean;
     /** The auth file, relative to the hub's auth directory (null when CLIProxyAPI does not name it). */
     file: string | null;
-    /** The one login of its provider that serves requests (the others stay in the hub, disabled). */
+    /** It serves requests (enabled); a disabled login stays in the hub unused. */
     active: boolean;
 }
-/**
- * Marks each provider's active login: an enabled login whose file is one of `activeFiles` (the hub's active.json).
- * Without them (unreadable), a provider's only enabled login is its active one.
- */
-export declare function markActive(accounts: HubAccount[], activeFiles: ReadonlySet<string> | null): HubAccount[];
 /** The hub's logins from its management API (wakes the hub). */
 export declare function hubAccounts(info: HubInfo, timeoutMs?: number): Promise<HubAccount[]>;
 /** Whether the hub answers /healthz through its callback URL, and the edge's reason when it does not. */
@@ -253,8 +248,8 @@ export interface ImportResult {
     };
     /**
      * added: accounts this import gave the hub; already: accounts the hub had (its tokens stay); moved_aside: where this
-     * computer's auth files went once the hub had them (`<dir>.moved-to-shardflux`). active: each provider's one login
-     * that serves requests; disabled: the provider's other logins, kept in the hub (shard cli-proxy use switches).
+     * computer's auth files went once the hub had them (`<dir>.moved-to-shardflux`). active: the logins that serve
+     * requests; disabled: logins kept in the hub unused (as they were on the computer, or by --use).
      */
     logins: {
         uploaded: string[];
@@ -301,9 +296,9 @@ export declare function matchLogins<T extends {
  * one: the hub's copy may hold a newer refresh token), start the forwarder on 127.0.0.1:8317 and put the hub info into
  * the machine template.
  *
- * One login per provider serves requests. `--use <email|file>` (repeatable, one per provider) picks it; otherwise a
- * provider the hub already serves keeps its active login, and a provider new to the hub starts with this computer's
- * oldest login of it. Every other login is uploaded with `"disabled": true` and kept in the hub.
+ * Each login arrives as it is on this computer (enabled or disabled), and the hub routes across the enabled ones as
+ * the user's config says. `--use <email|file>` (repeatable, one per provider) makes that login the only one serving
+ * its provider (the provider's others are kept in the hub, disabled), as `shard cli-proxy use` does.
  */
 export declare function importCliProxy(ctx: Ctx, opts?: ImportOptions): Promise<ImportResult>;
 export interface ExportOptions {
@@ -335,46 +330,25 @@ export interface ExportResult {
  */
 export declare function exportCliProxy(ctx: Ctx, opts?: ExportOptions): Promise<ExportResult>;
 export interface UseResult {
-    /** Each provider this command set, with the login it had and the one it has now. */
+    /** Each provider this command set to one login, with the login that served it alone before (null if not one) and the one now. */
     switched: Array<{
         provider: string;
         from: LoginRef | null;
         to: LoginRef;
     }>;
-    /** Every provider's active login, and the other logins kept in the hub, disabled. */
+    /** The logins that serve requests now, and the ones kept in the hub, disabled. */
     active: LoginRef[];
     disabled: LoginRef[];
 }
 /**
- * `shard cli-proxy use <email|file>`: makes that login its provider's active one in the hub (an email with a Claude
- * and a Codex login sets both); the provider's other logins stay in the hub, disabled. Under the hub's logins lock.
+ * `shard cli-proxy use <email|file>`: that login alone serves its provider (an email with a Claude and a Codex login
+ * sets both); the provider's other logins stay in the hub, disabled. `--all`: every login serves again, and the hub
+ * routes across them as its config says. Under the hub's logins lock.
  */
 export declare function useCliProxyLogin(ctx: Ctx, spec: string, opts?: {
     hub?: HubCloud;
+    all?: boolean;
 }): Promise<UseResult>;
-/** How often the forwarder checks that the hub serves one login per provider while it runs. */
-export declare const HUB_LOGIN_CHECK_MS: number;
-/** How soon it looks again when the hub was asleep (a VM's request may wake it any moment; looking never wakes it). */
-export declare const HUB_LOGIN_ASLEEP_MS = 60000;
-/** The least time between two checks a request asks for (requests come in bursts). */
-export declare const HUB_LOGIN_NUDGE_MS = 10000;
-export interface HubLoginChecks {
-    /** A request arrived: the hub is awake or waking. Checks now unless a check found it running and fixed recently. */
-    nudge(): void;
-    stop(): void;
-}
-/**
- * The forwarder's check that the hub serves one login per provider (enforceHubLoginsIfRunning), never waking the hub:
- * at start; then every HUB_LOGIN_CHECK_MS while it runs and every HUB_LOGIN_ASLEEP_MS while it sleeps; and at the first
- * request after it slept (nudge), so a hub set up before one login per provider cannot fail over between logins for
- * long after it wakes. One check at a time.
- */
-export declare function hubLoginChecks(ctx: Ctx, source: () => HubInfo | null, log: (line: string) => void, opts?: {
-    hub?: HubCloud;
-    everyMs?: number;
-    asleepMs?: number;
-    nudgeMs?: number;
-}): HubLoginChecks;
 /**
  * After the edge refused the hub's callback URL (`callback_invalid`: the API key that created it was revoked):
  * replaces the URLs the edge refuses (under the hub's lock), saves them locally and gives VMs the new VM address.