@chalksurf/cli 0.2.2 → 0.2.4

package/dist/commands/job.js

@@ -1,172 +0,0 @@
-import { CliCommandError } from '../lib/cli-error.js';
-import { normalizeChoiceValues, normalizeLimit, normalizeOffset, normalizeOptionalText, } from '../lib/command-options.js';
-import { createResolvedApiClient, mapApiErrorToCliError } from '../lib/session.js';
-import { formatCliJobSummary, getWaitError, getWaitExitCode, serializeCliJob, throwSilentExitCode, waitForCliJobs, } from '../lib/user-jobs.js';
-const jobStatusOptions = ['pending', 'in_progress', 'completed', 'failed'];
-const jobTypeOptions = [
-    'exercise_sheet_import',
-    'exercise_import',
-    'exercise_solution_import',
-    'exercise_solution_generation',
-    'exercise_translation_generation',
-    'exercise_sheet_translation_generation',
-];
-const normalizeTimeoutMs = (timeoutMs) => {
-    const normalizedTimeoutMs = timeoutMs ?? 300000;
-    if (!Number.isFinite(normalizedTimeoutMs) || normalizedTimeoutMs <= 0) {
-        throw new CliCommandError('--timeout-ms must be a positive number.', 2);
-    }
-    return normalizedTimeoutMs;
-};
-const formatJobListOutput = ({ jobs }) => {
-    if (jobs.length === 0) {
-        return 'No jobs found.';
-    }
-    return jobs.map((job) => formatCliJobSummary(job)).join('\n');
-};
-export const registerJobCommands = (jobYargs, context) => {
-    return jobYargs
-        .command('list', 'List jobs for the current user', (listYargs) => listYargs
-        .option('status', {
-        array: true,
-        type: 'string',
-        describe: `Only include jobs with these statuses (${jobStatusOptions.join(', ')})`,
-    })
-        .option('type', {
-        array: true,
-        type: 'string',
-        describe: `Only include jobs with these types (${jobTypeOptions.join(', ')})`,
-    })
-        .option('include-viewed', {
-        type: 'boolean',
-        default: false,
-        describe: 'Include jobs already marked as viewed',
-    })
-        .option('include-dismissed', {
-        type: 'boolean',
-        default: false,
-        describe: 'Include jobs already dismissed in the UI',
-    })
-        .option('limit', {
-        type: 'number',
-        default: 20,
-        describe: 'Maximum number of jobs to return',
-    })
-        .option('offset', {
-        type: 'number',
-        default: 0,
-        describe: 'Number of matching jobs to skip',
-    })
-        .example('chalksurf job list --status failed --include-dismissed --json', 'Find failed jobs for retry')
-        .example('chalksurf --profile prod-codex job list --type exercise_sheet_import --json', 'Inspect agent imports'), async (argv) => {
-        const statuses = normalizeChoiceValues({
-            allowedValues: jobStatusOptions,
-            label: '--status',
-            values: argv.status,
-        });
-        const types = normalizeChoiceValues({
-            allowedValues: jobTypeOptions,
-            label: '--type',
-            values: argv.type,
-        });
-        const limit = normalizeLimit(argv.limit);
-        const offset = normalizeOffset(argv.offset);
-        const { apiClient } = await createResolvedApiClient({
-            context,
-            baseUrlFlagValue: normalizeOptionalText(argv.baseUrl) ?? undefined,
-            organizationFlagValue: normalizeOptionalText(argv.organization) ?? undefined,
-            profileName: argv.profile,
-        });
-        let jobs;
-        try {
-            jobs = await apiClient.listUserJobs({
-                statuses,
-                types,
-                includeViewed: argv.includeViewed === true,
-                includeDismissed: argv.includeDismissed === true,
-                limit,
-                offset,
-            });
-        }
-        catch (error) {
-            throw mapApiErrorToCliError(error);
-        }
-        const serializedJobs = jobs.map(serializeCliJob);
-        context.output.print({
-            request: {
-                statuses: statuses ?? [],
-                types: types ?? [],
-                includeViewed: argv.includeViewed === true,
-                includeDismissed: argv.includeDismissed === true,
-                limit,
-                offset,
-            },
-            jobs: serializedJobs,
-            count: serializedJobs.length,
-        }, (result) => formatJobListOutput({ jobs: result.jobs }), {
-            command: 'job list',
-        });
-    })
-        .command('get <jobId>', 'Fetch a single job', (getYargs) => getYargs
-        .positional('jobId', {
-        type: 'string',
-        describe: 'Job ID to fetch',
-    })
-        .example('chalksurf job get job_123', 'Read one job in human-readable mode')
-        .example('chalksurf job get job_123 --json', 'Read one job in machine-readable mode'), async (argv) => {
-        const { apiClient } = await createResolvedApiClient({
-            context,
-            baseUrlFlagValue: argv.baseUrl,
-            organizationFlagValue: argv.organization,
-            profileName: argv.profile,
-        });
-        let job;
-        try {
-            job = await apiClient.getUserJob(String(argv.jobId));
-        }
-        catch (error) {
-            throw mapApiErrorToCliError(error);
-        }
-        const serializedJob = serializeCliJob(job);
-        context.output.print({ job: serializedJob }, (result) => formatCliJobSummary(result.job), {
-            command: 'job get',
-        });
-    })
-        .command('wait <jobIds..>', 'Poll jobs until they complete, fail, or time out', (waitYargs) => waitYargs
-        .positional('jobIds', {
-        array: true,
-        type: 'string',
-        describe: 'One or more job IDs to wait for',
-    })
-        .option('timeout-ms', {
-        type: 'number',
-        default: 300000,
-        describe: 'Maximum time to wait before timing out',
-    })
-        .example('chalksurf job wait job_123 job_124', 'Wait for one or more jobs to reach a terminal state')
-        .example('chalksurf job wait job_123 --timeout-ms 60000 --json', 'Poll a job for up to 60 seconds'), async (argv) => {
-        const { apiClient } = await createResolvedApiClient({
-            context,
-            baseUrlFlagValue: argv.baseUrl,
-            organizationFlagValue: argv.organization,
-            profileName: argv.profile,
-        });
-        const timeoutMs = normalizeTimeoutMs(argv.timeoutMs);
-        const waitResult = await waitForCliJobs({
-            getUserJob: async (jobId) => await apiClient.getUserJob(jobId),
-            jobIds: (argv.jobIds ?? []).map(String),
-            now: context.now,
-            sleep: context.sleep,
-            timeoutMs,
-        });
-        const waitError = getWaitError(waitResult);
-        context.output.print(waitResult, (result) => result.jobs.map((job) => formatCliJobSummary(job)).join('\n'), {
-            command: 'job wait',
-            ok: waitError == null,
-            error: waitError,
-        });
-        throwSilentExitCode(getWaitExitCode(waitResult));
-    })
-        .demandCommand(1)
-        .strict();
-};

