@chalksurf/cli 0.1.0

package/dist/commands/sheet.js

@@ -0,0 +1,278 @@
+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 { 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',
+};
+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 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;
+    }
+};
+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 buildCommandSources = async ({ cwd, 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 loadSheetImportManifest({
+            cwd,
+            manifestPath,
+            stdin,
+        });
+        return {
+            organizationId: manifest.organizationId,
+            sources: manifest.sources,
+            wait: wait || manifest.wait === true,
+        };
+    }
+    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,
+    };
+};
+const buildSheetImportJobs = ({ importResultJobs, resolvedSources, waitedJobsById, }) => {
+    return importResultJobs.map((job, index) => {
+        const source = resolvedSources[index];
+        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,
+            error: waitedJob?.error,
+            exerciseSheetId: waitedJob?.exerciseSheetId,
+        };
+    });
+};
+const formatQueuedImportOutput = (jobs) => {
+    return [
+        `Queued ${jobs.length} import${jobs.length === 1 ? '' : 's'}.`,
+        ...jobs.map((job) => `${job.jobId}  ${job.relativePath}`),
+    ]
+        .filter(Boolean)
+        .join('\n');
+};
+const formatWaitedImportOutput = (jobs) => {
+    return [
+        `${jobs.length} job${jobs.length === 1 ? '' : 's'} queued.`,
+        ...jobs.map((job) => formatCliJobSummary({
+            id: job.jobId,
+            status: job.status ?? 'pending',
+            type: 'exercise_sheet_import',
+            createdAt: '',
+            updatedAt: '',
+            error: job.error,
+            exerciseSheetId: job.exerciseSheetId,
+        })),
+    ]
+        .filter(Boolean)
+        .join('\n');
+};
+export const registerSheetCommands = (sheetYargs, context) => {
+    return sheetYargs
+        .command('import [sources..]', 'Import one or more exercise sheet sources', (importYargs) => importYargs
+        .positional('sources', {
+        array: true,
+        type: 'string',
+        describe: 'Local file paths, directories, or HTTP(S) URLs',
+    })
+        .option('manifest', {
+        type: 'string',
+        describe: 'Load sources from a manifest file, or "-" for stdin',
+    })
+        .option('relative-path', {
+        type: 'string',
+        describe: 'Override the relative path for a single positional source',
+    })
+        .option('timeout-ms', {
+        type: 'number',
+        default: 300000,
+        describe: 'Maximum time to wait before timing out',
+    })
+        .option('wait', {
+        type: 'boolean',
+        default: false,
+        describe: 'Wait for the queued jobs to finish',
+    }), async (argv) => {
+        const config = await context.configStore.load();
+        const rawSources = (argv.sources ?? []).map(String);
+        const manifestPath = argv.manifest === '' ? '-' : argv.manifest;
+        const normalizedRawSources = manifestPath === '-' && rawSources[0] === '-' ? rawSources.slice(1) : rawSources;
+        const resolvedBaseUrl = requireResolvedBaseUrl({
+            flagValue: argv.baseUrl,
+            env: context.env,
+            config,
+        });
+        const resolvedToken = requireResolvedToken({
+            env: context.env,
+            config,
+        });
+        const commandSources = await buildCommandSources({
+            cwd: context.cwd,
+            manifestPath,
+            rawSources: normalizedRawSources,
+            relativePath: argv.relativePath,
+            stdin: context.stdin,
+            wait: argv.wait,
+        });
+        const organizationId = resolveRequestedOrganizationId({
+            flagValue: argv.organization,
+            fallbackValue: commandSources.organizationId,
+            env: context.env,
+            config,
+        });
+        const apiClient = createApiClient({
+            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,
+            });
+            const formData = await buildFormData(resolvedSources);
+            let importResult;
+            try {
+                importResult = await apiClient.importExerciseSheet(formData);
+            }
+            catch (error) {
+                throw mapApiErrorToCliError(error);
+            }
+            if (!commandSources.wait) {
+                const jobs = buildSheetImportJobs({
+                    importResultJobs: importResult.jobs,
+                    resolvedSources,
+                });
+                context.output.print({
+                    organizationId: organizationId ?? null,
+                    jobs,
+                    waited: false,
+                }, (result) => formatQueuedImportOutput(result.jobs));
+                return;
+            }
+            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),
+            });
+            const waitedJobsById = new Map(waitResult.jobs.map((job) => [job.id, job]));
+            const jobs = buildSheetImportJobs({
+                importResultJobs: importResult.jobs,
+                resolvedSources,
+                waitedJobsById,
+            });
+            context.output.print({
+                organizationId: organizationId ?? null,
+                jobs,
+                timedOut: waitResult.timedOut,
+                waited: true,
+            }, (result) => formatWaitedImportOutput(result.jobs));
+            throwSilentExitCode(getWaitExitCode(waitResult));
+        }
+        finally {
+            await cleanupResolvedSources(resolvedSources);
+        }
+    })
+        .demandCommand(1)
+        .strict();
+};

