@chalksurf/cli 0.2.0 → 0.2.2

package/README.md

@@ -2,20 +2,20 @@
 
 Publishable ChalkSurf CLI package.
 
-Current internal release line: `0.1.0`. Expect breaking changes while the CLI is still only used internally.
+Current internal release line: `0.2.2`. Expect breaking changes while the CLI is still only used internally.
 
 ## Installation
 
 Run the published CLI without a global install:
 
 ```bash
-npx @chalksurf/cli@0.1.0 --help
+npx @chalksurf/cli@0.2.2 --help
 ```
 
 Install it globally when you want a persistent local binary:
 
 ```bash
-npm install -g @chalksurf/cli@0.1.0
+npm install -g @chalksurf/cli@0.2.2
 chalksurf --version
 ```
 
@@ -24,7 +24,8 @@ chalksurf --version
 Interactive operator flow:
 
 ```bash
-chalksurf auth login --base-url https://api.chalksurf.com
+chalksurf auth login --profile prod-cztamas --base-url https://chalksurf-api.fly.dev
+chalksurf profile use prod-cztamas
 chalksurf org list
 chalksurf sheet import ./fixtures/algebra.pdf --wait
 ```
@@ -32,38 +33,41 @@ chalksurf sheet import ./fixtures/algebra.pdf --wait
 Headless or agent flow:
 
 ```bash
-CHALKSURF_BASE_URL=https://api.chalksurf.com \
 CHALKSURF_TOKEN=cs_cli_... \
-CHALKSURF_ORGANIZATION_ID=org_123 \
-npx @chalksurf/cli@0.1.0 sheet import --manifest - --wait --json < import.json
+printf '%s' "$CHALKSURF_TOKEN" | npx @chalksurf/cli@0.2.2 auth login \
+  --profile prod-codex \
+  --base-url https://chalksurf-api.fly.dev \
+  --with-token
+
+npx @chalksurf/cli@0.2.2 --profile prod-codex sheet import --manifest - --wait --json < import.json
 ```
 
-Sheet import manifests use top-level `sheets[]`, where each sheet has one `targetFolderPath` and one or more ordered `sources[]`. See [the canonical example](./docs/examples/sheet-import-manifest.json).
+Sheet import manifests use top-level `sheets[]`, where each sheet has one `targetFolderPath` and one or more ordered `sources[]`. See [the canonical example](./packages/cli/docs/examples/sheet-import-manifest.json).
 
 ## Docs
 
-- [Manual operator guide](./docs/manual.md)
-- [Agent and Codex guide](./docs/agents.md)
-- [Manifest reference](./docs/manifest.md)
-- [Exit codes and JSON errors](./docs/exit-codes.md)
-- [Sheet import schema](./schemas/sheet-import-manifest.schema.json)
-- [Exercise import schema](./schemas/exercise-import-manifest.schema.json)
-- [Exercise solution import schema](./schemas/exercise-solution-import-manifest.schema.json)
+- [Manual operator guide](./packages/cli/docs/manual.md)
+- [Agent and Codex guide](./packages/cli/docs/agents.md)
+- [Manifest reference](./packages/cli/docs/manifest.md)
+- [Exit codes and JSON errors](./packages/cli/docs/exit-codes.md)
+- [Sheet import schema](./packages/cli/schemas/sheet-import-manifest.schema.json)
+- [Exercise import schema](./packages/cli/schemas/exercise-import-manifest.schema.json)
+- [Exercise solution import schema](./packages/cli/schemas/exercise-solution-import-manifest.schema.json)
+- [Exercise sheet solution import schema](./packages/cli/schemas/exercise-sheet-solution-import-manifest.schema.json)
 
 ## Local And Staging Testing
 
-Use separate config files per environment so local and staging tokens do not overwrite each other:
+Use separate profiles so local, staging, production, human, and agent tokens do not overwrite each other:
 
 ```bash
-export CHALKSURF_CONFIG_PATH=/tmp/chalksurf-local.json
-npm run cli-dev -- auth login --base-url http://localhost:8080
+npm run cli-dev -- auth login --profile dev-cztamas --base-url http://localhost:8080
+npm run cli-dev -- profile use dev-cztamas
 npm run cli-dev -- auth status --json
 npm run cli-dev -- sheet import ./fixtures/algebra.pdf --wait --json
 ```
 
 ```bash
-export CHALKSURF_CONFIG_PATH=/tmp/chalksurf-staging.json
-npm run cli-dev -- auth login --base-url https://staging-api.chalksurf.com
-npm run cli-dev -- auth status --json
-npm run cli-dev -- sheet import https://example.com/worksheet.docx --single-sheet --target-folder Imported --json
+npm run cli-dev -- auth login --profile staging-codex --base-url https://chalksurf-api-staging.fly.dev
+npm run cli-dev -- --profile staging-codex auth status --json
+npm run cli-dev -- --profile staging-codex sheet import https://example.com/worksheet.docx --single-sheet --target-folder Imported --json
 ```

