@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

package/src/tui-compiled/raw/shared/c7d252bedee01600-pi.js

@@ -0,0 +1,206 @@
+// The Pi renderer: walks the same menu model the OpenCode dialog draws, with
+// Pi's extension UI (`select`, `confirm`, `input`, `notify`). It sees only the
+// payloads the menu's seam produces, and applies actions through the menu,
+// so the confirmation and input checks are the same as on OpenCode.
+/**
+ * Shows `entries` with `select` and returns the chosen value. Labels are made
+ * unique, since `select` answers with the label.
+ */
+async function pick(ui, title, entries) {
+    const byLabel = new Map();
+    const labels = [];
+    for (const entry of entries) {
+        let label = entry.label;
+        for (let n = 2; byLabel.has(label); n++)
+            label = `${entry.label} (${n})`;
+        byLabel.set(label, entry.value);
+        labels.push(label);
+    }
+    const chosen = await ui.select(title, labels);
+    return chosen === undefined ? undefined : byLabel.get(chosen);
+}
+function withLines(title, lines) {
+    return lines.length > 0 ? `${title}\n${lines.join('\n')}` : title;
+}
+/** A row as one line of text: its label, then its status when it has one. */
+function rowText(item) {
+    return item.status ? `${item.label} · ${item.status}` : item.label;
+}
+/**
+ * The read-only part of a section's select title: its lines, then each item
+ * that has no actions, under its group's header. Such an item does nothing
+ * when chosen, so it is shown as text rather than offered as an option. Pi's
+ * `select` cannot put text between options, so the headers of groups whose
+ * rows are all selectable are not shown.
+ */
+function sectionText(section) {
+    const text = [...section.lines];
+    let header;
+    for (const item of section.items) {
+        if (item.actions.length > 0)
+            continue;
+        if (item.group !== undefined && item.group !== header)
+            text.push(item.group);
+        header = item.group;
+        text.push(item.group !== undefined ? `  ${rowText(item)}` : rowText(item));
+    }
+    return text;
+}
+function itemTitle(item) {
+    const lines = item.detail ? [item.detail] : [];
+    for (const [name, value] of Object.entries(item.facts ?? {}))
+        lines.push(`${name}: ${String(value)}`);
+    return withLines(rowText(item), lines);
+}
+/** One knob's value, or undefined when the user backed out or typed nonsense. */
+async function askKnob(ui, knob) {
+    switch (knob.kind) {
+        case 'choice': {
+            const value = await pick(ui, knob.label, knob.choices.map((choice) => ({
+                label: choice.value === knob.value
+                    ? `${choice.label} (current)`
+                    : choice.label,
+                value: choice.value,
+            })));
+            return value === undefined ? undefined : { value };
+        }
+        case 'toggle': {
+            const value = await pick(ui, knob.label, [
+                { label: knob.value ? 'On (current)' : 'On', value: true },
+                { label: knob.value ? 'Off' : 'Off (current)', value: false },
+            ]);
+            return value === undefined ? undefined : { value };
+        }
+        case 'number': {
+            const range = knob.min !== undefined && knob.max !== undefined
+                ? ` (${knob.min}-${knob.max}${knob.required ? '' : ', empty clears'})`
+                : knob.required
+                    ? ''
+                    : ' (empty clears)';
+            const typed = await ui.input(`${knob.label}${range}`, knob.value !== undefined ? String(knob.value) : undefined);
+            if (typed === undefined)
+                return undefined;
+            const text = typed.trim();
+            if (text === '')
+                return knob.required && knob.value !== undefined
+                    ? { value: knob.value }
+                    : { value: null };
+            const number = Number(text);
+            if (!Number.isFinite(number)) {
+                ui.notify(`${knob.label} needs a number.`, 'error');
+                return undefined;
+            }
+            return { value: number };
+        }
+        case 'text': {
+            const typed = await ui.input(knob.label, knob.value ?? knob.placeholder);
+            if (typed === undefined)
+                return undefined;
+            const text = typed.trim();
+            if (text === '')
+                return knob.required && knob.value !== undefined
+                    ? { value: knob.value }
+                    : { value: null };
+            return { value: text };
+        }
+    }
+}
+async function askValues(ui, action) {
+    const values = {};
+    for (const knob of action.knobs) {
+        const answer = await askKnob(ui, knob);
+        if (!answer)
+            return undefined;
+        values[knob.id] = answer.value;
+    }
+    return values;
+}
+/**
+ * Runs one invocation of the slash command on Pi: sections, then an item or
+ * a section action, then the action's inputs and confirmation; after each
+ * apply the user is back in the same section with the refreshed menu. Each
+ * section's list ends with Back, which returns to the section list; backing
+ * out of the section list ends the invocation.
+ */
+export async function runPiCommandMenu(menu, ui, options = {}) {
+    const invocation = {
+        ...(options.sessionId !== undefined
+            ? { sessionId: options.sessionId }
+            : {}),
+        notify: (message, kind) => ui.notify(message, kind),
+    };
+    let model = (await menu.open(invocation)).menu;
+    for (;;) {
+        const chosen = await pick(ui, model.title, model.sections.map((section) => ({
+            label: section.lines[0]
+                ? `${section.title}: ${section.lines[0]}`
+                : section.title,
+            value: section.id,
+        })));
+        if (chosen === undefined)
+            return;
+        for (;;) {
+            const section = model.sections.find((entry) => entry.id === chosen);
+            if (!section)
+                break;
+            // Only rows that do something are options; the rest is title text.
+            const entries = [
+                ...section.items
+                    .filter((item) => item.actions.length > 0)
+                    .map((item) => ({
+                    label: rowText(item),
+                    value: { kind: 'item', item },
+                })),
+                ...section.actions.map((action) => ({
+                    label: action.label,
+                    value: { kind: 'action', action },
+                })),
+            ];
+            const text = sectionText(section);
+            if (entries.length === 0 && text.length === 0) {
+                ui.notify('Nothing to do here.');
+                break;
+            }
+            const choice = await pick(ui, withLines(section.title, text), [
+                ...entries,
+                { label: 'Back', value: { kind: 'back' } },
+            ]);
+            if (!choice || choice.kind === 'back')
+                break;
+            let action;
+            let item;
+            if (choice.kind === 'item') {
+                item = choice.item;
+                action = await pick(ui, itemTitle(item), item.actions.map((entry) => ({ label: entry.label, value: entry })));
+                if (!action)
+                    continue;
+            }
+            else {
+                action = choice.action;
+            }
+            const values = await askValues(ui, action);
+            if (!values)
+                continue;
+            if (action.confirm) {
+                const yes = await ui.confirm(action.label, action.confirm.message);
+                if (!yes) {
+                    ui.notify('Cancelled.');
+                    continue;
+                }
+            }
+            const result = await menu.apply({
+                command: model.command,
+                sectionId: section.id,
+                ...(item ? { itemId: item.id } : {}),
+                actionId: action.id,
+                values,
+                ...(action.confirm ? { confirmed: true } : {}),
+                ...(options.sessionId !== undefined
+                    ? { sessionId: options.sessionId }
+                    : {}),
+            }, invocation);
+            ui.notify(result.text, result.ok ? 'info' : 'error');
+            model = result.menu;
+        }
+    }
+}

