@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/platform/provider-loader.js

@@ -0,0 +1,251 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { execFileSync } from 'node:child_process';
+import { PLATFORM_PROVIDER_CONTRACT_VERSION, isPlatformProviderFactory, validatePlatformProvider } from './provider-contract.js';
+import { createGitHubProvider } from './github-provider.js';
+import { createNoneProvider } from './none-provider.js';
+import { wrapProviderOperations } from './provider-validation.js';
+const sessions = new Map();
+function findRepositoryRoot(cwd) {
+    try {
+        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch {
+        return cwd;
+    }
+}
+function failure(providerType, phase, code, message) {
+    return {
+        ok: false,
+        error: { code, message, retryable: false, providerType, phase }
+    };
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (!value || typeof value !== 'object')
+        return false;
+    return Object.values(value).every(isJsonValue);
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return '[' + value.map(canonicalJson).join(',') + ']';
+    if (value && typeof value === 'object') {
+        return '{' + Object.keys(value).sort().map((key) => JSON.stringify(key) + ':' + canonicalJson(value[key])).join(',') + '}';
+    }
+    return JSON.stringify(value);
+}
+function configFingerprint(config) {
+    return createHash('sha256').update(canonicalJson(config)).digest('hex');
+}
+function readPlatformConfig(repositoryRoot) {
+    try {
+        const file = path.join(repositoryRoot, '.agents', '.airc.json');
+        const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function selectedEntry(config, providerType) {
+    const platform = config.platform && typeof config.platform === 'object'
+        ? config.platform
+        : {};
+    const providers = platform.providers && typeof platform.providers === 'object' && !Array.isArray(platform.providers)
+        ? platform.providers
+        : {};
+    const entry = providers[providerType];
+    return entry && typeof entry === 'object' && !Array.isArray(entry)
+        ? entry
+        : {};
+}
+function resolveExternalSource(repositoryRoot, source, providerType) {
+    try {
+        const isPath = source.startsWith('.') || path.isAbsolute(source) || /^[A-Za-z]:[\\/]/u.test(source);
+        const resolved = isPath
+            ? path.resolve(repositoryRoot, source)
+            : createRequire(path.join(repositoryRoot, 'package.json')).resolve(source);
+        const realPath = fs.realpathSync(resolved);
+        const importUrl = pathToFileURL(realPath).href;
+        return { ok: true, value: { sourceIdentity: importUrl, importUrl } };
+    }
+    catch {
+        return {
+            ok: false,
+            error: {
+                code: 'PLATFORM_PROVIDER_SOURCE_RESOLUTION_FAILED',
+                message: 'Selected provider source could not be resolved',
+                retryable: false,
+                providerType,
+                phase: 'source-resolution'
+            }
+        };
+    }
+}
+async function instantiateProvider(providerType, repositoryRoot, importUrl, config, client) {
+    const input = {
+        providerType,
+        contractVersion: PLATFORM_PROVIDER_CONTRACT_VERSION,
+        repositoryRoot,
+        config
+    };
+    if (providerType === 'github')
+        return createGitHubProvider(input, client);
+    if (providerType === 'none')
+        return createNoneProvider(input);
+    let moduleValue;
+    try {
+        moduleValue = await import(__rewriteRelativeImportExtension(importUrl));
+    }
+    catch {
+        throw Object.assign(new Error('Selected provider source could not be imported'), {
+            code: 'PLATFORM_PROVIDER_IMPORT_FAILED'
+        });
+    }
+    const factory = moduleValue.default;
+    if (!isPlatformProviderFactory(factory)) {
+        throw Object.assign(new Error('Selected provider must default-export an async factory'), {
+            code: 'PLATFORM_PROVIDER_EXPORT_INVALID'
+        });
+    }
+    let provider;
+    try {
+        const candidate = factory(input);
+        if (!candidate || typeof candidate.then !== 'function') {
+            throw Object.assign(new Error('Provider factory must return a Promise'), {
+                code: 'PLATFORM_PROVIDER_EXPORT_INVALID'
+            });
+        }
+        provider = await candidate;
+    }
+    catch (cause) {
+        if (cause && typeof cause === 'object' && 'code' in cause
+            && cause.code === 'PLATFORM_PROVIDER_EXPORT_INVALID')
+            throw cause;
+        throw Object.assign(new Error('Provider factory failed'), {
+            code: 'PLATFORM_PROVIDER_FACTORY_FAILED'
+        });
+    }
+    if (provider && typeof provider === 'object' && 'type' in provider && provider.type !== providerType) {
+        throw Object.assign(new Error('Provider type does not match platform.type'), {
+            code: 'PLATFORM_PROVIDER_TYPE_MISMATCH'
+        });
+    }
+    if (provider && typeof provider === 'object' && 'contractVersion' in provider
+        && provider.contractVersion !== PLATFORM_PROVIDER_CONTRACT_VERSION) {
+        throw Object.assign(new Error('Provider contract version is unsupported'), {
+            code: 'PLATFORM_PROVIDER_VERSION_UNSUPPORTED'
+        });
+    }
+    const validated = validatePlatformProvider(provider, providerType);
+    if (!validated.ok) {
+        throw Object.assign(new Error(validated.error.message), {
+            code: validated.error.code
+        });
+    }
+    return wrapProviderOperations(validated.value);
+}
+async function loadPlatformProvider(options = {}) {
+    const workingDirectory = path.resolve(options.cwd || process.cwd());
+    const repositoryRoot = path.resolve(findRepositoryRoot(workingDirectory));
+    const config = readPlatformConfig(repositoryRoot);
+    const platform = config.platform && typeof config.platform === 'object'
+        ? config.platform
+        : {};
+    const providerType = options.platformType
+        ?? (typeof platform.type === 'string' ? platform.type : '');
+    if (!providerType)
+        return failure('', 'config', 'PLATFORM_PROVIDER_CONFIG_INVALID', 'platform.type must be a non-empty string');
+    const entry = selectedEntry(config, providerType);
+    const rawConfig = entry.config === undefined ? {} : entry.config;
+    if (!rawConfig || typeof rawConfig !== 'object' || Array.isArray(rawConfig) || !isJsonValue(rawConfig)) {
+        return failure(providerType, 'config', 'PLATFORM_PROVIDER_CONFIG_INVALID', 'Selected provider config must be a JSON object');
+    }
+    const providerConfig = rawConfig;
+    let sourceIdentity;
+    let importUrl = null;
+    if (providerType === 'github' || providerType === 'none') {
+        sourceIdentity = 'builtin:' + providerType + '@' + PLATFORM_PROVIDER_CONTRACT_VERSION;
+    }
+    else {
+        if (typeof entry.source !== 'string' || !entry.source.trim()) {
+            return failure(providerType, 'config', 'PLATFORM_PROVIDER_SOURCE_MISSING', 'Selected provider source is required');
+        }
+        const resolved = resolveExternalSource(repositoryRoot, entry.source, providerType);
+        if (!resolved.ok)
+            return resolved;
+        sourceIdentity = resolved.value.sourceIdentity;
+        importUrl = resolved.value.importUrl;
+    }
+    const key = [
+        repositoryRoot,
+        providerType,
+        sourceIdentity,
+        configFingerprint(providerConfig)
+    ].join('\u0000');
+    const reuseSession = !(providerType === 'github' && options.client);
+    let session = reuseSession ? sessions.get(key) : undefined;
+    if (!session) {
+        session = instantiateProvider(providerType, repositoryRoot, importUrl, providerConfig, options.client);
+        if (reuseSession) {
+            sessions.set(key, session);
+            session.catch(() => {
+                if (sessions.get(key) === session)
+                    sessions.delete(key);
+            });
+        }
+    }
+    try {
+        const provider = await session;
+        return {
+            ok: true,
+            value: { provider, providerType, repositoryRoot, workingDirectory, sourceIdentity }
+        };
+    }
+    catch (cause) {
+        const code = cause && typeof cause === 'object' && 'code' in cause && typeof cause.code === 'string'
+            ? cause.code
+            : 'PLATFORM_PROVIDER_FACTORY_FAILED';
+        const phase = code === 'PLATFORM_PROVIDER_IMPORT_FAILED'
+            ? 'import'
+            : code === 'PLATFORM_PROVIDER_EXPORT_INVALID'
+                ? 'export'
+                : code === 'PLATFORM_PROVIDER_TYPE_MISMATCH' || code === 'PLATFORM_PROVIDER_VERSION_UNSUPPORTED' || code === 'PLATFORM_PROVIDER_CONTRACT_INVALID'
+                    ? 'validation'
+                    : 'factory';
+        const messages = {
+            PLATFORM_PROVIDER_IMPORT_FAILED: 'Selected provider source could not be imported',
+            PLATFORM_PROVIDER_EXPORT_INVALID: 'Selected provider must default-export an async factory',
+            PLATFORM_PROVIDER_TYPE_MISMATCH: 'Provider type does not match platform.type',
+            PLATFORM_PROVIDER_VERSION_UNSUPPORTED: 'Provider contract version is unsupported',
+            PLATFORM_PROVIDER_CONTRACT_INVALID: 'Provider does not satisfy the platform provider contract',
+            PLATFORM_PROVIDER_FACTORY_FAILED: 'Selected provider factory failed'
+        };
+        return failure(providerType, phase, code, messages[code] ?? 'Selected provider failed to load');
+    }
+}
+function clearProviderSessions() {
+    sessions.clear();
+}
+export { canonicalJson, clearProviderSessions, configFingerprint, findRepositoryRoot, loadPlatformProvider };
+//# sourceMappingURL=provider-loader.js.map