package/dist/commands/org.js

@@ -1,115 +0,0 @@
-import { createApiClient } from '../lib/api-client.js';
-import { CliCommandError } from '../lib/cli-error.js';
-import { resolveOrganization } from '../lib/config-store.js';
-import { mapApiErrorToCliError, requireResolvedBaseUrl, requireResolvedToken } from '../lib/session.js';
-const serializeOrganization = ({ organizationId, organizationName, organizationType, role, selected, }) => {
-    return {
-        id: organizationId,
-        name: organizationName,
-        role,
-        selected,
-        type: organizationType,
-    };
-};
-export const registerOrgCommands = (orgYargs, context) => {
-    return orgYargs
-        .command('list', 'List organizations available to the authenticated user', (listYargs) => listYargs
-        .example('chalksurf org list', 'List organizations for the default profile')
-        .example('chalksurf --profile prod-codex org list --json', 'Inspect organizations for a specific profile'), async (argv) => {
-        const config = await context.configStore.loadProfile({ profileName: argv.profile });
-        const resolvedBaseUrl = requireResolvedBaseUrl({
-            flagValue: argv.baseUrl,
-            env: context.env,
-            config,
-        });
-        const resolvedToken = requireResolvedToken({
-            env: context.env,
-            config,
-        });
-        const apiClient = createApiClient({
-            baseUrl: resolvedBaseUrl.value,
-            token: resolvedToken.value,
-        });
-        let profile;
-        try {
-            profile = await apiClient.getUserProfile();
-        }
-        catch (error) {
-            throw mapApiErrorToCliError(error);
-        }
-        const resolvedOrganization = resolveOrganization({
-            flagValue: argv.organization,
-            env: context.env,
-            config,
-            profile,
-        });
-        resolvedOrganization.warnings.forEach((warning) => {
-            context.output.info(warning);
-        });
-        const organizations = profile.organizationMemberships.map((membership) => serializeOrganization({
-            ...membership,
-            selected: membership.organizationId === resolvedOrganization.organization?.organizationId,
-        }));
-        context.output.print({
-            organizations,
-            profile: config.profileName,
-            profileSource: config.profileSource,
-            selectedOrganizationId: resolvedOrganization.organization?.organizationId ?? null,
-            selectedOrganizationSource: resolvedOrganization.source,
-        }, (result) => result.organizations
-            .map((organization) => `${organization.selected ? '*' : ' '} ${organization.name} (${organization.id}) [${organization.type}, ${organization.role}]`)
-            .join('\n'), {
-            command: 'org list',
-        });
-    })
-        .command('use <organizationId>', 'Set the default organization used by the CLI', (useYargs) => {
-        return useYargs
-            .positional('organizationId', {
-            type: 'string',
-            describe: 'Organization ID to store as the default',
-        })
-            .example('chalksurf --profile prod-codex org use org_123', 'Store org_123 in the prod-codex profile');
-    }, async (argv) => {
-        const config = await context.configStore.loadProfile({ profileName: argv.profile });
-        const resolvedBaseUrl = requireResolvedBaseUrl({
-            flagValue: argv.baseUrl,
-            env: context.env,
-            config,
-        });
-        const resolvedToken = requireResolvedToken({
-            env: context.env,
-            config,
-        });
-        const apiClient = createApiClient({
-            baseUrl: resolvedBaseUrl.value,
-            token: resolvedToken.value,
-        });
-        let profile;
-        try {
-            profile = await apiClient.getUserProfile();
-        }
-        catch (error) {
-            throw mapApiErrorToCliError(error);
-        }
-        const organization = profile.organizationMemberships.find((membership) => membership.organizationId === String(argv.organizationId));
-        if (!organization) {
-            throw new CliCommandError(`Organization "${String(argv.organizationId)}" is not accessible to the current user.`, 2);
-        }
-        await context.configStore.update({ profileName: argv.profile }, (currentConfig) => ({
-            ...currentConfig,
-            organizationId: organization.organizationId,
-        }));
-        context.output.print({
-            organization: serializeOrganization({
-                ...organization,
-                selected: true,
-            }),
-            profile: config.profileName,
-            profileSource: config.profileSource,
-        }, (result) => `Default organization set to ${result.organization.name} (${result.organization.id}).`, {
-            command: 'org use',
-        });
-    })
-        .demandCommand(1)
-        .strict();
-};

