@undefineds.co/xpod 0.3.57 → 0.3.61

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

@@ -0,0 +1,289 @@
+import { useSyncExternalStore } from 'react';
+import { AI_CONNECTION_PROVIDERS, createAiConnectionClient, normalizeAiConnectionThrownError, } from './ai-connection-client.js';
+import { parseAiConnectionServiceAccess } from './service-access.js';
+export const PROVIDERS = [
+    { id: 'openai', name: 'OpenAI', browserMode: 'browserAssistedApiKey', browserLabel: '打开官方控制台' },
+    { id: 'anthropic', name: 'Anthropic', browserMode: 'browserAssistedApiKey', browserLabel: '打开官方控制台' },
+    { id: 'kimi', name: 'Kimi', browserMode: 'deviceCodeOAuth', browserLabel: '浏览器鉴权' },
+    { id: 'bailian', name: '百炼', browserMode: 'browserAssistedApiKey', browserLabel: '打开官方控制台' },
+    { id: 'deepseek', name: 'DeepSeek', browserMode: 'connectUnsupported', browserLabel: '浏览器鉴权不支持' },
+];
+if (PROVIDERS.map((provider) => provider.id).join(',') !== AI_CONNECTION_PROVIDERS.join(',')) {
+    throw new Error('AI Connection provider UI is out of sync with the client catalog');
+}
+export function createAiConnectionController(host) {
+    const sessionSnapshot = host.solid.session.getSnapshot();
+    const sessionStatus = sessionStatusFromSnapshot(sessionSnapshot);
+    const pod = host.solid.pod;
+    const authenticated = sessionSnapshot.status === 'authenticated'
+        && pod.status === 'ready';
+    const client = authenticated
+        ? createAiConnectionClient({
+            webId: sessionSnapshot.webId,
+            podBaseUrl: pod.current.podUrl,
+            authenticatedFetch: host.solid.session.fetch,
+        })
+        : null;
+    let selectedProvider = 'openai';
+    let searchQuery = '';
+    let providerStates = {};
+    let providerSummaries = {};
+    let providerLoadError;
+    let providerLoadGeneration = 0;
+    let providerLoadPromise;
+    let serviceAccessState = client ? 'checking' : 'missing';
+    let serviceAccessPromise;
+    const listeners = new Set();
+    const notify = () => listeners.forEach((listener) => listener());
+    const controller = {
+        client,
+        sessionStatus,
+        podStatus: pod.status,
+        error: pod.status === 'error'
+            ? pod.error
+            : sessionSnapshot.status === 'error' && !sessionSnapshot.webId
+                ? sessionSnapshot.error
+                : undefined,
+        login: host.solid.requireLogin,
+        openExternal: host.navigation.openExternal,
+        clientConfigurationBridge: host.capabilities.aiClientConfiguration,
+        get selectedProvider() {
+            return selectedProvider;
+        },
+        get searchQuery() {
+            return searchQuery;
+        },
+        get providerStates() {
+            return providerStates;
+        },
+        get providerSummaries() {
+            return providerSummaries;
+        },
+        get providerLoadError() {
+            return providerLoadError;
+        },
+        get serviceAccessState() {
+            return serviceAccessState;
+        },
+        selectProvider(provider) {
+            if (selectedProvider === provider)
+                return;
+            selectedProvider = provider;
+            notify();
+        },
+        selectFirstUnconfiguredProvider() {
+            const provider = PROVIDERS.find((candidate) => providerStates[candidate.id] === 'unconfigured') ?? PROVIDERS[0];
+            if (provider)
+                controller.selectProvider(provider.id);
+        },
+        setSearchQuery(value) {
+            if (searchQuery === value)
+                return;
+            searchQuery = value;
+            notify();
+        },
+        setProviderState(provider, state) {
+            if (providerStates[provider] === state)
+                return;
+            providerLoadGeneration += 1;
+            providerStates = { ...providerStates, [provider]: state };
+            const summary = durableSummaryFromProductState(provider, state);
+            if (summary) {
+                providerSummaries = {
+                    ...providerSummaries,
+                    [provider]: summary,
+                };
+            }
+            notify();
+        },
+        async ensureServiceAccess() {
+            if (serviceAccessPromise)
+                return serviceAccessPromise;
+            serviceAccessPromise = (async () => {
+                if (!client) {
+                    serviceAccessState = 'missing';
+                    notify();
+                    return;
+                }
+                if (!host.solid.permissions) {
+                    serviceAccessState = 'capabilityUnavailable';
+                    notify();
+                    return;
+                }
+                if (host.solid.pod.status !== 'ready') {
+                    serviceAccessState = 'missing';
+                    notify();
+                    return;
+                }
+                serviceAccessState = 'checking';
+                notify();
+                try {
+                    const descriptor = parseAiConnectionServiceAccess(await client.getServiceAccess(), host.solid.pod.current.podUrl);
+                    const status = await host.solid.permissions.ensureAgentAccess(descriptor);
+                    serviceAccessState = status.status === 'granted'
+                        ? 'granted'
+                        : status.status;
+                    notify();
+                    if (status.status === 'granted') {
+                        await controller.loadProviders();
+                    }
+                }
+                catch (error) {
+                    serviceAccessState = error instanceof Error && error.message.startsWith('invalid_')
+                        ? 'invalidDescriptor'
+                        : 'permissionDenied';
+                    notify();
+                }
+                finally {
+                    serviceAccessPromise = undefined;
+                }
+            })();
+            return serviceAccessPromise;
+        },
+        async revokeServiceAccess() {
+            if (!client) {
+                serviceAccessState = 'missing';
+                notify();
+                return;
+            }
+            if (!host.solid.permissions) {
+                serviceAccessState = 'capabilityUnavailable';
+                notify();
+                return;
+            }
+            if (host.solid.pod.status !== 'ready') {
+                serviceAccessState = 'missing';
+                notify();
+                return;
+            }
+            serviceAccessState = 'checking';
+            notify();
+            try {
+                const descriptor = parseAiConnectionServiceAccess(await client.getServiceAccess(), host.solid.pod.current.podUrl);
+                const status = await host.solid.permissions.revokeAgentAccess(descriptor);
+                serviceAccessState = status.status === 'granted'
+                    ? 'granted'
+                    : status.status;
+                notify();
+            }
+            catch (error) {
+                serviceAccessState = error instanceof Error && error.message.startsWith('invalid_')
+                    ? 'invalidDescriptor'
+                    : 'permissionDenied';
+                notify();
+            }
+        },
+        async loadProviders() {
+            if (!client)
+                return;
+            if (providerLoadPromise)
+                return providerLoadPromise;
+            providerLoadPromise = (async () => {
+                const generation = providerLoadGeneration + 1;
+                providerLoadGeneration = generation;
+                providerLoadError = undefined;
+                notify();
+                try {
+                    const summaries = await client.listProviders();
+                    if (generation !== providerLoadGeneration)
+                        return;
+                    providerSummaries = Object.fromEntries(summaries.map((summary) => [summary.provider, summary]));
+                    providerStates = Object.fromEntries(PROVIDERS.map((provider) => [
+                        provider.id,
+                        productStateFromSummary(providerSummaries[provider.id]),
+                    ]));
+                    notify();
+                }
+                catch (error) {
+                    if (generation !== providerLoadGeneration)
+                        return;
+                    providerLoadError = errorMessage(error);
+                    notify();
+                }
+                finally {
+                    providerLoadPromise = undefined;
+                }
+            })();
+            return providerLoadPromise;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+    return controller;
+}
+function sessionStatusFromSnapshot(snapshot) {
+    if (snapshot.status === 'initializing')
+        return 'authenticating';
+    if (snapshot.status === 'authenticated')
+        return 'authenticated';
+    if (snapshot.status === 'error' && snapshot.webId)
+        return 'expired';
+    return 'anonymous';
+}
+export function useSelectedProvider(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.selectedProvider, () => controller.selectedProvider);
+}
+export function useProviderSearch(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.searchQuery, () => controller.searchQuery);
+}
+export function useProviderStates(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.providerStates, () => controller.providerStates);
+}
+export function useProviderSummaries(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.providerSummaries, () => controller.providerSummaries);
+}
+export function useProviderLoadError(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.providerLoadError, () => controller.providerLoadError);
+}
+export function useServiceAccessState(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.serviceAccessState, () => controller.serviceAccessState);
+}
+function productStateFromSummary(summary) {
+    if (!summary || summary.status === 'disconnected')
+        return 'unconfigured';
+    if (summary.status === 'reauthRequired')
+        return 'attention';
+    return summary.authMode === 'browserAssistedApiKey' ? 'configured' : 'connected';
+}
+function durableSummaryFromProductState(provider, state) {
+    if (state === 'configured') {
+        return {
+            provider,
+            status: 'connected',
+            authMode: 'browserAssistedApiKey',
+            connect: {
+                modes: ['browserAssistedApiKey'],
+                configured: true,
+            },
+        };
+    }
+    if (state === 'connected') {
+        return {
+            provider,
+            status: 'connected',
+            connect: {
+                modes: ['deviceCodeOAuth', 'browserAssistedApiKey'],
+                configured: true,
+            },
+        };
+    }
+    if (state === 'attention') {
+        return undefined;
+    }
+    if (state === 'loading') {
+        return undefined;
+    }
+    return {
+        provider,
+        status: 'disconnected',
+        connect: {
+            modes: ['browserAssistedApiKey'],
+            configured: false,
+        },
+    };
+}
+function errorMessage(error) {
+    return normalizeAiConnectionThrownError(error);
+}

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

