@cortexkit/opencode-antigravity-auth 2.2.0 → 3.0.0

package/dist/src/common-auth-embedded/logger/engine.d.ts

@@ -0,0 +1,100 @@
+import type { CaptureSink } from './capture-sink.js';
+import { type RedactionOptions } from './redact.js';
+export type Level = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+/** A logger that writes to a file, and to a capture sink when one is given. */
+export interface InitLoggerOptions extends RedactionOptions {
+    /** Receives every emitted record, scrubbed, alongside the file. */
+    captureSink?: CaptureSink;
+    /**
+     * Path of the file lines are appended to, or a function returning it.
+     *
+     * A function is what a host passes when its destination can move while the
+     * process runs — an operator or a test changing the variable that names the
+     * log file expects the next line to land in the new file, and a value
+     * captured once at init would keep writing to the old one.
+     */
+    file: string | (() => string);
+    /** Level floor applied when no `setLogLevel` call has overridden it. */
+    level?: Level | (() => Level | undefined);
+}
+/**
+ * A logger with no file: the capture sink is its only destination. Nothing
+ * is written to disk or printed, for a host that forwards records to its own
+ * log.
+ */
+export interface SinkOnlyLoggerOptions extends RedactionOptions {
+    /** Receives every emitted record, scrubbed. */
+    captureSink: CaptureSink;
+    file?: undefined;
+    /** Level floor applied when no `setLogLevel` call has overridden it. */
+    level?: Level | (() => Level | undefined);
+}
+/**
+ * What a logger is configured with: a file (`InitLoggerOptions`, the shape
+ * every release before this one accepted, kept as its own interface so a
+ * caller deriving a type from it with `Pick` or `extends` keeps compiling) or
+ * a capture sink alone.
+ */
+export type LoggerOptions = InitLoggerOptions | SinkOnlyLoggerOptions;
+export interface ChannelLogger {
+    error(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+    trace(message: string, data?: unknown): void;
+}
+/**
+ * A logger with its own file, level, redaction, capture sink and buffer.
+ * Two instances in one process never touch each other's settings or lines,
+ * so two plugins that load one shared copy of this module each keep their own
+ * log by holding their own instance.
+ */
+export interface LoggerInstance {
+    /** A logger whose lines carry `channel` and go to this instance's file. */
+    createLogger(channel: string): ChannelLogger;
+    /**
+     * Point this instance at a host's file and level. Idempotent: calling it
+     * again replaces both. A runtime level installed by `setLogLevel` is left
+     * alone, because it is the operator's explicit choice and outranks the
+     * floor a host computed at start-up.
+     */
+    configure(options: LoggerOptions): void;
+    /** Operator override of the level floor; undefined removes it. */
+    setLogLevel(level: Level | undefined): void;
+    /**
+     * Write whatever is buffered. Safe to call synchronously from a
+     * process-exit handler, which is how each host drains the buffer on
+     * shutdown.
+     */
+    flushLogs(): void;
+}
+/**
+ * A logger instance of its own, configured with `options`. A plugin whose
+ * copy of this module may be shared with another plugin in the same process
+ * uses this instead of `initLogger`, so neither replaces the other's file,
+ * level, redaction or capture sink.
+ */
+export declare function createLoggerInstance(options: LoggerOptions): LoggerInstance;
+/**
+ * Point the module's default logger at a host's file and level, and return
+ * it. Idempotent: calling it again replaces both. A runtime level installed
+ * by `setLogLevel` is deliberately left alone, because it is the operator's
+ * explicit choice and outranks the floor a host computed at start-up.
+ */
+export declare function initLogger(options: LoggerOptions): LoggerInstance;
+export declare function setLogLevel(l: Level | undefined): void;
+/**
+ * Write whatever the default logger has buffered. Safe to call synchronously
+ * from a process-exit handler, which is how each host drains the buffer on
+ * shutdown.
+ */
+export declare function flushLogs(): void;
+export declare function createLogger(channel: string): ChannelLogger;
+export declare function flushForTest(): Promise<void>;
+/**
+ * Return the default logger to its uninitialised state. Only a test needs
+ * this: a single process runs every test file, so a file path left over from
+ * one test would keep a later "logger was never initialised" case writing
+ * lines.
+ */
+export declare function resetLoggerForTest(): void;

package/dist/src/common-auth-embedded/logger/engine.js

@@ -0,0 +1,246 @@
+import { appendFileSync, chmodSync, existsSync, renameSync, statSync, } from 'node:fs';
+import { createRedactor } from './redact.js';
+const ORDER = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4,
+};
+const MAX_BYTES = 5 * 1024 * 1024;
+const ROTATE_KEEP = 3;
+function chmodPrivate(path) {
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        /* never throw */
+    }
+}
+function rotateIfNeeded(f) {
+    try {
+        if (!(existsSync(f) && statSync(f).size >= MAX_BYTES))
+            return;
+        for (let i = ROTATE_KEEP - 1; i >= 1; i--) {
+            if (existsSync(`${f}.${i}`)) {
+                const rotated = `${f}.${i + 1}`;
+                renameSync(`${f}.${i}`, rotated);
+                chmodPrivate(rotated);
+            }
+        }
+        const rotated = `${f}.1`;
+        renameSync(f, rotated);
+        chmodPrivate(rotated);
+    }
+    catch {
+        /* never throw */
+    }
+}
+function safeSerialize(data) {
+    try {
+        return ` ${JSON.stringify(data)}`;
+    }
+    catch {
+        return ' [unserializable]';
+    }
+}
+/**
+ * One logger's settings and buffer.
+ *
+ * Where lines are written and the level floor start unset unless `options`
+ * supplies them. A host decides where its log lives (that decision reads host
+ * environment variables and host directories, neither of which belongs in
+ * shared code) and configures the logger before it runs any command. Until
+ * then every `log.*` call is a silent no-op: throwing would turn the first
+ * command a host forgot to wire into a crash, and buffering would hold
+ * credential-bearing lines for a configuration that may never arrive.
+ */
+function createEngine(options) {
+    let logFileSource;
+    let initLevelSource;
+    let runtimeLevel;
+    let redactor = createRedactor();
+    let captureSink;
+    let buffer = [];
+    let timer;
+    function configure(next) {
+        logFileSource = next.file;
+        initLevelSource = next.level;
+        redactor = createRedactor(next);
+        captureSink = next.captureSink;
+    }
+    function setLogLevel(l) {
+        if (l === undefined || l in ORDER)
+            runtimeLevel = l;
+    }
+    function logFilePath() {
+        if (logFileSource === undefined)
+            return undefined;
+        const resolved = typeof logFileSource === 'function' ? logFileSource() : logFileSource;
+        return resolved || undefined;
+    }
+    function configuredLevel() {
+        if (runtimeLevel)
+            return runtimeLevel;
+        const floor = typeof initLevelSource === 'function'
+            ? initLevelSource()
+            : initLevelSource;
+        if (floor && floor in ORDER)
+            return floor;
+        return 'info';
+    }
+    function flushLogs() {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        if (!buffer.length)
+            return;
+        let file;
+        try {
+            file = logFilePath();
+        }
+        catch {
+            buffer = [];
+            return;
+        }
+        const text = buffer.join('');
+        buffer = [];
+        if (!file)
+            return;
+        try {
+            rotateIfNeeded(file);
+            if (existsSync(file))
+                chmodPrivate(file);
+            appendFileSync(file, text, { encoding: 'utf8', mode: 0o600 });
+        }
+        catch {
+            /* never throw */
+        }
+    }
+    function schedule() {
+        if (!timer)
+            timer = setTimeout(() => {
+                timer = undefined;
+                flushLogs();
+            }, 500);
+    }
+    function emit(channel, level, message, data) {
+        // Unconfigured (neither a file nor a sink) stays a silent no-op.
+        if (logFileSource === undefined && captureSink === undefined)
+            return;
+        try {
+            if (ORDER[level] > ORDER[configuredLevel()])
+                return;
+            const scrubbedMessage = redactor.redactStrings(message);
+            let scrubbedData;
+            try {
+                scrubbedData = redactor.redact(data);
+            }
+            catch {
+                scrubbedData = '[unserializable]';
+            }
+            const line = `[${new Date().toISOString()}] ${level.toUpperCase()} [${channel}] ${scrubbedMessage}` +
+                (data === undefined ? '' : safeSerialize(scrubbedData)) +
+                '\n';
+            // A failing observer must not prevent file logging or escape into the host.
+            try {
+                captureSink?.({
+                    channel,
+                    level,
+                    message: scrubbedMessage,
+                    data: scrubbedData,
+                });
+            }
+            catch { }
+            // A sink-only logger has no file to buffer lines for.
+            if (logFileSource === undefined)
+                return;
+            buffer.push(line);
+            if (buffer.length >= 50)
+                flushLogs();
+            else
+                schedule();
+        }
+        catch {
+            // Provider and redaction failures must never turn diagnostics into a host crash.
+        }
+    }
+    function createLogger(channel) {
+        return {
+            error: (m, d) => emit(channel, 'error', m, d),
+            warn: (m, d) => emit(channel, 'warn', m, d),
+            info: (m, d) => emit(channel, 'info', m, d),
+            debug: (m, d) => emit(channel, 'debug', m, d),
+            trace: (m, d) => emit(channel, 'trace', m, d),
+        };
+    }
+    function reset() {
+        buffer = [];
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        logFileSource = undefined;
+        initLevelSource = undefined;
+        runtimeLevel = undefined;
+        redactor = createRedactor();
+        captureSink = undefined;
+    }
+    if (options)
+        configure(options);
+    return { configure, createLogger, setLogLevel, flushLogs, reset };
+}
+/**
+ * A logger instance of its own, configured with `options`. A plugin whose
+ * copy of this module may be shared with another plugin in the same process
+ * uses this instead of `initLogger`, so neither replaces the other's file,
+ * level, redaction or capture sink.
+ */
+export function createLoggerInstance(options) {
+    const { configure, createLogger, setLogLevel, flushLogs } = createEngine(options);
+    return { configure, createLogger, setLogLevel, flushLogs };
+}
+/**
+ * The instance behind the module-level functions below, which keep the
+ * single-plugin API: one plugin per copy of this module calls `initLogger`
+ * and `createLogger` without holding an instance.
+ */
+const defaultEngine = createEngine();
+/**
+ * Point the module's default logger at a host's file and level, and return
+ * it. Idempotent: calling it again replaces both. A runtime level installed
+ * by `setLogLevel` is deliberately left alone, because it is the operator's
+ * explicit choice and outranks the floor a host computed at start-up.
+ */
+export function initLogger(options) {
+    defaultEngine.configure(options);
+    const { configure, createLogger, setLogLevel, flushLogs } = defaultEngine;
+    return { configure, createLogger, setLogLevel, flushLogs };
+}
+export function setLogLevel(l) {
+    defaultEngine.setLogLevel(l);
+}
+/**
+ * Write whatever the default logger has buffered. Safe to call synchronously
+ * from a process-exit handler, which is how each host drains the buffer on
+ * shutdown.
+ */
+export function flushLogs() {
+    defaultEngine.flushLogs();
+}
+export function createLogger(channel) {
+    return defaultEngine.createLogger(channel);
+}
+export async function flushForTest() {
+    defaultEngine.flushLogs();
+}
+/**
+ * Return the default logger to its uninitialised state. Only a test needs
+ * this: a single process runs every test file, so a file path left over from
+ * one test would keep a later "logger was never initialised" case writing
+ * lines.
+ */
+export function resetLoggerForTest() {
+    defaultEngine.reset();
+}