package/dist/lib/api-client.js

@@ -0,0 +1,71 @@
+const normalizeBaseUrl = (baseUrl) => {
+    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+};
+const getErrorMessage = (payload, status) => {
+    return payload?.error?.message ?? `API request failed with status ${status}`;
+};
+const getResponseData = async ({ response, batched }) => {
+    const body = (await response.json());
+    const payload = batched ? body[0] : body;
+    if (!response.ok) {
+        throw new Error(getErrorMessage(payload, response.status));
+    }
+    if (payload?.error) {
+        throw new Error(payload.error.message);
+    }
+    if (!payload?.result) {
+        throw new Error('API response is missing a result payload');
+    }
+    return payload.result.data;
+};
+export const createApiClient = ({ baseUrl, token, organizationId, fetchImpl = fetch, }) => {
+    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    const createHeaders = ({ includeJsonContentType }) => {
+        const headers = new Headers();
+        if (token) {
+            headers.set('authorization', `Bearer ${token}`);
+        }
+        if (organizationId) {
+            headers.set('x-organization-id', organizationId);
+        }
+        if (includeJsonContentType) {
+            headers.set('content-type', 'application/json');
+        }
+        return headers;
+    };
+    const query = async (procedureName, input) => {
+        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(), {
+            method: 'GET',
+            headers: createHeaders({ includeJsonContentType: false }),
+        });
+        return await getResponseData({ response, batched: true });
+    };
+    const mutation = async (procedureName, input) => {
+        const isFormDataInput = input instanceof FormData;
+        const response = await fetchImpl(new URL(`trpc/${procedureName}`, normalizedBaseUrl).toString(), {
+            method: 'POST',
+            headers: createHeaders({ includeJsonContentType: !isFormDataInput }),
+            body: isFormDataInput ? input : JSON.stringify(input ?? {}),
+        });
+        return await getResponseData({ response, batched: false });
+    };
+    return {
+        query,
+        mutation,
+        getUserProfile: async () => {
+            return await query('getUserProfile', null);
+        },
+        listUserJobs: async () => {
+            return await query('listUserJobs', null);
+        },
+        getUserJob: async (id) => {
+            return await query('getUserJob', { id });
+        },
+        importExerciseSheet: async (formData) => {
+            return await mutation('importExerciseSheet', formData);
+        },
+    };
+};

package/dist/lib/cli-error.js

@@ -0,0 +1,10 @@
+export class CliCommandError extends Error {
+    exitCode;
+    shouldReport;
+    constructor(message, exitCode, shouldReport = true) {
+        super(message);
+        this.name = 'CliCommandError';
+        this.exitCode = exitCode;
+        this.shouldReport = shouldReport;
+    }
+}

package/dist/lib/config-store.js

