@cortexkit/common-auth 0.2.4 → 0.2.6

package/dist/commands/seam.js

@@ -0,0 +1,185 @@
+// The one way out of the process for anything the command menu shows. Every
+// payload a renderer receives (the dialog payload and every apply result) is
+// produced here: each part is projected field by field from its definition,
+// so action bodies and stray properties never travel, and the whole payload
+// is then scrubbed of credential-shaped property names as a backstop. Nothing
+// outside this module can build a payload without passing through
+// `dialogPayload` or `applyResult`.
+/** The confirmation shown when an irreversible action names none. */
+export const DEFAULT_IRREVERSIBLE_CONFIRMATION = 'This cannot be undone. Continue?';
+const CREDENTIAL_NAMES = new Set([
+    'access',
+    'refresh',
+    'apikey',
+    'password',
+    'authheader',
+    'credential',
+    'credentials',
+]);
+/**
+ * True for a property name that looks like it holds a secret. Case, `-` and
+ * `_` are ignored, so `api_key`, `API-Key` and `apiKey` all match. Any name
+ * ending in `token`, `key` or `secret` matches: no menu field is named that
+ * way, so a match is a leak whatever the rest of the name says.
+ */
+function isCredentialName(name) {
+    const normalized = name.toLowerCase().replace(/[-_]/g, '');
+    return (CREDENTIAL_NAMES.has(normalized) ||
+        normalized.endsWith('token') ||
+        normalized.endsWith('key') ||
+        normalized.endsWith('secret'));
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** A copy of `value` without credential-shaped properties; their paths go to `found`. */
+function scrub(value, path, found) {
+    if (Array.isArray(value))
+        return value.map((entry, index) => scrub(entry, `${path}[${index}]`, found));
+    if (!isPlainRecord(value))
+        return value;
+    const out = {};
+    for (const [name, entry] of Object.entries(value)) {
+        if (isCredentialName(name)) {
+            found.push(`${path}.${name}`);
+            continue;
+        }
+        Object.defineProperty(out, name, {
+            value: scrub(entry, `${path}.${name}`, found),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return out;
+}
+function sealed(payload, command, logger) {
+    const found = [];
+    const clean = scrub(payload, 'payload', found);
+    if (found.length > 0)
+        logger.warn('credential-shaped field dropped from a command payload', {
+            command,
+            fields: found,
+        });
+    return clean;
+}
+function projectChoice(choice) {
+    return { value: String(choice.value), label: String(choice.label) };
+}
+function projectKnob(knob) {
+    switch (knob.kind) {
+        case 'choice':
+            return {
+                kind: 'choice',
+                id: knob.id,
+                label: knob.label,
+                choices: (knob.choices ?? []).map(projectChoice),
+                ...(knob.value !== undefined ? { value: knob.value } : {}),
+            };
+        case 'toggle':
+            return {
+                kind: 'toggle',
+                id: knob.id,
+                label: knob.label,
+                value: knob.value === true,
+            };
+        case 'number':
+            return {
+                kind: 'number',
+                id: knob.id,
+                label: knob.label,
+                ...(knob.value !== undefined ? { value: knob.value } : {}),
+                ...(knob.min !== undefined ? { min: knob.min } : {}),
+                ...(knob.max !== undefined ? { max: knob.max } : {}),
+                ...(knob.required ? { required: true } : {}),
+            };
+        case 'text':
+            return {
+                kind: 'text',
+                id: knob.id,
+                label: knob.label,
+                ...(knob.value !== undefined ? { value: knob.value } : {}),
+                ...(knob.placeholder !== undefined
+                    ? { placeholder: knob.placeholder }
+                    : {}),
+                ...(knob.masked ? { masked: true } : {}),
+                ...(knob.required ? { required: true } : {}),
+            };
+    }
+}
+/**
+ * The confirmation an action must pass before it runs, or undefined. An
+ * irreversible action always has one, even when its definition (built
+ * outside the type checker) names none.
+ */
+export function confirmationOf(action) {
+    if (action.irreversible === true)
+        return {
+            message: action.confirm || DEFAULT_IRREVERSIBLE_CONFIRMATION,
+            irreversible: true,
+        };
+    if (action.confirm)
+        return { message: action.confirm, irreversible: false };
+    return undefined;
+}
+function projectAction(action) {
+    const confirm = confirmationOf(action);
+    return {
+        id: action.id,
+        label: action.label,
+        ...(action.description !== undefined
+            ? { description: action.description }
+            : {}),
+        knobs: (action.knobs ?? []).map(projectKnob),
+        ...(confirm ? { confirm } : {}),
+    };
+}
+/** The account fields a renderer may show; see `MenuAccount`. */
+export function projectAccount(account) {
+    return {
+        id: account.id,
+        ...(account.label !== undefined ? { label: account.label } : {}),
+        enabled: account.enabled,
+        type: account.type,
+        ...(account.identity !== undefined ? { identity: account.identity } : {}),
+    };
+}
+function projectItem(item) {
+    return {
+        id: item.id,
+        label: item.label,
+        ...(item.detail !== undefined ? { detail: item.detail } : {}),
+        ...(item.account ? { account: projectAccount(item.account) } : {}),
+        ...(item.facts !== undefined ? { facts: item.facts } : {}),
+        actions: (item.actions ?? []).map(projectAction),
+    };
+}
+function projectSection(section) {
+    const { content } = section;
+    return {
+        id: section.id,
+        slot: section.slot,
+        title: section.title,
+        lines: (content.lines ?? []).map(String),
+        items: (content.items ?? []).map(projectItem),
+        actions: (content.actions ?? []).map(projectAction),
+        ...(content.facts !== undefined ? { facts: content.facts } : {}),
+    };
+}
+function projectMenu(command, title, sections) {
+    return { command, title, sections: sections.map(projectSection) };
+}
+/** The payload a host's TUI receives when the slash command opens. */
+export function dialogPayload(command, title, sections, logger) {
+    return sealed({ command, menu: projectMenu(command, title, sections) }, command, logger);
+}
+/** An apply's result: the message and the refreshed menu. */
+export function applyResult(command, title, sections, outcome, logger) {
+    return sealed({
+        command,
+        ok: outcome.ok,
+        text: outcome.text,
+        ...(outcome.needsConfirmation ? { needsConfirmation: true } : {}),
+        menu: projectMenu(command, title, sections),
+    }, command, logger);
+}

package/dist/dump/index.d.ts

@@ -1 +1,90 @@
-export {};
+export interface DumpLogger {
+    debug(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+}
+export interface DumpOptions {
+    /** Directory dumps are written to; a function is read on every dump. */
+    dir: string | (() => string);
+    /** Initial state; `setEnabled` switches it at runtime. Default off. */
+    enabled?: boolean;
+    /** Written into every filename. Default the current process id. */
+    pid?: number;
+    /** Clock for filenames and `createdAt`. Default `Date.now`. */
+    now?: () => number;
+    logger?: DumpLogger;
+    /**
+     * Key names redacted wherever they appear in headers, request metadata and
+     * the body, on top of the common credential set. Compared lower-cased with
+     * `-` and `_` removed, so `ChatGPT-Account-Id` and `chatgptAccountId` match
+     * `chatgptaccountid`.
+     */
+    secretKeys?: readonly string[];
+    /** Value patterns scrubbed from every string, on top of the common token patterns. */
+    secretPatterns?: readonly RegExp[];
+    /**
+     * Keys, at any depth of the body, whose values are declarations rather than
+     * data: their strings are scrubbed but their key names are never redacted.
+     * Default `['tools']`.
+     */
+    schemaKeys?: readonly string[];
+    /**
+     * Provider summary of the parsed body, stored in the metadata as `body`.
+     * It receives the redacted body.
+     */
+    summarize?: (body: Record<string, unknown>) => Record<string, unknown>;
+}
+export interface DumpInput {
+    /** The session the request belongs to; missing means `session-unknown`. */
+    session?: string | null;
+    /**
+     * Diff baseline group: a dump is diffed against the previous dump of the
+     * same session and channel (for example, one per transport).
+     */
+    channel: string;
+    /** Finer label for the filename, e.g. prewarm or main; it does not split the baseline. */
+    phase?: string;
+    bodyText: string;
+    accountId?: string;
+    url?: string;
+    method?: string;
+    headers?: ConstructorParameters<typeof Headers>[0];
+    status?: number;
+    error?: string;
+    /** Extra metadata, redacted like the body. */
+    meta?: Record<string, unknown>;
+}
+export interface DumpDiff {
+    changed: boolean;
+    firstByte: number;
+    lastPreviousByte: number;
+    lastCurrentByte: number;
+    changedPreviousBytes?: number;
+    changedCurrentBytes?: number;
+    previousBytes: number;
+    currentBytes: number;
+}
+export interface DumpResult {
+    id: string;
+    files: {
+        body: string;
+        metadata: string;
+        request: string;
+    };
+}
+export interface Dumper {
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    /**
+     * Write `<id>.body.json`, `<id>.meta.json` and `<id>.request.json`. Returns
+     * undefined when dumps are off or the write failed; dumping is diagnostic
+     * and never throws into the request path.
+     */
+    dump(input: DumpInput): Promise<DumpResult | undefined>;
+}
+/**
+ * Where two bodies first and last differ, in string offsets into the dumped
+ * (redacted) text. Offsets count UTF-16 units, as the plugins' cache analysis
+ * always has.
+ */
+export declare function diffDumpBodies(previous: string | undefined, current: string): DumpDiff | null;
+export declare function createDumper(options: DumpOptions): Dumper;

package/dist/dump/index.js

@@ -1,2 +1,292 @@
-// Placeholder so the export resolves until this subpath is built.
-export {};
+import { createHash } from 'node:crypto';
+import { chmod, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createRedactor } from '../logger/redact.js';
+const PREVIOUS_BODY_LIMIT = 100;
+const UNKNOWN_SESSION = 'session-unknown';
+function shortSession(session) {
+    return session.length <= 16 ? session : `${session.slice(0, 12)}…`;
+}
+function fileSegment(value, fallback) {
+    const normalized = value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!normalized)
+        return fallback;
+    return normalized.slice(0, 80);
+}
+function hashText(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function normalizeKey(key) {
+    return key.toLowerCase().replace(/[-_]/g, '');
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Where two bodies first and last differ, in string offsets into the dumped
+ * (redacted) text. Offsets count UTF-16 units, as the plugins' cache analysis
+ * always has.
+ */
+export function diffDumpBodies(previous, current) {
+    if (previous === undefined)
+        return null;
+    if (previous === current) {
+        return {
+            changed: false,
+            firstByte: -1,
+            lastPreviousByte: -1,
+            lastCurrentByte: -1,
+            previousBytes: previous.length,
+            currentBytes: current.length,
+        };
+    }
+    let firstByte = 0;
+    while (firstByte < previous.length &&
+        firstByte < current.length &&
+        previous[firstByte] === current[firstByte]) {
+        firstByte++;
+    }
+    let previousTail = previous.length - 1;
+    let currentTail = current.length - 1;
+    while (previousTail >= firstByte &&
+        currentTail >= firstByte &&
+        previous[previousTail] === current[currentTail]) {
+        previousTail--;
+        currentTail--;
+    }
+    return {
+        changed: true,
+        firstByte,
+        lastPreviousByte: previousTail,
+        lastCurrentByte: currentTail,
+        changedPreviousBytes: previousTail - firstByte + 1,
+        changedCurrentBytes: currentTail - firstByte + 1,
+        previousBytes: previous.length,
+        currentBytes: current.length,
+    };
+}
+export function createDumper(options) {
+    let enabled = options.enabled === true;
+    let counter = 0;
+    const pid = options.pid ?? process.pid;
+    const now = options.now ?? Date.now;
+    const log = options.logger;
+    const extraKeys = new Set((options.secretKeys ?? []).map(normalizeKey));
+    const redactor = createRedactor({
+        extraSecretKeys: (normalized) => extraKeys.has(normalized),
+        extraValuePatterns: [...(options.secretPatterns ?? [])],
+    });
+    const schemaKeys = new Set(options.schemaKeys ?? ['tools']);
+    /**
+     * Last dumped (redacted) body per baseline key, in memory for this process.
+     * A key missing here, on its first dump or after eviction, is looked up on
+     * disk.
+     */
+    const previousBodies = new Map();
+    const resolveDir = () => typeof options.dir === 'function' ? options.dir() : options.dir;
+    /** The mask for a secret key name, or undefined for an ordinary key. */
+    function maskFor(key) {
+        // The shared redactor masks a secret key whatever its value, so probing it
+        // with null answers "is this key a secret" without duplicating its rules.
+        const masked = redactor.redact({ [key]: null })[key];
+        return masked === null ? undefined : masked;
+    }
+    /**
+     * Redact by key name and scrub token-shaped strings, except below a schema
+     * key, where only strings are scrubbed: a tool parameter named `api_key`
+     * declares what the tool accepts, and masking that node would leave a
+     * schema that no longer parses. Key order is kept because dumps are diffed
+     * against each other.
+     */
+    function scrub(value) {
+        if (Array.isArray(value))
+            return value.map(scrub);
+        if (isRecord(value)) {
+            const out = {};
+            for (const [key, entry] of Object.entries(value)) {
+                const mask = maskFor(key);
+                if (schemaKeys.has(key))
+                    out[key] = redactor.redactStrings(entry);
+                else if (mask !== undefined)
+                    out[key] = mask;
+                else
+                    out[key] = scrub(entry);
+            }
+            return out;
+        }
+        return redactor.redactStrings(value);
+    }
+    function scrubBody(bodyText) {
+        let parsed;
+        try {
+            parsed = JSON.parse(bodyText);
+        }
+        catch {
+            // Not JSON: no keys to judge, but token-shaped strings still go.
+            return {
+                text: redactor.redactStrings(bodyText),
+                parsed: undefined,
+            };
+        }
+        const scrubbed = scrub(parsed);
+        const scrubbedText = JSON.stringify(scrubbed);
+        // Nothing redacted: keep the original bytes, whitespace included, so the
+        // dump is exactly what was sent.
+        const text = JSON.stringify(parsed) === scrubbedText ? bodyText : scrubbedText;
+        return { text, parsed: isRecord(scrubbed) ? scrubbed : undefined };
+    }
+    /**
+     * The newest earlier dump of this baseline key, read back from the dump
+     * directory. The in-memory baseline dies with the process, and the first
+     * request after a restart is the one most likely to break the prompt cache,
+     * so it is the one whose diff matters most. Reading the dumps themselves
+     * needs no extra state, and clearing the directory clears the baseline with
+     * it. Any failure is no baseline.
+     */
+    async function recoverBaseline(dir, session, channel, baselineKey) {
+        const marker = `-${fileSegment(session, UNKNOWN_SESSION)}-${fileSegment(channel, 'channel')}`;
+        let names;
+        try {
+            names = await readdir(dir);
+        }
+        catch {
+            return undefined;
+        }
+        // Names start with an ISO timestamp, so reverse lexicographic order is
+        // newest first. The metadata's key decides the match: a filename segment
+        // is truncated and sanitised, so two sessions can share one.
+        const candidates = names
+            .filter((name) => name.endsWith('.meta.json') && name.includes(marker))
+            .sort()
+            .reverse();
+        for (const name of candidates) {
+            try {
+                const metadata = JSON.parse(await readFile(join(dir, name), 'utf8'));
+                if (metadata?.baselineKey !== baselineKey)
+                    continue;
+                return await readFile(join(dir, name.replace(/\.meta\.json$/, '.body.json')), 'utf8');
+            }
+            catch {
+                // A file removed or half-written by another process: try the next.
+            }
+        }
+        return undefined;
+    }
+    function remember(key, text) {
+        if (!previousBodies.has(key)) {
+            while (previousBodies.size >= PREVIOUS_BODY_LIMIT) {
+                const oldest = previousBodies.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                previousBodies.delete(oldest);
+            }
+        }
+        previousBodies.set(key, text);
+    }
+    async function dump(input) {
+        if (!enabled)
+            return undefined;
+        counter++;
+        const session = input.session?.trim() || UNKNOWN_SESSION;
+        const dir = resolveDir();
+        const createdAt = new Date(now()).toISOString();
+        // The pid makes names unique across processes: each process starts its
+        // counter at zero, so two processes dumping the same session in the same
+        // millisecond into a shared directory would otherwise pick the same name.
+        const id = [
+            createdAt.replace(/[:.]/g, '-'),
+            String(pid),
+            String(counter).padStart(6, '0'),
+            fileSegment(session, UNKNOWN_SESSION),
+            fileSegment(input.channel, 'channel'),
+            ...(input.phase ? [fileSegment(input.phase, 'phase')] : []),
+        ].join('-');
+        const prefix = join(dir, id);
+        const files = {
+            body: `${prefix}.body.json`,
+            metadata: `${prefix}.meta.json`,
+            request: `${prefix}.request.json`,
+        };
+        // Hashed so the metadata identifies the baseline without spelling out the
+        // full session id.
+        const baselineKey = hashText(`${input.channel}\u0000${session}`);
+        try {
+            await mkdir(dir, { recursive: true, mode: 0o700 });
+            // mkdir's mode does not apply to a directory that already exists.
+            await chmod(dir, 0o700);
+            let previous = previousBodies.get(baselineKey);
+            let baselineSource = previous === undefined ? undefined : 'memory';
+            if (previous === undefined) {
+                previous = await recoverBaseline(dir, session, input.channel, baselineKey);
+                if (previous !== undefined)
+                    baselineSource = 'disk';
+            }
+            const body = scrubBody(input.bodyText);
+            const metadata = {
+                id,
+                createdAt,
+                pid,
+                session: shortSession(session),
+                channel: input.channel,
+                ...(input.phase ? { phase: input.phase } : {}),
+                accountId: input.accountId,
+                status: input.status,
+                error: input.error === undefined
+                    ? undefined
+                    : redactor.redactStrings(input.error),
+                baselineKey,
+                bodyBytes: Buffer.byteLength(input.bodyText, 'utf8'),
+                bodyHash: hashText(input.bodyText),
+                // Diffed on the redacted text that lands in the body file, so offsets
+                // index the file an operator can open, and a baseline read back from
+                // disk (also redacted) compares like with like.
+                diff: diffDumpBodies(previous, body.text),
+                baselineSource,
+                body: body.parsed
+                    ? { parseable: true, ...options.summarize?.(body.parsed) }
+                    : { parseable: false },
+                ...(input.meta ? { extra: scrub(input.meta) } : {}),
+                files,
+            };
+            const request = scrub({
+                url: input.url,
+                method: input.method,
+                accountId: input.accountId,
+                headers: input.headers === undefined
+                    ? undefined
+                    : Object.fromEntries(new Headers(input.headers).entries()),
+            });
+            // `wx`: a name collision fails loudly instead of overwriting a dump.
+            const write = (path, text) => writeFile(path, text, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            await Promise.all([
+                write(files.body, body.text),
+                write(files.metadata, `${JSON.stringify(metadata, null, 2)}\n`),
+                write(files.request, `${JSON.stringify(request, null, 2)}\n`),
+            ]);
+            remember(baselineKey, body.text);
+            log?.debug('dumped request', {
+                id,
+                session: shortSession(session),
+                body: files.body,
+            });
+            return { id, files };
+        }
+        catch (error) {
+            log?.warn('request dump failed', {
+                session: shortSession(session),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return undefined;
+        }
+    }
+    return {
+        isEnabled: () => enabled,
+        setEnabled: (value) => {
+            enabled = value;
+        },
+        dump,
+    };
+}

package/dist/store/errors.d.ts

@@ -1,6 +1,6 @@
 import type { StoredCredential } from './schema.js';
 /** Every library operation that can fail, as named in the failure value. */
-export type PoolOperation = 'initialize' | 'add' | 'replace' | 'rotate' | 'disable' | 'enable' | 'remove' | 'reorder' | 'recordIdentity' | 'refresh' | 'pull';
+export type PoolOperation = 'initialize' | 'add' | 'replace' | 'rotate' | 'disable' | 'enable' | 'remove' | 'reorder' | 'updateSettings' | 'recordIdentity' | 'refresh' | 'pull';
 /**
  * How far an operation got before it failed.
  *

package/dist/store/index.d.ts

@@ -14,3 +14,5 @@ export type { AddInput, AddResult, FailureHook, RemoveOptions, RemoveResult, Rem
 export type { PullReason } from './runtime.js';
 export type { ApiKeyCredential, OAuthCredential, PoolCredential, PoolRow, QuotaCodec, StoredCredential, } from './schema.js';
 export { fingerprintOf, LEGACY_STORE_VERSION, POOL_KEY, POOL_ROWS_KEY, POOL_SCHEMA_VERSION, REFRESH_STAMP_TOLERANCE_MS, rowLockKey, } from './schema.js';
+export type { PoolSettings, SettingsMutator, SettingsRead, UpdateSettingsOptions, UpdateSettingsResult, } from './settings.js';
+export { POOL_OWNED_KEYS } from './settings.js';

package/dist/store/index.js

@@ -3,3 +3,4 @@ export { countUnknownIdentityRows, DUPLICATE_IDENTITY_REASON, } from './identity
 export { openPoolStore } from './pool.js';
 export { POOL_LOCK_DEFAULTS } from './refresh-lock.js';
 export { fingerprintOf, LEGACY_STORE_VERSION, POOL_KEY, POOL_ROWS_KEY, POOL_SCHEMA_VERSION, REFRESH_STAMP_TOLERANCE_MS, rowLockKey, } from './schema.js';
+export { POOL_OWNED_KEYS } from './settings.js';

package/dist/store/pool.d.ts

@@ -7,6 +7,7 @@ import { type ProviderRefresh, type RefreshOptions, type RefreshOutcome } from '
 import { type LockEnvironment, type PoolLockOptions, type PoolLockSpec } from './refresh-lock.js';
 import { type AddInput, type AddResult, type RemoveOptions, type RemoveResult, type ReorderOptions, type ReorderResult, type RowOperationOptions, type RowToggleOptions } from './rows.js';
 import { type PoolCredential, type PoolRow, type QuotaCodec, type StoredCredential } from './schema.js';
+import { type SettingsMutator, type SettingsRead, type UpdateSettingsOptions, type UpdateSettingsResult } from './settings.js';
 export interface OpenPoolStoreOptions {
     /** The provider every row of this pool belongs to; keys the provider-wide lock. */
     provider: string;
@@ -108,6 +109,17 @@ export interface PoolStore {
      * provider-wide lock. Roster rows and their entries are left unchanged.
      */
     reorder(ids: readonly string[], options?: ReorderOptions): Promise<ReorderResult>;
+    /**
+     * The plugin's settings (since 0.2.6): every top-level key of the config
+     * file except the pool-owned ones (`POOL_OWNED_KEYS`). Never writes.
+     */
+    readSettings(): Promise<SettingsRead>;
+    /**
+     * One locked write of the plugin's settings (since 0.2.6) beside the pool,
+     * in the config file. Refuses a result that sets a pool-owned key
+     * (`invalid-input`). Takes `extraLocks`, then the store locks.
+     */
+    updateSettings(mutator: SettingsMutator, options?: UpdateSettingsOptions): Promise<UpdateSettingsResult>;
     recordIdentity(id: string, identity: string, options?: RowOperationOptions): Promise<{
         id: string;
         disabled: string[];

package/dist/store/pool.js

@@ -5,6 +5,7 @@ import { refreshRow, } from './refresh.js';
 import { POOL_LOCK_DEFAULTS, } from './refresh-lock.js';
 import { addRow, disableRow, enableRow, recordRowIdentity, removeRow, reorderRows, replaceRow, rotateRow, } from './rows.js';
 import { POOL_SCHEMA_VERSION, } from './schema.js';
+import { readPoolSettings, updatePoolSettings, } from './settings.js';
 /**
  * Process-wide memory per config file: ids whose per-row entry a library
  * write dropped (not reused in this process), and rows a load-time pull
@@ -95,6 +96,8 @@ export function openPoolStore(options) {
         enable: (id, callOptions) => enableRow(rt, id, callOptions),
         remove: (id, callOptions) => removeRow(rt, id, callOptions),
         reorder: (ids, callOptions) => reorderRows(rt, ids, callOptions),
+        readSettings: () => readPoolSettings(rt),
+        updateSettings: (mutator, callOptions) => updatePoolSettings(rt, mutator, callOptions),
         recordIdentity: (id, identity, callOptions) => recordRowIdentity(rt, id, identity, callOptions),
         refresh: (id, provider, callOptions) => refreshRow(rt, id, provider, callOptions),
         recordQuota: (id, attribution, observation) => recordQuota(rt, id, attribution, observation),