@cortexkit/opencode-openai-auth 0.11.0 → 1.0.0

package/src/tui-compiled/raw/shared/9020c407ce64f672-ordered.js

@@ -0,0 +1,58 @@
+// `ordered` routing: admitted rows tried in a fixed order, moving to the next
+// row only when a response carries one of the caller's retry statuses.
+import { admit, } from "./45bf5343bbbf9add-admission.js";
+/** The former main row's id when the caller supplies none. */
+export const DEFAULT_FORMER_MAIN_ID = 'main';
+/**
+ * Resolves a persisted `routing.mode` value. `main-first` and
+ * `fallback-first` are aliases of `ordered` that move the former main row;
+ * an absent or unrecognised value is `ordered` in roster order. The
+ * persisted value is only read here, never rewritten.
+ */
+export function resolveRoutingMode(value) {
+    switch (value) {
+        case 'sticky-balanced':
+            return { mode: 'sticky-balanced', placement: 'roster' };
+        case 'main-first':
+            return { mode: 'ordered', placement: 'main-first' };
+        case 'fallback-first':
+            return { mode: 'ordered', placement: 'fallback-first' };
+        default:
+            return { mode: 'ordered', placement: 'roster' };
+    }
+}
+/**
+ * Orders `ids` (in roster order) for a placement: `main-first` moves the row
+ * named `formerMainId` to the front, `fallback-first` to the back, and
+ * `roster` (or a missing former main row) keeps roster order.
+ */
+export function orderForPlacement(ids, placement, formerMainId = DEFAULT_FORMER_MAIN_ID) {
+    if (placement === 'roster' || !ids.includes(formerMainId))
+        return [...ids];
+    const rest = ids.filter((id) => id !== formerMainId);
+    return placement === 'main-first'
+        ? [formerMainId, ...rest]
+        : [...rest, formerMainId];
+}
+export function routeOrdered(input) {
+    const admission = admit(input);
+    const admitted = new Set(admission.admitted.map((row) => row.id));
+    const order = orderForPlacement(input.rows.map((row) => row.id), input.placement ?? 'roster', input.formerMainId).filter((id) => admitted.has(id) && input.killswitch?.get(id) !== false);
+    return { order, admission };
+}
+/**
+ * The next row to try, given the attempts so far: the first row when none
+ * has been tried, the next untried row when the last attempt's status is one
+ * of `retryStatuses`, and undefined otherwise (the last response stands) or
+ * when every row has been tried.
+ */
+export function nextOrderedAttempt(order, attempts, retryStatuses) {
+    const last = attempts.at(-1);
+    if (last !== undefined) {
+        if (last.status === undefined || !retryStatuses.includes(last.status)) {
+            return undefined;
+        }
+    }
+    const tried = new Set(attempts.map((attempt) => attempt.id));
+    return order.find((id) => !tried.has(id));
+}

package/src/tui-compiled/raw/shared/905bffc0220f43d0-map.js

