@chalksurf/cli 0.1.0 → 0.2.0

package/dist/lib/import-files.js

@@ -0,0 +1,120 @@
+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;
+};

package/dist/lib/import-output.js

@@ -0,0 +1,67 @@
+export const buildCliImportSources = ({ resolvedSources, getExtra, }) => {
+    return resolvedSources.map((resolvedSource, sourceIndex) => ({
+        sourceIndex,
+        sourceInputIndex: resolvedSource.sourceInputIndex,
+        sourceId: resolvedSource.sourceInput.sourceId ?? null,
+        kind: resolvedSource.kind,
+        input: resolvedSource.input,
+        fileName: resolvedSource.fileName,
+        relativePath: resolvedSource.relativePath,
+        ...(getExtra ? getExtra(resolvedSource) : {}),
+    }));
+};
+export const summarizeCliImportJobs = ({ jobs, sourceCount, sourceInputCount, timedOut, }) => {
+    const summary = {
+        sourceCount,
+        sourceInputCount,
+        jobCount: jobs.length,
+        queued: 0,
+        pending: 0,
+        inProgress: 0,
+        completed: 0,
+        failed: 0,
+        timedOut,
+    };
+    for (const job of jobs) {
+        if (job.status === 'queued') {
+            summary.queued += 1;
+            continue;
+        }
+        if (job.status === 'pending') {
+            summary.pending += 1;
+            continue;
+        }
+        if (job.status === 'in_progress') {
+            summary.inProgress += 1;
+            continue;
+        }
+        if (job.status === 'completed') {
+            summary.completed += 1;
+            continue;
+        }
+        summary.failed += 1;
+    }
+    return summary;
+};
+export const formatCliImportSummary = (summary) => {
+    const parts = [];
+    if (summary.queued > 0) {
+        parts.push(`${summary.queued} queued`);
+    }
+    if (summary.pending > 0) {
+        parts.push(`${summary.pending} pending`);
+    }
+    if (summary.inProgress > 0) {
+        parts.push(`${summary.inProgress} in progress`);
+    }
+    if (summary.completed > 0) {
+        parts.push(`${summary.completed} completed`);
+    }
+    if (summary.failed > 0) {
+        parts.push(`${summary.failed} failed`);
+    }
+    if (summary.timedOut) {
+        parts.push('timed out');
+    }
+    return `Summary: ${parts.join(', ') || '0 jobs'}.`;
+};

package/dist/lib/manifest.js