@@ -0,0 +1,176 @@
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { CliCommandError } from './cli-error.js';
+export const chalksurfBaseUrlEnvVar = 'CHALKSURF_BASE_URL';
+export const chalksurfTokenEnvVar = 'CHALKSURF_TOKEN';
+export const chalksurfOrganizationIdEnvVar = 'CHALKSURF_ORGANIZATION_ID';
+export const chalksurfConfigPathEnvVar = 'CHALKSURF_CONFIG_PATH';
+const normalizeOptionalString = (value) => {
+    const trimmedValue = value?.trim();
+    return trimmedValue ? trimmedValue : undefined;
+};
+const normalizeStoredBaseUrl = (value) => {
+    const normalizedValue = normalizeOptionalString(value);
+    return normalizedValue?.replace(/\/+$/, '') || undefined;
+};
+const sanitizeConfig = (config) => {
+    return Object.fromEntries(Object.entries({
+        token: normalizeOptionalString(config.token),
+        baseUrl: normalizeStoredBaseUrl(config.baseUrl),
+        organizationId: normalizeOptionalString(config.organizationId),
+    }).filter(([, value]) => value !== undefined));
+};
+const getDefaultConfigPath = ({ env, platform, homeDirectory, }) => {
+    const explicitConfigPath = normalizeOptionalString(env[chalksurfConfigPathEnvVar]);
+    if (explicitConfigPath) {
+        return explicitConfigPath;
+    }
+    if (platform === 'win32') {
+        return join(env.APPDATA || join(homeDirectory, 'AppData', 'Roaming'), 'chalksurf', 'config.json');
+    }
+    if (platform === 'darwin') {
+        return join(homeDirectory, 'Library', 'Application Support', 'chalksurf', 'config.json');
+    }
+    return join(env.XDG_CONFIG_HOME || join(homeDirectory, '.config'), 'chalksurf', 'config.json');
+};
+const findOrganizationMembership = ({ memberships, organizationId, }) => {
+    return memberships.find((membership) => membership.organizationId === organizationId) ?? null;
+};
+const getFallbackOrganization = (memberships) => {
+    const personalOrganization = memberships.find((membership) => membership.organizationType === 'user') ?? memberships[0] ?? null;
+    if (!personalOrganization) {
+        return null;
+    }
+    return {
+        organization: personalOrganization,
+        source: personalOrganization.organizationType === 'user' ? 'default-personal' : 'default-first',
+    };
+};
+export const resolveBaseUrl = ({ flagValue, env, config, }) => {
+    const normalizedFlagValue = normalizeStoredBaseUrl(flagValue);
+    if (normalizedFlagValue) {
+        return { value: normalizedFlagValue, source: 'flag' };
+    }
+    const normalizedEnvValue = normalizeStoredBaseUrl(env[chalksurfBaseUrlEnvVar]);
+    if (normalizedEnvValue) {
+        return { value: normalizedEnvValue, source: 'env' };
+    }
+    const normalizedConfigValue = normalizeStoredBaseUrl(config.baseUrl);
+    if (normalizedConfigValue) {
+        return { value: normalizedConfigValue, source: 'config' };
+    }
+    return { source: 'none' };
+};
+export const resolveToken = ({ env, config }) => {
+    const normalizedEnvValue = normalizeOptionalString(env[chalksurfTokenEnvVar]);
+    if (normalizedEnvValue) {
+        return { value: normalizedEnvValue, source: 'env' };
+    }
+    const normalizedConfigValue = normalizeOptionalString(config.token);
+    if (normalizedConfigValue) {
+        return { value: normalizedConfigValue, source: 'config' };
+    }
+    return { source: 'none' };
+};
+export const resolveOrganization = ({ flagValue, env, config, profile, }) => {
+    const flagOrganizationId = normalizeOptionalString(flagValue);
+    if (flagOrganizationId) {
+        const organization = findOrganizationMembership({
+            memberships: profile.organizationMemberships,
+            organizationId: flagOrganizationId,
+        });
+        if (!organization) {
+            throw new CliCommandError(`Organization "${flagOrganizationId}" is not accessible to the current user.`, 2);
+        }
+        return { organization, source: 'flag', warnings: [] };
+    }
+    const envOrganizationId = normalizeOptionalString(env[chalksurfOrganizationIdEnvVar]);
+    if (envOrganizationId) {
+        const organization = findOrganizationMembership({
+            memberships: profile.organizationMemberships,
+            organizationId: envOrganizationId,
+        });
+        if (!organization) {
+            throw new CliCommandError(`Organization "${envOrganizationId}" from ${chalksurfOrganizationIdEnvVar} is not accessible to the current user.`, 2);
+        }
+        return { organization, source: 'env', warnings: [] };
+    }
+    const configOrganizationId = normalizeOptionalString(config.organizationId);
+    if (configOrganizationId) {
+        const organization = findOrganizationMembership({
+            memberships: profile.organizationMemberships,
+            organizationId: configOrganizationId,
+        });
+        if (organization) {
+            return { organization, source: 'config', warnings: [] };
+        }
+        const fallbackOrganization = getFallbackOrganization(profile.organizationMemberships);
+        if (!fallbackOrganization) {
+            return {
+                organization: null,
+                source: 'none',
+                warnings: [`Stored organization "${configOrganizationId}" is no longer accessible.`],
+            };
+        }
+        return {
+            organization: fallbackOrganization.organization,
+            source: fallbackOrganization.source,
+            warnings: [
+                `Stored organization "${configOrganizationId}" is no longer accessible; using "${fallbackOrganization.organization.organizationName}" instead.`,
+            ],
+        };
+    }
+    const fallbackOrganization = getFallbackOrganization(profile.organizationMemberships);
+    if (!fallbackOrganization) {
+        return { organization: null, source: 'none', warnings: [] };
+    }
+    return {
+        organization: fallbackOrganization.organization,
+        source: fallbackOrganization.source,
+        warnings: [],
+    };
+};
+export const createConfigStore = ({ configPath, env = process.env, platform = process.platform, homeDirectory = homedir(), fs = { chmod, mkdir, readFile, rm, writeFile }, } = {}) => {
+    const resolvedConfigPath = configPath || getDefaultConfigPath({ env, platform, homeDirectory });
+    const load = async () => {
+        try {
+            const configContents = await fs.readFile(resolvedConfigPath, 'utf8');
+            const parsedConfig = JSON.parse(configContents);
+            return sanitizeConfig(parsedConfig);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return {};
+            }
+            if (error instanceof SyntaxError) {
+                throw new CliCommandError(`Failed to parse CLI config at ${resolvedConfigPath}.`, 2);
+            }
+            throw error;
+        }
+    };
+    const save = async (config) => {
+        const sanitizedConfig = sanitizeConfig(config);
+        if (Object.keys(sanitizedConfig).length === 0) {
+            await fs.rm(resolvedConfigPath, { force: true });
+            return sanitizedConfig;
+        }
+        await fs.mkdir(dirname(resolvedConfigPath), { recursive: true, mode: 0o700 });
+        await fs.writeFile(resolvedConfigPath, `${JSON.stringify(sanitizedConfig, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        await fs.chmod(resolvedConfigPath, 0o600);
+        return sanitizedConfig;
+    };
+    const update = async (updater) => {
+        const currentConfig = await load();
+        const nextConfig = await updater(currentConfig);
+        return await save(nextConfig);
+    };
+    return {
+        path: resolvedConfigPath,
+        load,
+        save,
+        update,
+    };
+};

package/dist/lib/manifest.js

@@ -0,0 +1,107 @@
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { CliCommandError } from './cli-error.js';
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null;
+};
+const normalizeOptionalString = (value) => {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalizedValue = value.trim();
+    return normalizedValue.length > 0 ? normalizedValue : undefined;
+};
+const isInteractiveStdin = (stdin) => {
+    return stdin.isTTY === true;
+};
+const readTextFromStdin = async (stdin) => {
+    let text = '';
+    for await (const chunk of stdin) {
+        text += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+    }
+    return text;
+};
+const parseManifestSource = (value, index) => {
+    if (!isObject(value)) {
+        throw new CliCommandError(`Manifest source at index ${index} must be an object.`, 2);
+    }
+    const kind = normalizeOptionalString(value.kind);
+    if (kind === 'local') {
+        const path = normalizeOptionalString(value.path);
+        if (!path) {
+            throw new CliCommandError(`Manifest local source at index ${index} must include a path.`, 2);
+        }
+        return {
+            kind: 'local',
+            path,
+            relativePath: normalizeOptionalString(value.relativePath),
+        };
+    }
+    if (kind === 'directory') {
+        const path = normalizeOptionalString(value.path);
+        if (!path) {
+            throw new CliCommandError(`Manifest directory source at index ${index} must include a path.`, 2);
+        }
+        return {
+            kind: 'directory',
+            path,
+            relativeRoot: normalizeOptionalString(value.relativeRoot),
+        };
+    }
+    if (kind === 'url') {
+        const url = normalizeOptionalString(value.url);
+        if (!url) {
+            throw new CliCommandError(`Manifest URL source at index ${index} must include a url.`, 2);
+        }
+        return {
+            kind: 'url',
+            url,
+            relativePath: normalizeOptionalString(value.relativePath),
+        };
+    }
+    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);
+    }
+    if (!Array.isArray(parsedManifest.sources) || parsedManifest.sources.length === 0) {
+        throw new CliCommandError('Manifest must include a non-empty sources array.', 2);
+    }
+    const wait = typeof parsedManifest.wait === 'boolean' ? parsedManifest.wait : undefined;
+    return {
+        organizationId: normalizeOptionalString(parsedManifest.organizationId),
+        wait,
+        sources: parsedManifest.sources.map((source, index) => parseManifestSource(source, index)),
+    };
+};
+export const loadSheetImportManifest = async ({ cwd, manifestPath, stdin, }) => {
+    if (manifestPath === '-') {
+        if (isInteractiveStdin(stdin)) {
+            throw new CliCommandError('No manifest was piped on stdin. Pipe JSON into "chalksurf sheet import --manifest -".', 2);
+        }
+        return parseManifest(await readTextFromStdin(stdin));
+    }
+    const resolvedManifestPath = resolve(cwd, manifestPath);
+    let fileStats;
+    try {
+        fileStats = await stat(resolvedManifestPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new CliCommandError(`Manifest file "${manifestPath}" does not exist.`, 2);
+        }
+        throw error;
+    }
+    if (!fileStats.isFile()) {
+        throw new CliCommandError(`Manifest path "${manifestPath}" is not a file.`, 2);
+    }
+    return parseManifest(await readFile(resolvedManifestPath, 'utf8'));
+};

package/dist/lib/output.js

@@ -0,0 +1,24 @@
+const ensureTrailingNewline = (value) => {
+    return value.endsWith('\n') ? value : `${value}\n`;
+};
+const writeLine = (writer, value) => {
+    writer.write(ensureTrailingNewline(value));
+};
+export const createOutput = ({ json, stdout, stderr, }) => {
+    return {
+        print: (value, humanFormatter) => {
+            if (json) {
+                writeLine(stdout, JSON.stringify(value, null, 2));
+                return;
+            }
+            const message = typeof humanFormatter === 'function' ? humanFormatter(value) : humanFormatter;
+            writeLine(stdout, message);
+        },
+        info: (message) => {
+            writeLine(stderr, message);
+        },
+        error: (message) => {
+            writeLine(stderr, message);
+        },
+    };
+};