@undefineds.co/linx 0.2.17 → 0.2.19

package/dist/lib/ai-command.js

@@ -1,27 +1,20 @@
-import { resolveLinxPodUrl } from '../../vendor/client/dist/index.js';
-import { aiConfigProviderUri, buildAIConfigMutationPlan, buildAIConfigProviderStateMap, getAIConfigProviderMetadata, normalizeAIConfigProviderId as extractAIConfigProviderId, normalizeAIConfigResourceId as extractAIConfigResourceId, sameAIConfigProviderFamily as sameAIConfigProviderId, } from '@undefineds.co/models/ai-config';
-import { DCTerms, RDFS, UDFS, XPOD_AI, XPOD_CREDENTIAL } from '@undefineds.co/models';
-import { getClientCredentials, loadCredentials } from './credentials-store.js';
+import { resolveLinxPodUrl } from '@undefineds.co/models/client';
+import { aiModelTable, aiProviderTable, buildAIConfigMutationPlan, buildAIConfigProviderStateMap, credentialTable, drizzle, getAIConfigProviderMetadata, initSolidTables, normalizeAIConfigProviderId, normalizeAIConfigResourceId, sameAIConfigProviderFamily, solidSchema, } from './models.js';
+import { getClientCredentialId, getClientCredentialKey, getClientCredentials, loadCredentials } from './credentials-store.js';
 import { loadAccountSession } from './account-session.js';
 import { authenticatedFetch, getAccessToken } from './solid-auth.js';
+import { getOidcAccessToken } from './oidc-auth.js';
 import { promptPassword } from './prompt.js';