package/dist/src/common-auth-embedded/logger/index.d.ts

@@ -0,0 +1,6 @@
+export type { CaptureSink, LogTestRecord } from './capture-sink.js';
+export { createCaptureSink } from './capture-sink.js';
+export type { ChannelLogger, InitLoggerOptions, Level, LoggerInstance, LoggerOptions, SinkOnlyLoggerOptions, } from './engine.js';
+export { createLogger, createLoggerInstance, flushForTest, flushLogs, initLogger, resetLoggerForTest, setLogLevel, } from './engine.js';
+export type { RedactionOptions, Redactor } from './redact.js';
+export { createRedactor, redact, redactStrings } from './redact.js';

package/dist/src/common-auth-embedded/logger/index.js

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

package/dist/src/common-auth-embedded/logger/redact.d.ts

@@ -0,0 +1,11 @@
+export interface RedactionOptions {
+    extraSecretKeys?: (normalizedKey: string) => boolean;
+    extraValuePatterns?: RegExp[];
+}
+export declare function createRedactor(options?: RedactionOptions): {
+    redact: (value: unknown) => unknown;
+    redactStrings: (value: unknown) => unknown;
+};
+export type Redactor = ReturnType<typeof createRedactor>;
+export declare const redact: (value: unknown) => unknown;
+export declare const redactStrings: (value: unknown) => unknown;