package/src/tui-compiled/raw/shared/c852a15cfe489d12-pool.js

@@ -0,0 +1,120 @@
+import { recordQuota } from "./a62a27a204266acd-attribution.js";
+import { initializePool, readPool, } from "./458b934e92490331-mutate.js";
+import { updateProviderStateRow, } from "./97484d9bb98c705b-provider-state.js";
+import { publication, publishRoster, } from "./83068c0dbe8a6f13-publication.js";
+import { PullScheduler } from "./a910277ac43a8626-pull.js";
+import { refreshRow, } from "./9d3fc9e37456504e-refresh.js";
+import { POOL_LOCK_DEFAULTS, } from "./43fc9e6b994519c7-refresh-lock.js";
+import { addRow, disableRow, enableRow, recordRowIdentity, removeRow, reorderRows, replaceRow, rotateRow, } from "./fe02abeadc535f77-rows.js";
+import { POOL_SCHEMA_VERSION, } from "./cd94316a888b0a8e-schema.js";
+import { readPoolSettings, updatePoolSettings, } from "./836fc615de6afbd9-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
+ * already fired for.
+ */
+const processMemory = new Map();
+function memoryFor(configPath) {
+    let memory = processMemory.get(configPath);
+    if (!memory) {
+        memory = { removedIds: new Set(), firedAtLoad: new Set() };
+        processMemory.set(configPath, memory);
+    }
+    return memory;
+}
+function toLoad(result) {
+    if (result.status === 'ready')
+        return {
+            status: 'ready',
+            schemaVersion: POOL_SCHEMA_VERSION,
+            rows: result.rows,
+        };
+    if (result.status === 'pending-migration')
+        return {
+            status: 'pending-migration',
+            roster: Array.isArray(result.config.accounts)
+                ? result.config.accounts
+                : [],
+        };
+    return result;
+}
+export function openPoolStore(options) {
+    const memory = memoryFor(options.configPath);
+    const lockDefaults = {
+        ...POOL_LOCK_DEFAULTS,
+        ...options.lockOptions,
+    };
+    const ctx = {
+        provider: options.provider,
+        configPath: options.configPath,
+        statePath: options.statePath,
+        codec: options.quota,
+        ...(options.providerState ? { providerState: options.providerState } : {}),
+        now: options.now ?? Date.now,
+        storeLocks: options.storeLocks ?? [
+            { name: 'save', path: options.configPath },
+            { name: 'save', path: options.statePath },
+        ],
+        lockDefaults,
+        lockEnv: {
+            now: options.now ?? Date.now,
+            ...(options.onLockEvent ? { onLockEvent: options.onLockEvent } : {}),
+            ...(options.onLockStep ? { onLockStep: options.onLockStep } : {}),
+        },
+        removedIds: memory.removedIds,
+        requireCredentialStamps: options.requireCredentialStamps === true,
+        requireRemovedFingerprint: options.requireRemovedFingerprint === true,
+        ...(options.logger ? { logger: options.logger } : {}),
+        ...(options.onStep ? { onStep: options.onStep } : {}),
+        ...(options.hold ? { hold: options.hold } : {}),
+    };
+    const pulls = new PullScheduler(() => rt, options.pull, options.onPullFailure, memory.firedAtLoad, options.logger);
+    const rt = {
+        ctx,
+        providerLock: options.providerLock ?? {
+            name: `provider-${encodeURIComponent(options.provider)}`,
+            path: options.statePath,
+        },
+        rowLockOptions: options.rowLockOptions ?? {},
+        firePull: (id, reason) => pulls.fire(id, reason),
+    };
+    return {
+        async load() {
+            const result = await readPool(ctx);
+            if (result.status === 'ready') {
+                // A torn row is no candidate, but its pull is fired too: the pull
+                // completes the row on disk before reading it, so an interrupted
+                // replace of an OAuth row heals at the next load.
+                for (const row of result.rows)
+                    if ((row.candidate || (row.torn && row.enabled)) &&
+                        row.type === 'oauth' &&
+                        row.needsFirstReading)
+                        pulls.fire(row.id, 'load');
+            }
+            return toLoad(result);
+        },
+        async read() {
+            return toLoad(await readPool(ctx));
+        },
+        async initialize(input = {}) {
+            return { status: await initializePool(ctx, input.dropKeys ?? []) };
+        },
+        add: (input, callOptions) => addRow(rt, input, callOptions),
+        publishRoster: (plan, callOptions) => publishRoster(rt, plan, callOptions),
+        publication: (operationId) => publication(rt, operationId),
+        replace: (id, credential, input, callOptions) => replaceRow(rt, id, credential, input, callOptions),
+        rotate: (id, credential, input, callOptions) => rotateRow(rt, id, credential, input, callOptions),
+        updateProviderState: (id, fence, mutator, callOptions) => updateProviderStateRow(rt, id, fence, mutator, callOptions),
+        disable: (id, reason, callOptions) => disableRow(rt, id, reason, callOptions),
+        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, attribution, callOptions) => recordRowIdentity(rt, id, identity, attribution, callOptions),
+        refresh: (id, provider, callOptions) => refreshRow(rt, id, provider, callOptions),
+        recordQuota: (id, attribution, observation) => recordQuota(rt, id, attribution, observation),
+        requestReading: (id) => pulls.fire(id, 'admission'),
+        pullsSettled: () => pulls.settled(),
+    };
+}

package/src/tui-compiled/raw/shared/cc9e0702a752cea7-index.js

@@ -0,0 +1,3 @@
+export { createCaptureSink } from "./415792e85d80819e-capture-sink.js";
+export { createLogger, createLoggerInstance, flushForTest, flushLogs, initLogger, resetLoggerForTest, setLogLevel, } from "./d7dcba96fea1685c-engine.js";
+export { createRedactor, redact, redactStrings } from "./d319517e3ea6ad70-redact.js";