@chalksurf/cli 0.2.2 → 0.2.4

package/dist/lib/api-client.js

@@ -1,86 +0,0 @@
-const normalizeBaseUrl = (baseUrl) => {
-    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-};
-const getErrorMessage = (payload, status) => {
-    return payload?.error?.message ?? `API request failed with status ${status}`;
-};
-const getResponseData = async ({ response, batched }) => {
-    const body = (await response.json());
-    const payload = batched ? body[0] : body;
-    if (!response.ok) {
-        throw new Error(getErrorMessage(payload, response.status));
-    }
-    if (payload?.error) {
-        throw new Error(payload.error.message);
-    }
-    if (!payload?.result) {
-        throw new Error('API response is missing a result payload');
-    }
-    return payload.result.data;
-};
-export const createApiClient = ({ baseUrl, token, organizationId, }) => {
-    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-    const createHeaders = ({ includeJsonContentType }) => {
-        const headers = new Headers();
-        if (token) {
-            headers.set('authorization', `Bearer ${token}`);
-        }
-        if (organizationId) {
-            headers.set('x-organization-id', organizationId);
-        }
-        if (includeJsonContentType) {
-            headers.set('content-type', 'application/json');
-        }
-        return headers;
-    };
-    const query = async (procedureName, input) => {
-        const url = new URL(`trpc/${procedureName}`, normalizedBaseUrl);
-        url.searchParams.set('batch', '1');
-        url.searchParams.set('input', JSON.stringify({ 0: input ?? null }));
-        const response = await fetch(url.toString(), {
-            method: 'GET',
-            headers: createHeaders({ includeJsonContentType: false }),
-        });
-        return await getResponseData({ response, batched: true });
-    };
-    const mutation = async (procedureName, input) => {
-        const isFormDataInput = input instanceof FormData;
-        const response = await fetch(new URL(`trpc/${procedureName}`, normalizedBaseUrl).toString(), {
-            method: 'POST',
-            headers: createHeaders({ includeJsonContentType: !isFormDataInput }),
-            body: isFormDataInput ? input : JSON.stringify(input ?? {}),
-        });
-        return await getResponseData({ response, batched: false });
-    };
-    return {
-        query,
-        mutation,
-        getUserProfile: async () => {
-            return await query('getUserProfile', null);
-        },
-        listUserJobs: async (input) => {
-            return await query('listUserJobs', input ?? null);
-        },
-        getUserJob: async (id) => {
-            return await query('getUserJob', { id });
-        },
-        searchExercises: async (input) => {
-            return await mutation('searchExercises', input);
-        },
-        searchExerciseSheets: async (input) => {
-            return await mutation('searchExerciseSheets', input);
-        },
-        importExerciseSheet: async (formData) => {
-            return await mutation('importExerciseSheet', formData);
-        },
-        importExercise: async (formData) => {
-            return await mutation('importExercise', formData);
-        },
-        importExerciseSolution: async (formData) => {
-            return await mutation('importExerciseSolution', formData);
-        },
-        importExerciseSheetSolutions: async (formData) => {
-            return await mutation('importExerciseSheetSolutions', formData);
-        },
-    };
-};

package/dist/lib/cli-error.js

@@ -1,46 +0,0 @@
-const cliErrorCodeByExitCode = {
-    1: 'unexpected_error',
-    2: 'usage_error',
-    3: 'not_authenticated',
-    4: 'source_resolution_failed',
-    5: 'api_error',
-    6: 'wait_timed_out',
-    7: 'job_failed',
-};
-const isRetryableCliErrorCode = (code) => {
-    return ['api_error', 'wait_timed_out'].includes(code);
-};
-export const getCliErrorCode = (exitCode) => {
-    return cliErrorCodeByExitCode[exitCode] ?? 'unexpected_error';
-};
-export const createSerializableCliError = ({ code, exitCode, message, retryable, }) => {
-    const resolvedCode = code ?? getCliErrorCode(exitCode);
-    return {
-        code: resolvedCode,
-        exitCode,
-        message,
-        retryable: retryable ?? isRetryableCliErrorCode(resolvedCode),
-    };
-};
-export class CliCommandError extends Error {
-    code;
-    exitCode;
-    retryable;
-    shouldReport;
-    constructor(message, exitCode, shouldReport = true, options = {}) {
-        super(message);
-        this.name = 'CliCommandError';
-        this.code = options.code ?? getCliErrorCode(exitCode);
-        this.exitCode = exitCode;
-        this.retryable = options.retryable ?? isRetryableCliErrorCode(this.code);
-        this.shouldReport = shouldReport;
-    }
-}
-export const serializeCliError = (error) => {
-    return createSerializableCliError({
-        code: error.code,
-        exitCode: error.exitCode,
-        message: error.message,
-        retryable: error.retryable,
-    });
-};

