@chalksurf/cli 0.2.2 → 0.2.4

package/dist/lib/source-resolver.js

@@ -1,272 +0,0 @@
-import { createWriteStream } from 'node:fs';
-import { mkdtemp, open, readdir, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { basename, isAbsolute, relative, resolve } from 'node:path';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import pLimit from 'p-limit';
-import { CliCommandError } from './cli-error.js';
-const sourceResolutionExitCode = 4;
-const defaultMaxConcurrentUrlDownloads = 4;
-const htmlSniffBytes = 1024;
-const genericMimeTypes = new Set(['application/octet-stream', 'binary/octet-stream']);
-const createSourceResolutionError = (message) => {
-    return new CliCommandError(message, sourceResolutionExitCode);
-};
-const normalizeRelativePath = (relativePath) => {
-    const normalizedSegments = relativePath
-        .replaceAll('\\', '/')
-        .split('/')
-        .filter((segment) => segment.length > 0 && segment !== '.');
-    if (normalizedSegments.some((segment) => segment === '..')) {
-        throw createSourceResolutionError(`Relative path "${relativePath}" cannot contain "..".`);
-    }
-    const normalizedRelativePath = normalizedSegments.join('/');
-    if (!normalizedRelativePath) {
-        throw createSourceResolutionError('Relative path cannot be empty.');
-    }
-    return normalizedRelativePath;
-};
-const ensureExistingFile = async (filePath, label) => {
-    let fileStats;
-    try {
-        fileStats = await stat(filePath);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw createSourceResolutionError(`${label} "${filePath}" does not exist.`);
-        }
-        throw error;
-    }
-    if (!fileStats.isFile()) {
-        throw createSourceResolutionError(`${label} "${filePath}" is not a file.`);
-    }
-};
-const ensureExistingDirectory = async (directoryPath, label) => {
-    let directoryStats;
-    try {
-        directoryStats = await stat(directoryPath);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw createSourceResolutionError(`${label} "${directoryPath}" does not exist.`);
-        }
-        throw error;
-    }
-    if (!directoryStats.isDirectory()) {
-        throw createSourceResolutionError(`${label} "${directoryPath}" is not a directory.`);
-    }
-};
-const isContainedWithin = ({ childPath, parentPath }) => {
-    const relativePath = relative(parentPath, childPath);
-    if (!relativePath) {
-        return true;
-    }
-    return !relativePath.startsWith('..') && !isAbsolute(relativePath);
-};
-const collectFilesRecursively = async (directoryPath) => {
-    const directoryEntries = await readdir(directoryPath, { withFileTypes: true });
-    const sortedEntries = directoryEntries.sort((leftEntry, rightEntry) => leftEntry.name.localeCompare(rightEntry.name));
-    const filePaths = [];
-    for (const directoryEntry of sortedEntries) {
-        const entryPath = resolve(directoryPath, directoryEntry.name);
-        if (directoryEntry.isDirectory()) {
-            filePaths.push(...(await collectFilesRecursively(entryPath)));
-            continue;
-        }
-        if (directoryEntry.isFile()) {
-            filePaths.push(entryPath);
-        }
-    }
-    return filePaths;
-};
-const deriveRelativePathFromUrl = (url) => {
-    const fileName = basename(decodeURIComponent(url.pathname));
-    if (!fileName) {
-        throw createSourceResolutionError(`URL source "${url.toString()}" does not include a file name. Pass a relative path explicitly.`);
-    }
-    return fileName;
-};
-const normalizeMimeType = (contentTypeHeaderValue) => {
-    const mimeType = contentTypeHeaderValue?.split(';', 1)[0]?.trim().toLowerCase();
-    return mimeType || undefined;
-};
-const stripLeadingHtmlComments = (value) => {
-    let normalizedValue = value.trimStart();
-    while (normalizedValue.startsWith('<!--')) {
-        const commentEndIndex = normalizedValue.indexOf('-->');
-        if (commentEndIndex === -1) {
-            return normalizedValue;
-        }
-        normalizedValue = normalizedValue.slice(commentEndIndex + 3).trimStart();
-    }
-    return normalizedValue;
-};
-const looksLikeHtmlDocument = (value) => {
-    const normalizedValue = stripLeadingHtmlComments(value.replace(/^\uFEFF/, ''));
-    return /^<(?:!doctype html|html|head|body)\b/i.test(normalizedValue);
-};
-const sniffMimeType = async ({ filePath, responseMimeType }) => {
-    if (responseMimeType && !genericMimeTypes.has(responseMimeType)) {
-        return responseMimeType;
-    }
-    const fileHandle = await open(filePath, 'r');
-    try {
-        const buffer = Buffer.alloc(htmlSniffBytes);
-        const { bytesRead } = await fileHandle.read(buffer, 0, buffer.length, 0);
-        const filePrefix = buffer.subarray(0, bytesRead).toString('utf8');
-        if (looksLikeHtmlDocument(filePrefix)) {
-            return 'text/html';
-        }
-        return responseMimeType;
-    }
-    finally {
-        await fileHandle.close();
-    }
-};
-const resolveLocalFileSource = async ({ source, cwd, sourceInputIndex, }) => {
-    const resolvedPath = resolve(cwd, source.path);
-    await ensureExistingFile(resolvedPath, 'Local source');
-    const relativePath = normalizeRelativePath(source.relativePath ?? basename(resolvedPath));
-    return [
-        {
-            kind: 'local',
-            input: source.path,
-            filePath: resolvedPath,
-            fileName: basename(relativePath),
-            relativePath,
-            sourceInputIndex,
-            sourceInput: source,
-        },
-    ];
-};
-const resolveDirectorySource = async ({ source, cwd, sourceInputIndex, }) => {
-    const resolvedDirectoryPath = resolve(cwd, source.path);
-    const resolvedRelativeRoot = resolve(cwd, source.relativeRoot ?? source.path);
-    await ensureExistingDirectory(resolvedDirectoryPath, 'Directory source');
-    await ensureExistingDirectory(resolvedRelativeRoot, 'Directory relativeRoot');
-    if (!isContainedWithin({ childPath: resolvedDirectoryPath, parentPath: resolvedRelativeRoot })) {
-        throw createSourceResolutionError(`Directory source "${resolvedDirectoryPath}" is not contained within relativeRoot "${resolvedRelativeRoot}".`);
-    }
-    const filePaths = await collectFilesRecursively(resolvedDirectoryPath);
-    if (filePaths.length === 0) {
-        throw createSourceResolutionError(`Directory source "${resolvedDirectoryPath}" does not contain any files.`);
-    }
-    return filePaths.map((filePath) => {
-        const relativePath = normalizeRelativePath(relative(resolvedRelativeRoot, filePath));
-        return {
-            kind: 'local',
-            input: filePath,
-            filePath,
-            fileName: basename(relativePath),
-            relativePath,
-            sourceInputIndex,
-            sourceInput: source,
-        };
-    });
-};
-const resolveUrlSource = async ({ source, sourceInputIndex, }) => {
-    let parsedUrl;
-    try {
-        parsedUrl = new URL(source.url);
-    }
-    catch {
-        throw createSourceResolutionError(`URL source "${source.url}" is not a valid URL.`);
-    }
-    if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
-        throw createSourceResolutionError(`URL source "${source.url}" must use http or https.`);
-    }
-    const relativePath = normalizeRelativePath(source.relativePath ?? deriveRelativePathFromUrl(parsedUrl));
-    const downloadDirectoryPath = await mkdtemp(resolve(tmpdir(), 'chalksurf-cli-source-'));
-    const downloadedFilePath = resolve(downloadDirectoryPath, basename(relativePath));
-    try {
-        const response = await fetch(source.url);
-        if (!response.ok) {
-            throw createSourceResolutionError(`Failed to download "${source.url}": HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`);
-        }
-        if (!response.body) {
-            throw createSourceResolutionError(`Failed to download "${source.url}": response body was empty.`);
-        }
-        const responseMimeType = normalizeMimeType(response.headers.get('content-type'));
-        await pipeline(Readable.fromWeb(response.body), createWriteStream(downloadedFilePath));
-        const mimeType = await sniffMimeType({
-            filePath: downloadedFilePath,
-            responseMimeType,
-        });
-        return [
-            {
-                kind: 'url',
-                input: source.url,
-                filePath: downloadedFilePath,
-                fileName: basename(relativePath),
-                mimeType,
-                relativePath,
-                sourceInputIndex,
-                cleanupPath: downloadDirectoryPath,
-                sourceInput: source,
-            },
-        ];
-    }
-    catch (error) {
-        await rm(downloadDirectoryPath, { force: true, recursive: true });
-        if (error instanceof CliCommandError) {
-            throw error;
-        }
-        const message = error instanceof Error ? error.message : 'Unknown download error';
-        throw createSourceResolutionError(`Failed to download "${source.url}": ${message}`);
-    }
-};
-const assertUniqueRelativePaths = (resolvedSources) => {
-    const seenRelativePaths = new Set();
-    for (const resolvedSource of resolvedSources) {
-        if (seenRelativePaths.has(resolvedSource.relativePath)) {
-            throw createSourceResolutionError(`Resolved sources contain duplicate relative path "${resolvedSource.relativePath}".`);
-        }
-        seenRelativePaths.add(resolvedSource.relativePath);
-    }
-};
-export const cleanupResolvedSources = async (resolvedSources) => {
-    const cleanupPaths = Array.from(new Set(resolvedSources
-        .map((resolvedSource) => resolvedSource.cleanupPath)
-        .filter((cleanupPath) => cleanupPath !== undefined)));
-    await Promise.all(cleanupPaths.map(async (cleanupPath) => {
-        await rm(cleanupPath, { force: true, recursive: true });
-    }));
-};
-export const resolveSources = async ({ sources, cwd = process.cwd(), maxConcurrentUrlDownloads = defaultMaxConcurrentUrlDownloads, }) => {
-    const limitUrlDownloads = pLimit(Math.max(1, maxConcurrentUrlDownloads));
-    const settledSourceGroups = await Promise.allSettled(sources.map(async (source, sourceInputIndex) => {
-        if (source.kind === 'local') {
-            return await resolveLocalFileSource({
-                source: source,
-                cwd,
-                sourceInputIndex,
-            });
-        }
-        if (source.kind === 'directory') {
-            return await resolveDirectorySource({
-                source: source,
-                cwd,
-                sourceInputIndex,
-            });
-        }
-        return await limitUrlDownloads(() => resolveUrlSource({
-            source: source,
-            sourceInputIndex,
-        }));
-    }));
-    const resolvedSources = settledSourceGroups.flatMap((result) => (result.status === 'fulfilled' ? result.value : []));
-    const firstRejectedResult = settledSourceGroups.find((result) => result.status === 'rejected');
-    if (firstRejectedResult?.status === 'rejected') {
-        await cleanupResolvedSources(resolvedSources);
-        throw firstRejectedResult.reason;
-    }
-    try {
-        assertUniqueRelativePaths(resolvedSources);
-        return resolvedSources;
-    }
-    catch (error) {
-        await cleanupResolvedSources(resolvedSources);
-        throw error;
-    }
-};