package/dist/commands/profile.js

@@ -1,97 +0,0 @@
-import { CliCommandError } from '../lib/cli-error.js';
-import { assertValidProfileName, resolveProfile } from '../lib/config-store.js';
-const serializeProfile = ({ profileName, profileConfig, selected, }) => {
-    return {
-        baseUrl: profileConfig.baseUrl ?? null,
-        hasToken: Boolean(profileConfig.token),
-        name: profileName,
-        organizationId: profileConfig.organizationId ?? null,
-        selected,
-    };
-};
-const formatProfile = (profile) => {
-    const marker = profile.selected ? '*' : ' ';
-    const baseUrl = profile.baseUrl ?? 'no base URL';
-    const token = profile.hasToken ? 'token' : 'no token';
-    const organization = profile.organizationId ? `org ${profile.organizationId}` : 'no org';
-    return `${marker} ${profile.name} (${baseUrl}, ${token}, ${organization})`;
-};
-export const registerProfileCommands = (profileYargs, context) => {
-    return profileYargs
-        .command('list', 'List locally stored CLI profiles', (listYargs) => listYargs
-        .example('chalksurf profile list', 'List locally stored profiles')
-        .example('chalksurf --profile prod-codex profile list --json', 'Show the active profile in JSON mode'), async (argv) => {
-        const rootConfig = await context.configStore.loadRoot();
-        let activeProfile = null;
-        try {
-            activeProfile =
-                Object.keys(rootConfig.profiles).length === 0
-                    ? null
-                    : resolveProfile({
-                        flagValue: argv.profile,
-                        env: context.env,
-                        config: rootConfig,
-                    });
-        }
-        catch (error) {
-            if (!(error instanceof CliCommandError) || !error.message.startsWith('No active ChalkSurf profile')) {
-                throw error;
-            }
-        }
-        const profiles = Object.entries(rootConfig.profiles).map(([profileName, profileConfig]) => serializeProfile({
-            profileName,
-            profileConfig,
-            selected: profileName === activeProfile?.profileName,
-        }));
-        context.output.print({
-            activeProfile: activeProfile?.profileName ?? null,
-            activeProfileSource: activeProfile?.profileSource ?? null,
-            defaultProfile: rootConfig.defaultProfile ?? null,
-            profiles,
-        }, (result) => result.profiles.length === 0 ? 'No profiles configured.' : result.profiles.map(formatProfile).join('\n'), {
-            command: 'profile list',
-        });
-    })
-        .command('use <profileName>', 'Set the default profile used by the CLI', (useYargs) => useYargs
-        .positional('profileName', {
-        type: 'string',
-        describe: 'Profile name to make the default',
-    })
-        .example('chalksurf profile use prod-cztamas', 'Use prod-cztamas by default for future commands'), async (argv) => {
-        const profileName = String(argv.profileName ?? '');
-        assertValidProfileName(profileName);
-        const rootConfig = await context.configStore.setDefaultProfile(profileName);
-        const profileConfig = rootConfig.profiles[profileName];
-        if (!profileConfig) {
-            throw new CliCommandError(`Profile "${profileName}" does not exist.`, 2);
-        }
-        context.output.print({
-            defaultProfile: profileName,
-            profile: serializeProfile({
-                profileName,
-                profileConfig,
-                selected: true,
-            }),
-        }, (result) => `Default profile set to ${result.defaultProfile}.`, {
-            command: 'profile use',
-        });
-    })
-        .command('delete <profileName>', 'Delete a locally stored CLI profile', (deleteYargs) => deleteYargs
-        .positional('profileName', {
-        type: 'string',
-        describe: 'Profile name to delete',
-    })
-        .example('chalksurf profile delete prod-codex', 'Delete the prod-codex profile'), async (argv) => {
-        const profileName = String(argv.profileName ?? '');
-        assertValidProfileName(profileName);
-        const rootConfig = await context.configStore.deleteProfile(profileName);
-        context.output.print({
-            deletedProfile: profileName,
-            defaultProfile: rootConfig.defaultProfile ?? null,
-        }, (result) => `Deleted profile ${result.deletedProfile}.`, {
-            command: 'profile delete',
-        });
-    })
-        .demandCommand(1)
-        .strict();
-};