package/dist/lib/command-options.js

@@ -1,61 +0,0 @@
-import { CliCommandError } from './cli-error.js';
-export const cliDefaultLimit = 20;
-export const cliMaxLimit = 100;
-const normalizeOptionalString = (value) => {
-    const normalizedValue = value?.trim();
-    return normalizedValue ? normalizedValue : undefined;
-};
-export const normalizeOptionalText = (value) => {
-    return normalizeOptionalString(value) ?? null;
-};
-export const normalizeLimit = (value) => {
-    const normalizedValue = value ?? cliDefaultLimit;
-    if (!Number.isInteger(normalizedValue) || normalizedValue < 1 || normalizedValue > cliMaxLimit) {
-        throw new CliCommandError(`--limit must be an integer between 1 and ${cliMaxLimit}.`, 2);
-    }
-    return normalizedValue;
-};
-export const normalizeOffset = (value) => {
-    const normalizedValue = value ?? 0;
-    if (!Number.isInteger(normalizedValue) || normalizedValue < 0) {
-        throw new CliCommandError('--offset must be a non-negative integer.', 2);
-    }
-    return normalizedValue;
-};
-export const normalizeOptionalInteger = ({ label, value }) => {
-    if (value === undefined) {
-        return null;
-    }
-    if (!Number.isInteger(value)) {
-        throw new CliCommandError(`${label} must be an integer.`, 2);
-    }
-    return value;
-};
-export const normalizeChoiceValues = ({ allowedValues, label, values, }) => {
-    if (!values || values.length === 0) {
-        return undefined;
-    }
-    const normalizedValues = values.map((value) => value.trim()).filter((value) => value.length > 0);
-    const invalidValue = normalizedValues.find((value) => !allowedValues.includes(value));
-    if (invalidValue) {
-        throw new CliCommandError(`${label} must be one of: ${allowedValues.join(', ')}`, 2);
-    }
-    return Array.from(new Set(normalizedValues));
-};
-export const normalizeStringValues = (values) => {
-    if (!values || values.length === 0) {
-        return [];
-    }
-    return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
-};
-export const ownershipOptions = ['own', 'public', 'all'];
-export const normalizeOwnership = (value) => {
-    const normalizedValue = normalizeOptionalString(value) ?? 'own';
-    if (!ownershipOptions.includes(normalizedValue)) {
-        throw new CliCommandError(`--ownership must be one of: ${ownershipOptions.join(', ')}`, 2);
-    }
-    return normalizedValue;
-};
-export const toApiOwnership = (ownership) => {
-    return ownership === 'all' ? null : ownership;
-};

package/dist/lib/config-store.js