package/dist/lib/translation-languages.js

@@ -1,16 +0,0 @@
-import { CliCommandError } from './cli-error.js';
-export const translationLanguages = ['english', 'hungarian', 'german', 'french', 'spanish', 'italian'];
-export const resolveRequestedTranslateToLanguages = (rawValues) => {
-    if (!rawValues || rawValues.length === 0) {
-        return undefined;
-    }
-    const invalidLanguage = rawValues.find((value) => !translationLanguages.includes(value));
-    if (invalidLanguage) {
-        throw new CliCommandError(`--translate-to must be one of: ${translationLanguages.join(', ')}`, 2);
-    }
-    const languages = rawValues;
-    if (new Set(languages).size !== languages.length) {
-        throw new CliCommandError('--translate-to languages must be unique.', 2);
-    }
-    return languages;
-};

package/dist/lib/user-jobs.js

@@ -1,99 +0,0 @@
-import { CliCommandError, createSerializableCliError } from './cli-error.js';
-import { mapApiErrorToCliError } from './session.js';
-const isTerminalJob = (job) => {
-    return ['completed', 'failed'].includes(job.status);
-};
-export const serializeCliJob = (job) => {
-    return {
-        id: job.id,
-        status: job.status,
-        type: job.type,
-        createdAt: job.createdAt,
-        updatedAt: job.updatedAt,
-        error: job.result?.error,
-        exerciseId: job.result?.exerciseId,
-        exerciseIds: job.result?.exerciseIds,
-        exerciseSheetId: job.result?.exerciseSheetId,
-        eligibleExerciseCount: job.result?.eligibleExerciseCount,
-        nonUpdatableExerciseCount: job.result?.nonUpdatableExerciseCount,
-        resultCode: job.result?.resultCode,
-        skippedExerciseCount: job.result?.skippedExerciseCount,
-        translationJobs: job.result?.translationJobs,
-        unmatchedImportedSolutionCount: job.result?.unmatchedImportedSolutionCount,
-        updatedExerciseCount: job.result?.updatedExerciseCount,
-    };
-};
-export const formatCliJobSummary = (job) => {
-    if (job.status === 'completed') {
-        if (job.exerciseSheetId) {
-            return `${job.id} completed -> ${job.exerciseSheetId}`;
-        }
-        if (job.exerciseId) {
-            return `${job.id} completed -> ${job.exerciseId}`;
-        }
-        return `${job.id} completed`;
-    }
-    if (job.status === 'failed') {
-        return `${job.id} failed -> ${job.error ?? 'Unknown error'}`;
-    }
-    return `${job.id} ${job.status}`;
-};
-export const getWaitExitCode = ({ jobs, timedOut }) => {
-    if (timedOut) {
-        return 6;
-    }
-    if (jobs.some((job) => job.status === 'failed')) {
-        return 7;
-    }
-    return 0;
-};
-export const getWaitError = ({ jobs, timedOut }) => {
-    if (timedOut) {
-        return createSerializableCliError({
-            exitCode: 6,
-            message: 'Timed out before all jobs completed.',
-        });
-    }
-    if (jobs.some((job) => job.status === 'failed')) {
-        return createSerializableCliError({
-            exitCode: 7,
-            message: 'One or more jobs failed.',
-        });
-    }
-    return undefined;
-};
-export const waitForCliJobs = async ({ getUserJob, jobIds, maxPollIntervalMs = 5000, now, sleep, timeoutMs = 300000, }) => {
-    const startedAt = now();
-    let nextPollDelayMs = 1000;
-    let latestJobs = [];
-    while (true) {
-        try {
-            latestJobs = await Promise.all(jobIds.map(async (jobId) => await getUserJob(jobId)));
-        }
-        catch (error) {
-            throw mapApiErrorToCliError(error);
-        }
-        if (latestJobs.every(isTerminalJob)) {
-            return {
-                jobs: latestJobs.map(serializeCliJob),
-                timedOut: false,
-            };
-        }
-        const elapsedMs = now() - startedAt;
-        if (elapsedMs >= timeoutMs) {
-            return {
-                jobs: latestJobs.map(serializeCliJob),
-                timedOut: true,
-            };
-        }
-        const remainingMs = timeoutMs - elapsedMs;
-        await sleep(Math.max(0, Math.min(nextPollDelayMs, remainingMs)));
-        nextPollDelayMs = Math.min(nextPollDelayMs * 2, maxPollIntervalMs);
-    }
-};
-export const throwSilentExitCode = (exitCode) => {
-    if (exitCode === 0) {
-        return;
-    }
-    throw new CliCommandError('', exitCode, false);
-};