hotcodepush 0.0.1 → 0.2.0

package/dist/commands/device/probe.js

@@ -0,0 +1,253 @@
+import { ChannelIndexSchema, evaluateChannelIndex, } from '@hotcodepush/protocol';
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { deviceOptionShape } from '../../utils/device-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { resolveFilesBaseUrl } from '../../utils/hosts.js';
+import { printDetails, printJson, printTable } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { promptSelect, promptText } from '../../utils/prompts.js';
+import { resolveAttributePairs } from '../../utils/release-conditions.js';
+import { channelOptionShape, fetchAppId, fetchChannelId, } from '../../utils/resource-resolution.js';
+import { readApiUrl } from '../../utils/user-config.js';
+const INDEX_FETCH_TIMEOUT_MS = 30_000;
+// No release is older than the binary, so a device without a created binary has no floor.
+const NO_FLOOR = new Date(0).toISOString();
+export default defineCommand({
+    description: 'Answer why a device did not update: fetch the live index as a device would, evaluate it and mark every condition of every release.',
+    examples: [
+        'hotcodepush device probe --platform ios --binary-version 2.4.1 --binary-build 57',
+        'hotcodepush device probe --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...deviceOptionShape,
+        attribute: z
+            .array(z.string())
+            .optional()
+            .describe('An attribute the app sets, key=value, repeatable.'),
+        binaryBuild: z
+            .string()
+            .optional()
+            .describe("The store build's build number, CFBundleVersion or versionCode."),
+        binaryVersion: z
+            .string()
+            .optional()
+            .describe("The store build's version, CFBundleShortVersionString or versionName."),
+        platform: z
+            .enum(['android', 'ios'])
+            .optional()
+            .describe('The platform, ios or android.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const projectConfig = readProjectConfig(options.config);
+        const appId = await fetchAppId(hotCodePush, options, projectConfig);
+        const fetchedDevice = options.device === undefined
+            ? undefined
+            : await hotCodePush.apps.devices.get({
+                appId,
+                deviceId: options.device,
+            });
+        const channel = await hotCodePush.apps.channels.get({
+            appId,
+            channelId: await fetchChannelId(hotCodePush, appId, {
+                ...options,
+                channel: options.channel ?? fetchedDevice?.channelId ?? undefined,
+            }, projectConfig),
+        });
+        const platform = options.platform ??
+            fetchedDevice?.platform ??
+            (await promptSelect('--platform', 'Which platform?', [
+                { label: 'iOS', value: 'ios' },
+                { label: 'Android', value: 'android' },
+            ], options));
+        const binaryVersion = options.binaryVersion ??
+            fetchedDevice?.binaryVersion ??
+            (await promptText('--binary-version', 'Which app version?', options));
+        const binaryBuild = options.binaryBuild ??
+            fetchedDevice?.binaryBuild ??
+            (await promptText('--binary-build', 'Which build number?', options));
+        const binary = (await fetchAllPages(page => hotCodePush.apps.binaries.list({ appId, ...page }))).find(candidate => candidate.platform === platform &&
+            candidate.version === binaryVersion &&
+            candidate.build === binaryBuild);
+        const servedIndex = await fetchServedIndex(appId, channel.id, platform);
+        const unknownFacts = resolveUnknownFacts(fetchedDevice, binary);
+        const builtAt = binary?.createdAt ?? null;
+        const device = {
+            attributes: {
+                ...fetchedDevice?.attributes,
+                ...Object.fromEntries(resolveAttributePairs(options.attribute).map(({ key, value }) => [
+                    key,
+                    value,
+                ])),
+            },
+            binaryBuild,
+            binaryVersion,
+            builtAt: builtAt ?? NO_FLOOR,
+            currentRelease: fetchedDevice === undefined
+                ? null
+                : await fetchCurrentRelease(hotCodePush, fetchedDevice, servedIndex),
+            deviceId: fetchedDevice?.deviceId ?? '',
+            failedBundleIds: fetchedDevice === undefined
+                ? []
+                : resolveFailedBundleIds(await fetchAllPages(page => hotCodePush.apps.devices.events.list({
+                    appId,
+                    deviceId: fetchedDevice.deviceId,
+                    ...page,
+                })), servedIndex.index),
+            fingerprint: fetchedDevice?.fingerprint ?? binary?.fingerprint ?? null,
+            osVersion: fetchedDevice?.osVersion ?? '',
+            reportedAt: fetchedDevice?.lastSeenAt ?? null,
+        };
+        const evaluation = servedIndex.index === null
+            ? null
+            : evaluateKnownFacts(servedIndex.index, device, unknownFacts);
+        if (options.json) {
+            printJson({
+                channelId: channel.id,
+                device: { ...device, builtAt },
+                outcome: evaluation?.outcome ?? null,
+                platform,
+                sequence: servedIndex.index?.sequence ?? null,
+                status: servedIndex.status,
+                unknownFacts,
+                url: servedIndex.url,
+                verdicts: evaluation?.verdicts ?? [],
+            });
+            return;
+        }
+        printDetails([
+            ['Channel', `${channel.name}, ${platform}`],
+            ['Index', resolveServedIndexText(servedIndex)],
+            [
+                'Outcome',
+                evaluation === null ? 'none' : resolveOutcomeText(evaluation),
+            ],
+            [
+                'Unknown',
+                unknownFacts.length === 0
+                    ? 'nothing'
+                    : `${unknownFacts.join(', ')}, treated as passing. Pass --device for the facts of a real device.`,
+            ],
+        ]);
+        if (evaluation !== null && servedIndex.index !== null) {
+            printTable({
+                emptyText: 'The index offers no release.',
+                headers: ['RELEASE', 'ROLLOUT', 'CONDITIONS', 'VERDICT'],
+                nextOffset: null,
+                rows: evaluation.verdicts.map(verdict => [
+                    `#${verdict.release.number}`,
+                    `${verdict.release.rolloutPercent}%`,
+                    resolveConditionsText(verdict, unknownFacts),
+                    verdict.isEligible
+                        ? 'eligible'
+                        : `${verdict.reason ?? 'skipped'}${verdict.conditionType === undefined ? '' : ` (${verdict.conditionType})`}`,
+                ]),
+            });
+        }
+    },
+});
+// The index may no longer carry the release, so its number then comes from the API.
+async function fetchCurrentRelease(hotCodePush, fetchedDevice, servedIndex) {
+    const releaseId = fetchedDevice.currentReleaseId;
+    if (releaseId === null) {
+        return null;
+    }
+    const indexRelease = servedIndex.index?.releases.find(({ id }) => id === releaseId);
+    const number = indexRelease?.number ??
+        (await hotCodePush.apps.releases.get({
+            appId: fetchedDevice.appId,
+            releaseId,
+        })).number;
+    return { id: releaseId, number };
+}
+// The same request a device makes.
+async function fetchServedIndex(appId, channelId, platform) {
+    const url = `${resolveFilesBaseUrl(readApiUrl())}/apps/${appId}/channels/${channelId}/${platform}/v1/index.json`;
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(INDEX_FETCH_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        await response.body?.cancel();
+        return { index: null, status: response.status, url };
+    }
+    return {
+        index: ChannelIndexSchema.parse(await response.json()),
+        status: response.status,
+        url,
+    };
+}
+// Rollouts count as reached and conditions on unknown facts as passing, so only known facts decide.
+function evaluateKnownFacts(index, device, unknownFacts) {
+    const releasesById = new Map(index.releases.map(release => [release.id, release]));
+    const knownIndex = {
+        ...index,
+        releases: index.releases.map(release => ({
+            ...release,
+            conditions: release.conditions.filter(({ type }) => !unknownFacts.includes(type)),
+            rolloutPercent: unknownFacts.includes('rollout')
+                ? 100
+                : release.rolloutPercent,
+        })),
+    };
+    const { outcome, verdicts } = evaluateChannelIndex(knownIndex, device);
+    const resolveServedRelease = (release) => releasesById.get(release.id) ?? release;
+    return {
+        outcome: outcome.release === null
+            ? outcome
+            : { ...outcome, release: resolveServedRelease(outcome.release) },
+        verdicts: verdicts.map(verdict => ({
+            ...verdict,
+            release: resolveServedRelease(verdict.release),
+        })),
+    };
+}
+function resolveConditionsText(verdict, unknownFacts) {
+    const knownVerdicts = [...verdict.conditions];
+    const conditionTexts = verdict.release.conditions.map(({ type }) => {
+        if (unknownFacts.includes(type)) {
+            return `${type} unknown`;
+        }
+        const conditionVerdict = knownVerdicts.shift();
+        return `${type} ${conditionVerdict?.isSatisfied ? 'pass' : 'fail'}`;
+    });
+    return conditionTexts.join(', ') || 'none';
+}
+function resolveFailedBundleIds(events, index) {
+    const failedReleaseIds = new Set(events
+        .filter(({ type }) => type === 'failed')
+        .map(({ releaseId }) => releaseId));
+    return (index?.releases ?? [])
+        .filter(({ id }) => failedReleaseIds.has(id))
+        .map(({ bundleId }) => bundleId);
+}
+function resolveOutcomeText({ outcome }) {
+    const releaseText = outcome.release === null
+        ? 'the embedded bundle'
+        : `release #${outcome.release.number}`;
+    switch (outcome.status) {
+        case 'available':
+            return `available, ${releaseText}${outcome.isMandatory ? ', mandatory' : ''}`;
+        case 'skipped':
+            return `skipped, ${outcome.reason}${outcome.conditionType === undefined ? '' : ` (${outcome.conditionType})`}, ${releaseText}`;
+        case 'up_to_date':
+            return `up_to_date, ${releaseText}`;
+    }
+}
+// The index sequence is the publish time in milliseconds.
+function resolveServedIndexText({ index, status, url }) {
+    return index === null
+        ? `none: HTTP ${status} at ${url}, so a device gets no release`
+        : `published ${new Date(index.sequence).toISOString()}`;
+}
+function resolveUnknownFacts(fetchedDevice, binary) {
+    if (fetchedDevice !== undefined) {
+        return [];
+    }
+    return binary?.fingerprint === undefined || binary.fingerprint === null
+        ? ['fingerprint', 'os', 'rollout']
+        : ['os', 'rollout'];
+}

package/dist/commands/doctor.js

@@ -0,0 +1,364 @@
+import { ProjectConfigurationSchema, resolveSigningKeyId, } from '@hotcodepush/protocol';
+import { INIT_MANUAL_STEP, PACKAGE_JSON, PROJECT_CONFIG_FILE_NAME, } from '../config/consts.js';
+import { createApiClient } from '../utils/api-client.js';
+import { defineCommand } from '../utils/command.js';
+import { fetchCurrentUser, isUnauthenticatedError, resolveCredentialText, } from '../utils/credential.js';
+import { resolveCliError, resolveSentence } from '../utils/error-mapping.js';
+import { CliError, InvalidJsonError, NotLoggedInError, ReportedFailureError, SigningKeyUnavailableError, UnknownFrameworkError, } from '../utils/errors.js';
+import { detectFramework } from '../utils/framework.js';
+import { resolveFrameworkModule } from '../utils/frameworks/index.js';
+import { readInstalledPackageVersion, readSdkDependencyVersion, } from '../utils/frameworks/sdk-package.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { resolveFilesBaseUrl, resolveUpdatesBaseUrl } from '../utils/hosts.js';
+import { printOutcomeRows } from '../utils/outcome.js';
+import { printJson, resolveQuantityText } from '../utils/output.js';
+import { readPackageJson } from '../utils/package-json.js';
+import { ID_SCHEMA, locateProjectConfigFile, readProjectConfigFile, resolveProjectChannel, } from '../utils/project-config.js';
+import { fetchChannels, fetchHasSigningKey, fetchResourceId, fetchSigningKeys, } from '../utils/resource-resolution.js';
+import { readSigningKeyPair } from '../utils/signing-private-key.js';
+import { isEnvironmentToken, readToken } from '../utils/token-store.js';
+import { readApiUrl } from '../utils/user-config.js';
+const CHANNEL_NAME_SCHEMA = ProjectConfigurationSchema.shape.channel;
+const PROBE_TIMEOUT_MS = 5000;
+export default defineCommand({
+    description: 'Check the project: its configuration, the hook wiring, the signing key, the hosts and the versions a bug report needs.',
+    authentication: 'optional',
+    examples: ['hotcodepush doctor', 'hotcodepush doctor --json'],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const project = readProject(options.config);
+        const { app, checks: sessionAndAppChecks } = await checkSessionAndApp(project);
+        const checks = [
+            checkConfiguration(project),
+            ...sessionAndAppChecks,
+            ...checkFramework(project),
+            await checkHosts(),
+            await checkSigningKey(project, app),
+            checkVersions(project),
+        ];
+        const status = checks.some(({ status }) => status === 'failed')
+            ? 'failed'
+            : 'clean';
+        if (options.json) {
+            printJson({ checks, status });
+        }
+        else {
+            printOutcomeRows(checks.map(({ check, manualStep, message, status }) => ({
+                manualStep,
+                message,
+                name: check,
+                status,
+            })));
+        }
+        if (status === 'failed') {
+            throw new ReportedFailureError('doctor_failed');
+        }
+    },
+});
+function readProject(configPath) {
+    const { directoryPath, filePath } = locateProjectConfigFile(configPath);
+    const framework = resolveProjectFramework(directoryPath);
+    const project = {
+        directoryPath,
+        framework,
+        packageJson: framework instanceof CliError
+            ? undefined
+            : readPackageJson(directoryPath),
+        projectConfig: undefined,
+    };
+    if (filePath === undefined) {
+        return project;
+    }
+    try {
+        return { ...project, projectConfig: readProjectConfigFile(filePath) };
+    }
+    catch (error) {
+        if (!(error instanceof InvalidJsonError)) {
+            throw error;
+        }
+        return { ...project, projectConfigError: error };
+    }
+}
+function checkConfiguration({ directoryPath, projectConfig, projectConfigError, }) {
+    if (projectConfigError !== undefined) {
+        return resolveFailedCheck('configuration', projectConfigError);
+    }
+    if (projectConfig === undefined) {
+        return {
+            check: 'configuration',
+            code: 'project_config_missing',
+            manualStep: INIT_MANUAL_STEP,
+            message: `There is no ${PROJECT_CONFIG_FILE_NAME} in ${directoryPath} or a directory above it.`,
+            status: 'failed',
+        };
+    }
+    const problems = resolveConfigurationProblems(projectConfig);
+    if (problems.length > 0) {
+        return {
+            check: 'configuration',
+            code: 'project_config_invalid',
+            manualStep: INIT_MANUAL_STEP,
+            message: `The file ${PROJECT_CONFIG_FILE_NAME} ${problems.join(' and ')}.`,
+            status: 'failed',
+        };
+    }
+    return {
+        check: 'configuration',
+        message: `The file ${PROJECT_CONFIG_FILE_NAME} names app ${projectConfig.appId} and channel ${resolveProjectChannel(projectConfig)}.`,
+        status: 'ok',
+    };
+}
+// A file without `channel` follows the schema default.
+function resolveConfigurationProblems(projectConfig) {
+    const problems = [];
+    if (projectConfig.appId === undefined) {
+        problems.push('lacks appId');
+    }
+    else if (!ID_SCHEMA.safeParse(projectConfig.appId).success) {
+        problems.push('has an appId that is not an id');
+    }
+    if (projectConfig.channel !== undefined &&
+        !CHANNEL_NAME_SCHEMA.safeParse(projectConfig.channel).success) {
+        problems.push('has a channel that is not a channel name');
+    }
+    return problems;
+}
+// A refused credential, or an API that cannot be asked, fails the session check and leaves the app out.
+async function checkSessionAndApp({ projectConfig, }) {
+    let user;
+    try {
+        if (readToken() === undefined) {
+            return {
+                app: undefined,
+                checks: [
+                    {
+                        check: 'session',
+                        message: 'You are not logged in, so the app is not checked against the API.',
+                        status: 'skipped',
+                    },
+                ],
+            };
+        }
+        user = await fetchCurrentUser();
+    }
+    catch (error) {
+        return { app: undefined, checks: [resolveFailedSessionCheck(error)] };
+    }
+    const sessionCheck = {
+        check: 'session',
+        message: resolveCredentialText(user, isEnvironmentToken()),
+        status: 'ok',
+    };
+    const { app, check } = await checkApp(projectConfig);
+    return { app, checks: [sessionCheck, check] };
+}
+function resolveFailedSessionCheck(error) {
+    const { code, fix, message } = resolveCliError(error);
+    if (isUnauthenticatedError(error) || error instanceof NotLoggedInError) {
+        return {
+            check: 'session',
+            code,
+            manualStep: 'Run "hotcodepush login", or set a valid HOTCODEPUSH_TOKEN.',
+            message: 'The API does not accept the credential.',
+            status: 'failed',
+        };
+    }
+    return {
+        check: 'session',
+        code,
+        manualStep: fix ?? undefined,
+        message: `The credential cannot be checked. ${resolveSentence(message)}`,
+        status: 'failed',
+    };
+}
+async function checkApp(projectConfig) {
+    if (projectConfig?.appId === undefined ||
+        !ID_SCHEMA.safeParse(projectConfig.appId).success) {
+        return {
+            app: undefined,
+            check: {
+                check: 'app',
+                message: 'The configuration names no app and channel to check.',
+                status: 'skipped',
+            },
+        };
+    }
+    const { appId } = projectConfig;
+    const hotCodePush = createApiClient();
+    try {
+        const [app, channel] = await Promise.all([
+            hotCodePush.apps.get({ appId }),
+            fetchResourceId('channel', resolveProjectChannel(projectConfig), () => fetchChannels(hotCodePush, appId), PROJECT_CONFIG_FILE_NAME).then(channelId => hotCodePush.apps.channels.get({ appId, channelId })),
+        ]);
+        return {
+            app,
+            check: {
+                check: 'app',
+                message: `The app ${app.name} and the channel ${channel.name} exist.`,
+                status: 'ok',
+            },
+        };
+    }
+    catch (error) {
+        return {
+            app: undefined,
+            check: {
+                check: 'app',
+                code: resolveCliError(error).code,
+                manualStep: INIT_MANUAL_STEP,
+                message: `The API does not know the app or the channel. ${resolveSentence(error instanceof Error ? error.message : String(error))}`,
+                status: 'failed',
+            },
+        };
+    }
+}
+// No key file is looked for, since an upload is told where its key is.
+// A key the app has but the file does not list fails, since an upload from that project would go unsigned.
+async function checkSigningKey({ projectConfig }, app) {
+    const publicKeys = projectConfig?.appId === undefined ? [] : (projectConfig.publicKeys ?? []);
+    try {
+        if (publicKeys.length === 0 &&
+            app !== undefined &&
+            (await fetchHasSigningKey(createApiClient(), app.id))) {
+            return {
+                check: 'signing_key',
+                code: 'public_key_unlisted',
+                manualStep: `Run "hotcodepush signing-key list --json" and add each publicKey to publicKeys in ${PROJECT_CONFIG_FILE_NAME}.`,
+                message: `The app has a signing key and ${PROJECT_CONFIG_FILE_NAME} lists none.`,
+                status: 'failed',
+            };
+        }
+        const unregisteredKeyCount = app === undefined || publicKeys.length === 0
+            ? 0
+            : await fetchUnregisteredPublicKeyCount(app.id, publicKeys);
+        if (unregisteredKeyCount > 0) {
+            return {
+                check: 'signing_key',
+                code: 'public_key_unregistered',
+                manualStep: 'Run "hotcodepush signing-key list --json" and keep in publicKeys only the keys it prints.',
+                message: `The file ${PROJECT_CONFIG_FILE_NAME} lists ${resolveQuantityText(unregisteredKeyCount, 'public key')} the app has not registered.`,
+                status: 'failed',
+            };
+        }
+        return await checkSigningPrivateKey(publicKeys);
+    }
+    catch (error) {
+        return resolveFailedCheck('signing_key', error);
+    }
+}
+// No variable while keys are listed is fine, since an upload is told where its key is.
+async function checkSigningPrivateKey(publicKeys) {
+    try {
+        const signingKeyPair = await readSigningKeyPair(publicKeys, undefined);
+        return signingKeyPair === null
+            ? {
+                check: 'signing_key',
+                message: 'Code signing is off. Run "hotcodepush signing-key create" to turn it on.',
+                status: 'skipped',
+            }
+            : {
+                check: 'signing_key',
+                message: `HOTCODEPUSH_SIGNING_KEY signs with key ${resolveSigningKeyId(signingKeyPair.publicKey)}.`,
+                status: 'ok',
+            };
+    }
+    catch (error) {
+        if (error instanceof SigningKeyUnavailableError) {
+            return {
+                check: 'signing_key',
+                message: 'Code signing is on. An upload signs with --private-key-path or HOTCODEPUSH_SIGNING_KEY.',
+                status: 'ok',
+            };
+        }
+        throw error;
+    }
+}
+// An upload signed with an unregistered key is refused.
+async function fetchUnregisteredPublicKeyCount(appId, publicKeys) {
+    const registeredPublicKeys = new Set((await fetchSigningKeys(createApiClient(), appId)).map(({ publicKey }) => publicKey));
+    return publicKeys.filter(publicKey => !registeredPublicKeys.has(publicKey))
+        .length;
+}
+// The resource file is not checked, since every build writes it into the app, never into the project.
+function checkFramework(project) {
+    const { framework } = project;
+    if (framework instanceof CliError) {
+        return [resolveFailedCheck('framework', framework)];
+    }
+    return framework.checkWiring(project);
+}
+// Any HTTP answer counts and a network error does not.
+async function checkHosts() {
+    let apiUrl;
+    try {
+        apiUrl = readApiUrl();
+    }
+    catch (error) {
+        return resolveFailedCheck('hosts', error);
+    }
+    const hosts = [
+        ['api', `${apiUrl.replace(/\/+$/, '')}/health`],
+        ['files', resolveFilesBaseUrl(apiUrl)],
+        ['updates', resolveUpdatesBaseUrl(apiUrl)],
+    ];
+    const unreachable = (await Promise.all(hosts.map(async ([name, url]) => (await isReachable(url)) ? undefined : `${name} (${url})`))).filter(host => host !== undefined);
+    if (unreachable.length > 0) {
+        return {
+            check: 'hosts',
+            code: 'host_unreachable',
+            manualStep: 'Check the network, the API URL in config.json and the HOTCODEPUSH_*_BASE_URL variables.',
+            message: `The CLI cannot reach ${unreachable.join(', ')}.`,
+            status: 'failed',
+        };
+    }
+    return {
+        check: 'hosts',
+        message: `The hosts ${hosts.map(([name]) => name).join(', ')} are reachable.`,
+        status: 'ok',
+    };
+}
+function checkVersions({ directoryPath, framework, packageJson, }) {
+    const versions = [
+        `${PACKAGE_JSON.name} ${PACKAGE_JSON.version}`,
+        `node ${process.version}`,
+    ];
+    if (!(framework instanceof CliError)) {
+        versions.push(...framework.versionedPackageNames.map(packageName => `${packageName} ${readInstalledPackageVersion(directoryPath, packageName) ?? packageJson?.dependencies?.[packageName] ?? 'missing'}`), ...(framework.versionedSdkDependencyNames ?? []).map(packageName => `${packageName} ${readSdkDependencyVersion(directoryPath, framework.packageName, packageName) ?? 'missing'}`));
+    }
+    return {
+        check: 'versions',
+        message: `The versions are ${versions.join(', ')}.`,
+        status: 'ok',
+    };
+}
+function resolveFailedCheck(check, error) {
+    const { code, fix, message } = resolveCliError(error);
+    return {
+        check,
+        code,
+        manualStep: fix ?? undefined,
+        message: resolveSentence(message),
+        status: 'failed',
+    };
+}
+async function isReachable(url) {
+    try {
+        await fetch(url, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveProjectFramework(directoryPath) {
+    try {
+        return resolveFrameworkModule(detectFramework(directoryPath));
+    }
+    catch (error) {
+        if (error instanceof UnknownFrameworkError ||
+            error instanceof InvalidJsonError) {
+            return error;
+        }
+        throw error;
+    }
+}