-const XSD_DATE_TIME = 'http://www.w3.org/2001/XMLSchema#dateTime';
 let aiRuntimePromise = null;
 async function loadAiRuntime() {
     if (!aiRuntimePromise) {
         aiRuntimePromise = Promise.resolve({
-            DCTerms,
-            RDFS,
-            UDFS,
-            XPOD_AI,
-            XPOD_CREDENTIAL,
-            aiConfigProviderUri,
             buildAIConfigMutationPlan,
             buildAIConfigProviderStateMap,
-            extractAIConfigProviderId,
-            extractAIConfigResourceId,
             getAIConfigProviderMetadata,
-            sameAIConfigProviderId,
+            normalizeAIConfigProviderId,
+            normalizeAIConfigResourceId,
+            sameAIConfigProviderFamily,
         });
     }
     return aiRuntimePromise;
@@ -31,104 +24,6 @@ function maskSecret(value) {
         return '****';
     return `${value.slice(0, 4)}****${value.slice(-4)}`;
 }
-function absolutePodUri(podUrl, relativePath) {
-    return `${podUrl.replace(/\/?$/, '/')}${relativePath.replace(/^\/+/, '')}`;
-}
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function quoteLiteral(value) {
-    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
-}
-function dateTimeLiteral(value) {
-    return `"${value.toISOString()}"^^<${XSD_DATE_TIME}>`;
-}
-function splitResourceBlocks(turtle, resourceUrl) {
-    if (!turtle.trim())
-        return [];
-    const pattern = new RegExp(`(?=<${escapeRegex(resourceUrl)}#)`);
-    return turtle
-        .split(pattern)
-        .map((block) => block.trim())
-        .filter(Boolean);
-}
-function matchLiteral(block, predicateUri) {
-    const match = block.match(new RegExp(`<${escapeRegex(predicateUri)}>\\s+"([^"]*)"(?:\\^\\^<[^>]+>)?`));
-    return match?.[1];
-}
-function matchIri(block, predicateUri) {
-    const match = block.match(new RegExp(`<${escapeRegex(predicateUri)}>\\s+<([^>]+)>`));
-    return match?.[1];
-}
-function matchFirstLiteral(block, predicateUris) {
-    for (const predicateUri of predicateUris) {
-        if (!predicateUri)
-            continue;
-        const value = matchLiteral(block, predicateUri);
-        if (value !== undefined)
-            return value;
-    }
-    return undefined;
-}
-function matchFirstIri(block, predicateUris) {
-    for (const predicateUri of predicateUris) {
-        if (!predicateUri)
-            continue;
-        const value = matchIri(block, predicateUri);
-        if (value !== undefined)
-            return value;
-    }
-    return undefined;
-}
-function parseCredentialRows(turtle, resourceUrl, runtime) {
-    return splitResourceBlocks(turtle, resourceUrl)
-        .map((block) => {
-        const subject = block.match(new RegExp(`^<${escapeRegex(resourceUrl)}#([^>]+)>`));
-        if (!subject?.[1])
-            return null;
-        return {
-            id: subject[1],
-            provider: matchFirstIri(block, [runtime.XPOD_CREDENTIAL.provider, runtime.UDFS.provider]),
-            service: matchFirstLiteral(block, [runtime.XPOD_CREDENTIAL.service, runtime.UDFS.service]),
-            status: matchFirstLiteral(block, [runtime.XPOD_CREDENTIAL.status, runtime.UDFS.status]),
-            apiKey: matchFirstLiteral(block, [runtime.XPOD_CREDENTIAL.apiKey, runtime.UDFS.apiKey]),
-            baseUrl: matchFirstLiteral(block, [runtime.XPOD_CREDENTIAL.baseUrl, runtime.UDFS.baseUrl]),
-            label: matchFirstLiteral(block, [runtime.XPOD_CREDENTIAL.label, runtime.RDFS.label]),
-        };
-    })
-        .filter(Boolean);
-}
-function parseProviderRows(turtle, resourceUrl, runtime) {
-    return splitResourceBlocks(turtle, resourceUrl)
-        .map((block) => {
-        const subject = block.match(new RegExp(`^<${escapeRegex(resourceUrl)}#([^>]+)>`));
-        if (!subject?.[1])
-            return null;
-        return {
-            id: subject[1],
-            baseUrl: matchFirstLiteral(block, [runtime.XPOD_AI.baseUrl, runtime.UDFS.baseUrl]),
-            proxyUrl: matchFirstLiteral(block, [runtime.XPOD_AI.proxyUrl, runtime.UDFS.proxyUrl]),
-            hasModel: matchFirstIri(block, [runtime.XPOD_AI.hasModel, runtime.UDFS.hasModel]),
-        };
-    })
-        .filter(Boolean);
-}
-function parseModelRows(turtle, resourceUrl, runtime) {
-    return splitResourceBlocks(turtle, resourceUrl)
-        .map((block) => {
-        const subject = block.match(new RegExp(`^<${escapeRegex(resourceUrl)}#([^>]+)>`));
-        if (!subject?.[1])
-            return null;
-        return {
-            id: subject[1],
-            displayName: matchFirstLiteral(block, [runtime.XPOD_AI.displayName, runtime.RDFS.label]),
-            modelType: matchFirstLiteral(block, [runtime.XPOD_AI.modelType, runtime.UDFS.modelType]),
-            isProvidedBy: matchFirstIri(block, [runtime.XPOD_AI.isProvidedBy, runtime.UDFS.isProvidedBy]),
-            status: matchFirstLiteral(block, [runtime.XPOD_AI.status, runtime.UDFS.status]),
-        };
-    })
-        .filter(Boolean);
-}
 async function requireApiKey(argv) {
     if (argv['api-key']?.trim()) {
         return argv['api-key'].trim();
@@ -144,160 +39,202 @@ async function resolvePodWriteContext(urlOverride) {
     if (!creds) {
         throw new Error('No local client credentials found. Run `linx login` first.');
     }
+    if (!creds.webId) {
+        throw new Error('No WebID found in local credentials. Run `linx login` again.');
+    }
     const clientCreds = getClientCredentials(creds);
-    if (!clientCreds) {
-        throw new Error('Only client credentials auth is supported for `linx ai connect`.');
+    let accessToken = null;
+    if (clientCreds) {
+        const baseUrl = (urlOverride ?? creds.url).replace(/\/?$/, '/');
+        const tokenResult = await getAccessToken(getClientCredentialId(clientCreds), getClientCredentialKey(clientCreds), baseUrl);
+        accessToken = tokenResult?.accessToken ?? null;
+    }
+    else {
+        accessToken = await getOidcAccessToken(creds);
     }
-    const baseUrl = (urlOverride ?? creds.url).replace(/\/?$/, '/');
-    const tokenResult = await getAccessToken(clientCreds.clientId, clientCreds.clientSecret, baseUrl);
-    if (!tokenResult) {
+    if (!accessToken) {
         throw new Error('Failed to obtain Pod access token. Run `linx login` again.');
     }
     return {
-        accessToken: tokenResult.accessToken,
+        accessToken,
+        webId: creds.webId,
         podUrl: loadAccountSession()?.podUrl || resolveLinxPodUrl(creds.webId),
     };
 }
-async function patchResource(resourceUrl, accessToken, body) {
-    const res = await authenticatedFetch(resourceUrl, accessToken, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/sparql-update' },
-        body,
+function createAiConfigDb(context) {
+    const solidSession = {
+        info: {
+            isLoggedIn: true,
+            webId: context.webId,
+            podUrl: context.podUrl,
+        },
+        fetch: (input, init) => (authenticatedFetch(requestInputToUrl(input), context.accessToken, init)),
+        logout: async () => { },
+    };
+    return drizzle(solidSession, {
+        logger: false,
+        disableInteropDiscovery: true,
+        schema: solidSchema,
     });
-    if (!res.ok) {
-        throw new Error(`Failed to update ${resourceUrl}.`);
-    }
 }
-async function fetchResourceText(resourceUrl, accessToken) {
-    const res = await authenticatedFetch(resourceUrl, accessToken, {
-        headers: { Accept: 'text/turtle' },
-    });
-    if (res.status === 404) {
-        return '';
+async function loadAiConfigRows(db) {
+    await initSolidTables(db, [credentialTable, aiProviderTable, aiModelTable]);
+    const [credentialRows, providerRows, modelRows] = await Promise.all([
+        db.select().from(credentialTable).execute(),
+        db.select().from(aiProviderTable).execute(),
+        db.select().from(aiModelTable).execute(),
+    ]);
+    return { credentialRows, providerRows, modelRows };
+}
+async function upsertByLocator(db, table, locator, insert, update) {
+    const existing = await db.findByLocator(table, locator);
+    if (!existing) {
+        await db.insert(table).values(insert).execute();
+        return;
     }
-    if (!res.ok) {
-        throw new Error(`Failed to read ${resourceUrl}.`);
+    await db.updateByLocator(table, locator, update);
+}
+async function deleteByLocatorIfExists(db, table, locator) {
+    const existing = await db.findByLocator(table, locator);
+    if (existing) {
+        await db.deleteByLocator(table, locator);
     }
-    return res.text();
 }
-function buildProviderSparql(runtime, resourceUrl, podUrl, payload) {
-    const subject = `<${resourceUrl}#${payload.id}>`;
-    const deletes = [
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.baseUrl}> ?oldBaseUrl }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.proxyUrl}> ?oldProxyUrl }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.hasModel}> ?oldHasModel }`,
-    ];
-    const inserts = [`${subject} a <${runtime.XPOD_AI.Provider}> .`];
-    if (payload.baseUrl) {
-        inserts.push(`${subject} <${runtime.XPOD_AI.baseUrl}> ${quoteLiteral(payload.baseUrl)} .`);
+function requestInputToUrl(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof URL)
+        return input.toString();
+    if (typeof Request !== 'undefined' && input instanceof Request)
+        return input.url;
+    return String(input);
+}
+export async function runAiCommand(argv, dependencies = {}) {
+    const action = argv.action;
+    const aiRuntime = dependencies.aiRuntime ?? await loadAiRuntime();
+    const podContext = await (dependencies.resolvePodWriteContext ?? resolvePodWriteContext)(argv.url);
+    const db = (dependencies.createDb ?? createAiConfigDb)(podContext);
+    const { credentialRows, providerRows, modelRows } = await (dependencies.loadAiConfigRows ?? loadAiConfigRows)(db);
+    const write = dependencies.write ?? ((chunk) => process.stdout.write(chunk));
+    const upsert = dependencies.upsertByLocator ?? upsertByLocator;
+    const deleteIfExists = dependencies.deleteByLocatorIfExists ?? deleteByLocatorIfExists;
+    const getApiKey = dependencies.requireApiKey ?? requireApiKey;
+    if (action === 'status') {
+        const states = aiRuntime.buildAIConfigProviderStateMap({
+            fallbackToCatalogModels: false,
+            credentialRows,
+            providerRows,
+            modelRows,
+        });
+        const filtered = Object.values(states).filter((state) => {
+            if (!state.apiKey)
+                return false;
+            if (!argv.provider)
+                return true;
+            return aiRuntime.sameAIConfigProviderFamily(argv.provider, state.id);
+        });
+        if (filtered.length === 0) {
+            write('No LinX cloud AI credentials found.\n');
+            return;
+        }
+        const lines = [];
+        for (const state of filtered) {
+            lines.push(`provider: ${state.id}`);
+            if (state.selectedModelId) {
+                lines.push(`model: ${state.selectedModelId}`);
+            }
+            lines.push(`api-key: ${maskSecret(state.apiKey)}`);
+            lines.push('');
+        }
+        write(`${lines.join('\n').trimEnd()}\n`);
+        return;
     }
-    if (payload.proxyUrl) {
-        inserts.push(`${subject} <${runtime.XPOD_AI.proxyUrl}> ${quoteLiteral(payload.proxyUrl)} .`);
+    const providerArg = argv.provider?.trim();
+    if (!providerArg) {
+        throw new Error(action === 'disconnect'
+            ? 'Usage: linx ai disconnect <provider>'
+            : 'Usage: linx ai connect <provider> --api-key <key>');
     }
-    if (payload.hasModel) {
-        inserts.push(`${subject} <${runtime.XPOD_AI.hasModel}> <${absolutePodUri(podUrl, payload.hasModel)}> .`);
+    const provider = aiRuntime.normalizeAIConfigProviderId(providerArg);
+    if (action === 'disconnect') {
+        for (const row of credentialRows) {
+            const rowProvider = typeof row.provider === 'string' ? row.provider : row.id;
+            if (!aiRuntime.sameAIConfigProviderFamily(rowProvider, provider)) {
+                continue;
+            }
+            await deleteIfExists(db, credentialTable, { id: row.id });
+        }
+        write(`Disconnected AI provider: ${provider}\n`);
+        return;
     }
-    return `DELETE {
-  ${subject} <${runtime.XPOD_AI.baseUrl}> ?oldBaseUrl .
-  ${subject} <${runtime.XPOD_AI.proxyUrl}> ?oldProxyUrl .
-  ${subject} <${runtime.XPOD_AI.hasModel}> ?oldHasModel .
-}
-INSERT {
-  ${inserts.join('\n  ')}
-}
-WHERE {
-  ${deletes.join('\n  ')}
-}`;
-}
-function buildCredentialSparql(runtime, resourceUrl, podUrl, payload) {
-    const subject = `<${resourceUrl}#${payload.id}>`;
-    const deletes = [
-        `OPTIONAL { ${subject} <${runtime.XPOD_CREDENTIAL.provider}> ?oldProvider }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_CREDENTIAL.service}> ?oldService }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_CREDENTIAL.status}> ?oldStatus }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_CREDENTIAL.apiKey}> ?oldApiKey }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_CREDENTIAL.baseUrl}> ?oldBaseUrl }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_CREDENTIAL.label}> ?oldLabel }`,
-    ];
-    const inserts = [
-        `${subject} a <${runtime.XPOD_CREDENTIAL.Credential}> .`,
-        `${subject} <${runtime.XPOD_CREDENTIAL.provider}> <${absolutePodUri(podUrl, payload.provider)}> .`,
-        `${subject} <${runtime.XPOD_CREDENTIAL.service}> ${quoteLiteral(payload.service)} .`,
-        `${subject} <${runtime.XPOD_CREDENTIAL.status}> ${quoteLiteral(payload.status)} .`,
-    ];
-    if (payload.apiKey) {
-        inserts.push(`${subject} <${runtime.XPOD_CREDENTIAL.apiKey}> ${quoteLiteral(payload.apiKey)} .`);
+    const apiKey = await getApiKey(argv);
+    const modelId = argv.model?.trim();
+    const plan = aiRuntime.buildAIConfigMutationPlan({
+        providerId: provider,
+        currentProviderRows: providerRows,
+        currentCredentialRows: credentialRows,
+        currentModelRows: modelRows,
+        updates: {
+            enabled: true,
+            apiKey,
+            baseUrl: argv['base-url']?.trim() || undefined,
+            models: modelId
+                ? [{
+                        id: modelId,
+                        name: modelId,
+                        enabled: true,
+                        capabilities: [],
+                    }]
+                : undefined,
+        },
+    });
+    if (plan.providerPayload?.id) {
+        await upsert(db, aiProviderTable, { id: plan.providerPayload.id }, plan.providerPayload, {
+            baseUrl: plan.providerPayload.baseUrl,
+            proxyUrl: plan.providerPayload.proxyUrl,
+            hasModel: plan.providerPayload.hasModel,
+        });
     }
-    if (payload.baseUrl) {
-        inserts.push(`${subject} <${runtime.XPOD_CREDENTIAL.baseUrl}> ${quoteLiteral(payload.baseUrl)} .`);
+    if (plan.credentialPayload?.id
+        && plan.credentialPayload.provider
+        && plan.credentialPayload.service
+        && plan.credentialPayload.status) {
+        await upsert(db, credentialTable, { id: plan.credentialPayload.id }, plan.credentialPayload, {
+            provider: plan.credentialPayload.provider,
+            service: plan.credentialPayload.service,
+            status: plan.credentialPayload.status,
+            apiKey: plan.credentialPayload.apiKey,
+            baseUrl: plan.credentialPayload.baseUrl,
+            label: plan.credentialPayload.label,
+        });
     }
-    if (payload.label) {
-        inserts.push(`${subject} <${runtime.XPOD_CREDENTIAL.label}> ${quoteLiteral(payload.label)} .`);
+    for (const modelPayload of plan.modelUpserts) {
+        if (!modelPayload.id || !modelPayload.isProvidedBy || !modelPayload.createdAt || !modelPayload.updatedAt) {
+            continue;
+        }
+        await upsert(db, aiModelTable, {
+            id: modelPayload.id,
+            isProvidedBy: modelPayload.isProvidedBy,
+        }, modelPayload, {
+            displayName: modelPayload.displayName,
+            modelType: modelPayload.modelType,
+            isProvidedBy: modelPayload.isProvidedBy,
+            status: modelPayload.status,
+            updatedAt: modelPayload.updatedAt,
+        });
     }
-    return `DELETE {
-  ${subject} <${runtime.XPOD_CREDENTIAL.provider}> ?oldProvider .
-  ${subject} <${runtime.XPOD_CREDENTIAL.service}> ?oldService .
-  ${subject} <${runtime.XPOD_CREDENTIAL.status}> ?oldStatus .
-  ${subject} <${runtime.XPOD_CREDENTIAL.apiKey}> ?oldApiKey .
-  ${subject} <${runtime.XPOD_CREDENTIAL.baseUrl}> ?oldBaseUrl .
-  ${subject} <${runtime.XPOD_CREDENTIAL.label}> ?oldLabel .
-}
-INSERT {
-  ${inserts.join('\n  ')}
-}
-WHERE {
-  ${deletes.join('\n  ')}
-}`;
-}
-function buildModelSparql(runtime, resourceUrl, podUrl, payload) {
-    const subject = `<${resourceUrl}#${payload.id}>`;
-    const deletes = [
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.displayName}> ?oldDisplayName }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.modelType}> ?oldModelType }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.isProvidedBy}> ?oldIsProvidedBy }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.status}> ?oldStatus }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.createdAt}> ?oldCreatedAt }`,
-        `OPTIONAL { ${subject} <${runtime.XPOD_AI.updatedAt}> ?oldUpdatedAt }`,
-    ];
-    const inserts = [
-        `${subject} a <${runtime.XPOD_AI.Model}> .`,
-        `${subject} <${runtime.XPOD_AI.displayName}> ${quoteLiteral(payload.displayName || payload.id)} .`,
-        `${subject} <${runtime.XPOD_AI.modelType}> ${quoteLiteral(payload.modelType || 'chat')} .`,
-        `${subject} <${runtime.XPOD_AI.isProvidedBy}> <${absolutePodUri(podUrl, payload.isProvidedBy)}> .`,
-        `${subject} <${runtime.XPOD_AI.status}> ${quoteLiteral(payload.status || 'active')} .`,
-        `${subject} <${runtime.XPOD_AI.createdAt}> ${dateTimeLiteral(payload.createdAt)} .`,
-        `${subject} <${runtime.XPOD_AI.updatedAt}> ${dateTimeLiteral(payload.updatedAt)} .`,
-    ];
-    return `DELETE {
-  ${subject} <${runtime.XPOD_AI.displayName}> ?oldDisplayName .
-  ${subject} <${runtime.XPOD_AI.modelType}> ?oldModelType .
-  ${subject} <${runtime.XPOD_AI.isProvidedBy}> ?oldIsProvidedBy .
-  ${subject} <${runtime.XPOD_AI.status}> ?oldStatus .
-  ${subject} <${runtime.XPOD_AI.createdAt}> ?oldCreatedAt .
-  ${subject} <${runtime.XPOD_AI.updatedAt}> ?oldUpdatedAt .
-}
-INSERT {
-  ${inserts.join('\n  ')}
-}
-WHERE {
-  ${deletes.join('\n  ')}
-}`;
-}
-function buildCredentialDeleteSparql(runtime, providerRef) {
-    return `DELETE {
-  ?credential ?predicate ?object .
-}
-WHERE {
-  {
-    ?credential <${runtime.XPOD_CREDENTIAL.provider}> <${providerRef}> ;
-      ?predicate ?object .
-  }
-  UNION
-  {
-    ?credential <${runtime.UDFS.provider}> <${providerRef}> ;
-      ?predicate ?object .
-  }
-}`;
+    for (const modelIdToDelete of plan.modelDeleteIds) {
+        await deleteIfExists(db, aiModelTable, {
+            id: modelIdToDelete,
+            isProvidedBy: plan.providerId,
+        });
+    }
+    const metadata = aiRuntime.getAIConfigProviderMetadata(provider);
+    write(`Connected AI provider: ${metadata.id}\n`);
+    if (modelId) {
+        write(`model: ${aiRuntime.normalizeAIConfigResourceId(modelId)}\n`);
+    }
+    write(`api-key: ${maskSecret(apiKey)}\n`);
 }
 export const aiCommand = {
     command: 'ai <action> [provider]',
@@ -309,130 +246,12 @@ export const aiCommand = {
     })
         .positional('provider', {
         type: 'string',
-        description: 'Provider/backend id, for example anthropic, openai, codebuddy',
+        description: 'Provider/backend id, for example claude, anthropic, codebuddy, codex',
     })
         .option('url', { type: 'string', description: 'Server base URL override' })
         .option('api-key', { type: 'string', description: 'Provider API key' })
         .option('model', { type: 'string', description: 'Default model id' })
         .option('base-url', { type: 'string', description: 'Provider API base URL override' }),
-    handler: async (argv) => {
-        const action = argv.action;
-        const aiRuntime = await loadAiRuntime();
-        const { accessToken, podUrl } = await resolvePodWriteContext(argv.url);
-        const providerResource = absolutePodUri(podUrl, '/settings/ai/providers.ttl');
-        const credentialResource = absolutePodUri(podUrl, '/settings/credentials.ttl');
-        const modelResource = absolutePodUri(podUrl, '/settings/ai/models.ttl');
-        if (action === 'status') {
-            const [credentialTurtle, providerTurtle, modelTurtle] = await Promise.all([
-                fetchResourceText(credentialResource, accessToken),
-                fetchResourceText(providerResource, accessToken),
-                fetchResourceText(modelResource, accessToken),
-            ]);
-            const states = aiRuntime.buildAIConfigProviderStateMap({
-                fallbackToCatalogModels: false,
-                credentialRows: parseCredentialRows(credentialTurtle, credentialResource, aiRuntime),
-                providerRows: parseProviderRows(providerTurtle, providerResource, aiRuntime),
-                modelRows: parseModelRows(modelTurtle, modelResource, aiRuntime),
-            });
-            const filtered = Object.values(states).filter((state) => {
-                if (!state.apiKey)
-                    return false;
-                if (!argv.provider)
-                    return true;
-                return aiRuntime.sameAIConfigProviderId(argv.provider, state.id);
-            });
-            if (filtered.length === 0) {
-                process.stdout.write('No LinX cloud AI credentials found.\n');
-                return;
-            }
-            const lines = [];
-            for (const state of filtered) {
-                lines.push(`provider: ${state.id}`);
-                if (state.selectedModelId) {
-                    lines.push(`model: ${state.selectedModelId}`);
-                }
-                lines.push(`api-key: ${maskSecret(state.apiKey)}`);
-                lines.push('');
-            }
-            process.stdout.write(`${lines.join('\n').trimEnd()}\n`);
-            return;
-        }
-        const providerArg = argv.provider?.trim();
-        if (!providerArg) {
-            throw new Error(action === 'disconnect'
-                ? 'Usage: linx ai disconnect <provider>'
-                : 'Usage: linx ai connect <provider> --api-key <key>');
-        }
-        const provider = aiRuntime.extractAIConfigProviderId(providerArg);
-        if (action === 'disconnect') {
-            const providerRef = absolutePodUri(podUrl, `/settings/ai/providers.ttl#${provider}`);
-            await patchResource(credentialResource, accessToken, buildCredentialDeleteSparql(aiRuntime, providerRef));
-            process.stdout.write(`Disconnected AI provider: ${provider}\n`);
-            return;
-        }
-        const apiKey = await requireApiKey(argv);
-        const modelId = argv.model?.trim();
-        const plan = aiRuntime.buildAIConfigMutationPlan({
-            providerId: provider,
-            currentProviderRows: [],
-            currentCredentialRows: [],
-            currentModelRows: [],
-            updates: {
-                enabled: true,
-                apiKey,
-                baseUrl: argv['base-url']?.trim() || undefined,
-                models: modelId
-                    ? [{
-                            id: modelId,
-                            name: modelId,
-                            enabled: true,
-                            capabilities: [],
-                        }]
-                    : undefined,
-            },
-        });
-        if (plan.providerPayload?.id) {
-            await patchResource(providerResource, accessToken, buildProviderSparql(aiRuntime, providerResource, podUrl, {
-                id: plan.providerPayload.id,
-                baseUrl: plan.providerPayload.baseUrl,
-                proxyUrl: plan.providerPayload.proxyUrl,
-                hasModel: plan.providerPayload.hasModel,
-            }));
-        }
-        if (plan.credentialPayload?.id
-            && plan.credentialPayload.provider
-            && plan.credentialPayload.service
-            && plan.credentialPayload.status) {
-            await patchResource(credentialResource, accessToken, buildCredentialSparql(aiRuntime, credentialResource, podUrl, {
-                id: plan.credentialPayload.id,
-                provider: plan.credentialPayload.provider,
-                service: plan.credentialPayload.service,
-                status: plan.credentialPayload.status,
-                apiKey: plan.credentialPayload.apiKey,
-                baseUrl: plan.credentialPayload.baseUrl,
-                label: plan.credentialPayload.label,
-            }));
-        }
-        for (const modelPayload of plan.modelUpserts) {
-            if (!modelPayload.id || !modelPayload.isProvidedBy || !modelPayload.createdAt || !modelPayload.updatedAt) {
-                continue;
-            }
-            await patchResource(modelResource, accessToken, buildModelSparql(aiRuntime, modelResource, podUrl, {
-                id: modelPayload.id,
-                displayName: modelPayload.displayName,
-                modelType: modelPayload.modelType,
-                isProvidedBy: modelPayload.isProvidedBy,
-                status: modelPayload.status,
-                createdAt: modelPayload.createdAt,
-                updatedAt: modelPayload.updatedAt,
-            }));
-        }
-        const metadata = aiRuntime.getAIConfigProviderMetadata(provider);
-        process.stdout.write(`Connected AI provider: ${metadata.id}\n`);
-        if (modelId) {
-            process.stdout.write(`model: ${aiRuntime.extractAIConfigResourceId(modelId)}\n`);
-        }
-        process.stdout.write(`api-key: ${maskSecret(apiKey)}\n`);
-    },
+    handler: async (argv) => runAiCommand(argv),
 };
 //# sourceMappingURL=ai-command.js.map