@@ -1,6 +1,8 @@
 import { readFile, stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { z } from 'zod';
 import { CliCommandError } from './cli-error.js';
+import { translationLanguages } from './translation-languages.js';
 const isObject = (value) => {
     return typeof value === 'object' && value !== null;
 };
@@ -11,6 +13,88 @@ const normalizeOptionalString = (value) => {
     const normalizedValue = value.trim();
     return normalizedValue.length > 0 ? normalizedValue : undefined;
 };
+const translationLanguageListSchema = z
+    .array(z.enum(translationLanguages))
+    .min(1, { message: 'translateTo must include at least one language.' })
+    .refine((languages) => new Set(languages).size === languages.length, {
+    message: 'translateTo languages must be unique.',
+});
+const parseTranslateTo = ({ value, label }) => {
+    if (value == null) {
+        return undefined;
+    }
+    const parsedLanguages = translationLanguageListSchema.safeParse(value);
+    if (!parsedLanguages.success) {
+        const issue = parsedLanguages.error.issues[0];
+        throw new CliCommandError(`${label} has invalid translateTo: ${issue?.message ?? 'Invalid languages.'}`, 2);
+    }
+    return parsedLanguages.data;
+};
+const parseManifestObject = (manifestText) => {
+    let parsedManifest;
+    try {
+        parsedManifest = JSON.parse(manifestText);
+    }
+    catch {
+        throw new CliCommandError('Manifest must be valid JSON.', 2);
+    }
+    if (!isObject(parsedManifest)) {
+        throw new CliCommandError('Manifest must be a JSON object.', 2);
+    }
+    return parsedManifest;
+};
+const parseSourceManifestObject = (manifestText) => {
+    const parsedManifest = parseManifestObject(manifestText);
+    if (!Array.isArray(parsedManifest.sources) || parsedManifest.sources.length === 0) {
+        throw new CliCommandError('Manifest must include a non-empty sources array.', 2);
+    }
+    return parsedManifest;
+};
+const isValidTargetFolderPath = (value) => {
+    const normalizedSegments = value
+        .replaceAll('\\', '/')
+        .split('/')
+        .filter((segment) => segment.length > 0);
+    return normalizedSegments.length > 0 && normalizedSegments.every((segment) => segment !== '.' && segment !== '..');
+};
+const parseTargetFolderPath = ({ value, label }) => {
+    if (value === null) {
+        return null;
+    }
+    const normalizedValue = normalizeOptionalString(value);
+    if (!normalizedValue) {
+        throw new CliCommandError(`${label} must include targetFolderPath as a string or null.`, 2);
+    }
+    if (!isValidTargetFolderPath(normalizedValue)) {
+        throw new CliCommandError(`${label} targetFolderPath must be a normalized folder path without "." or ".." segments.`, 2);
+    }
+    return normalizedValue;
+};
+const parseManifestMetadata = ({ parsedManifest, topLevelFields, }) => {
+    const wait = typeof parsedManifest.wait === 'boolean' ? parsedManifest.wait : undefined;
+    return {
+        organizationId: normalizeOptionalString(parsedManifest.organizationId),
+        wait,
+        ...(topLevelFields.includes('exerciseId')
+            ? { exerciseId: normalizeOptionalString(parsedManifest.exerciseId) }
+            : {}),
+        ...(topLevelFields.includes('exerciseSheetId')
+            ? { exerciseSheetId: normalizeOptionalString(parsedManifest.exerciseSheetId) }
+            : {}),
+    };
+};
+const assertUniqueSourceIds = (sources) => {
+    const seenSourceIds = new Set();
+    for (const source of sources) {
+        if (!source.sourceId) {
+            continue;
+        }
+        if (seenSourceIds.has(source.sourceId)) {
+            throw new CliCommandError(`Manifest sourceId "${source.sourceId}" must be unique.`, 2);
+        }
+        seenSourceIds.add(source.sourceId);
+    }
+};
 const isInteractiveStdin = (stdin) => {
     return stdin.isTTY === true;
 };
@@ -21,11 +105,15 @@ const readTextFromStdin = async (stdin) => {
     }
     return text;
 };