@@ -1,354 +0,0 @@
-import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { CliCommandError } from './cli-error.js';
-export const chalksurfBaseUrlEnvVar = 'CHALKSURF_BASE_URL';
-export const chalksurfTokenEnvVar = 'CHALKSURF_TOKEN';
-export const chalksurfOrganizationIdEnvVar = 'CHALKSURF_ORGANIZATION_ID';
-export const chalksurfProfileEnvVar = 'CHALKSURF_PROFILE';
-export const chalksurfConfigPathEnvVar = 'CHALKSURF_CONFIG_PATH';
-export const cliConfigSchemaVersion = 2;
-export const implicitDefaultProfileName = 'default';
-const profileNamePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const normalizeOptionalString = (value) => {
-    const trimmedValue = value?.trim();
-    return trimmedValue ? trimmedValue : undefined;
-};
-const normalizeStoredBaseUrl = (value) => {
-    const normalizedValue = normalizeOptionalString(value);
-    return normalizedValue?.replace(/\/+$/, '') || undefined;
-};
-const isRecord = (value) => {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-};
-export const assertValidProfileName = (profileName) => {
-    if (!profileNamePattern.test(profileName)) {
-        throw new CliCommandError(`Invalid profile "${profileName}". Profile names must start with a letter or number and contain only letters, numbers, ".", "_", or "-".`, 2);
-    }
-};
-const normalizeProfileName = (value) => {
-    const profileName = normalizeOptionalString(value);
-    if (!profileName) {
-        return undefined;
-    }
-    assertValidProfileName(profileName);
-    return profileName;
-};
-const sanitizeProfileConfig = (config) => {
-    return Object.fromEntries(Object.entries({
-        token: normalizeOptionalString(config.token),
-        baseUrl: normalizeStoredBaseUrl(config.baseUrl),
-        organizationId: normalizeOptionalString(config.organizationId),
-    }).filter(([, value]) => value !== undefined));
-};
-const hasProfileConfigValues = (config) => {
-    return Boolean(config.baseUrl || config.token || config.organizationId);
-};
-const readProfileConfig = (value) => {
-    if (!isRecord(value)) {
-        return {};
-    }
-    return sanitizeProfileConfig({
-        baseUrl: typeof value.baseUrl === 'string' ? value.baseUrl : undefined,
-        organizationId: typeof value.organizationId === 'string' ? value.organizationId : undefined,
-        token: typeof value.token === 'string' ? value.token : undefined,
-    });
-};
-const sanitizeRootConfig = (config) => {
-    const profiles = Object.fromEntries(Object.entries(config.profiles)
-        .map(([profileName, profileConfig]) => {
-        const normalizedProfileName = normalizeProfileName(profileName);
-        const sanitizedProfileConfig = sanitizeProfileConfig(profileConfig);
-        return normalizedProfileName && hasProfileConfigValues(sanitizedProfileConfig)
-            ? [normalizedProfileName, sanitizedProfileConfig]
-            : null;
-    })
-        .filter((entry) => entry !== null));
-    const defaultProfile = normalizeProfileName(config.defaultProfile);
-    return {
-        schemaVersion: cliConfigSchemaVersion,
-        ...(defaultProfile && profiles[defaultProfile] ? { defaultProfile } : {}),
-        profiles,
-    };
-};
-const readRootConfig = (value) => {
-    if (!isRecord(value)) {
-        return { schemaVersion: cliConfigSchemaVersion, profiles: {} };
-    }
-    if (isRecord(value.profiles)) {
-        const profiles = Object.fromEntries(Object.entries(value.profiles)
-            .map(([profileName, profileConfig]) => {
-            const sanitizedProfileConfig = readProfileConfig(profileConfig);
-            return hasProfileConfigValues(sanitizedProfileConfig)
-                ? [profileName, sanitizedProfileConfig]
-                : null;
-        })
-            .filter((entry) => entry !== null));
-        return sanitizeRootConfig({
-            schemaVersion: cliConfigSchemaVersion,
-            defaultProfile: typeof value.defaultProfile === 'string' ? value.defaultProfile : undefined,
-            profiles,
-        });
-    }
-    const legacyProfile = readProfileConfig(value);
-    if (!hasProfileConfigValues(legacyProfile)) {
-        return { schemaVersion: cliConfigSchemaVersion, profiles: {} };
-    }
-    return {
-        schemaVersion: cliConfigSchemaVersion,
-        defaultProfile: implicitDefaultProfileName,
-        profiles: {
-            [implicitDefaultProfileName]: legacyProfile,
-        },
-    };
-};
-const rootConfigHasProfiles = (config) => Object.keys(config.profiles).length > 0;
-const getDefaultConfigPath = ({ env, platform, homeDirectory, }) => {
-    const explicitConfigPath = normalizeOptionalString(env[chalksurfConfigPathEnvVar]);
-    if (explicitConfigPath) {
-        return explicitConfigPath;
-    }
-    if (platform === 'win32') {
-        return join(env.APPDATA || join(homeDirectory, 'AppData', 'Roaming'), 'chalksurf', 'config.json');
-    }
-    if (platform === 'darwin') {
-        return join(homeDirectory, 'Library', 'Application Support', 'chalksurf', 'config.json');
-    }
-    return join(env.XDG_CONFIG_HOME || join(homeDirectory, '.config'), 'chalksurf', 'config.json');
-};
-const findOrganizationMembership = ({ memberships, organizationId, }) => {
-    return memberships.find((membership) => membership.organizationId === organizationId) ?? null;
-};
-const getFallbackOrganization = (memberships) => {
-    const personalOrganization = memberships.find((membership) => membership.organizationType === 'user') ?? memberships[0] ?? null;
-    if (!personalOrganization) {
-        return null;
-    }
-    return {
-        organization: personalOrganization,
-        source: personalOrganization.organizationType === 'user' ? 'default-personal' : 'default-first',
-    };
-};
-export const resolveBaseUrl = ({ flagValue, env, config, }) => {
-    const normalizedFlagValue = normalizeStoredBaseUrl(flagValue);
-    if (normalizedFlagValue) {
-        return { value: normalizedFlagValue, source: 'flag' };
-    }
-    const normalizedEnvValue = normalizeStoredBaseUrl(env[chalksurfBaseUrlEnvVar]);
-    if (normalizedEnvValue) {
-        return { value: normalizedEnvValue, source: 'env' };
-    }
-    const normalizedConfigValue = normalizeStoredBaseUrl(config.baseUrl);
-    if (normalizedConfigValue) {
-        return { value: normalizedConfigValue, source: 'config' };
-    }
-    return { source: 'none' };
-};
-export const resolveToken = ({ env, config }) => {
-    const normalizedEnvValue = normalizeOptionalString(env[chalksurfTokenEnvVar]);
-    if (normalizedEnvValue) {
-        return { value: normalizedEnvValue, source: 'env' };
-    }
-    const normalizedConfigValue = normalizeOptionalString(config.token);
-    if (normalizedConfigValue) {
-        return { value: normalizedConfigValue, source: 'config' };
-    }
-    return { source: 'none' };
-};
-export const resolveProfile = ({ flagValue, env, config, }) => {
-    const flagProfileName = normalizeProfileName(flagValue);
-    if (flagProfileName) {
-        return { profileName: flagProfileName, profileSource: 'flag' };
-    }
-    const envProfileName = normalizeProfileName(env[chalksurfProfileEnvVar]);
-    if (envProfileName) {
-        return { profileName: envProfileName, profileSource: 'env' };
-    }
-    const defaultProfile = normalizeProfileName(config.defaultProfile);
-    if (defaultProfile) {
-        return { profileName: defaultProfile, profileSource: 'config' };
-    }
-    if (!rootConfigHasProfiles(config)) {
-        return { profileName: implicitDefaultProfileName, profileSource: 'implicit-default' };
-    }
-    throw new CliCommandError(`No active ChalkSurf profile selected. Pass --profile, set ${chalksurfProfileEnvVar}, or run "chalksurf profile use <profile>".`, 2);
-};
-export const resolveOrganization = ({ flagValue, env, config, profile, }) => {
-    const flagOrganizationId = normalizeOptionalString(flagValue);
-    if (flagOrganizationId) {
-        const organization = findOrganizationMembership({
-            memberships: profile.organizationMemberships,
-            organizationId: flagOrganizationId,
-        });
-        if (!organization) {
-            throw new CliCommandError(`Organization "${flagOrganizationId}" is not accessible to the current user.`, 2);
-        }
-        return { organization, source: 'flag', warnings: [] };
-    }
-    const envOrganizationId = normalizeOptionalString(env[chalksurfOrganizationIdEnvVar]);
-    if (envOrganizationId) {
-        const organization = findOrganizationMembership({
-            memberships: profile.organizationMemberships,
-            organizationId: envOrganizationId,
-        });
-        if (!organization) {
-            throw new CliCommandError(`Organization "${envOrganizationId}" from ${chalksurfOrganizationIdEnvVar} is not accessible to the current user.`, 2);
-        }
-        return { organization, source: 'env', warnings: [] };
-    }
-    const configOrganizationId = normalizeOptionalString(config.organizationId);
-    if (configOrganizationId) {
-        const organization = findOrganizationMembership({
-            memberships: profile.organizationMemberships,
-            organizationId: configOrganizationId,
-        });
-        if (organization) {
-            return { organization, source: 'config', warnings: [] };
-        }
-        const fallbackOrganization = getFallbackOrganization(profile.organizationMemberships);
-        if (!fallbackOrganization) {
-            return {
-                organization: null,
-                source: 'none',
-                warnings: [`Stored organization "${configOrganizationId}" is no longer accessible.`],
-            };
-        }
-        return {
-            organization: fallbackOrganization.organization,
-            source: fallbackOrganization.source,
-            warnings: [
-                `Stored organization "${configOrganizationId}" is no longer accessible; using "${fallbackOrganization.organization.organizationName}" instead.`,
-            ],
-        };
-    }
-    const fallbackOrganization = getFallbackOrganization(profile.organizationMemberships);
-    if (!fallbackOrganization) {
-        return { organization: null, source: 'none', warnings: [] };
-    }
-    return {
-        organization: fallbackOrganization.organization,
-        source: fallbackOrganization.source,
-        warnings: [],
-    };
-};
-export const createConfigStore = ({ configPath, env = process.env, platform = process.platform, homeDirectory = homedir(), fs = { chmod, mkdir, readFile, rm, writeFile }, } = {}) => {
-    const resolvedConfigPath = configPath || getDefaultConfigPath({ env, platform, homeDirectory });
-    const load = async () => {
-        const rootConfig = await loadRoot();
-        const resolvedProfile = resolveProfile({ env, config: rootConfig });
-        const profileConfig = rootConfig.profiles[resolvedProfile.profileName] ?? {};
-        return {
-            ...profileConfig,
-            ...resolvedProfile,
-        };
-    };
-    const loadRoot = async () => {
-        try {
-            const configContents = await fs.readFile(resolvedConfigPath, 'utf8');
-            const parsedConfig = JSON.parse(configContents);
-            return readRootConfig(parsedConfig);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return { schemaVersion: cliConfigSchemaVersion, profiles: {} };
-            }
-            if (error instanceof SyntaxError) {
-                throw new CliCommandError(`Failed to parse CLI config at ${resolvedConfigPath}.`, 2);
-            }
-            throw error;
-        }
-    };
-    const loadProfile = async ({ profileName } = {}) => {
-        const rootConfig = await loadRoot();
-        const resolvedProfile = resolveProfile({ flagValue: profileName, env, config: rootConfig });
-        const profileConfig = rootConfig.profiles[resolvedProfile.profileName] ?? {};
-        return {
-            ...profileConfig,
-            ...resolvedProfile,
-        };
-    };
-    const saveRoot = async (config) => {
-        const sanitizedConfig = sanitizeRootConfig(config);
-        if (!rootConfigHasProfiles(sanitizedConfig)) {
-            await fs.rm(resolvedConfigPath, { force: true });
-            return sanitizedConfig;
-        }
-        await fs.mkdir(dirname(resolvedConfigPath), { recursive: true, mode: 0o700 });
-        await fs.writeFile(resolvedConfigPath, `${JSON.stringify(sanitizedConfig, null, 2)}\n`, {
-            mode: 0o600,
-        });
-        await fs.chmod(resolvedConfigPath, 0o600);
-        return sanitizedConfig;
-    };
-    const save = async (config) => {
-        const rootConfig = await loadRoot();
-        const nextProfileConfig = sanitizeProfileConfig(config);
-        const nextRootConfig = {
-            ...rootConfig,
-            profiles: {
-                ...rootConfig.profiles,
-            },
-        };
-        if (hasProfileConfigValues(nextProfileConfig)) {
-            nextRootConfig.profiles[config.profileName] = nextProfileConfig;
-        }
-        else {
-            delete nextRootConfig.profiles[config.profileName];
-        }
-        if (config.profileSource === 'implicit-default' && hasProfileConfigValues(nextProfileConfig)) {
-            nextRootConfig.defaultProfile = config.profileName;
-        }
-        return await saveRoot(nextRootConfig);
-    };
-    const update = async ({ profileName }, updater) => {
-        const currentConfig = await loadProfile({ profileName });
-        const nextProfileConfig = await updater(currentConfig);
-        return await save({
-            ...nextProfileConfig,
-            profileName: currentConfig.profileName,
-            profileSource: currentConfig.profileSource,
-        });
-    };
-    const setDefaultProfile = async (profileName) => {
-        const normalizedProfileName = normalizeProfileName(profileName);
-        if (!normalizedProfileName) {
-            throw new CliCommandError('Profile name is required.', 2);
-        }
-        const rootConfig = await loadRoot();
-        if (!rootConfig.profiles[normalizedProfileName]) {
-            throw new CliCommandError(`Profile "${normalizedProfileName}" does not exist. Run "chalksurf auth login --profile ${normalizedProfileName} --base-url <url>" first.`, 2);
-        }
-        return await saveRoot({
-            ...rootConfig,
-            defaultProfile: normalizedProfileName,
-        });
-    };
-    const deleteProfile = async (profileName) => {
-        const normalizedProfileName = normalizeProfileName(profileName);
-        if (!normalizedProfileName) {
-            throw new CliCommandError('Profile name is required.', 2);
-        }
-        const rootConfig = await loadRoot();
-        if (!rootConfig.profiles[normalizedProfileName]) {
-            throw new CliCommandError(`Profile "${normalizedProfileName}" does not exist.`, 2);
-        }
-        const profiles = { ...rootConfig.profiles };
-        delete profiles[normalizedProfileName];
-        return await saveRoot({
-            schemaVersion: cliConfigSchemaVersion,
-            ...(rootConfig.defaultProfile === normalizedProfileName ? {} : { defaultProfile: rootConfig.defaultProfile }),
-            profiles,
-        });
-    };
-    return {
-        path: resolvedConfigPath,
-        load,
-        loadProfile,
-        loadRoot,
-        save,
-        saveRoot,
-        update,
-        setDefaultProfile,
-        deleteProfile,
-    };
-};

