@chalksurf/cli 0.1.0 → 0.2.0

package/dist/commands/sheet.js

@@ -1,163 +1,226 @@
-import { openAsBlob } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { extname, resolve } from 'node:path';
 import { createApiClient } from '../lib/api-client.js';
 import { CliCommandError } from '../lib/cli-error.js';
-import { loadSheetImportManifest } from '../lib/manifest.js';
+import { buildFileImportCommandSources, buildFileImportFormData, normalizeWaitTimeoutMs } from '../lib/import-files.js';
+import { buildCliImportSources, formatCliImportSummary, summarizeCliImportJobs, } from '../lib/import-output.js';
+import { loadSheetImportManifest, } from '../lib/manifest.js';
 import { mapApiErrorToCliError, requireResolvedBaseUrl, requireResolvedToken, resolveRequestedOrganizationId, } from '../lib/session.js';
-import { cleanupResolvedSources, resolveSources, } from '../lib/source-resolver.js';
-import { formatCliJobSummary, getWaitExitCode, throwSilentExitCode, waitForCliJobs } from '../lib/user-jobs.js';
-const mimeTypesByExtension = {
-    '.avif': 'image/avif',
-    '.doc': 'application/msword',
-    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    '.gif': 'image/gif',
-    '.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',
+import { cleanupResolvedSources, resolveSources } from '../lib/source-resolver.js';
+import { translationLanguages } from '../lib/translation-languages.js';
+import { formatCliJobSummary, getWaitError, getWaitExitCode, throwSilentExitCode, waitForCliJobs, } from '../lib/user-jobs.js';
+const hasUniqueItems = (values) => new Set(values).size === values.length;
+const isValidTargetFolderPath = (value) => {
+    const normalizedSegments = value
+        .replaceAll('\\', '/')
+        .split('/')
+        .filter((segment) => segment.length > 0);
+    return normalizedSegments.length > 0 && normalizedSegments.every((segment) => segment !== '.' && segment !== '..');
 };
-const normalizeTimeoutMs = (timeoutMs) => {
-    const normalizedTimeoutMs = timeoutMs ?? 300000;
-    if (!Number.isFinite(normalizedTimeoutMs) || normalizedTimeoutMs <= 0) {
-        throw new CliCommandError('--timeout-ms must be a positive number.', 2);
+const assertValidSheetImportPlan = (plan) => {
+    if (plan.sheets.length === 0) {
+        throw new CliCommandError('Invalid sheet import plan: sheets must include at least one sheet.', 2);
     }
-    return normalizedTimeoutMs;
+    plan.sheets.forEach((sheet) => {
+        if (sheet.sourceIndexes.length === 0) {
+            throw new CliCommandError('Invalid sheet import plan: sourceIndexes must include at least one source.', 2);
+        }
+        if (!sheet.sourceIndexes.every((sourceIndex) => Number.isInteger(sourceIndex) && sourceIndex >= 0)) {
+            throw new CliCommandError('Invalid sheet import plan: sourceIndexes must contain only non-negative integers.', 2);
+        }
+        if (!hasUniqueItems(sheet.sourceIndexes)) {
+            throw new CliCommandError('Invalid sheet import plan: sourceIndexes must be unique within a sheet.', 2);
+        }
+        if (sheet.targetFolderPath !== null && !isValidTargetFolderPath(sheet.targetFolderPath)) {
+            throw new CliCommandError('Invalid sheet import plan: targetFolderPath must be a normalized folder path without "." or ".." segments.', 2);
+        }
+        if (sheet.translateToLanguages && !hasUniqueItems(sheet.translateToLanguages)) {
+            throw new CliCommandError('Invalid sheet import plan: translateToLanguages must be unique.', 2);
+        }
+    });
 };
-const guessMimeType = (fileName) => {
-    return mimeTypesByExtension[extname(fileName).toLowerCase()] ?? 'application/octet-stream';
+const normalizeOptionalTitle = (value) => {
+    const normalizedValue = value?.trim();
+    if (!normalizedValue) {
+        return undefined;
+    }
+    return normalizedValue;
 };
-const isHttpUrl = (value) => {
-    try {
-        const parsedUrl = new URL(value);
-        return ['http:', 'https:'].includes(parsedUrl.protocol);
+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);
     }
-    catch {
-        return false;
+    return languages;
+};
+const normalizeOptionalTargetFolderPath = (value) => {
+    const normalizedValue = value?.trim();
+    if (!normalizedValue) {
+        return null;
     }
+    return normalizedValue;
 };
-const buildFormData = async (resolvedSources) => {
-    const formData = new FormData();
-    await Promise.all(resolvedSources.map(async (resolvedSource, index) => {
-        const 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;
+const getFolderPathFromRelativePath = (relativePath) => {
+    const normalizedSegments = relativePath
+        .replaceAll('\\', '/')
+        .split('/')
+        .filter((segment) => segment.length > 0);
+    if (normalizedSegments.length <= 1) {
+        return null;
+    }
+    return normalizedSegments.slice(0, -1).join('/');
 };
-const buildCommandSources = async ({ cwd, manifestPath, rawSources, relativePath, stdin, wait, }) => {
-    if (manifestPath && rawSources.length > 0) {
-        throw new CliCommandError('Pass positional sources or --manifest, not both.', 2);
+const assertSheetImportFlagUsage = ({ manifestPath, singleSheet, sources, targetFolderPath, title, translateTo, }) => {
+    if (manifestPath && singleSheet) {
+        throw new CliCommandError('--single-sheet cannot be used with --manifest. Define grouped sheet imports in the manifest.', 2);
+    }
+    if (manifestPath && targetFolderPath !== null) {
+        throw new CliCommandError('--target-folder cannot be used with --manifest. Set targetFolderPath in the manifest.', 2);
     }
-    if (manifestPath && relativePath) {
-        throw new CliCommandError('--relative-path can only be used with a single positional source.', 2);
+    if (targetFolderPath !== null && !singleSheet) {
+        throw new CliCommandError('--target-folder can only be used with --single-sheet.', 2);
+    }
+    if (!title && !translateTo) {
+        return;
     }
     if (manifestPath) {
-        const manifest = await loadSheetImportManifest({
-            cwd,
-            manifestPath,
-            stdin,
-        });
-        return {
-            organizationId: manifest.organizationId,
-            sources: manifest.sources,
-            wait: wait || manifest.wait === true,
-        };
+        throw new CliCommandError('--title and --translate-to cannot be used with --manifest. Set the import metadata in the manifest instead.', 2);
     }
-    if (rawSources.length === 0) {
-        throw new CliCommandError('At least one source or --manifest is required.', 2);
+    if (!singleSheet && (sources.length !== 1 || sources[0]?.kind === 'directory')) {
+        throw new CliCommandError('--title and --translate-to can only be used with a single non-directory source. Use --manifest for multi-source imports.', 2);
     }
-    if (relativePath && rawSources.length !== 1) {
-        throw new CliCommandError('--relative-path can only be used with a single positional source.', 2);
+};
+const buildSheetImportSources = ({ sources, title, translateTo, }) => {
+    if (!title && !translateTo) {
+        return sources;
     }
-    const sources = [];
-    for (const rawSource of rawSources) {
-        if (isHttpUrl(rawSource)) {
-            sources.push({
-                kind: 'url',
-                url: rawSource,
-                relativePath,
-            });
-            continue;
+    return sources.map((source, index) => {
+        if (index !== 0) {
+            return source;
         }
-        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;
+        return {
+            ...source,
+            title,
+            translateTo,
+        };
+    });
+};
+const buildSourceIndexesByInputIndex = (sources) => {
+    const sourceIndexesByInputIndex = new Map();
+    sources.forEach((source) => {
+        const sourceIndexes = sourceIndexesByInputIndex.get(source.sourceInputIndex) ?? [];
+        sourceIndexes.push(source.sourceIndex);
+        sourceIndexesByInputIndex.set(source.sourceInputIndex, sourceIndexes);
+    });
+    return sourceIndexesByInputIndex;
+};
+const resolveGroupedSourceIndexes = ({ groups, sourceIndexesByInputIndex, }) => {
+    return groups.map((group, groupIndex) => {
+        const sourceIndexes = group.sourceInputIndexes.flatMap((sourceInputIndex) => {
+            const resolvedSourceIndexes = sourceIndexesByInputIndex.get(sourceInputIndex);
+            if (!resolvedSourceIndexes || resolvedSourceIndexes.length === 0) {
+                throw new CliCommandError(`Manifest sheet at index ${groupIndex} references source index ${sourceInputIndex}, but it resolved to no files.`, 2);
             }
+            return resolvedSourceIndexes;
+        });
+        return {
+            sourceIndexes,
+            targetFolderPath: group.targetFolderPath,
+            titleOverride: group.title,
+            translateToLanguages: group.translateTo,
+        };
+    });
+};
+const buildSheetImportPlan = ({ groupedManifestSheets, requestedTargetFolderPath, requestedTitle, requestedTranslateTo, singleSheet, sources, }) => {
+    const sourceIndexesByInputIndex = buildSourceIndexesByInputIndex(sources);
+    const rawPlan = groupedManifestSheets
+        ? {
+            sheets: resolveGroupedSourceIndexes({
+                groups: groupedManifestSheets,
+                sourceIndexesByInputIndex,
+            }),
         }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                throw error;
+        : singleSheet
+            ? {
+                sheets: [
+                    {
+                        sourceIndexes: sources.map((source) => source.sourceIndex),
+                        targetFolderPath: requestedTargetFolderPath,
+                        titleOverride: requestedTitle,
+                        translateToLanguages: requestedTranslateTo,
+                    },
+                ],
             }
-        }
-        sources.push({
-            kind: 'local',
-            path: rawSource,
-            relativePath,
-        });
-    }
-    return {
-        organizationId: undefined,
-        sources,
-        wait: wait === true,
-    };
+            : {
+                sheets: sources.map((source) => ({
+                    sourceIndexes: [source.sourceIndex],
+                    targetFolderPath: getFolderPathFromRelativePath(source.relativePath),
+                    titleOverride: source.title,
+                    translateToLanguages: source.translateTo,
+                })),
+            };
+    assertValidSheetImportPlan(rawPlan);
+    return rawPlan;
 };
-const buildSheetImportJobs = ({ importResultJobs, resolvedSources, waitedJobsById, }) => {
+const buildSheetImportJobs = ({ importResultJobs, sources, waitedJobsById, }) => {
     return importResultJobs.map((job, index) => {
-        const source = resolvedSources[index];
+        const sourceIndexes = job.sourceIndexes ?? (sources[index] ? [sources[index].sourceIndex] : []);
         const waitedJob = waitedJobsById?.get(job.jobId);
         return {
             jobId: job.jobId,
-            fileName: job.fileName,
-            relativePath: job.relativePath,
-            source: {
-                kind: source?.kind ?? 'local',
-                input: source?.input ?? job.relativePath,
-                relativePath: source?.relativePath ?? job.relativePath,
-            },
-            status: waitedJob?.status,
+            sourceIndexes,
+            sourceIds: Array.from(new Set(sourceIndexes
+                .map((sourceIndex) => sources[sourceIndex]?.sourceId)
+                .filter((sourceId) => sourceId != null))),
+            status: waitedJob?.status ?? 'queued',
             error: waitedJob?.error,
             exerciseSheetId: waitedJob?.exerciseSheetId,
         };
     });
 };
-const formatQueuedImportOutput = (jobs) => {
+const buildSheetImportRequest = ({ inputMode, organizationId, timeoutMs, wait, }) => {
+    return {
+        organizationId,
+        inputMode,
+        wait,
+        timeoutMs,
+        target: {},
+    };
+};
+const formatSheetJobSourceLabel = ({ job, sources, }) => {
+    if (job.sourceIndexes.length !== 1) {
+        return `${job.sourceIndexes.length} source${job.sourceIndexes.length === 1 ? '' : 's'}`;
+    }
+    const firstSource = sources[job.sourceIndexes[0]];
+    return firstSource?.relativePath ?? 'unknown source';
+};
+const formatQueuedImportOutput = ({ jobs, summary, sources, }) => {
     return [
         `Queued ${jobs.length} import${jobs.length === 1 ? '' : 's'}.`,
-        ...jobs.map((job) => `${job.jobId}  ${job.relativePath}`),
+        ...jobs.map((job) => `${job.jobId}  ${formatSheetJobSourceLabel({ job, sources })}`),
+        jobs.length > 1 ? formatCliImportSummary(summary) : null,
     ]
         .filter(Boolean)
         .join('\n');
 };
-const formatWaitedImportOutput = (jobs) => {
+const formatWaitedImportOutput = ({ jobs, summary, }) => {
     return [
         `${jobs.length} job${jobs.length === 1 ? '' : 's'} queued.`,
         ...jobs.map((job) => formatCliJobSummary({
             id: job.jobId,
-            status: job.status ?? 'pending',
+            status: job.status === 'queued' ? 'pending' : job.status,
             type: 'exercise_sheet_import',
             createdAt: '',
             updatedAt: '',
             error: job.error,
             exerciseSheetId: job.exerciseSheetId,
         })),
+        jobs.length > 1 ? formatCliImportSummary(summary) : null,
     ]
         .filter(Boolean)
         .join('\n');
@@ -177,6 +240,24 @@ export const registerSheetCommands = (sheetYargs, context) => {
         .option('relative-path', {
         type: 'string',
         describe: 'Override the relative path for a single positional source',
+    })
+        .option('single-sheet', {
+        type: 'boolean',
+        default: false,
+        describe: 'Import all positional sources into one sheet',
+    })
+        .option('target-folder', {
+        type: 'string',
+        describe: 'Place a --single-sheet import into this destination folder (defaults to root)',
+    })
+        .option('title', {
+        type: 'string',
+        describe: 'Override the imported title for a single-sheet import',
+    })
+        .option('translate-to', {
+        array: true,
+        type: 'string',
+        describe: `Generate translated sheet content for these languages (${translationLanguages.join(', ')})`,
     })
         .option('timeout-ms', {
         type: 'number',
@@ -187,7 +268,14 @@ export const registerSheetCommands = (sheetYargs, context) => {
         type: 'boolean',
         default: false,
         describe: 'Wait for the queued jobs to finish',
-    }), async (argv) => {
+    })
+        .example('chalksurf sheet import ./fixtures/algebra.pdf --title "OKTV 2014 Round 1" --translate-to english --wait', 'Import a sheet, override its title, and request an English translation')
+        .example('chalksurf sheet import ./fixtures/round-1-a.pdf ./fixtures/round-1-b.pdf --single-sheet --target-folder Contests --wait', 'Import multiple source files into one sheet and place the result into a target folder')
+        .example('cat sheet-import.json | chalksurf sheet import --manifest - --wait --json', 'Drive multi-source sheet imports from a manifest in an agent or CI flow')
+        .epilogue([
+        'When --wait is set, the command exits only after the full requested import is complete.',
+        'For translated sheet imports, that includes generating and storing the requested translations.',
+    ].join('\n')), async (argv) => {
         const config = await context.configStore.load();
         const rawSources = (argv.sources ?? []).map(String);
         const manifestPath = argv.manifest === '' ? '-' : argv.manifest;
@@ -201,14 +289,32 @@ export const registerSheetCommands = (sheetYargs, context) => {
             env: context.env,
             config,
         });
-        const commandSources = await buildCommandSources({
+        const commandSources = await buildFileImportCommandSources({
             cwd: context.cwd,
+            loadManifest: loadSheetImportManifest,
             manifestPath,
             rawSources: normalizedRawSources,
             relativePath: argv.relativePath,
             stdin: context.stdin,
             wait: argv.wait,
         });
+        const requestedTitle = normalizeOptionalTitle(argv.title);
+        const requestedTranslateTo = resolveRequestedTranslateToLanguages(argv.translateTo);
+        const requestedTargetFolderPath = normalizeOptionalTargetFolderPath(argv.targetFolder);
+        const singleSheet = argv.singleSheet === true;
+        assertSheetImportFlagUsage({
+            manifestPath,
+            singleSheet,
+            sources: commandSources.sources,
+            targetFolderPath: requestedTargetFolderPath,
+            title: requestedTitle,
+            translateTo: requestedTranslateTo,
+        });
+        const sheetSources = buildSheetImportSources({
+            sources: commandSources.sources,
+            title: requestedTitle,
+            translateTo: requestedTranslateTo,
+        });
         const organizationId = resolveRequestedOrganizationId({
             flagValue: argv.organization,
             fallbackValue: commandSources.organizationId,
@@ -219,16 +325,36 @@ export const registerSheetCommands = (sheetYargs, context) => {
             baseUrl: resolvedBaseUrl.value,
             token: resolvedToken.value,
             organizationId,
-            fetchImpl: context.fetchImpl,
         });
         let resolvedSources = [];
         try {
             resolvedSources = await resolveSources({
                 cwd: context.cwd,
-                fetchImpl: context.fetchImpl,
-                sources: commandSources.sources,
+                sources: sheetSources,
+            });
+            const sources = buildCliImportSources({
+                resolvedSources,
+                getExtra: (resolvedSource) => ({
+                    title: resolvedSource.sourceInput.title,
+                    translateTo: resolvedSource.sourceInput.translateTo,
+                }),
+            });
+            const formData = await buildFileImportFormData(resolvedSources);
+            const sheetImportPlan = buildSheetImportPlan({
+                groupedManifestSheets: commandSources.sheetGroups,
+                requestedTargetFolderPath,
+                requestedTitle,
+                requestedTranslateTo,
+                singleSheet,
+                sources,
+            });
+            formData.set('sheetImportPlan', JSON.stringify(sheetImportPlan));
+            const request = buildSheetImportRequest({
+                inputMode: manifestPath ? 'manifest' : 'arguments',
+                organizationId: organizationId ?? null,
+                timeoutMs: commandSources.wait ? normalizeWaitTimeoutMs(argv.timeoutMs) : null,
+                wait: commandSources.wait,
             });
-            const formData = await buildFormData(resolvedSources);
             let importResult;
             try {
                 importResult = await apiClient.importExerciseSheet(formData);
@@ -239,34 +365,65 @@ export const registerSheetCommands = (sheetYargs, context) => {
             if (!commandSources.wait) {
                 const jobs = buildSheetImportJobs({
                     importResultJobs: importResult.jobs,
-                    resolvedSources,
+                    sources,
+                });
+                const summary = summarizeCliImportJobs({
+                    jobs,
+                    sourceCount: sources.length,
+                    sourceInputCount: sheetSources.length,
+                    timedOut: false,
                 });
                 context.output.print({
-                    organizationId: organizationId ?? null,
+                    request,
+                    sources,
                     jobs,
-                    waited: false,
-                }, (result) => formatQueuedImportOutput(result.jobs));
+                    summary,
+                }, (result) => formatQueuedImportOutput({
+                    jobs: result.jobs,
+                    summary: result.summary,
+                    sources: result.sources,
+                }), {
+                    command: 'sheet import',
+                });
                 return;
             }
+            const waitTimeoutMs = normalizeWaitTimeoutMs(argv.timeoutMs);
             const waitResult = await waitForCliJobs({
                 getUserJob: async (jobId) => await apiClient.getUserJob(jobId),
                 jobIds: importResult.jobs.map((job) => job.jobId),
                 now: context.now,
                 sleep: context.sleep,
-                timeoutMs: normalizeTimeoutMs(argv.timeoutMs),
+                timeoutMs: waitTimeoutMs,
             });
             const waitedJobsById = new Map(waitResult.jobs.map((job) => [job.id, job]));
             const jobs = buildSheetImportJobs({
                 importResultJobs: importResult.jobs,
-                resolvedSources,
+                sources,
                 waitedJobsById,
             });
-            context.output.print({
-                organizationId: organizationId ?? null,
+            const summary = summarizeCliImportJobs({
                 jobs,
+                sourceCount: sources.length,
+                sourceInputCount: sheetSources.length,
                 timedOut: waitResult.timedOut,
-                waited: true,
-            }, (result) => formatWaitedImportOutput(result.jobs));
+            });
+            const waitError = getWaitError(waitResult);
+            context.output.print({
+                request: {
+                    ...request,
+                    timeoutMs: waitTimeoutMs,
+                },
+                sources,
+                jobs,
+                summary,
+            }, (result) => formatWaitedImportOutput({
+                jobs: result.jobs,
+                summary: result.summary,
+            }), {
+                command: 'sheet import',
+                ok: waitError == null,
+                error: waitError,
+            });
             throwSilentExitCode(getWaitExitCode(waitResult));
         }
         finally {

package/dist/lib/api-client.js

@@ -18,7 +18,7 @@ const getResponseData = async ({ response, batched }) => {
     }
     return payload.result.data;
 };
-export const createApiClient = ({ baseUrl, token, organizationId, fetchImpl = fetch, }) => {
+export const createApiClient = ({ baseUrl, token, organizationId, }) => {
     const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
     const createHeaders = ({ includeJsonContentType }) => {
         const headers = new Headers();
@@ -37,7 +37,7 @@ export const createApiClient = ({ baseUrl, token, organizationId, fetchImpl = fe
         const url = new URL(`trpc/${procedureName}`, normalizedBaseUrl);
         url.searchParams.set('batch', '1');
         url.searchParams.set('input', JSON.stringify({ 0: input ?? null }));
-        const response = await fetchImpl(url.toString(), {
+        const response = await fetch(url.toString(), {
             method: 'GET',
             headers: createHeaders({ includeJsonContentType: false }),
         });
@@ -45,7 +45,7 @@ export const createApiClient = ({ baseUrl, token, organizationId, fetchImpl = fe
     };
     const mutation = async (procedureName, input) => {
         const isFormDataInput = input instanceof FormData;
-        const response = await fetchImpl(new URL(`trpc/${procedureName}`, normalizedBaseUrl).toString(), {
+        const response = await fetch(new URL(`trpc/${procedureName}`, normalizedBaseUrl).toString(), {
             method: 'POST',
             headers: createHeaders({ includeJsonContentType: !isFormDataInput }),
             body: isFormDataInput ? input : JSON.stringify(input ?? {}),
@@ -67,5 +67,11 @@ export const createApiClient = ({ baseUrl, token, organizationId, fetchImpl = fe
         importExerciseSheet: async (formData) => {
             return await mutation('importExerciseSheet', formData);
         },
+        importExercise: async (formData) => {
+            return await mutation('importExercise', formData);
+        },
+        importExerciseSolution: async (formData) => {
+            return await mutation('importExerciseSolution', formData);
+        },
     };
 };

package/dist/lib/cli-error.js

@@ -1,10 +1,46 @@
+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) {
+    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,
+    });
+};