@zalosai/zalos-cli 0.2.13

package/dist/commands/page-markdown.js

@@ -0,0 +1,213 @@
+import { Image } from '@tiptap/extension-image';
+import { Heading } from '@tiptap/extension-heading';
+import { TaskItem, TaskList } from '@tiptap/extension-list';
+import { Paragraph } from '@tiptap/extension-paragraph';
+import { MarkdownManager } from '@tiptap/markdown';
+import { renderToHTMLString } from '@tiptap/static-renderer/pm/html-string';
+import { StarterKit } from '@tiptap/starter-kit';
+import { ValidationError } from '../utils/errors.js';
+function escapeBlockMarkers(value) {
+    const escapedMarkers = value.replace(/(^|\n)(?=(?:#{1,6}\s|```|!\[|[-+*]\s|>\s?|---\s*(?:\n|$)|\*\*\*\s*(?:\n|$)|___\s*(?:\n|$)))/g, '$1\\');
+    return escapedMarkers.replace(/(^|\n)(\d+)([.)])(?=\s)/g, '$1$2\\$3');
+}
+const MarkdownParagraph = Paragraph.extend({
+    renderMarkdown: (node, helpers) => {
+        const content = Array.isArray(node.content) ? node.content : [];
+        return escapeBlockMarkers(helpers.renderChildren(content));
+    },
+});
+function splitHeadingBreaks(content) {
+    return content.flatMap((node) => {
+        if (node.type !== 'text' || typeof node.text !== 'string' || !node.text.includes('<br>'))
+            return [node];
+        return node.text.split('<br>').flatMap((text, index, parts) => {
+            const output = text ? [{ ...node, text }] : [];
+            if (index < parts.length - 1)
+                output.push({ type: 'hardBreak' });
+            return output;
+        });
+    });
+}
+const MarkdownHeading = Heading.extend({
+    parseMarkdown: (token, helpers) => helpers.createNode('heading', { level: token.depth || 1 }, splitHeadingBreaks(helpers.parseInline(token.tokens || []))),
+    renderMarkdown: (node, helpers) => {
+        const level = typeof node.attrs?.level === 'number' ? node.attrs.level : 1;
+        const content = helpers.renderChildren(node.content || []).replace(/ {2}\n/g, '<br>');
+        return `${'#'.repeat(level)} ${content}`;
+    },
+});
+function escapeImageAlt(value) {
+    return value.replace(/[\\[\]]/g, '\\$&');
+}
+const MarkdownImage = Image.extend({
+    renderMarkdown: (node) => {
+        const src = typeof node.attrs?.src === 'string' ? node.attrs.src : '';
+        const alt = typeof node.attrs?.alt === 'string' ? escapeImageAlt(node.attrs.alt) : '';
+        const title = typeof node.attrs?.title === 'string' ? node.attrs.title : '';
+        return title ? `![${alt}](${src} "${title}")` : `![${alt}](${src})`;
+    },
+});
+const pageExtensions = [
+    StarterKit.configure({
+        link: { openOnClick: false },
+        heading: false,
+        paragraph: false,
+    }),
+    MarkdownParagraph,
+    MarkdownHeading,
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    MarkdownImage,
+];
+const markdownManager = new MarkdownManager({ extensions: pageExtensions });
+const markdownNodeTypes = new Set([
+    'doc',
+    'paragraph',
+    'text',
+    'hardBreak',
+    'heading',
+    'blockquote',
+    'bulletList',
+    'orderedList',
+    'listItem',
+    'taskList',
+    'taskItem',
+    'codeBlock',
+    'horizontalRule',
+    'image',
+]);
+const markdownMarkTypes = new Set(['bold', 'italic', 'code', 'link', 'strike', 'underline']);
+function isNode(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPageContentNode(value) {
+    return typeof value === 'object' && value !== null;
+}
+function childNodes(node) {
+    if (!Array.isArray(node.content))
+        return [];
+    return node.content.filter(isPageContentNode);
+}
+function nodeText(node) {
+    if (typeof node.text === 'string')
+        return node.text;
+    if (typeof node.attrs?.alt === 'string')
+        return node.attrs.alt;
+    return childNodes(node)
+        .map((child) => nodeText(child).trim())
+        .filter(Boolean)
+        .join('\n');
+}
+function searchableText(contentJson) {
+    const content = Array.isArray(contentJson.content) ? contentJson.content : [];
+    return content
+        .filter(isPageContentNode)
+        .map((node) => nodeText(node).trim())
+        .filter(Boolean)
+        .join('\n\n');
+}
+function pageDocument(value) {
+    if (!isNode(value) || value.type !== 'doc')
+        throw new ValidationError('contentJson', 'Page content must be a Tiptap document');
+    return value;
+}
+function supportedUrl(value) {
+    if (typeof value !== 'string')
+        throw new ValidationError('markdown', 'Link URL is required');
+    if (value.startsWith('/') && !value.startsWith('//'))
+        return;
+    try {
+        const url = new URL(value);
+        if (!['http:', 'https:', 'mailto:'].includes(url.protocol))
+            throw new Error();
+    }
+    catch {
+        throw new ValidationError('markdown', `Unsupported link URL: ${value}`);
+    }
+}
+function validateMarkdownContent(value) {
+    if (!isNode(value) || typeof value.type !== 'string')
+        throw new ValidationError('contentJson', 'Page content contains an invalid Tiptap node');
+    if (!markdownNodeTypes.has(value.type))
+        throw new ValidationError('contentJson', `Tiptap node is not supported by Markdown: ${value.type}`);
+    if (value.type === 'image') {
+        if (!isNode(value.attrs) || typeof value.attrs.src !== 'string')
+            throw new ValidationError('contentJson', 'Image is missing its source URL');
+        if (Array.isArray(value.content) && value.content.length > 0)
+            throw new ValidationError('contentJson', 'Image captions are not supported by Markdown export');
+        supportedUrl(value.attrs.src);
+    }
+    if (Array.isArray(value.marks)) {
+        for (const mark of value.marks) {
+            if (!isNode(mark) || typeof mark.type !== 'string' || !markdownMarkTypes.has(mark.type))
+                throw new ValidationError('contentJson', `Tiptap mark is not supported by Markdown: ${isNode(mark) ? String(mark.type) : 'unknown'}`);
+            if (mark.type === 'link') {
+                if (!isNode(mark.attrs) || typeof mark.attrs.href !== 'string')
+                    throw new ValidationError('contentJson', 'Link URL is required');
+                supportedUrl(mark.attrs.href);
+            }
+        }
+    }
+    if (!Array.isArray(value.content))
+        return;
+    for (const child of value.content)
+        validateMarkdownContent(child);
+}
+function metadataFromMarkdown(markdown) {
+    const revision = /^<!-- zl-page (\{[^\n]+\}) -->\s*\n?/.exec(markdown);
+    if (!revision)
+        return { metadata: {}, source: markdown };
+    try {
+        const parsed = JSON.parse(revision[1]);
+        if (!isNode(parsed))
+            throw new Error();
+        return { metadata: parsed, source: markdown.slice(revision[0].length) };
+    }
+    catch {
+        throw new ValidationError('markdown', 'Invalid zl-page revision marker');
+    }
+}
+function titleAndBody(markdown) {
+    const firstHeading = /^#\s+(.+?)\s*(?:\n|$)/.exec(markdown);
+    return {
+        title: firstHeading?.[1] ?? 'Untitled',
+        body: firstHeading ? markdown.slice(firstHeading[0].length) : markdown,
+    };
+}
+export function importPageMarkdown(markdown) {
+    const { metadata, source } = metadataFromMarkdown(markdown);
+    const { title, body } = titleAndBody(source);
+    try {
+        const contentJson = markdownManager.parse(body);
+        validateMarkdownContent(contentJson);
+        return {
+            title,
+            contentJson: contentJson,
+            contentHtml: renderToHTMLString({
+                content: contentJson,
+                extensions: pageExtensions,
+            }),
+            searchableText: searchableText(contentJson),
+            ...(typeof metadata.id === 'string' ? { pageId: metadata.id } : {}),
+            ...(typeof metadata.expectedUpdatedAt === 'string'
+                ? { expectedUpdatedAt: metadata.expectedUpdatedAt }
+                : {}),
+        };
+    }
+    catch (error) {
+        if (error instanceof ValidationError)
+            throw error;
+        const message = error instanceof Error ? error.message : 'unknown Markdown conversion error';
+        throw new ValidationError('markdown', `Unable to convert Markdown: ${message}`);
+    }
+}
+export function exportPageMarkdown(input) {
+    const contentJson = pageDocument(input.contentJson);
+    validateMarkdownContent(input.contentJson);
+    const body = markdownManager.serialize(contentJson).trim();
+    const marker = input.id && input.expectedUpdatedAt
+        ? `<!-- zl-page ${JSON.stringify({ id: input.id, expectedUpdatedAt: input.expectedUpdatedAt })} -->\n`
+        : '';
+    return `${marker}# ${input.title}${body ? `\n\n${body}` : ''}\n`;
+}
+//# sourceMappingURL=page-markdown.js.map

package/dist/commands/page.js

@@ -0,0 +1,178 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { client } from '../client.js';
+import { exportPageMarkdown, importPageMarkdown } from './page-markdown.js';
+import { ValidationError } from '../utils/errors.js';
+import { printJson } from '../utils/output.js';
+import { action, dataRow, fields, isRow, printPage, resourceId, } from '../utils/product-api.js';
+function pageUpdatedAt(page) {
+    if (typeof page.updatedAt !== 'string' || !page.updatedAt) {
+        throw new ValidationError('updatedAt', 'Page response is missing its revision timestamp');
+    }
+    return page.updatedAt;
+}
+function pageContent(page) {
+    if (!isRow(page.contentJson))
+        throw new ValidationError('contentJson', 'Page response is missing Tiptap content');
+    return page.contentJson;
+}
+async function readPageMarkdown(path) {
+    try {
+        return importPageMarkdown(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (error instanceof ValidationError)
+            throw error;
+        throw new ValidationError('input', `Unable to read Markdown file: ${path}`);
+    }
+}
+export async function listPagesAction(options) {
+    const result = dataRow(await client.get('/pages'));
+    if (!Array.isArray(result.pages) || !result.pages.every(isRow)) {
+        throw new ValidationError('pages', 'Invalid Page list response');
+    }
+    printPage(result.pages, options);
+}
+export async function viewPageAction(id, options) {
+    const page = dataRow(await client.get(`/pages/${resourceId(id)}`));
+    if (options.fields) {
+        const selected = {};
+        for (const field of options.fields.split(',').map((value) => value.trim())) {
+            if (Object.hasOwn(page, field))
+                selected[field] = page[field];
+        }
+        printJson(selected);
+        return;
+    }
+    printJson(page);
+}
+export async function exportPageAction(id, options) {
+    const page = dataRow(await client.get(`/pages/${resourceId(id)}`));
+    const pageId = typeof page.id === 'string' ? resourceId(page.id) : resourceId(id);
+    if (typeof page.title !== 'string')
+        throw new ValidationError('title', 'Page response is missing title');
+    const markdown = exportPageMarkdown({
+        id: pageId,
+        title: page.title,
+        contentJson: pageContent(page),
+        expectedUpdatedAt: pageUpdatedAt(page),
+    });
+    if (options.output) {
+        await writeFile(options.output, markdown, { flag: 'wx', mode: 0o600 });
+        printJson({ output: options.output, pageId });
+        return;
+    }
+    process.stdout.write(markdown);
+}
+export async function createPageAction(options) {
+    const imported = await readPageMarkdown(options.input);
+    const payload = {
+        title: imported.title,
+        parentPageId: options.parentPageId ? resourceId(options.parentPageId) : null,
+        folderId: options.folderId ? resourceId(options.folderId) : null,
+    };
+    if (!options.apply || options.dryRun) {
+        printJson({
+            dryRun: true,
+            requests: [
+                { method: 'POST', path: '/pages', payload },
+                {
+                    method: 'PUT',
+                    path: '/pages/<created-page-id>/content',
+                    payload: {
+                        contentJson: imported.contentJson,
+                        contentHtml: imported.contentHtml,
+                        searchableText: imported.searchableText,
+                    },
+                },
+            ],
+        });
+        return;
+    }
+    const created = dataRow(await client.post('/pages', payload));
+    if (typeof created.id !== 'string')
+        throw new ValidationError('id', 'Page create response is missing ID');
+    const pageId = resourceId(created.id);
+    const saved = dataRow(await client.put(`/pages/${pageId}/content`, {
+        contentJson: imported.contentJson,
+        contentHtml: imported.contentHtml,
+        searchableText: imported.searchableText,
+        expectedUpdatedAt: pageUpdatedAt(created),
+    }));
+    printJson(saved);
+}
+export async function updatePageAction(id, options) {
+    const pageId = resourceId(id);
+    const imported = await readPageMarkdown(options.input);
+    if (imported.pageId && imported.pageId !== pageId) {
+        throw new ValidationError('input', 'Markdown export belongs to a different Page');
+    }
+    if (!options.apply || options.dryRun) {
+        printJson({
+            dryRun: true,
+            requests: [
+                { method: 'PATCH', path: `/pages/${pageId}`, payload: { title: imported.title } },
+                {
+                    method: 'PUT',
+                    path: `/pages/${pageId}/content`,
+                    payload: {
+                        contentJson: imported.contentJson,
+                        contentHtml: imported.contentHtml,
+                        searchableText: imported.searchableText,
+                    },
+                },
+            ],
+        });
+        return;
+    }
+    if (!imported.expectedUpdatedAt) {
+        throw new ValidationError('input', 'Update requires a current Markdown export with its revision marker');
+    }
+    const current = dataRow(await client.get(`/pages/${pageId}`));
+    if (pageUpdatedAt(current) !== imported.expectedUpdatedAt) {
+        throw new ValidationError('input', 'Page changed since export; export it again before updating');
+    }
+    let latest = current;
+    if (current.title !== imported.title) {
+        latest = dataRow(await client.patch(`/pages/${pageId}`, {
+            title: imported.title,
+            expectedUpdatedAt: imported.expectedUpdatedAt,
+        }));
+    }
+    const saved = dataRow(await client.put(`/pages/${pageId}/content`, {
+        contentJson: imported.contentJson,
+        contentHtml: imported.contentHtml,
+        searchableText: imported.searchableText,
+        expectedUpdatedAt: pageUpdatedAt(latest),
+    }));
+    printJson(saved);
+}
+export function registerPageCommand(program) {
+    const page = program.command('page').description('Manage Team Pages as Markdown documents');
+    page
+        .command('list')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (options) => action(() => listPagesAction({ ...options, ...fields(program) })));
+    page
+        .command('view <id>')
+        .action(async (id) => action(() => viewPageAction(id, fields(program))));
+    page
+        .command('export <id>')
+        .option('--output <path>', 'Markdown output file (must not exist)')
+        .action(async (id, options) => action(() => exportPageAction(id, options)));
+    page
+        .command('create')
+        .requiredOption('--input <file>', 'Markdown document')
+        .option('--parent-page-id <id>', 'Parent Page ID')
+        .option('--folder-id <id>', 'Page folder ID')
+        .option('--apply', 'Create the Page')
+        .option('--dry-run', 'Preview creation')
+        .action(async (options) => action(() => createPageAction(options)));
+    page
+        .command('update <id>')
+        .requiredOption('--input <file>', 'Markdown export')
+        .option('--apply', 'Apply the Page update')
+        .option('--dry-run', 'Preview update')
+        .action(async (id, options) => action(() => updatePageAction(id, options)));
+}
+//# sourceMappingURL=page.js.map

package/dist/commands/project.js

@@ -0,0 +1,97 @@
+import { client } from '../client.js';
+import { handleError } from '../utils/errors.js';
+import { filterSingle, printJson, printList } from '../utils/output.js';
+import { parseJson, validateId } from '../utils/validate.js';
+export async function listProjectsAction(options) {
+    const query = {};
+    if (options.teamId)
+        query['teamId'] = options.teamId;
+    if (options.cursor)
+        query['cursor'] = options.cursor;
+    const response = await client.get('/projects', Object.keys(query).length > 0 ? query : undefined);
+    const projects = options.includeArchived
+        ? response.data
+        : response.data.filter((project) => project['status'] !== 'archived');
+    printList(projects, options.fields, response.nextCursor);
+}
+export async function viewProjectAction(projectId, options) {
+    validateId(projectId, 'projectId');
+    const project = await client.get(`/projects/${projectId}`);
+    printJson(filterSingle(project, options.fields));
+}
+export async function createProjectAction(options) {
+    const payload = parseJson(options.json);
+    if (options.dryRun) {
+        printJson({ dryRun: true, method: 'POST', path: '/projects', payload });
+        return;
+    }
+    const result = await client.post('/projects', payload);
+    printJson(result);
+}
+export async function updateProjectAction(projectId, options) {
+    validateId(projectId, 'projectId');
+    const payload = parseJson(options.json);
+    if (options.dryRun) {
+        printJson({ dryRun: true, method: 'PATCH', path: `/projects/${projectId}`, payload });
+        return;
+    }
+    const result = await client.patch(`/projects/${projectId}`, payload);
+    printJson(result);
+}
+export function registerProjectCommand(program) {
+    const project = program.command('project').description('Manage projects');
+    project
+        .command('list')
+        .description('List projects')
+        .option('--team-id <id>', 'Filter by team ID')
+        .option('--cursor <token>', 'Pagination cursor from previous response')
+        .option('--include-archived', 'Include archived projects')
+        .action(async (options) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await listProjectsAction({ ...options, fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    project
+        .command('view <project-id>')
+        .description('View a project by ID')
+        .action(async (projectId) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await viewProjectAction(projectId, { fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    project
+        .command('create')
+        .description('Create a project')
+        .requiredOption('--json <payload>', 'Project fields as JSON')
+        .option('--dry-run', 'Preview without creating', false)
+        .action(async (options) => {
+        try {
+            await createProjectAction(options);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    project
+        .command('update <project-id>')
+        .description('Update a project')
+        .requiredOption('--json <payload>', 'Fields to update as JSON')
+        .option('--dry-run', 'Preview without updating', false)
+        .action(async (projectId, options) => {
+        try {
+            await updateProjectAction(projectId, options);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=project.js.map

package/dist/commands/schema.js

@@ -0,0 +1,178 @@
+import { handleError, ValidationError } from '../utils/errors.js';
+import { printJson } from '../utils/output.js';
+const SCHEMAS = {
+    task: {
+        resource: 'task',
+        endpoints: {
+            list: 'GET /api/projects/:projectId/tasks',
+            view: 'GET /api/tasks/:taskId',
+            create: 'POST /api/projects/:projectId/tasks',
+            update: 'PATCH /api/tasks/:taskId',
+            delete: 'DELETE /api/tasks/:taskId',
+            move: 'POST /api/projects/:projectId/tasks/:taskId/move',
+            uploadAttachment: 'POST /api/tasks/:taskId/attachments (multipart form field: file)',
+        },
+        fields: {
+            id: 'string (uuid)',
+            projectId: 'string (uuid)',
+            cycleId: 'string (uuid) | null',
+            title: 'string',
+            description: 'string | null',
+            stateId: 'string (uuid) — get valid IDs from: zl state list --project-id <id>',
+            priority: 'enum: critical | high | medium | low',
+            category: 'string | null',
+            assigneeId: 'string (uuid) | null',
+            dueDate: 'string (ISO date YYYY-MM-DD) | null',
+            sequenceId: 'number',
+            sortOrder: 'number',
+            linkedWorkflowId: 'string (uuid) | null',
+            url: 'string (canonical Motion task URL; included in create, view, update, and move responses)',
+            reviewRequired: 'boolean',
+            customProperties: 'object',
+            createdById: 'string (uuid)',
+            createdAt: 'string (ISO datetime)',
+            updatedAt: 'string (ISO datetime)',
+            label_ids: 'string[] — get valid IDs from: zl label list --project-id <id>',
+        },
+        createFields: {
+            title: 'string (required)',
+            stateId: 'string (uuid, optional — defaults to project default state)',
+            description: 'string (optional)',
+            priority: 'enum: critical | high | medium | low (optional)',
+            assigneeId: 'string (uuid, optional)',
+            dueDate: 'string YYYY-MM-DD (optional)',
+            cycleId: 'string (uuid, optional)',
+        },
+        updateFields: {
+            title: 'string',
+            description: 'string | null',
+            stateId: 'string (uuid)',
+            priority: 'enum: critical | high | medium | low',
+            assigneeId: 'string (uuid) | null',
+            dueDate: 'string YYYY-MM-DD | null',
+            cycleId: 'string (uuid) | null',
+            sortOrder: 'number',
+        },
+        moveFields: {
+            stateName: 'string (optional — target state name; defaults to an equivalent state)',
+        },
+    },
+    project: {
+        resource: 'project',
+        endpoints: {
+            list: 'GET /api/projects',
+            view: 'GET /api/projects/:id',
+            create: 'POST /api/projects',
+            update: 'PATCH /api/projects/:id',
+        },
+        fields: {
+            id: 'string (uuid)',
+            teamId: 'string (uuid)',
+            name: 'string',
+            description: 'string | null',
+            status: 'string',
+            startDate: 'string (ISO date) | null',
+            targetDate: 'string (ISO date) | null',
+            createdAt: 'string (ISO datetime)',
+            updatedAt: 'string (ISO datetime)',
+        },
+        createFields: {
+            name: 'string (required)',
+            description: 'string (optional)',
+            status: 'string (optional)',
+            startDate: 'string YYYY-MM-DD (optional)',
+            targetDate: 'string YYYY-MM-DD (optional)',
+        },
+    },
+    'api-token': {
+        resource: 'api-token',
+        endpoints: {
+            create: 'Browser-authorized CLI session: GET /api/auth/cli-login then POST /api/auth/cli-token',
+        },
+        fields: {
+            id: 'string (uuid)',
+            label: 'string',
+            teamId: 'string (uuid)',
+            scopes: 'string[]',
+            createdAt: 'string (ISO datetime)',
+            lastUsedAt: 'string (ISO datetime) | null',
+            expiresAt: 'string (ISO datetime) | null',
+        },
+        createFields: {
+            label: 'string (required, 1-64 characters)',
+            scopes: 'string[] (required — least-privilege scopes)',
+            expiresAt: 'string (future ISO datetime, required)',
+            team: 'selected in the authenticated browser from the user active memberships',
+        },
+    },
+    state: {
+        resource: 'state',
+        endpoints: { list: 'GET /api/projects/:projectId/states' },
+        fields: {
+            id: 'string (uuid)',
+            projectId: 'string (uuid)',
+            name: 'string',
+            color: 'string (hex)',
+            type: 'enum: backlog | unstarted | started | completed | cancelled',
+            isDefault: 'boolean',
+        },
+    },
+    label: {
+        resource: 'label',
+        endpoints: { list: 'GET /api/projects/:projectId/labels' },
+        fields: {
+            id: 'string (uuid)',
+            name: 'string',
+            color: 'string (hex)',
+        },
+    },
+    cycle: {
+        resource: 'cycle',
+        endpoints: {
+            list: 'GET /api/projects/:projectId/cycles',
+            view: 'GET /api/cycles/:cycleId',
+        },
+        fields: {
+            id: 'string (uuid)',
+            projectId: 'string (uuid)',
+            name: 'string',
+            status: 'enum: draft | active | completed',
+            startDate: 'string (ISO date) | null',
+            endDate: 'string (ISO date) | null',
+        },
+    },
+    member: {
+        resource: 'member',
+        endpoints: { list: 'GET /api/team/members' },
+        fields: {
+            id: 'string (uuid)',
+            name: 'string | null',
+            email: 'string',
+            role: 'string',
+            joinedAt: 'string (ISO datetime)',
+            status: 'active',
+        },
+    },
+};
+export function registerSchemaCommand(program) {
+    program
+        .command('schema [resource]')
+        .description('Print field schema for a Zalos resource (no network call)')
+        .action((resource) => {
+        try {
+            if (!resource) {
+                printJson({ resources: Object.keys(SCHEMAS) });
+                return;
+            }
+            const schema = SCHEMAS[resource];
+            if (!schema) {
+                throw new ValidationError('resource', `Unknown resource: ${resource}. Available: ${Object.keys(SCHEMAS).join(', ')}`);
+            }
+            printJson(schema);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=schema.js.map