@undefineds.co/xpod 0.3.58 → 0.3.62

package/node_modules/@undefineds.co/ai-connection/dist/ai-connection-client.js

@@ -0,0 +1,414 @@
+export const AI_CONNECTION_PROVIDERS = [
+    'openai',
+    'anthropic',
+    'kimi',
+    'bailian',
+    'deepseek',
+];
+export const AI_CONNECTION_GENERIC_ERROR_MESSAGE = 'AI Connection request failed. Please try again.';
+export function resolveAiConnectionApiBase(podBaseUrl) {
+    const parsed = new URL(podBaseUrl);
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new Error('Current Pod URL must use HTTP or HTTPS');
+    }
+    return parsed.origin;
+}
+export function createAiConnectionClient({ webId, podBaseUrl, authenticatedFetch, }) {
+    const apiBase = resolveAiConnectionApiBase(podBaseUrl);
+    const request = async (path, method, body, context = {}) => {
+        const response = await authenticatedFetch(`${apiBase}${path}`, {
+            method,
+            credentials: 'omit',
+            mode: 'cors',
+            headers: {
+                accept: 'application/json',
+                ...(body ? { 'content-type': 'application/json' } : {}),
+            },
+            ...(body ? { body: JSON.stringify(body) } : {}),
+        });
+        const payload = await readJson(response);
+        if (!response.ok) {
+            throw new Error(normalizeAiConnectionErrorMessage(payload, response.status, context));
+        }
+        return payload;
+    };
+    const providerPath = (provider) => {
+        assertProvider(provider);
+        return `/api/ai/gateway/providers/${provider}`;
+    };
+    const requestConnect = async (provider, path, method, body) => {
+        const payload = await request(`${providerPath(provider)}${path}`, method, body, { provider });
+        return parseConnectAttempt(payload, provider);
+    };
+    return {
+        webId,
+        apiBase,
+        getServiceAccess() {
+            return request('/api/applets/service-access/ai-connection', 'GET');
+        },
+        async listProviders() {
+            const payload = await request('/api/ai/connections/providers', 'GET');
+            return Array.isArray(payload.data)
+                ? payload.data.map(parseProviderSummary).filter(isDefined)
+                : [];
+        },
+        async listModels() {
+            const payload = await request('/v1/models', 'GET');
+            return Array.isArray(payload.data)
+                ? payload.data.map(parseGatewayModel).filter(isDefined)
+                : [];
+        },
+        async listGatewayKeys() {
+            const payload = await request('/api/ai/gateway/keys', 'GET');
+            return Array.isArray(payload.data)
+                ? payload.data.map(parseGatewayKeyRecord).filter(isDefined)
+                : [];
+        },
+        async createGatewayKey(input) {
+            const payload = await request('/api/ai/gateway/keys', 'POST', compactObject(input));
+            if (typeof payload.key !== 'string' || !payload.key) {
+                throw new Error('AI Connection did not return the one-time Gateway key');
+            }
+            const record = parseGatewayKeyRecord(payload.record);
+            if (!record) {
+                throw new Error('AI Connection returned an invalid Gateway key record');
+            }
+            return { plaintext: payload.key, record };
+        },
+        async revokeGatewayKey(keyId) {
+            const payload = await request(`/api/ai/gateway/keys/${encodeURIComponent(keyId)}`, 'DELETE');
+            return parseGatewayKeyRecord(payload.record);
+        },
+        async beginConnect(provider, mode) {
+            return await requestConnect(provider, '/connect/begin', 'POST', { mode });
+        },
+        connectStatus(provider, attempt) {
+            if (!attempt.attemptId) {
+                throw new Error('Connect attempt id is required');
+            }
+            const query = new URLSearchParams({
+                state: attempt.state ?? '',
+                signature: attempt.signature ?? '',
+            });
+            return requestConnect(provider, `/connect/status/${encodeURIComponent(attempt.attemptId)}?${query}`, 'GET');
+        },
+        completeApiKey(provider, attempt, apiKey, accountLabel) {
+            return requestConnect(provider, '/connect/complete-api-key', 'POST', compactObject({
+                attemptId: attempt.attemptId,
+                state: attempt.state,
+                signature: attempt.signature,
+                apiKey,
+                accountLabel,
+            }));
+        },
+        pollDevice(provider, attempt) {
+            return requestConnect(provider, '/connect/poll', 'POST', compactObject({
+                attemptId: attempt.attemptId,
+                state: attempt.state,
+                signature: attempt.signature,
+            }));
+        },
+        async disconnect(provider) {
+            const payload = await request(`${providerPath(provider)}/connect`, 'DELETE');
+            return parseCredential(payload.record);
+        },
+        quota(provider, refresh = false) {
+            return request(`${providerPath(provider)}/quota/${refresh ? 'refresh' : 'status'}`, refresh ? 'POST' : 'GET', refresh ? {} : undefined, { provider });
+        },
+    };
+}
+export function normalizeAiConnectionThrownError(error) {
+    if (error instanceof Error) {
+        return normalizeAiConnectionErrorText(error.message);
+    }
+    return normalizeAiConnectionErrorText(String(error));
+}
+export function normalizeAiConnectionErrorMessage(payload, status, context = {}) {
+    const code = errorCodeFromPayload(payload);
+    const coded = code ? messageForSafeErrorCode(code, context.provider) : undefined;
+    if (coded)
+        return coded;
+    const text = isRecord(payload) && typeof payload.error === 'string'
+        ? payload.error
+        : undefined;
+    if (text) {
+        const exact = messageForSafeErrorCode(text, context.provider);
+        if (exact)
+            return exact;
+        if (text === 'AI Connection service identity is unavailable') {
+            return text;
+        }
+    }
+    if (status === 401)
+        return 'Please sign in again to continue.';
+    if (status === 403)
+        return 'AI Connection permission was denied.';
+    if (status === 404 && context.provider) {
+        return `${providerLabel(context.provider)} connection is not configured.`;
+    }
+    if (status === 429)
+        return 'AI Connection is rate limited. Please try again later.';
+    if (status === 503)
+        return 'AI Connection service is unavailable.';
+    return AI_CONNECTION_GENERIC_ERROR_MESSAGE;
+}
+function normalizeAiConnectionErrorText(message) {
+    const exact = messageForSafeErrorCode(message);
+    if (exact)
+        return exact;
+    const prefix = message.split(':', 1)[0]?.trim();
+    const prefixed = prefix ? messageForSafeErrorCode(prefix) : undefined;
+    if (prefixed)
+        return prefixed;
+    if (message === 'AI Connection service identity is unavailable')
+        return message;
+    if (message.startsWith('invalid_'))
+        return 'AI Connection returned an invalid response.';
+    return AI_CONNECTION_GENERIC_ERROR_MESSAGE;
+}
+function errorCodeFromPayload(payload) {
+    if (!isRecord(payload))
+        return undefined;
+    if (typeof payload.code === 'string')
+        return payload.code;
+    if (typeof payload.errorCode === 'string')
+        return payload.errorCode;
+    if (typeof payload.error === 'string' && /^[a-z][a-z0-9_:-]{0,80}$/i.test(payload.error)) {
+        return payload.error;
+    }
+    return undefined;
+}
+function messageForSafeErrorCode(code, provider) {
+    switch (code.trim().toLowerCase().replace(/-/g, '_')) {
+        case 'not_configured':
+        case 'notconfigured':
+            return provider
+                ? `${providerLabel(provider)} connection is not configured.`
+                : 'AI provider connection is not configured.';
+        case 'unsupported':
+            return provider
+                ? `${providerLabel(provider)} does not support this operation.`
+                : 'This AI Connection operation is not supported.';
+        case 'service_identity_unavailable':
+            return 'AI Connection service identity is unavailable';
+        case 'unauthorized':
+            return 'Please sign in again to continue.';
+        case 'forbidden':
+        case 'permission_denied':
+            return 'AI Connection permission was denied.';
+        case 'rate_limited':
+            return 'AI Connection is rate limited. Please try again later.';
+        case 'service_unavailable':
+            return 'AI Connection service is unavailable.';
+        default:
+            return undefined;
+    }
+}
+function providerLabel(provider) {
+    switch (provider) {
+        case 'openai': return 'OpenAI';
+        case 'anthropic': return 'Anthropic';
+        case 'kimi': return 'Kimi';
+        case 'bailian': return 'Bailian';
+        case 'deepseek': return 'DeepSeek';
+    }
+}
+async function readJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`AI Connection returned invalid JSON (${response.status})`);
+    }
+}
+function assertProvider(provider) {
+    if (!AI_CONNECTION_PROVIDERS.includes(provider)) {
+        throw new Error(`Unsupported AI provider: ${provider}`);
+    }
+}
+function parseGatewayKeyRecord(value) {
+    if (!isRecord(value)
+        || typeof value.id !== 'string'
+        || typeof value.owner !== 'string'
+        || !Array.isArray(value.scopes)
+        || !value.scopes.every((scope) => typeof scope === 'string')
+        || typeof value.createdAt !== 'string') {
+        return undefined;
+    }
+    return compactObject({
+        id: value.id,
+        owner: value.owner,
+        scopes: value.scopes,
+        createdAt: value.createdAt,
+        expiresAt: stringValue(value.expiresAt),
+        lastUsedAt: stringValue(value.lastUsedAt),
+        revokedAt: stringValue(value.revokedAt),
+        name: stringValue(value.name),
+    });
+}
+function parseGatewayModel(value) {
+    if (!isRecord(value) || typeof value.id !== 'string')
+        return undefined;
+    if (isPlatformModelId(value.id))
+        return undefined;
+    const provider = providerValue(value.provider)
+        ?? providerValue(value.providerId)
+        ?? providerValue(value.owned_by)
+        ?? providerFromModelId(value.id);
+    if (!provider)
+        return undefined;
+    return compactObject({
+        id: value.id,
+        provider,
+        displayName: stringValue(value.displayName) ?? stringValue(value.name),
+        contextWindow: numberValue(value.contextWindow) ?? numberValue(value.context_window),
+        protocols: Array.isArray(value.protocols)
+            ? value.protocols.filter((protocol) => typeof protocol === 'string')
+            : undefined,
+    });
+}
+function isPlatformModelId(modelId) {
+    const normalized = modelId.toLowerCase();
+    return normalized === 'linx'
+        || normalized === 'linx-lite'
+        || normalized === 'undefineds/linx'
+        || normalized === 'undefineds/linx-lite';
+}
+function providerValue(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (normalized === 'alibaba' || normalized === 'dashscope')
+        return 'bailian';
+    return AI_CONNECTION_PROVIDERS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+function providerFromModelId(modelId) {
+    const prefix = modelId.split('/', 1)[0];
+    return modelId.includes('/') ? providerValue(prefix) : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function parseProviderSummary(value) {
+    if (!isRecord(value)
+        || typeof value.provider !== 'string'
+        || !isProviderStatus(value.status)
+        || !isRecord(value.connect)
+        || !Array.isArray(value.connect.modes)
+        || !value.connect.modes.every(isConnectMode)
+        || typeof value.connect.configured !== 'boolean') {
+        return undefined;
+    }
+    assertProvider(value.provider);
+    return compactObject({
+        provider: value.provider,
+        status: value.status,
+        authMode: stringValue(value.authMode),
+        accountLabel: stringValue(value.accountLabel),
+        expiresAt: stringValue(value.expiresAt),
+        reauthRequired: typeof value.reauthRequired === 'boolean' ? value.reauthRequired : undefined,
+        credentialIri: stringValue(value.credentialIri),
+        version: typeof value.version === 'number' ? value.version : undefined,
+        connect: compactObject({
+            modes: [...value.connect.modes],
+            configured: value.connect.configured,
+            message: stringValue(value.connect.message),
+        }),
+    });
+}
+function parseCredential(value) {
+    if (!isRecord(value)
+        || typeof value.id !== 'string'
+        || typeof value.credentialIri !== 'string'
+        || typeof value.webId !== 'string'
+        || typeof value.provider !== 'string'
+        || typeof value.authMode !== 'string'
+        || typeof value.status !== 'string') {
+        return undefined;
+    }
+    assertProvider(value.provider);
+    return compactObject({
+        id: value.id,
+        credentialIri: value.credentialIri,
+        webId: value.webId,
+        provider: value.provider,
+        authMode: value.authMode,
+        status: value.status,
+        accountLabel: stringValue(value.accountLabel),
+        expiresAt: stringValue(value.expiresAt),
+        version: typeof value.version === 'number' ? value.version : undefined,
+        reauthRequired: typeof value.reauthRequired === 'boolean' ? value.reauthRequired : undefined,
+    });
+}
+function parseConnectAttempt(value, expectedProvider) {
+    if (!isRecord(value)
+        || !isConnectMode(value.mode)
+        || !isConnectStatus(value.status)
+        || value.provider !== expectedProvider) {
+        throw new Error('AI Connection returned an invalid Connect response');
+    }
+    return compactObject({
+        mode: value.mode,
+        status: value.status,
+        provider: expectedProvider,
+        attemptId: stringValue(value.attemptId),
+        state: stringValue(value.state),
+        signature: stringValue(value.signature),
+        expiresAt: stringValue(value.expiresAt),
+        authorizationUrl: safeHttpUrl(value.authorizationUrl),
+        userCode: stringValue(value.userCode),
+        verificationUri: safeHttpUrl(value.verificationUri),
+        verificationUriComplete: safeHttpUrl(value.verificationUriComplete),
+        intervalSeconds: typeof value.intervalSeconds === 'number' ? value.intervalSeconds : undefined,
+        apiKeyManagementSupported: typeof value.apiKeyManagementSupported === 'boolean'
+            ? value.apiKeyManagementSupported
+            : undefined,
+        credentialId: stringValue(value.credentialId),
+        message: stringValue(value.message),
+    });
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function safeHttpUrl(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === 'https:' || parsed.protocol === 'http:' ? parsed.href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isConnectMode(value) {
+    return value === 'browserAssistedApiKey'
+        || value === 'deviceCodeOAuth'
+        || value === 'connectUnsupported';
+}
+function isConnectStatus(value) {
+    return value === 'pending'
+        || value === 'authorization_pending'
+        || value === 'slow_down'
+        || value === 'completed'
+        || value === 'expired'
+        || value === 'cancelled'
+        || value === 'unsupported';
+}
+function isProviderStatus(value) {
+    return value === 'connected' || value === 'disconnected' || value === 'reauthRequired';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isDefined(value) {
+    return value !== undefined;
+}

package/node_modules/@undefineds.co/ai-connection/dist/client-config/base-adapter.d.ts

@@ -0,0 +1,32 @@
+import { AiClientConfigTransaction } from './transaction';
+import type { AiClientConfigAdapter, AiClientConfigPlan, AiConnectionClientProfile, ClientDetection, ClientInspection, ClientVerification } from './types';
+export declare function hashWebId(webId: string): string;
+export declare function normalizeV1Endpoint(endpoint: string): string;
+export declare function normalizeMessagesEndpoint(endpoint: string): string;
+export declare function parseJsonObject(content: string | undefined, label: string): Record<string, unknown>;
+export declare function stringifyJson(value: unknown): string;
+export declare function looksLikePreviousXpodValue(value: unknown): boolean;
+export declare function stripLegacyXpodObject(value: Record<string, unknown>): void;
+export declare abstract class BaseAiClientConfigAdapter implements AiClientConfigAdapter {
+    protected readonly client: string;
+    private readonly executable;
+    protected readonly configPaths: string[];
+    protected readonly transaction: AiClientConfigTransaction;
+    protected readonly statePath: string;
+    protected constructor(client: string, executable: string, configPaths: string[], stateDirectory: string, transaction?: AiClientConfigTransaction);
+    detect(): Promise<ClientDetection>;
+    inspect(): Promise<ClientInspection>;
+    plan(profile: AiConnectionClientProfile): Promise<AiClientConfigPlan>;
+    apply(plan: AiClientConfigPlan): Promise<void>;
+    verify(profile: AiConnectionClientProfile): Promise<ClientVerification>;
+    restore(webId: string): Promise<void>;
+    protected abstract project(profile: AiConnectionClientProfile, current: Map<string, string | undefined>): Promise<Map<string, string>>;
+    protected abstract verifyProjection(profile: AiConnectionClientProfile): Promise<ClientVerification>;
+    protected abstract restoreFile(filePath: string, current: string | undefined, original: string | undefined, originallyExisted: boolean): Promise<string | null>;
+    protected readOptional(filePath: string): Promise<string | undefined>;
+    private validateProfile;
+    private readState;
+    private rejectSymlink;
+    private exists;
+    private isExecutableOnPath;
+}

package/node_modules/@undefineds.co/ai-connection/dist/client-config/base-adapter.js

@@ -0,0 +1,212 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { AiClientConfigTransaction } from './transaction.js';
+export function hashWebId(webId) {
+    return crypto.createHash('sha256').update(webId.trim(), 'utf8').digest('hex');
+}
+export function normalizeV1Endpoint(endpoint) {
+    const normalized = endpoint.trim().replace(/\/+$/, '');
+    return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`;
+}
+export function normalizeMessagesEndpoint(endpoint) {
+    return endpoint.trim().replace(/\/+$/, '').replace(/\/v1$/, '');
+}
+export function parseJsonObject(content, label) {
+    if (!content?.trim())
+        return {};
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Cannot configure ${label}: invalid JSON (${String(error)})`);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Cannot configure ${label}: root must be a JSON object`);
+    }
+    return value;
+}
+export function stringifyJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export function looksLikePreviousXpodValue(value) {
+    return typeof value === 'string' && (value.includes('xpod') ||
+        value.includes('/api/ai') ||
+        value.includes('xpod.'));
+}
+export function stripLegacyXpodObject(value) {
+    const legacy = value.xpod;
+    if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        delete value.xpod;
+    }
+}
+export class BaseAiClientConfigAdapter {
+    constructor(client, executable, configPaths, stateDirectory, transaction = new AiClientConfigTransaction()) {
+        this.client = client;
+        this.executable = executable;
+        this.configPaths = configPaths;
+        this.transaction = transaction;
+        this.statePath = path.join(stateDirectory, `.xpod-ai-connection-${client}.json`);
+    }
+    async detect() {
+        return {
+            installed: await this.isExecutableOnPath(),
+            configExists: (await Promise.all(this.configPaths.map((filePath) => this.exists(filePath)))).some(Boolean),
+            configPaths: [...this.configPaths],
+        };
+    }
+    async inspect() {
+        const state = await this.readState();
+        return {
+            ownership: state ? 'owned' : 'unowned',
+            ...(state ? { webIdHash: state.webIdHash } : {}),
+            configPaths: [...this.configPaths],
+        };
+    }
+    async plan(profile) {
+        this.validateProfile(profile);
+        const ownerHash = hashWebId(profile.webId);
+        const currentState = await this.readState();
+        if (currentState && currentState.webIdHash !== ownerHash) {
+            throw new Error(`${this.client} AI Connection projection is owned by another WebID`);
+        }
+        const contents = new Map();
+        for (const filePath of this.configPaths) {
+            await this.rejectSymlink(filePath);
+            contents.set(filePath, await this.readOptional(filePath));
+        }
+        const projected = await this.project(profile, contents);
+        const timestamp = Date.now();
+        const files = this.configPaths.map((filePath) => {
+            const prior = currentState?.files.find((file) => file.path === filePath);
+            const existed = contents.get(filePath) !== undefined;
+            return prior ?? {
+                path: filePath,
+                existed,
+                ...(existed ? { backupPath: `${filePath}.xpod-backup-${timestamp}` } : {}),
+            };
+        });
+        const writes = [...projected.entries()].map(([filePath, content]) => ({
+            path: filePath,
+            content,
+            backupPath: files.find((file) => file.path === filePath)?.backupPath,
+            createBackup: !currentState && contents.get(filePath) !== undefined,
+        }));
+        const state = {
+            version: 1,
+            client: this.client,
+            webIdHash: ownerHash,
+            files,
+        };
+        writes.push({ path: this.statePath, content: stringifyJson(state) });
+        return { client: this.client, webIdHash: ownerHash, writes };
+    }
+    async apply(plan) {
+        if (plan.client !== this.client) {
+            throw new Error(`Cannot apply ${plan.client} plan with ${this.client} adapter`);
+        }
+        await this.transaction.apply(plan.writes);
+    }
+    async verify(profile) {
+        const state = await this.readState();
+        if (!state || state.webIdHash !== hashWebId(profile.webId)) {
+            return { ok: false, reason: 'AI Connection ownership does not match the current WebID' };
+        }
+        return this.verifyProjection(profile);
+    }
+    async restore(webId) {
+        const state = await this.readState();
+        if (!state)
+            return;
+        if (state.webIdHash !== hashWebId(webId)) {
+            throw new Error(`${this.client} AI Connection projection is owned by another WebID`);
+        }
+        const writes = [];
+        for (const file of state.files) {
+            await this.rejectSymlink(file.path);
+            const current = await this.readOptional(file.path);
+            let original;
+            if (file.existed) {
+                if (!file.backupPath) {
+                    throw new Error(`Missing ${this.client} backup metadata for ${file.path}`);
+                }
+                await this.rejectSymlink(file.backupPath);
+                original = await this.readOptional(file.backupPath);
+                if (original === undefined) {
+                    throw new Error(`Missing ${this.client} backup at ${file.backupPath}`);
+                }
+            }
+            writes.push({
+                path: file.path,
+                content: await this.restoreFile(file.path, current, original, file.existed),
+            });
+        }
+        writes.push({ path: this.statePath, content: null });
+        await this.transaction.apply(writes);
+    }
+    async readOptional(filePath) {
+        try {
+            return await fs.promises.readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+    validateProfile(profile) {
+        if (!profile.endpoint.trim())
+            throw new Error('AI Connection endpoint is required');
+        if (!profile.gatewayKey.trim())
+            throw new Error('AI Connection Gateway key is required');
+        if (!profile.webId.trim())
+            throw new Error('Current WebID is required');
+    }
+    async readState() {
+        await this.rejectSymlink(this.statePath);
+        const content = await this.readOptional(this.statePath);
+        if (!content)
+            return undefined;
+        const parsed = parseJsonObject(content, `${this.client} ownership state`);
+        if (parsed.version !== 1 || parsed.client !== this.client || typeof parsed.webIdHash !== 'string' ||
+            !Array.isArray(parsed.files)) {
+            throw new Error(`Invalid ${this.client} AI Connection ownership state`);
+        }
+        return parsed;
+    }
+    async rejectSymlink(filePath) {
+        try {
+            if ((await fs.promises.lstat(filePath)).isSymbolicLink()) {
+                throw new Error(`Refusing to configure symbolic link: ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    async exists(filePath) {
+        try {
+            return (await fs.promises.lstat(filePath)).isFile();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+    async isExecutableOnPath() {
+        const pathValue = process.env.PATH ?? '';
+        for (const directory of pathValue.split(path.delimiter).filter(Boolean)) {
+            try {
+                await fs.promises.access(path.join(directory, this.executable), fs.constants.X_OK);
+                return true;
+            }
+            catch {
+                // Continue searching PATH.
+            }
+        }
+        return false;
+    }
+}

package/node_modules/@undefineds.co/ai-connection/dist/client-config/codex.d.ts

@@ -0,0 +1,14 @@
+import { BaseAiClientConfigAdapter } from './base-adapter';
+import type { AiConnectionClientProfile, ClientVerification } from './types';
+export interface CodexConfigAdapterOptions {
+    homeDir?: string;
+}
+export declare class CodexConfigAdapter extends BaseAiClientConfigAdapter {
+    private readonly configPath;
+    private readonly authPath;
+    constructor(options?: CodexConfigAdapterOptions);
+    protected project(profile: AiConnectionClientProfile, current: Map<string, string | undefined>): Promise<Map<string, string>>;
+    protected verifyProjection(profile: AiConnectionClientProfile): Promise<ClientVerification>;
+    protected restoreFile(filePath: string, current: string | undefined, original: string | undefined, originallyExisted: boolean): Promise<string | null>;
+    private removeManagedBlock;
+}