package/dist/bin/chalksurf.js

@@ -7,13 +7,15 @@ import { registerAuthCommands } from '../commands/auth.js';
 import { registerExerciseCommands } from '../commands/exercise.js';
 import { registerJobCommands } from '../commands/job.js';
 import { registerOrgCommands } from '../commands/org.js';
+import { registerProfileCommands } from '../commands/profile.js';
 import { registerSheetCommands } from '../commands/sheet.js';
 import { CliCommandError, createSerializableCliError, serializeCliError } from '../lib/cli-error.js';
 import { createConfigStore } from '../lib/config-store.js';
 import { createOutput } from '../lib/output.js';
 import { createPromptSecret } from '../lib/prompt-secret.js';
 const packageJson = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
-const createCli = ({ cwd, configPath, env, now, output, sleep, stdin, promptSecret, }) => {
+const createCli = ({ cwd, configPath, env, now, output, sleep, stdin, }) => {
+    const promptSecret = createPromptSecret();
     const commandContext = {
         cwd,
         configStore: createConfigStore({ configPath, env }),
@@ -42,6 +44,11 @@ const createCli = ({ cwd, configPath, env, now, output, sleep, stdin, promptSecr
         type: 'string',
         global: true,
         describe: 'Organization ID to use for this command',
+    })
+        .option('profile', {
+        type: 'string',
+        global: true,
+        describe: 'CLI profile to use for this command',
     })
         .option('version', {
         type: 'boolean',
@@ -50,6 +57,7 @@ const createCli = ({ cwd, configPath, env, now, output, sleep, stdin, promptSecr
     })
         .command('auth <subcommand>', 'Authentication commands', (authYargs) => registerAuthCommands(authYargs, commandContext), () => { })
         .command('org <subcommand>', 'Organization commands', (orgYargs) => registerOrgCommands(orgYargs, commandContext), () => { })
+        .command('profile <subcommand>', 'Profile commands', (profileYargs) => registerProfileCommands(profileYargs, commandContext), () => { })
         .command('exercise <subcommand>', 'Exercise commands', (exerciseYargs) => registerExerciseCommands(exerciseYargs, commandContext), () => { })
         .command('sheet <subcommand>', 'Exercise sheet commands', (sheetYargs) => registerSheetCommands(sheetYargs, commandContext), () => { })
         .command('job <subcommand>', 'Job commands', (jobYargs) => registerJobCommands(jobYargs, commandContext), () => { })
@@ -74,7 +82,7 @@ const parseCliWithCapturedOutput = async ({ cli, argv, stdout, }) => {
 const hasFlag = (argv, flags) => {
     return argv.some((argument) => flags.includes(argument));
 };
-const topLevelCommands = new Set(['auth', 'org', 'exercise', 'sheet', 'job']);
+const topLevelCommands = new Set(['auth', 'org', 'profile', 'exercise', 'sheet', 'job']);
 const hasTopLevelCommand = (argv) => {
     return argv.some((argument) => topLevelCommands.has(argument));
 };
@@ -94,7 +102,7 @@ const resolveCommandName = (argv) => {
     }
     return 'chalksurf';
 };
-export const runCli = async ({ argv, cwd = process.cwd(), configPath, env = process.env, nowImpl = Date.now, promptSecretImpl = createPromptSecret(), sleepImpl = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)), stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, }) => {
+export const runCli = async ({ argv, cwd = process.cwd(), configPath, env = process.env, nowImpl = Date.now, sleepImpl = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)), stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, }) => {
     const output = createOutput({
         json: hasFlag(argv, ['--json']),
         stdout,
@@ -107,7 +115,6 @@ export const runCli = async ({ argv, cwd = process.cwd(), configPath, env = proc
         env,
         now: nowImpl,
         output,
-        promptSecret: promptSecretImpl,
         sleep: sleepImpl,
         stdin,
     });

package/dist/commands/auth.js

@@ -38,10 +38,10 @@ export const registerAuthCommands = (authYargs, context) => {
             default: false,
             describe: 'Read the token from stdin when piping input',
         })
-            .example('chalksurf auth login --base-url https://api.chalksurf.com', 'Prompt for a CLI token and store it locally')
-            .example(`printf '%s' "$CHALKSURF_TOKEN" | chalksurf auth login --base-url https://api.chalksurf.com`, 'Read a CLI token from stdin instead of prompting');
+            .example('chalksurf auth login --profile prod-cztamas --base-url https://chalksurf-api.fly.dev', 'Prompt for a CLI token and store it in the prod-cztamas profile')
+            .example(`printf '%s' "$CHALKSURF_TOKEN" | chalksurf auth login --profile prod-codex --base-url https://chalksurf-api.fly.dev`, 'Read a CLI token from stdin into an explicit profile');
     }, async (argv) => {
-        const config = await context.configStore.load();
+        const config = await context.configStore.loadProfile({ profileName: argv.profile });
         const resolvedBaseUrl = requireResolvedBaseUrl({
             flagValue: argv.baseUrl,
             env: context.env,
@@ -70,7 +70,7 @@ export const registerAuthCommands = (authYargs, context) => {
             config,
             profile,
         });
-        await context.configStore.update((currentConfig) => ({
+        await context.configStore.update({ profileName: argv.profile }, (currentConfig) => ({
             ...currentConfig,
             token,
             baseUrl: resolvedBaseUrl.value,
@@ -84,6 +84,8 @@ export const registerAuthCommands = (authYargs, context) => {
             baseUrl: resolvedBaseUrl.value,
             baseUrlSource: resolvedBaseUrl.source,
             organization: serializeOrganization(resolvedOrganization.organization),
+            profile: config.profileName,
+            profileSource: config.profileSource,
             user: {
                 email: profile.email,
                 id: profile.id,
@@ -95,14 +97,15 @@ export const registerAuthCommands = (authYargs, context) => {
     })
         .command('status', 'Show the current authentication and organization state', (statusYargs) => statusYargs
         .example('chalksurf auth status', 'Show the current authenticated user and default organization')
-        .example('CHALKSURF_BASE_URL=https://api.chalksurf.com CHALKSURF_TOKEN=cs_cli_... chalksurf auth status --json', 'Inspect the active session in machine-readable mode')
+        .example('chalksurf --profile prod-codex auth status --json', 'Inspect a specific profile in machine-readable mode')
         .epilogue([
         'Resolution order:',
-        '  base URL: --base-url, then CHALKSURF_BASE_URL, then stored config',
-        '  token: CHALKSURF_TOKEN, then stored config',
-        '  organization: --organization, then CHALKSURF_ORGANIZATION_ID, then stored config',
+        '  profile: --profile, then CHALKSURF_PROFILE, then stored default profile',
+        '  base URL: --base-url, then CHALKSURF_BASE_URL, then active profile',
+        '  token: CHALKSURF_TOKEN, then active profile',
+        '  organization: --organization, then CHALKSURF_ORGANIZATION_ID, then active profile',
     ].join('\n')), async (argv) => {
-        const config = await context.configStore.load();
+        const config = await context.configStore.loadProfile({ profileName: argv.profile });
         const resolvedBaseUrl = requireResolvedBaseUrl({
             flagValue: argv.baseUrl,
             env: context.env,
@@ -138,6 +141,8 @@ export const registerAuthCommands = (authYargs, context) => {
             baseUrlSource: resolvedBaseUrl.source,
             organization: serializeOrganization(resolvedOrganization.organization),
             organizationSource: resolvedOrganization.source,
+            profile: config.profileName,
+            profileSource: config.profileSource,
             tokenSource: resolvedToken.source,
             user: {
                 email: profile.email,
@@ -148,16 +153,18 @@ export const registerAuthCommands = (authYargs, context) => {
             command: 'auth status',
         });
     })
-        .command('logout', 'Remove the locally stored CLI token', (logoutYargs) => logoutYargs.example('chalksurf auth logout', 'Remove the stored CLI token from local config'), async () => {
-        const config = await context.configStore.load();
+        .command('logout', 'Remove the locally stored CLI token', (logoutYargs) => logoutYargs.example('chalksurf auth logout', 'Remove the stored CLI token from local config'), async (argv) => {
+        const config = await context.configStore.loadProfile({ profileName: argv.profile });
         const hadStoredToken = Boolean(config.token);
-        await context.configStore.update((currentConfig) => ({
+        await context.configStore.update({ profileName: argv.profile }, (currentConfig) => ({
             ...currentConfig,
             token: undefined,
         }));
         context.output.print({
             clearedStoredToken: hadStoredToken,
             loggedOut: true,
+            profile: config.profileName,
+            profileSource: config.profileSource,
         }, hadStoredToken ? 'Stored CLI token removed.' : 'No stored CLI token was present.', {
             command: 'auth logout',
         });

package/dist/commands/exercise.js

@@ -1,12 +1,39 @@
 import { z } from 'zod';
 import { createApiClient } from '../lib/api-client.js';
 import { CliCommandError } from '../lib/cli-error.js';
+import { normalizeChoiceValues, normalizeLimit, normalizeOffset, normalizeOptionalInteger, normalizeOptionalText, normalizeOwnership, normalizeStringValues, toApiOwnership, } from '../lib/command-options.js';
 import { buildFileImportCommandSources, buildFileImportFormData, normalizeWaitTimeoutMs } from '../lib/import-files.js';
-import { buildCliImportSources, summarizeCliImportJobs, } from '../lib/import-output.js';
+import { buildCliImportSources, formatCliImportTranslationJobs, summarizeCliImportJobs, } from '../lib/import-output.js';
 import { loadExerciseImportManifest, loadExerciseSolutionImportManifest } from '../lib/manifest.js';
-import { mapApiErrorToCliError, requireResolvedBaseUrl, requireResolvedToken, resolveRequestedOrganizationId, } from '../lib/session.js';
+import { createResolvedApiClient, mapApiErrorToCliError, requireResolvedBaseUrl, requireResolvedToken, resolveRequestedOrganizationId, } from '../lib/session.js';
 import { cleanupResolvedSources, resolveSources } from '../lib/source-resolver.js';
+import { resolveRequestedTranslateToLanguages, translationLanguages, } from '../lib/translation-languages.js';
 import { getWaitError, getWaitExitCode, throwSilentExitCode, waitForCliJobs } from '../lib/user-jobs.js';
+const exerciseStatusOptions = ['verified', 'unverified', 'invalid'];
+const getExerciseTextPreview = ({ exercise, language }) => {
+    if (language && exercise.text[language]) {
+        return exercise.text[language];
+    }
+    return Object.values(exercise.text)[0] ?? '';
+};
+const formatExerciseSearchOutput = ({ exercises, language, totalCount, }) => {
+    if (exercises.length === 0) {
+        return 'No exercises found.';
+    }
+    return [
+        `${exercises.length} of ${totalCount} exercise${totalCount === 1 ? '' : 's'} returned.`,
+        ...exercises.map((exercise) => {
+            const preview = getExerciseTextPreview({ exercise, language }).replace(/\s+/g, ' ').trim();
+            const labels = exercise.labels.length > 0 ? ` [${exercise.labels.join(', ')}]` : '';
+            return `${exercise.id}  ${exercise.status}${labels}${preview ? `  ${preview}` : ''}`;
+        }),
+    ].join('\n');
+};
+const normalizeSearchNumberRange = ({ maxDifficulty, minDifficulty, }) => {
+    if (minDifficulty !== null && maxDifficulty !== null && minDifficulty > maxDifficulty) {
+        throw new CliCommandError('--min-difficulty cannot be greater than --max-difficulty.', 2);
+    }
+};
 const resolveRequestedUuid = ({ flagValue, fallbackValue, label, required = false, }) => {
     const resolvedValue = flagValue?.trim() || fallbackValue?.trim();
     if (!resolvedValue) {
@@ -50,6 +77,7 @@ const buildWaitedExerciseImportJob = ({ jobId, sources, waitedJob, }) => {
         error: waitedJob?.error,
         exerciseId: waitedJob?.exerciseId,
         exerciseIds: waitedJob?.exerciseIds,
+        translationJobs: waitedJob?.translationJobs,
     };
 };
 const formatQueuedImportOutput = (job) => {
@@ -66,13 +94,17 @@ const formatQueuedSolutionImportOutput = (job) => {
 };
 const formatWaitedImportOutput = (job) => {
     if (job.status === 'completed') {
+        const translationJobLines = formatCliImportTranslationJobs(job.translationJobs);
         if (job.exerciseIds && job.exerciseIds.length > 0) {
-            return `${job.jobId} completed -> ${job.exerciseIds.length} exercise${job.exerciseIds.length === 1 ? '' : 's'}`;
+            return [
+                `${job.jobId} completed -> ${job.exerciseIds.length} exercise${job.exerciseIds.length === 1 ? '' : 's'}`,
+                ...translationJobLines,
+            ].join('\n');
         }
         if (job.exerciseId) {
-            return `${job.jobId} completed -> ${job.exerciseId}`;
+            return [`${job.jobId} completed -> ${job.exerciseId}`, ...translationJobLines].join('\n');
         }
-        return `${job.jobId} completed`;
+        return [`${job.jobId} completed`, ...translationJobLines].join('\n');
     }
     if (job.status === 'failed') {
         return `${job.jobId} failed -> ${job.error ?? 'Unknown error'}`;
@@ -81,6 +113,133 @@ const formatWaitedImportOutput = (job) => {
 };
 export const registerExerciseCommands = (exerciseYargs, context) => {
     return exerciseYargs
+        .command('search', 'Search exercises visible to the selected organization', (searchYargs) => searchYargs
+        .option('text', {
+        type: 'string',
+        describe: 'Search exercise text. Requires --language.',
+    })
+        .option('language', {
+        type: 'string',
+        describe: 'Language to search or preview, such as english or hungarian',
+    })
+        .option('semantic', {
+        type: 'string',
+        describe: 'Run semantic search with this query text',
+    })
+        .option('label', {
+        array: true,
+        type: 'string',
+        describe: 'Require an exercise label or label prefix',
+    })
+        .option('age', {
+        type: 'number',
+        describe: 'Filter exercises appropriate for this age',
+    })
+        .option('min-difficulty', {
+        type: 'number',
+        describe: 'Minimum difficulty',
+    })
+        .option('max-difficulty', {
+        type: 'number',
+        describe: 'Maximum difficulty',
+    })
+        .option('status', {
+        array: true,
+        type: 'string',
+        describe: `Only include exercises with these statuses (${exerciseStatusOptions.join(', ')})`,
+    })
+        .option('ownership', {
+        type: 'string',
+        default: 'own',
+        describe: 'Visibility scope: own, public, or all',
+    })
+        .option('limit', {
+        type: 'number',
+        default: 20,
+        describe: 'Maximum number of exercises to return',
+    })
+        .option('offset', {
+        type: 'number',
+        default: 0,
+        describe: 'Number of matching exercises to skip',
+    })
+        .example('chalksurf exercise search --text "binomial theorem" --language english --ownership own --json', 'Verify imported exercises in the selected organization')
+        .example('chalksurf --profile prod-codex exercise search --label geometry.triangles --status unverified --json', 'Find agent-created exercises that still need review'), async (argv) => {
+        const text = normalizeOptionalText(argv.text);
+        const language = normalizeOptionalText(argv.language);
+        const semanticSearch = normalizeOptionalText(argv.semantic);
+        const ownership = normalizeOwnership(argv.ownership);
+        const labels = normalizeStringValues(argv.label);
+        const status = normalizeChoiceValues({
+            allowedValues: exerciseStatusOptions,
+            label: '--status',
+            values: argv.status,
+        });
+        const age = normalizeOptionalInteger({ label: '--age', value: argv.age });
+        const minDifficulty = normalizeOptionalInteger({
+            label: '--min-difficulty',
+            value: argv.minDifficulty,
+        });
+        const maxDifficulty = normalizeOptionalInteger({
+            label: '--max-difficulty',
+            value: argv.maxDifficulty,
+        });
+        normalizeSearchNumberRange({ minDifficulty, maxDifficulty });
+        if (text !== null && language === null) {
+            throw new CliCommandError('--language is required when --text is provided.', 2);
+        }
+        const limit = normalizeLimit(argv.limit);
+        const offset = normalizeOffset(argv.offset);
+        const { apiClient, organizationId } = await createResolvedApiClient({
+            context,
+            baseUrlFlagValue: argv.baseUrl,
+            organizationFlagValue: argv.organization,
+            profileName: argv.profile,
+        });
+        let searchResult;
+        try {
+            searchResult = await apiClient.searchExercises({
+                age,
+                language,
+                labels,
+                minDifficulty,
+                maxDifficulty,
+                text,
+                semanticSearch,
+                status,
+                ownership: toApiOwnership(ownership),
+                limit,
+                offset,
+            });
+        }
+        catch (error) {
+            throw mapApiErrorToCliError(error);
+        }
+        context.output.print({
+            request: {
+                age,
+                language,
+                labels,
+                minDifficulty,
+                maxDifficulty,
+                text,
+                semanticSearch,
+                status: status ?? [],
+                ownership,
+                limit,
+                offset,
+                organizationId: organizationId ?? null,
+            },
+            exercises: searchResult.exercises,
+            totalCount: searchResult.totalCount,
+        }, (result) => formatExerciseSearchOutput({
+            exercises: result.exercises,
+            language: result.request.language ?? undefined,
+            totalCount: result.totalCount,
+        }), {
+            command: 'exercise search',
+        });
+    })
         .command('import [sources..]', 'Import one or more exercises', (importYargs) => importYargs
         .positional('sources', {
         array: true,
@@ -103,6 +262,11 @@ export const registerExerciseCommands = (exerciseYargs, context) => {
         type: 'number',
         default: 300000,
         describe: 'Maximum time to wait before timing out',
+    })
+        .option('translate-to', {
+        array: true,
+        type: 'string',
+        describe: `Generate translated exercise content for these languages (${translationLanguages.join(', ')})`,
     })
         .option('wait', {
         type: 'boolean',
@@ -110,12 +274,16 @@ export const registerExerciseCommands = (exerciseYargs, context) => {
         describe: 'Wait for the queued job to finish',
     })
         .example('chalksurf exercise import ./fixtures/problem-set.pdf --sheet-id 00000000-0000-4000-8000-000000000001 --wait', 'Import a problem set into an existing sheet')
-        .example('cat exercise-import.json | chalksurf exercise import --manifest - --wait --json', 'Drive imports from a manifest in an agent or CI flow')
-        .epilogue('When --wait is set, the command exits after the queued import job reaches a terminal state.'), async (argv) => {
-        const config = await context.configStore.load();
+        .example('cat exercise-import.json | chalksurf --profile prod-codex exercise import --manifest - --wait --json', 'Drive imports from a manifest in an agent or CI flow')
+        .epilogue([
+        'When --wait is set, the command exits after the queued import job reaches a terminal state.',
+        'For translated exercise imports, requested translations continue as separate jobs listed in the import result.',
+    ].join('\n')), async (argv) => {
+        const config = await context.configStore.loadProfile({ profileName: argv.profile });
         const rawSources = (argv.sources ?? []).map(String);
         const manifestPath = argv.manifest === '' ? '-' : argv.manifest;
         const normalizedRawSources = manifestPath === '-' && rawSources[0] === '-' ? rawSources.slice(1) : rawSources;
+        const requestedTranslateTo = resolveRequestedTranslateToLanguages(argv.translateTo);
         const resolvedBaseUrl = requireResolvedBaseUrl({
             flagValue: argv.baseUrl,
             env: context.env,
@@ -145,6 +313,7 @@ export const registerExerciseCommands = (exerciseYargs, context) => {
             fallbackValue: commandSources.exerciseSheetId,
             label: '--sheet-id',
         });
+        const translateToLanguages = requestedTranslateTo ?? commandSources.translateTo;
         const apiClient = createApiClient({
             baseUrl: resolvedBaseUrl.value,
             token: resolvedToken.value,
@@ -170,6 +339,9 @@ export const registerExerciseCommands = (exerciseYargs, context) => {
             if (exerciseSheetId) {
                 formData.set('exerciseSheetId', exerciseSheetId);
             }
+            if (translateToLanguages && translateToLanguages.length > 0) {
+                formData.set('translateToLanguages', JSON.stringify(translateToLanguages));
+            }
             let importResult;
             try {
                 importResult = await apiClient.importExercise(formData);
@@ -283,9 +455,9 @@ export const registerExerciseCommands = (exerciseYargs, context) => {
         describe: 'Wait for the queued job to finish',
     })
         .example('chalksurf exercise import-solution 00000000-0000-4000-8000-000000000001 ./fixtures/solution.pdf --wait', 'Attach a solution file to an existing exercise')
-        .example('cat exercise-solution-import.json | chalksurf exercise import-solution --manifest - --wait --json', 'Drive solution imports from a manifest in an agent or CI flow')
+        .example('cat exercise-solution-import.json | chalksurf --profile prod-codex exercise import-solution --manifest - --wait --json', 'Drive solution imports from a manifest in an agent or CI flow')
         .epilogue('When --wait is set, the command exits after the queued import job reaches a terminal state.'), async (argv) => {
-        const config = await context.configStore.load();
+        const config = await context.configStore.loadProfile({ profileName: argv.profile });
         const rawSources = (argv.sources ?? []).map(String);
         const manifestPath = argv.manifest === '' ? '-' : argv.manifest;
         const normalizedRawSources = manifestPath === '-' && rawSources[0] === '-' ? rawSources.slice(1) : rawSources;