-const parseManifestSource = (value, index) => {
+const parseBaseManifestSource = (value, index) => {
     if (!isObject(value)) {
         throw new CliCommandError(`Manifest source at index ${index} must be an object.`, 2);
     }
     const kind = normalizeOptionalString(value.kind);
+    const sourceId = normalizeOptionalString(value.sourceId);
+    if ('title' in value || 'translateTo' in value) {
+        throw new CliCommandError(`Manifest source at index ${index} cannot include title or translateTo for this command.`, 2);
+    }
     if (kind === 'local') {
         const path = normalizeOptionalString(value.path);
         if (!path) {
@@ -35,6 +123,7 @@ const parseManifestSource = (value, index) => {
             kind: 'local',
             path,
             relativePath: normalizeOptionalString(value.relativePath),
+            sourceId,
         };
     }
     if (kind === 'directory') {
@@ -46,6 +135,7 @@ const parseManifestSource = (value, index) => {
             kind: 'directory',
             path,
             relativeRoot: normalizeOptionalString(value.relativeRoot),
+            sourceId,
         };
     }
     if (kind === 'url') {
@@ -57,35 +147,85 @@ const parseManifestSource = (value, index) => {
             kind: 'url',
             url,
             relativePath: normalizeOptionalString(value.relativePath),
+            sourceId,
         };
     }
     throw new CliCommandError(`Manifest source at index ${index} has unsupported kind "${String(value.kind)}".`, 2);
 };
-const parseManifest = (manifestText) => {
-    let parsedManifest;
-    try {
-        parsedManifest = JSON.parse(manifestText);
-    }
-    catch {
-        throw new CliCommandError('Manifest must be valid JSON.', 2);
-    }
-    if (!isObject(parsedManifest)) {
-        throw new CliCommandError('Manifest must be a JSON object.', 2);
+const parseExerciseImportManifest = (manifestText) => {
+    const parsedManifest = parseSourceManifestObject(manifestText);
+    const sources = parsedManifest.sources.map((source, index) => parseBaseManifestSource(source, index));
+    assertUniqueSourceIds(sources);
+    return {
+        ...parseManifestMetadata({
+            parsedManifest,
+            topLevelFields: ['exerciseSheetId'],
+        }),
+        sources,
+    };
+};
+const parseExerciseSolutionImportManifest = (manifestText) => {
+    const parsedManifest = parseSourceManifestObject(manifestText);
+    const sources = parsedManifest.sources.map((source, index) => parseBaseManifestSource(source, index));
+    assertUniqueSourceIds(sources);
+    return {
+        ...parseManifestMetadata({
+            parsedManifest,
+            topLevelFields: ['exerciseId'],
+        }),
+        sources,
+    };
+};
+const parseSheetImportManifest = (manifestText) => {
+    const parsedManifest = parseManifestObject(manifestText);
+    if ('sources' in parsedManifest) {
+        throw new CliCommandError('Sheet import manifests must use top-level sheets[]. Top-level sources[] is no longer supported.', 2);
     }
-    if (!Array.isArray(parsedManifest.sources) || parsedManifest.sources.length === 0) {
-        throw new CliCommandError('Manifest must include a non-empty sources array.', 2);
+    if (!Array.isArray(parsedManifest.sheets) || parsedManifest.sheets.length === 0) {
+        throw new CliCommandError('Manifest must include a non-empty sheets array.', 2);
     }
-    const wait = typeof parsedManifest.wait === 'boolean' ? parsedManifest.wait : undefined;
+    const sources = [];
+    const sheetGroups = [];
+    parsedManifest.sheets.forEach((sheetValue, sheetIndex) => {
+        if (!isObject(sheetValue)) {
+            throw new CliCommandError(`Manifest sheet at index ${sheetIndex} must be an object.`, 2);
+        }
+        if (!Array.isArray(sheetValue.sources) || sheetValue.sources.length === 0) {
+            throw new CliCommandError(`Manifest sheet at index ${sheetIndex} must include a non-empty sources array.`, 2);
+        }
+        const sourceInputIndexes = sheetValue.sources.map((sourceValue) => {
+            const flattenedSourceIndex = sources.length;
+            const parsedSource = parseBaseManifestSource(sourceValue, flattenedSourceIndex);
+            sources.push(parsedSource);
+            return flattenedSourceIndex;
+        });
+        sheetGroups.push({
+            sourceInputIndexes,
+            targetFolderPath: parseTargetFolderPath({
+                value: sheetValue.targetFolderPath,
+                label: `Manifest sheet at index ${sheetIndex}`,
+            }),
+            title: normalizeOptionalString(sheetValue.title),
+            translateTo: parseTranslateTo({
+                value: sheetValue.translateTo,
+                label: `Manifest sheet at index ${sheetIndex}`,
+            }),
+        });
+    });
+    assertUniqueSourceIds(sources);
     return {
-        organizationId: normalizeOptionalString(parsedManifest.organizationId),
-        wait,
-        sources: parsedManifest.sources.map((source, index) => parseManifestSource(source, index)),
+        ...parseManifestMetadata({
+            parsedManifest,
+            topLevelFields: [],
+        }),
+        sources,
+        sheetGroups,
     };
 };
-export const loadSheetImportManifest = async ({ cwd, manifestPath, stdin, }) => {
+const loadManifest = async ({ cwd, manifestPath, parseManifest, stdin, }) => {
     if (manifestPath === '-') {
         if (isInteractiveStdin(stdin)) {
-            throw new CliCommandError('No manifest was piped on stdin. Pipe JSON into "chalksurf sheet import --manifest -".', 2);
+            throw new CliCommandError('No manifest was piped on stdin. Pipe JSON into "--manifest -".', 2);
         }
         return parseManifest(await readTextFromStdin(stdin));
     }
@@ -105,3 +245,27 @@ export const loadSheetImportManifest = async ({ cwd, manifestPath, stdin, }) =>
     }
     return parseManifest(await readFile(resolvedManifestPath, 'utf8'));
 };
+export const loadExerciseImportManifest = async ({ cwd, manifestPath, stdin, }) => {
+    return await loadManifest({
+        cwd,
+        manifestPath,
+        parseManifest: parseExerciseImportManifest,
+        stdin,
+    });
+};
+export const loadExerciseSolutionImportManifest = async ({ cwd, manifestPath, stdin, }) => {
+    return await loadManifest({
+        cwd,
+        manifestPath,
+        parseManifest: parseExerciseSolutionImportManifest,
+        stdin,
+    });
+};
+export const loadSheetImportManifest = async ({ cwd, manifestPath, stdin, }) => {
+    return await loadManifest({
+        cwd,
+        manifestPath,
+        parseManifest: parseSheetImportManifest,
+        stdin,
+    });
+};

package/dist/lib/output.js

@@ -1,3 +1,4 @@
+const cliJsonSchemaVersion = 'v1';
 const ensureTrailingNewline = (value) => {
     return value.endsWith('\n') ? value : `${value}\n`;
 };
@@ -5,16 +6,48 @@ const writeLine = (writer, value) => {
     writer.write(ensureTrailingNewline(value));
 };
 export const createOutput = ({ json, stdout, stderr, }) => {
+    let warnings = [];
+    const consumeWarnings = () => {
+        const nextWarnings = warnings;
+        warnings = [];
+        return nextWarnings;
+    };
     return {
-        print: (value, humanFormatter) => {
+        json,
+        print: (value, humanFormatter, options) => {
             if (json) {
-                writeLine(stdout, JSON.stringify(value, null, 2));
+                writeLine(stdout, JSON.stringify({
+                    schemaVersion: cliJsonSchemaVersion,
+                    command: options.command,
+                    ok: options.ok ?? true,
+                    result: value,
+                    ...(options.error ? { error: options.error } : {}),
+                    warnings: consumeWarnings(),
+                }, null, 2));
                 return;
             }
             const message = typeof humanFormatter === 'function' ? humanFormatter(value) : humanFormatter;
             writeLine(stdout, message);
         },
+        printError: ({ command, error, result }) => {
+            if (json) {
+                writeLine(stdout, JSON.stringify({
+                    schemaVersion: cliJsonSchemaVersion,
+                    command,
+                    ok: false,
+                    ...(result === undefined ? {} : { result }),
+                    error,
+                    warnings: consumeWarnings(),
+                }, null, 2));
+                return;
+            }
+            writeLine(stderr, error.message);
+        },
         info: (message) => {
+            if (json) {
+                warnings.push(message);
+                return;
+            }
             writeLine(stderr, message);
         },
         error: (message) => {

package/dist/lib/prompt-secret.js

@@ -0,0 +1,32 @@
+import { createInterface } from 'node:readline/promises';
+import { Writable } from 'node:stream';
+export const createPromptSecret = ({ input = process.stdin, output = process.stderr, } = {}) => {
+    return async (message) => {
+        let muted = false;
+        const maskedOutput = new Writable({
+            write(chunk, encoding, callback) {
+                if (!muted) {
+                    output.write(chunk, encoding);
+                }
+                callback();
+            },
+        });
+        const readline = createInterface({
+            input,
+            output: maskedOutput,
+            terminal: true,
+        });
+        try {
+            output.write(message);
+            muted = true;
+            const value = await readline.question('');
+            muted = false;
+            output.write('\n');
+            return value.trim();
+        }
+        finally {
+            muted = false;
+            readline.close();
+        }
+    };
+};

package/dist/lib/session.js

@@ -21,7 +21,7 @@ export const requireResolvedBaseUrl = ({ flagValue, env, config, }) => {
 export const requireResolvedToken = ({ env, config, }) => {
     const resolvedToken = resolveToken({ env, config });
     if (!resolvedToken.value) {
-        throw new CliCommandError(`Not authenticated. Set ${chalksurfTokenEnvVar} or run "chalksurf auth login --with-token".`, 3);
+        throw new CliCommandError(`Not authenticated. Set ${chalksurfTokenEnvVar} or run "chalksurf auth login".`, 3);
     }
     return resolvedToken;
 };