@@ -0,0 +1,16 @@
+import type { WebExtensionModule } from '@undefineds.co/extension-sdk/web';
+import { type AiConnectionController } from './controller';
+export * from './ai-connection-client';
+export * from './AiClientConfigurationSection';
+export * from './AiConnectionPanel';
+export * from './AiConnectionList';
+export * from './AiConnectionMain';
+export * from './AiConnectionHeader';
+export * from './AiConnectionMainHeader';
+export * from './controller';
+export * from './AiProviderCard';
+export * from './AiQuotaCard';
+export * from './manifest';
+export declare const aiConnectionApplet: import("@undefineds.co/extension-sdk/web").TwoPaneAppletModule<AiConnectionController, unknown>;
+export declare const aiConnectionExtension: WebExtensionModule;
+export declare function createAiConnectionExtension(): WebExtensionModule;

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

@@ -0,0 +1,41 @@
+import { defineApplet } from '@undefineds.co/extension-sdk/web';
+import { AiConnectionList } from './AiConnectionList.js';
+import { AiConnectionMain } from './AiConnectionMain.js';
+import { AiConnectionHeader } from './AiConnectionHeader.js';
+import { AiConnectionMainHeader } from './AiConnectionMainHeader.js';
+import { createAiConnectionController, } from './controller.js';
+import { aiConnectionManifest } from './manifest.js';
+export * from './ai-connection-client.js';
+export * from './AiClientConfigurationSection.js';
+export * from './AiConnectionPanel.js';
+export * from './AiConnectionList.js';
+export * from './AiConnectionMain.js';
+export * from './AiConnectionHeader.js';
+export * from './AiConnectionMainHeader.js';
+export * from './controller.js';
+export * from './AiProviderCard.js';
+export * from './AiQuotaCard.js';
+export * from './manifest.js';
+const appletManifest = aiConnectionManifest.contributes.applets[0];
+export const aiConnectionApplet = defineApplet({
+    manifest: appletManifest,
+    createController: createAiConnectionController,
+    activate(controller) {
+        void controller.ensureServiceAccess();
+    },
+    slots: {
+        listHeader: AiConnectionHeader,
+        list: AiConnectionList,
+        mainHeader: AiConnectionMainHeader,
+        main: AiConnectionMain,
+    },
+});
+export const aiConnectionExtension = {
+    manifest: aiConnectionManifest,
+    applets: {
+        [appletManifest.appId]: aiConnectionApplet,
+    },
+};
+export function createAiConnectionExtension() {
+    return aiConnectionExtension;
+}

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