package/dist/lib/import-files.js

@@ -1,120 +0,0 @@
-import { openAsBlob } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { extname, resolve } from 'node:path';
-import { CliCommandError } from './cli-error.js';
-const mimeTypesByExtension = {
-    '.avif': 'image/avif',
-    '.doc': 'application/msword',
-    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    '.gif': 'image/gif',
-    '.htm': 'text/html',
-    '.html': 'text/html',
-    '.jpeg': 'image/jpeg',
-    '.jpg': 'image/jpeg',
-    '.md': 'text/markdown',
-    '.pdf': 'application/pdf',
-    '.png': 'image/png',
-    '.svg': 'image/svg+xml',
-    '.tex': 'text/plain',
-    '.tif': 'image/tiff',
-    '.tiff': 'image/tiff',
-    '.txt': 'text/plain',
-    '.webp': 'image/webp',
-};
-const guessMimeType = (fileName) => {
-    return mimeTypesByExtension[extname(fileName).toLowerCase()] ?? 'application/octet-stream';
-};
-const isHttpUrl = (value) => {
-    try {
-        const parsedUrl = new URL(value);
-        return ['http:', 'https:'].includes(parsedUrl.protocol);
-    }
-    catch {
-        return false;
-    }
-};
-export const buildFileImportFormData = async (resolvedSources) => {
-    const formData = new FormData();
-    await Promise.all(resolvedSources.map(async (resolvedSource, index) => {
-        const mimeType = resolvedSource.mimeType ?? guessMimeType(resolvedSource.fileName);
-        const fileBlob = await openAsBlob(resolvedSource.filePath, { type: mimeType });
-        const file = new File([fileBlob], resolvedSource.fileName, { type: mimeType });
-        formData.set(`file-${index}`, file);
-        formData.set(`path-${index}`, resolvedSource.relativePath);
-    }));
-    return formData;
-};
-export const buildFileImportCommandSources = async ({ cwd, loadManifest, manifestPath, rawSources, relativePath, stdin, wait, }) => {
-    if (manifestPath && rawSources.length > 0) {
-        throw new CliCommandError('Pass positional sources or --manifest, not both.', 2);
-    }
-    if (manifestPath && relativePath) {
-        throw new CliCommandError('--relative-path can only be used with a single positional source.', 2);
-    }
-    if (manifestPath) {
-        const manifest = await loadManifest({
-            cwd,
-            manifestPath,
-            stdin,
-        });
-        const { organizationId, sources, wait: manifestWait, ...manifestExtras } = manifest;
-        return {
-            organizationId,
-            sources,
-            wait: wait || manifestWait === true,
-            ...manifestExtras,
-        };
-    }
-    if (rawSources.length === 0) {
-        throw new CliCommandError('At least one source or --manifest is required.', 2);
-    }
-    if (relativePath && rawSources.length !== 1) {
-        throw new CliCommandError('--relative-path can only be used with a single positional source.', 2);
-    }
-    const sources = [];
-    for (const rawSource of rawSources) {
-        if (isHttpUrl(rawSource)) {
-            sources.push({
-                kind: 'url',
-                url: rawSource,
-                relativePath,
-            });
-            continue;
-        }
-        try {
-            const pathStats = await stat(resolve(cwd, rawSource));
-            if (pathStats.isDirectory()) {
-                if (relativePath) {
-                    throw new CliCommandError('--relative-path cannot be used with directory sources.', 2);
-                }
-                sources.push({
-                    kind: 'directory',
-                    path: rawSource,
-                });
-                continue;
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                throw error;
-            }
-        }
-        sources.push({
-            kind: 'local',
-            path: rawSource,
-            relativePath,
-        });
-    }
-    return {
-        organizationId: undefined,
-        sources,
-        wait: wait === true,
-    };
-};
-export const normalizeWaitTimeoutMs = (timeoutMs) => {
-    const normalizedTimeoutMs = timeoutMs ?? 300000;
-    if (!Number.isFinite(normalizedTimeoutMs) || normalizedTimeoutMs <= 0) {
-        throw new CliCommandError('--timeout-ms must be a positive number.', 2);
-    }
-    return normalizedTimeoutMs;
-};