package/dist/src/common-auth-embedded/logger/redact.js

@@ -0,0 +1,83 @@
+const SECRET_KEY_EXACT = /^(authorization|x-api-key|cookie|set-cookie|refresh|access|token)$/i;
+const TOKEN_VALUE = /\b(Bearer\s+[\w.-]+|sk-[\w-]+|eyJ[\w.-]+)\b|ckh_[A-Za-z0-9_-]{20,}/g;
+const MASK = '***REDACTED***';
+// How many errors deep a cause chain is followed. A chain this long is
+// already unreadable in a log line, and an unbounded one (each cause a fresh
+// object, so the cycle check never trips) must not grow the line forever.
+const MAX_ERROR_DEPTH = 8;
+// Error's own fields are non-enumerable, so a plain entry walk renders an
+// Error as `{}` and the name, message and stack a plugin logged are lost.
+// The tag check also recognises an Error from another realm (a worker or a
+// vm context), whose prototype is not this realm's Error.
+function isError(value) {
+    return (value instanceof Error ||
+        Object.prototype.toString.call(value) === '[object Error]');
+}
+export function createRedactor(options = {}) {
+    const patterns = [TOKEN_VALUE, ...(options.extraValuePatterns ?? [])].map((pattern) => new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`));
+    function isSecretKey(key) {
+        const normalized = key.toLowerCase().replace(/[-_]/g, '');
+        return (SECRET_KEY_EXACT.test(key) ||
+            normalized.includes('apikey') ||
+            normalized.endsWith('secret') ||
+            normalized.endsWith('password') ||
+            (normalized.endsWith('token') && !normalized.endsWith('tokens')) ||
+            !!options.extraSecretKeys?.(normalized));
+    }
+    // The fields every log reader wants first, then whatever else the error
+    // carries as its own enumerable properties (which is all an Error rendered
+    // as before). Every entry goes through the same key and string scrubbing as
+    // any other object, so a token in a message or stack is still masked.
+    function errorEntries(error) {
+        const fields = error;
+        const entries = [
+            ['name', error.name],
+            ['message', error.message],
+            ['stack', error.stack],
+        ];
+        for (const key of ['code', 'status', 'cause'])
+            if (fields[key] !== undefined)
+                entries.push([key, fields[key]]);
+        const listed = new Set(entries.map(([key]) => key));
+        for (const entry of Object.entries(error))
+            if (!listed.has(entry[0]))
+                entries.push(entry);
+        return entries;
+    }
+    function walk(value, keys, seen, errorDepth = 0) {
+        if (typeof value === 'string') {
+            return patterns.reduce((text, pattern) => text.replace(pattern, MASK), value);
+        }
+        if (!value || typeof value !== 'object')
+            return value;
+        if (seen.has(value))
+            return '[Circular]';
+        seen.add(value);
+        try {
+            if (Array.isArray(value))
+                return value.map((item) => walk(item, keys, seen, errorDepth));
+            const error = isError(value);
+            if (error && errorDepth >= MAX_ERROR_DEPTH)
+                return '[Truncated]';
+            const childDepth = error ? errorDepth + 1 : errorDepth;
+            // Define own properties so a diagnostic __proto__ key cannot change the output prototype.
+            return Object.fromEntries((error ? errorEntries(value) : Object.entries(value)).map(([key, item]) => [
+                key,
+                keys && isSecretKey(key)
+                    ? MASK
+                    : walk(item, keys, seen, childDepth),
+            ]));
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    return {
+        redact: (value) => walk(value, true, new WeakSet()),
+        // Schema keys describe arguments, not credentials; only their string values are scrubbed.
+        redactStrings: (value) => walk(value, false, new WeakSet()),
+    };
+}
+const defaultRedactor = createRedactor();
+export const redact = defaultRedactor.redact;
+export const redactStrings = defaultRedactor.redactStrings;

package/dist/src/common-auth-embedded/opencode2/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Why an OpenCode 2 auth hook refused a request.
+ *
+ * - `no-account`: the adapter had no account to offer for this request, so
+ *   the request is stopped before the host picks a transport. Also used when
+ *   session forgetting or installation disposal revokes an in-flight auth
+ *   selection: that selection no longer has an account it may send under.
+ * - `host-credential-on-wire`: after every rewrite, a header still carried
+ *   one of the host's placeholder credentials. Sending it would leak a
+ *   non-routable value to the provider and fail with a confusing error.
+ */
+export type OpenCode2AuthFailureKind = 'no-account' | 'host-credential-on-wire';
+export declare class OpenCode2AuthError extends Error {
+    readonly kind: OpenCode2AuthFailureKind;
+    readonly providerID: string;
+    readonly sessionID: string;
+    readonly requestKind: string;
+    constructor(details: {
+        kind: OpenCode2AuthFailureKind;
+        providerID: string;
+        sessionID: string;
+        requestKind: string;
+        message?: string;
+    });
+}

package/dist/src/common-auth-embedded/opencode2/errors.js

@@ -0,0 +1,15 @@
+export class OpenCode2AuthError extends Error {
+    kind;
+    providerID;
+    sessionID;
+    requestKind;
+    constructor(details) {
+        super(details.message ??
+            `${details.providerID} ${details.requestKind} request refused (${details.kind})`);
+        this.name = 'OpenCode2AuthError';
+        this.kind = details.kind;
+        this.providerID = details.providerID;
+        this.sessionID = details.sessionID;
+        this.requestKind = details.requestKind;
+    }
+}

package/dist/src/common-auth-embedded/opencode2/index.d.ts

@@ -0,0 +1,8 @@
+export type { OpenCode2AuthFailureKind } from './errors.js';
+export { OpenCode2AuthError } from './errors.js';
+export { ATTEMPT_HEADER, applyHeaderEdits, DEFAULT_MAX_RECORDS, installOpenCode2Auth, } from './install.js';
+export type { FormAnswer, LoginContext, PoolAuthorization, PoolLoginMethod, RegisterOpenCode2AuthMethodsOptions, VaultActivationMethod, } from './integration.js';
+export { isPlaceholderCredential, PLACEHOLDER_LIFETIME_MS, PLACEHOLDER_METADATA_KEY, PLACEHOLDER_PREFIX, placeholderCredential, placeholderSecret, registerOpenCode2AuthMethods, VAULT_ACTIVATION_INSTRUCTIONS, } from './integration.js';
+export type { ServerSentEvent } from './sse.js';
+export { watchServerSentEvents } from './sse.js';
+export type { AccountHeadersResult, AccountRequest, Attempt, AttemptEndReason, AttemptOutcome, ChooseAccountInput, EventVerdict, HeaderEdits, HostError, InstallOpenCode2AuthOptions, LimitSignal, OpenCode2AuthAdapter, OpenCode2AuthEventName, OpenCode2AuthEvents, OpenCode2AuthInstallation, OpenCode2AuthLogger, OpenCode2HookContext, RequestKind, RequestScope, ResponseAccount, RetryReason, SelectingHook, Transport, } from './types.js';

package/dist/src/common-auth-embedded/opencode2/index.js

@@ -0,0 +1,4 @@
+export { OpenCode2AuthError } from './errors.js';
+export { ATTEMPT_HEADER, applyHeaderEdits, DEFAULT_MAX_RECORDS, installOpenCode2Auth, } from './install.js';
+export { isPlaceholderCredential, PLACEHOLDER_LIFETIME_MS, PLACEHOLDER_METADATA_KEY, PLACEHOLDER_PREFIX, placeholderCredential, placeholderSecret, registerOpenCode2AuthMethods, VAULT_ACTIVATION_INSTRUCTIONS, } from './integration.js';
+export { watchServerSentEvents } from './sse.js';

package/dist/src/common-auth-embedded/opencode2/install.d.ts

@@ -0,0 +1,55 @@
+import type { HeaderEdits, InstallOpenCode2AuthOptions, OpenCode2AuthAdapter, OpenCode2AuthInstallation, OpenCode2HookContext } from './types.js';
+export declare const DEFAULT_MAX_RECORDS = 512;
+/**
+ * The request header `model.request` sets to the attempt it started. The
+ * host builds the HTTP request and the WebSocket handshake from the headers
+ * `model.request` leaves, so `http.request` and `experimental.ws.handshake`
+ * read it to find their own attempt among several of one session and kind,
+ * and remove it: it never reaches the wire.
+ */
+export declare const ATTEMPT_HEADER = "x-common-auth-attempt";
+/** Applies edits to a plain header record, replacing every spelling of each name. */
+export declare function applyHeaderEdits(target: Record<string, string>, edits: HeaderEdits): void;
+/**
+ * Installs multi-account auth on OpenCode 2's own provider drivers. Every
+ * hook is scoped to `adapter.providerID`:
+ *
+ * - `model.request` picks the account for one model call of a session and
+ *   request kind, which starts a new attempt, sets its headers and marks the
+ *   request with the attempt (`ATTEMPT_HEADER`);
+ * - `http.request` and `experimental.ws.handshake` find the attempt by that
+ *   mark, remove it and set the account headers again, because the host
+ *   applies its own credential after `model.request`;
+ * - `experimental.ws.send` (only when the adapter rewrites frames) rewrites
+ *   each outgoing frame;
+ * - `http.response` and `experimental.ws.receive` read quota, refusals,
+ *   whether output has started and when the response ended, attributed to
+ *   an attempt by the rules below;
+ * - `retry` asks the host to retry at once when an account was refused
+ *   before any output, so `model.request` runs again and can pick another
+ *   account, and refuses to retry once output has started.
+ *
+ * Attribution. A send belongs to the attempt named by the mark
+ * `model.request` left on it, so several attempts of one session and kind
+ * can be in flight at once, each on its own account. An HTTP response
+ * belongs to the attempt whose `http.request` produced its request object,
+ * and to nothing else. The host hands `http.response` the request object the
+ * `http.request` hooks left, so a different object means a later hook
+ * replaced it; nothing then proves which send the response answers, and its
+ * feedback is dropped rather than guessed by recency. A WebSocket frame
+ * names no attempt, so frames go to the newest open attempt of their session
+ * and kind that went out over WebSocket, and an older one is abandoned as
+ * soon as a newer attempt of that session and kind begins or goes out over
+ * WebSocket: the host runs one exchange at a time on a session's socket.
+ * Anything else is attributed to no attempt and reaches no adapter callback
+ * or listener.
+ *
+ * With `gateOnPlaceholder`, `model.request` is a no-op. Each transport hook
+ * compares the host-prepared secret exactly, then selects a fresh attempt only
+ * for an owned send. Request-object attribution therefore needs no attempt
+ * header. Frames are owned by the latest handshake of their session and kind;
+ * retry runs only when the session's latest transport was owned. The host's
+ * retry hook has no request identity, so concurrent mixed-ownership calls
+ * cannot be distinguished there; owned retries retain the heuristic above.
+ */
+export declare function installOpenCode2Auth<Q, A = unknown>(ctx: OpenCode2HookContext, adapter: OpenCode2AuthAdapter<Q, A>, options?: InstallOpenCode2AuthOptions): Promise<OpenCode2AuthInstallation<Q, A>>;