@undefineds.co/xpod 0.3.57 → 0.3.61

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

@@ -0,0 +1,21 @@
+import { BaseAiClientConfigAdapter } from './base-adapter';
+import type { AiConnectionClientProfile, ClientVerification } from './types';
+type EnvProjection = (profile: AiConnectionClientProfile) => Record<string, string>;
+declare abstract class JsonEnvAdapter extends BaseAiClientConfigAdapter {
+    private readonly envProjection;
+    protected readonly settingsPath: string;
+    protected constructor(client: string, settingsPath: string, envProjection: EnvProjection);
+    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>;
+}
+export interface JsonEnvConfigAdapterOptions {
+    homeDir?: string;
+}
+export declare class ClaudeCodeConfigAdapter extends JsonEnvAdapter {
+    constructor(options?: JsonEnvConfigAdapterOptions);
+}
+export declare class CodeBuddyConfigAdapter extends JsonEnvAdapter {
+    constructor(options?: JsonEnvConfigAdapterOptions);
+}
+export {};

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

@@ -0,0 +1,82 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { BaseAiClientConfigAdapter, looksLikePreviousXpodValue, normalizeMessagesEndpoint, normalizeV1Endpoint, parseJsonObject, stringifyJson, stripLegacyXpodObject, } from './base-adapter.js';
+class JsonEnvAdapter extends BaseAiClientConfigAdapter {
+    constructor(client, settingsPath, envProjection) {
+        super(client, client === 'claude-code' ? 'claude' : 'codebuddy', [settingsPath], path.dirname(settingsPath));
+        this.envProjection = envProjection;
+        this.settingsPath = settingsPath;
+    }
+    async project(profile, current) {
+        const settings = parseJsonObject(current.get(this.settingsPath), `${this.client} settings.json`);
+        const env = settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env)
+            ? { ...settings.env }
+            : {};
+        Object.assign(env, this.envProjection(profile));
+        settings.env = env;
+        return new Map([[this.settingsPath, stringifyJson(settings)]]);
+    }
+    async verifyProjection(profile) {
+        try {
+            const settings = parseJsonObject(await fs.promises.readFile(this.settingsPath, 'utf8'), `${this.client} settings.json`);
+            const env = settings.env;
+            const expected = this.envProjection(profile);
+            const ok = env !== undefined && Object.entries(expected).every(([key, value]) => env[key] === value);
+            return ok ? { ok: true } : {
+                ok: false,
+                reason: `${this.client} projection differs from the requested connection`,
+            };
+        }
+        catch (error) {
+            return { ok: false, reason: String(error) };
+        }
+    }
+    async restoreFile(_filePath, current, original, originallyExisted) {
+        const restored = parseJsonObject(current, `${this.client} settings.json`);
+        const before = parseJsonObject(original, `${this.client} original settings.json`);
+        stripLegacyXpodObject(restored);
+        const restoredEnv = isObject(restored.env) ? { ...restored.env } : {};
+        const beforeEnv = isObject(before.env) ? before.env : {};
+        for (const key of Object.keys(this.envProjection({
+            endpoint: 'https://owned.invalid',
+            gatewayKey: 'owned',
+            webId: 'https://owned.invalid/profile#me',
+        }))) {
+            if (Object.prototype.hasOwnProperty.call(beforeEnv, key) && !looksLikePreviousXpodValue(beforeEnv[key])) {
+                restoredEnv[key] = beforeEnv[key];
+            }
+            else {
+                delete restoredEnv[key];
+            }
+        }
+        if (Object.keys(restoredEnv).length > 0 || Object.prototype.hasOwnProperty.call(before, 'env')) {
+            restored.env = restoredEnv;
+        }
+        else {
+            delete restored.env;
+        }
+        return !originallyExisted && Object.keys(restored).length === 0 ? null : stringifyJson(restored);
+    }
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export class ClaudeCodeConfigAdapter extends JsonEnvAdapter {
+    constructor(options = {}) {
+        const settingsPath = path.join(options.homeDir ?? os.homedir(), '.claude', 'settings.json');
+        super('claude-code', settingsPath, (profile) => ({
+            ANTHROPIC_BASE_URL: normalizeMessagesEndpoint(profile.endpoint),
+            ANTHROPIC_AUTH_TOKEN: profile.gatewayKey,
+        }));
+    }
+}
+export class CodeBuddyConfigAdapter extends JsonEnvAdapter {
+    constructor(options = {}) {
+        const settingsPath = path.join(options.homeDir ?? os.homedir(), '.codebuddy', 'settings.json');
+        super('codebuddy', settingsPath, (profile) => ({
+            CODEBUDDY_BASE_URL: normalizeV1Endpoint(profile.endpoint),
+            CODEBUDDY_API_KEY: profile.gatewayKey,
+        }));
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BaseAiClientConfigAdapter } from './base-adapter';
+import type { AiConnectionClientProfile, ClientVerification } from './types';
+export interface PiConfigAdapterOptions {
+    homeDir?: string;
+}
+export declare class PiConfigAdapter extends BaseAiClientConfigAdapter {
+    private readonly settingsPath;
+    private readonly modelsPath;
+    constructor(options?: PiConfigAdapterOptions);
+    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>;
+}

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

@@ -0,0 +1,83 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { BaseAiClientConfigAdapter, looksLikePreviousXpodValue, normalizeV1Endpoint, parseJsonObject, stringifyJson, stripLegacyXpodObject, } from './base-adapter.js';
+export class PiConfigAdapter extends BaseAiClientConfigAdapter {
+    constructor(options = {}) {
+        const dir = path.join(options.homeDir ?? os.homedir(), '.pi', 'agent');
+        const settingsPath = path.join(dir, 'settings.json');
+        const modelsPath = path.join(dir, 'models.json');
+        super('pi', 'pi', [settingsPath, modelsPath], dir);
+        this.settingsPath = settingsPath;
+        this.modelsPath = modelsPath;
+    }
+    async project(profile, current) {
+        const settings = parseJsonObject(current.get(this.settingsPath), 'Pi settings.json');
+        const models = parseJsonObject(current.get(this.modelsPath), 'Pi models.json');
+        const providers = models.providers && typeof models.providers === 'object' && !Array.isArray(models.providers)
+            ? { ...models.providers }
+            : {};
+        const model = profile.model?.trim() || 'default';
+        settings.defaultProvider = 'xpod';
+        settings.defaultModel = model;
+        providers.xpod = {
+            baseUrl: normalizeV1Endpoint(profile.endpoint),
+            apiKey: profile.gatewayKey,
+            authHeader: true,
+            api: 'openai-responses',
+            models: [{ id: model, name: model }],
+        };
+        models.providers = providers;
+        return new Map([
+            [this.settingsPath, stringifyJson(settings)],
+            [this.modelsPath, stringifyJson(models)],
+        ]);
+    }
+    async verifyProjection(profile) {
+        try {
+            const models = parseJsonObject(await fs.promises.readFile(this.modelsPath, 'utf8'), 'Pi models.json');
+            const xpod = models.providers?.xpod;
+            const ok = xpod?.baseUrl === normalizeV1Endpoint(profile.endpoint) &&
+                xpod.apiKey === profile.gatewayKey;
+            return ok ? { ok: true } : { ok: false, reason: 'Pi projection differs from the requested connection' };
+        }
+        catch (error) {
+            return { ok: false, reason: String(error) };
+        }
+    }
+    async restoreFile(filePath, current, original, originallyExisted) {
+        const restored = parseJsonObject(current, `Pi ${path.basename(filePath)}`);
+        const before = parseJsonObject(original, `Pi original ${path.basename(filePath)}`);
+        stripLegacyXpodObject(restored);
+        if (filePath === this.settingsPath) {
+            restoreOwnedProperty(restored, before, 'defaultProvider');
+            restoreOwnedProperty(restored, before, 'defaultModel');
+        }
+        else {
+            const restoredProviders = isObject(restored.providers) ? { ...restored.providers } : {};
+            const beforeProviders = isObject(before.providers) ? before.providers : {};
+            restoreOwnedProperty(restoredProviders, beforeProviders, 'xpod');
+            if (Object.keys(restoredProviders).length > 0 || Object.prototype.hasOwnProperty.call(before, 'providers')) {
+                restored.providers = restoredProviders;
+            }
+            else {
+                delete restored.providers;
+            }
+        }
+        return !originallyExisted && Object.keys(restored).length === 0 ? null : stringifyJson(restored);
+    }
+}
+function restoreOwnedProperty(target, original, key) {
+    if (key === 'xpod' || looksLikePreviousXpodValue(original[key])) {
+        delete target[key];
+    }
+    else if (Object.prototype.hasOwnProperty.call(original, key)) {
+        target[key] = original[key];
+    }
+    else {
+        delete target[key];
+    }
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -0,0 +1,17 @@
+import type { ConfigWrite } from './types';
+export interface AiClientConfigTransactionDependencies {
+    rename?: (from: string, to: string) => Promise<void>;
+}
+export declare class AiClientConfigTransaction {
+    private readonly rename;
+    constructor(dependencies?: AiClientConfigTransactionDependencies);
+    apply(writes: ConfigWrite[]): Promise<void>;
+    private preparePath;
+    private rejectSymlink;
+    private snapshot;
+    private stage;
+    private writeNewFile;
+    private rollback;
+    private syncDirectory;
+    private exists;
+}

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

@@ -0,0 +1,153 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class AiClientConfigTransaction {
+    constructor(dependencies = {}) {
+        this.rename = dependencies.rename ?? fs.promises.rename;
+    }
+    async apply(writes) {
+        const uniquePaths = new Set(writes.map((write) => path.resolve(write.path)));
+        if (uniquePaths.size !== writes.length) {
+            throw new Error('AI client configuration transaction contains duplicate paths');
+        }
+        for (const write of writes) {
+            await this.preparePath(write.path);
+            if (write.backupPath) {
+                await this.preparePath(write.backupPath);
+            }
+        }
+        const snapshots = await Promise.all(writes.map((write) => this.snapshot(write.path)));
+        const staged = new Map();
+        try {
+            for (const write of writes) {
+                const snapshot = snapshots.find((candidate) => candidate.path === write.path);
+                if (write.createBackup && write.backupPath && snapshot.existed) {
+                    if (await this.exists(write.backupPath)) {
+                        throw new Error(`AI client configuration backup already exists: ${write.backupPath}`);
+                    }
+                    await this.writeNewFile(write.backupPath, snapshot.content, snapshot.mode ?? 0o600);
+                }
+                if (write.content !== null) {
+                    staged.set(write.path, await this.stage(write.path, write.content));
+                }
+            }
+            for (const write of writes) {
+                if (write.content === null) {
+                    await fs.promises.rm(write.path, { force: true });
+                }
+                else {
+                    await this.rename(staged.get(write.path), write.path);
+                    await fs.promises.chmod(write.path, 0o600);
+                    await this.syncDirectory(path.dirname(write.path));
+                }
+            }
+        }
+        catch (error) {
+            await this.rollback(snapshots);
+            throw error;
+        }
+        finally {
+            await Promise.all([...staged.values()].map((tempPath) => fs.promises.rm(tempPath, { force: true }).catch(() => undefined)));
+        }
+    }
+    async preparePath(filePath) {
+        const directory = path.dirname(filePath);
+        await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+        await this.rejectSymlink(directory, true);
+        await this.rejectSymlink(filePath);
+    }
+    async rejectSymlink(filePath, allowDirectory = false) {
+        try {
+            const stats = await fs.promises.lstat(filePath);
+            if (stats.isSymbolicLink()) {
+                throw new Error(`Refusing to configure symbolic link: ${filePath}`);
+            }
+            if (!allowDirectory && stats.isDirectory()) {
+                throw new Error(`Refusing to replace directory with AI client configuration: ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    async snapshot(filePath) {
+        try {
+            const stats = await fs.promises.lstat(filePath);
+            if (!stats.isFile()) {
+                throw new Error(`AI client configuration is not a regular file: ${filePath}`);
+            }
+            return {
+                path: filePath,
+                existed: true,
+                content: await fs.promises.readFile(filePath),
+                mode: stats.mode & 0o777,
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return { path: filePath, existed: false };
+            }
+            throw error;
+        }
+    }
+    async stage(targetPath, content) {
+        const tempPath = path.join(path.dirname(targetPath), `.${path.basename(targetPath)}.xpod-tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`);
+        await this.writeNewFile(tempPath, Buffer.from(content, 'utf8'), 0o600);
+        return tempPath;
+    }
+    async writeNewFile(filePath, content, mode) {
+        const handle = await fs.promises.open(filePath, 'wx', mode);
+        try {
+            await handle.writeFile(content);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await fs.promises.chmod(filePath, 0o600);
+        await this.syncDirectory(path.dirname(filePath));
+    }
+    async rollback(snapshots) {
+        for (const snapshot of [...snapshots].reverse()) {
+            try {
+                if (!snapshot.existed) {
+                    await fs.promises.rm(snapshot.path, { force: true });
+                    continue;
+                }
+                const tempPath = await this.stage(snapshot.path, snapshot.content.toString('utf8'));
+                await this.rename(tempPath, snapshot.path);
+                await fs.promises.chmod(snapshot.path, snapshot.mode ?? 0o600);
+                await this.syncDirectory(path.dirname(snapshot.path));
+            }
+            catch {
+                // Preserve the initiating failure. Backups remain available for recovery.
+            }
+        }
+    }
+    async syncDirectory(directory) {
+        let handle;
+        try {
+            handle = await fs.promises.open(directory, 'r');
+            await handle.sync();
+        }
+        catch (error) {
+            if (!['EINVAL', 'ENOTSUP', 'EISDIR'].includes(error.code ?? '')) {
+                throw error;
+            }
+        }
+        finally {
+            await handle?.close();
+        }
+    }
+    async exists(filePath) {
+        try {
+            await fs.promises.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+export interface AiConnectionClientProfile {
+    endpoint: string;
+    gatewayKey: string;
+    webId: string;
+    model?: string;
+}
+export type ClientOwnership = 'unowned' | 'owned' | 'foreign';
+export interface ClientDetection {
+    installed: boolean;
+    configExists: boolean;
+    configPaths: string[];
+}
+export interface ClientInspection {
+    ownership: ClientOwnership;
+    webIdHash?: string;
+    configPaths: string[];
+}
+export interface ClientVerification {
+    ok: boolean;
+    reason?: string;
+}
+export interface ConfigWrite {
+    path: string;
+    content: string | null;
+    backupPath?: string;
+    createBackup?: boolean;
+}
+export interface AiClientConfigPlan {
+    client: string;
+    webIdHash: string;
+    writes: ConfigWrite[];
+}
+export interface AiClientConfigAdapter {
+    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>;
+}

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

@@ -0,0 +1 @@
+export {};

package/node_modules/@undefineds.co/ai-connection/dist/controller.d.ts

@@ -0,0 +1,42 @@
+import type { WebExtensionHost, WebExtensionSessionStatus, WebExtensionSolidPodStatus } from '@undefineds.co/extension-sdk/web';
+import { type AiConnectionClient, type AiConnectionProvider, type AiProviderConnectionSummary } from './ai-connection-client';
+import type { AiClientConfigurationBridge } from './AiClientConfigurationSection';
+export interface AiProviderDefinition {
+    id: AiConnectionProvider;
+    name: string;
+    browserMode: 'browserAssistedApiKey' | 'deviceCodeOAuth' | 'connectUnsupported';
+    browserLabel: string;
+}
+export declare const PROVIDERS: AiProviderDefinition[];
+export type ProviderProductState = 'loading' | 'unconfigured' | 'configured' | 'connected' | 'attention';
+export type ServiceAccessState = 'checking' | 'granted' | 'missing' | 'permissionDenied' | 'capabilityUnavailable' | 'invalidDescriptor';
+export interface AiConnectionController {
+    readonly client: AiConnectionClient | null;
+    readonly sessionStatus: WebExtensionSessionStatus;
+    readonly podStatus: WebExtensionSolidPodStatus;
+    readonly error?: Error;
+    readonly login: () => Promise<void>;
+    readonly openExternal: (url: string) => Promise<void>;
+    readonly clientConfigurationBridge?: AiClientConfigurationBridge;
+    readonly selectedProvider: AiConnectionProvider;
+    readonly searchQuery: string;
+    readonly providerStates: Partial<Record<AiConnectionProvider, ProviderProductState>>;
+    readonly providerSummaries: Partial<Record<AiConnectionProvider, AiProviderConnectionSummary>>;
+    readonly providerLoadError?: string;
+    readonly serviceAccessState: ServiceAccessState;
+    selectProvider(provider: AiConnectionProvider): void;
+    selectFirstUnconfiguredProvider(): void;
+    setSearchQuery(value: string): void;
+    setProviderState(provider: AiConnectionProvider, state: ProviderProductState): void;
+    ensureServiceAccess(): Promise<void>;
+    revokeServiceAccess(): Promise<void>;
+    loadProviders(): Promise<void>;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createAiConnectionController(host: WebExtensionHost): AiConnectionController;
+export declare function useSelectedProvider(controller: AiConnectionController): AiConnectionProvider;
+export declare function useProviderSearch(controller: AiConnectionController): string;
+export declare function useProviderStates(controller: AiConnectionController): Partial<Record<AiConnectionProvider, ProviderProductState>>;
+export declare function useProviderSummaries(controller: AiConnectionController): Partial<Record<AiConnectionProvider, AiProviderConnectionSummary>>;
+export declare function useProviderLoadError(controller: AiConnectionController): string | undefined;
+export declare function useServiceAccessState(controller: AiConnectionController): ServiceAccessState;