@@ -0,0 +1,105 @@
+// The per-row quota map: what the pool knows about one row's limits.
+//
+// A row's quota is a set of keyed limits. Each key is a (scope, window label)
+// pair: the scope is `all` for a limit that binds every request, or a model
+// family name for a limit that binds only that family; the label names the
+// window the provider reports (for example `primary` or `secondary`). Each key
+// holds one entry, which is either a reading, a retirement tombstone (the key
+// held a reading until an authoritative observation stopped reporting it), or
+// an absence record (an authoritative observation reported the key as having
+// no limit before any reading was seen). Tombstones and absence records are
+// evidence that the key is known to be unlimited; a missing key is unknown.
+//
+// Beside the limits sits the credit budget, a third pressure axis with its own
+// reset clock. It is a tri-state: absent (never reported), a reading, or
+// cleared (the provider reported that no budget exists).
+//
+// The map is plain JSON so the store can persist it without interpreting it.
+/** The scope of a limit that binds every request regardless of model. */
+export const ALL_SCOPE = 'all';
+/** The window label required when an admission call supplies none. */
+export const DEFAULT_REQUIRED_LABELS = Object.freeze([
+    'primary',
+]);
+export function emptyQuotaMap() {
+    return { limits: [] };
+}
+/** The time an entry speaks for: its reading, retirement or absence time. */
+export function entryTime(entry) {
+    return entry.kind === 'retired' ? entry.retiredAt : entry.checkedAt;
+}
+export function limitKey(scope, label) {
+    // JSON-encoding the pair keeps keys unambiguous for any scope or label text.
+    return JSON.stringify([scope, label]);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isName(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function optional(record, key, check) {
+    return record[key] === undefined || check(record[key]);
+}
+function isPositiveFinite(value) {
+    return isFiniteNumber(value) && value > 0;
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isQuotaEntry(value) {
+    if (!isRecord(value) || !isName(value.scope) || !isName(value.label)) {
+        return false;
+    }
+    switch (value.kind) {
+        case 'reading':
+            return (isFiniteNumber(value.checkedAt) &&
+                isFiniteNumber(value.usedPercent) &&
+                optional(value, 'resetsAt', isString) &&
+                optional(value, 'windowMinutes', isPositiveFinite));
+        case 'retired':
+            return isFiniteNumber(value.retiredAt);
+        case 'absent':
+            return isFiniteNumber(value.checkedAt);
+        default:
+            return false;
+    }
+}
+export function isCreditBudgetEntry(value) {
+    if (!isRecord(value) || !isFiniteNumber(value.checkedAt))
+        return false;
+    if (value.kind === 'cleared')
+        return true;
+    return (value.kind === 'reading' &&
+        typeof value.reached === 'boolean' &&
+        optional(value, 'remainingPercent', isFiniteNumber) &&
+        optional(value, 'usedPercent', isFiniteNumber) &&
+        optional(value, 'resetsAt', isString) &&
+        optional(value, 'limit', isFiniteNumber) &&
+        optional(value, 'used', isFiniteNumber) &&
+        optional(value, 'remaining', isFiniteNumber) &&
+        optional(value, 'unit', isString));
+}
+/**
+ * True when `value` is a well-formed quota map. Unrecognised top-level keys
+ * are tolerated (and preserved by merge) so a newer writer's additions
+ * survive; a malformed entry, a duplicated (scope, label) key or a malformed
+ * budget makes the whole map invalid.
+ */
+export function isQuotaMap(value) {
+    if (!isRecord(value) || !Array.isArray(value.limits))
+        return false;
+    const seen = new Set();
+    for (const entry of value.limits) {
+        if (!isQuotaEntry(entry))
+            return false;
+        const key = limitKey(entry.scope, entry.label);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+    }
+    return optional(value, 'budget', isCreditBudgetEntry);
+}

package/src/tui-compiled/raw/shared/94820e324f2b4c09-seam.js

@@ -0,0 +1,301 @@
+// 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 as a backstop: credential-shaped property names are
+// dropped and every string value is passed through the redactor. Nothing
+// outside this module can build a payload without passing through
+// `dialogPayload` or `applyResult`. A failed action never shows its raw
+// exception text: `projectFailure` turns it into a stable code and a message
+// the library or the plugin wrote for the user.
+import { createRedactor } from "./cc9e0702a752cea7-index.js";
+import { PoolOperationError } from "./54eba94fd64c8c3c-index.js";
+/**
+ * Secret shapes the seam masks on top of the logger's (bearer tokens, `sk-`
+ * keys, JWTs, vault host tokens): a value assigned to a secret-named field
+ * (`client_secret=…`, `"api_key": "…"`, `Authorization: …`), and a run of 32
+ * or more hex digits, the shape of a minted request secret. A plugin adds its
+ * provider's key shapes through `RedactionOptions.extraValuePatterns`.
+ */
+const SEAM_VALUE_PATTERNS = [
+    /\b[\w-]*(?:secret|token|password|passwd|api[_-]?key|authorization|verifier)["']?\s*[:=]\s*["']?(?:(?:Bearer|Basic)\s+)?[^\s"'&,;}]+/gi,
+    /\b[0-9a-fA-F]{32,}\b/g,
+];
+/** The string redactor every value crossing the seam goes through. */
+export function createTextRedactor(options = {}) {
+    const { redactStrings } = createRedactor({
+        ...options,
+        extraValuePatterns: [
+            ...SEAM_VALUE_PATTERNS,
+            ...(options.extraValuePatterns ?? []),
+        ],
+    });
+    return (text) => redactStrings(text);
+}
+/**
+ * A failure whose message was written for the user. An action throws it to
+ * show `message` with the stable `code`; any other thrown value is shown only
+ * as a generic message, because its text may quote a request, a response or
+ * a credential. `code` is lowercase letters, digits and dashes; anything else
+ * is reported as `action-failed`.
+ */
+export class CommandError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'CommandError';
+        this.code = code;
+    }
+}
+const CODE_SHAPE = /^[a-z][a-z0-9-]{0,63}$/;
+/** The code and message shown for an exception the seam cannot vouch for. */
+export const ACTION_FAILED = {
+    code: 'action-failed',
+    text: 'That action failed.',
+};
+/**
+ * Store failure kinds whose message the store composes itself from row ids
+ * and the plugin's own refusal reasons (`protect`). Other kinds can carry a
+ * lock or filesystem error's text, or an arbitrary exception from a hook, so
+ * they show a generic message with the kind as the code.
+ */
+const STORE_KINDS_WITH_OWN_MESSAGE = new Set([
+    'unknown-row',
+    'invalid-row',
+    'invalid-input',
+    'id-exists',
+    'id-removed',
+    'type-mismatch',
+    'no-credential',
+    'row-disabled',
+    'row-protected',
+    'duplicate-identity',
+    'row-key-changed',
+    'invalid-order',
+    'pending-migration',
+    'provider',
+    'pull',
+    'attribution',
+]);
+/** The code and display text for a thrown value; never its raw text. */
+export function projectFailure(error) {
+    if (error instanceof CommandError)
+        return {
+            code: CODE_SHAPE.test(error.code) ? error.code : ACTION_FAILED.code,
+            text: error.message,
+        };
+    if (error instanceof PoolOperationError)
+        return {
+            code: `pool-${error.kind}`,
+            text: STORE_KINDS_WITH_OWN_MESSAGE.has(error.kind)
+                ? error.message
+                : `The account pool could not do that (${error.kind}).`,
+        };
+    return ACTION_FAILED;
+}
+/** 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 and with every
+ * string redacted; the paths of both go to `report`.
+ */
+function scrub(value, path, report) {
+    if (typeof value === 'string') {
+        const clean = report.redact(value);
+        if (clean !== value)
+            report.redacted.push(path);
+        return clean;
+    }
+    if (Array.isArray(value))
+        return value.map((entry, index) => scrub(entry, `${path}[${index}]`, report));
+    if (!isPlainRecord(value))
+        return value;
+    const out = {};
+    for (const [name, entry] of Object.entries(value)) {
+        if (isCredentialName(name)) {
+            report.dropped.push(`${path}.${name}`);
+            continue;
+        }
+        Object.defineProperty(out, name, {
+            value: scrub(entry, `${path}.${name}`, report),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return out;
+}
+function sealed(payload, command, seam) {
+    const report = {
+        redact: seam.redact,
+        dropped: [],
+        redacted: [],
+    };
+    const clean = scrub(payload, 'payload', report);
+    if (report.dropped.length > 0)
+        seam.logger.warn('credential-shaped field dropped from a command payload', {
+            command,
+            fields: report.dropped,
+        });
+    if (report.redacted.length > 0)
+        seam.logger.warn('secret-shaped text masked in a command payload', {
+            command,
+            fields: report.redacted,
+        });
+    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':
+            // A masked input holds a secret, so its current value is never shown;
+            // the action still receives it when the user leaves the input alone.
+            return {
+                kind: 'text',
+                id: knob.id,
+                label: knob.label,
+                ...(knob.value !== undefined && !knob.masked
+                    ? { 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 }
+            : {}),
+        ...(action.group !== undefined ? { group: String(action.group) } : {}),
+        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.group !== undefined ? { group: String(item.group) } : {}),
+        ...(item.status !== undefined ? { status: String(item.status) } : {}),
+        ...(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, seam) {
+    return sealed({ command, menu: projectMenu(command, title, sections) }, command, seam);
+}
+/** An apply's result: the message and the refreshed menu. */
+export function applyResult(command, title, sections, outcome, seam) {
+    return sealed({
+        command,
+        ok: outcome.ok,
+        text: String(outcome.text),
+        ...(!outcome.ok && outcome.code !== undefined
+            ? { code: CODE_SHAPE.test(outcome.code) ? outcome.code : 'refused' }
+            : {}),
+        ...(outcome.needsConfirmation ? { needsConfirmation: true } : {}),
+        menu: projectMenu(command, title, sections),
+    }, command, seam);
+}