@@ -0,0 +1 @@
+export declare const aiConnectionManifest: import("@undefineds.co/extension-sdk/manifest").ExtensionManifest;

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

@@ -0,0 +1,18 @@
+import { validateExtensionManifest } from '@undefineds.co/extension-sdk/manifest';
+export const aiConnectionManifest = validateExtensionManifest({
+    extensionId: 'https://undefineds.co/extensions/ai-connection',
+    name: 'AI Connection',
+    version: '0.1.0',
+    sdkVersion: '1',
+    contributes: {
+        applets: [{
+                appId: 'https://undefineds.co/applets/ai-connection',
+                name: 'AI Connection',
+                entry: '.',
+                commands: [],
+                layout: 'two-pane',
+            }],
+    },
+    dataModels: [],
+    hostCapabilities: ['navigation.openExternal', 'aiClientConfiguration'],
+});

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

@@ -0,0 +1,3 @@
+import type { SolidServiceAccessRequest } from '@undefineds.co/extension-sdk/web';
+export declare const AI_CONNECTION_APPLET_ID = "co.undefineds.ai-connection";
+export declare function parseAiConnectionServiceAccess(value: unknown, currentPodUrl: string): SolidServiceAccessRequest;

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

@@ -0,0 +1,133 @@
+export const AI_CONNECTION_APPLET_ID = 'co.undefineds.ai-connection';
+const KNOWN_RESOURCE_IDS = new Set([
+    'providerCredentials',
+    'providerDefinitions',
+    'gatewayAccessKeys',
+    'quotaSnapshots',
+]);
+export function parseAiConnectionServiceAccess(value, currentPodUrl) {
+    if (!isRecord(value))
+        throw new Error('invalid_descriptor');
+    if (value.appletId !== AI_CONNECTION_APPLET_ID)
+        throw new Error('invalid_applet_id');
+    const service = value.service;
+    if (!isRecord(service)
+        || typeof service.webId !== 'string'
+        || typeof service.label !== 'string'
+        || !isAbsoluteHttpUrl(service.webId)) {
+        throw new Error('invalid_service');
+    }
+    if (!Array.isArray(value.resources) || value.resources.length === 0) {
+        throw new Error('invalid_empty_resources');
+    }
+    const podRoot = normalizeContainerUrl(currentPodUrl);
+    const ids = new Set();
+    const resources = value.resources.map((resource) => parseResource(resource, podRoot, ids));
+    return {
+        appletId: AI_CONNECTION_APPLET_ID,
+        service: {
+            webId: service.webId,
+            label: service.label,
+        },
+        resources,
+    };
+}
+function parseResource(value, podRoot, ids) {
+    if (!isRecord(value)
+        || typeof value.id !== 'string'
+        || typeof value.url !== 'string'
+        || value.mediaType !== 'text/turtle'
+        || !isRecord(value.access)) {
+        throw new Error('invalid_resource');
+    }
+    if (!KNOWN_RESOURCE_IDS.has(value.id) || ids.has(value.id)) {
+        throw new Error('invalid_resource');
+    }
+    assertSafeResourceUrlString(value.url);
+    let url;
+    try {
+        url = new URL(value.url);
+    }
+    catch {
+        throw new Error('invalid_resource');
+    }
+    if (!isInsideContainer(url, podRoot)) {
+        throw new Error('invalid_resource');
+    }
+    ids.add(value.id);
+    return {
+        id: value.id,
+        url: url.href,
+        mediaType: 'text/turtle',
+        access: parseAccess(value.access),
+    };
+}
+function assertSafeResourceUrlString(value) {
+    if (/%(?![0-9a-fA-F]{2})/.test(value)
+        || /%(?:2f|5c)/i.test(value)
+        || value.includes('\\')) {
+        throw new Error('invalid_resource');
+    }
+    const rawPath = extractRawPath(value);
+    if (hasDotSegment(rawPath)) {
+        throw new Error('invalid_resource');
+    }
+    try {
+        const decodedPath = decodeURIComponent(rawPath);
+        if (decodedPath.includes('\\') || hasDotSegment(decodedPath)) {
+            throw new Error('invalid_resource');
+        }
+    }
+    catch {
+        throw new Error('invalid_resource');
+    }
+}
+function extractRawPath(value) {
+    const withoutHash = value.split('#', 1)[0] ?? value;
+    const withoutQuery = withoutHash.split('?', 1)[0] ?? withoutHash;
+    return withoutQuery.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/\\?#]*/i, '');
+}
+function hasDotSegment(path) {
+    return path.split('/').some((segment) => segment === '.' || segment === '..');
+}
+function parseAccess(value) {
+    const keys = Object.keys(value);
+    if (keys.some((key) => key !== 'read' && key !== 'append' && key !== 'write')
+        || value.read !== true
+        || value.append !== true
+        || value.write !== true) {
+        throw new Error('invalid_resource');
+    }
+    return {
+        read: true,
+        append: true,
+        write: true,
+    };
+}
+function normalizeContainerUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error('invalid_current_pod');
+    }
+    if (!url.pathname.endsWith('/')) {
+        url.pathname = `${url.pathname}/`;
+    }
+    return url;
+}
+function isInsideContainer(url, root) {
+    return (url.protocol === 'http:' || url.protocol === 'https:')
+        && url.origin === root.origin
+        && url.pathname.startsWith(root.pathname);
+}
+function isAbsoluteHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/node_modules/@undefineds.co/ai-connection/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@undefineds.co/ai-connection",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/ai-connection-client.d.ts",
+      "import": "./dist/ai-connection-client.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./client-config": {
+      "types": "./dist/client-config/index.d.ts",
+      "import": "./dist/client-config/index.js",
+      "require": "./dist/client-config/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../../scripts/fix-dist-js-imports.mjs dist && bun build src/client-config/index.ts --target=node --format=cjs --outfile=dist/client-config/index.cjs",
+    "test": "vitest run --config ../../vitest.packages.config.mts"
+  },
+  "dependencies": {
+    "lucide-react": "^0.475.0"
+  },
+  "peerDependencies": {
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.14",
+    "jsdom": "^29.1.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}