@zalosai/zalos-cli 0.2.13

package/dist/commands/setup.js

@@ -0,0 +1,34 @@
+import { resolveEnvironment } from '../environments.js';
+import { runDatabaseTool } from '../utils/developer-db.js';
+import { handleError } from '../utils/errors.js';
+import { printJson } from '../utils/output.js';
+import { doctorReport } from './doctor.js';
+export async function runSetup(environment, deps) {
+    resolveEnvironment({ flag: environment });
+    await deps.run(['setup']);
+    await deps.login();
+    return deps.doctor(environment);
+}
+export function registerSetupCommand(program) {
+    program
+        .command('setup')
+        .description('Configure database access, sign in, and check access')
+        .action(async () => {
+        try {
+            const environment = resolveEnvironment({ env: process.env.ZL_ENVIRONMENT }).name;
+            const { loginAction } = await import('./auth.js');
+            const result = await runSetup(environment, {
+                run: runDatabaseTool,
+                login: () => loginAction(),
+                doctor: doctorReport,
+            });
+            printJson(result);
+            if (!result.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=setup.js.map

package/dist/commands/state.js

@@ -0,0 +1,30 @@
+import { client } from '../client.js';
+import { handleError } from '../utils/errors.js';
+import { printList } from '../utils/output.js';
+import { validateId } from '../utils/validate.js';
+export async function listStatesAction(options) {
+    validateId(options.projectId, 'projectId');
+    const query = {};
+    if (options.cursor)
+        query['cursor'] = options.cursor;
+    const response = await client.get(`/projects/${options.projectId}/states`, Object.keys(query).length > 0 ? query : undefined);
+    printList(response.data, options.fields, response.nextCursor);
+}
+export function registerStateCommand(program) {
+    const state = program.command('state').description('Manage task states');
+    state
+        .command('list')
+        .description('List states for a project')
+        .requiredOption('--project-id <id>', 'Project ID')
+        .option('--cursor <token>', 'Pagination cursor from previous response')
+        .action(async (options) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await listStatesAction({ ...options, fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=state.js.map

package/dist/commands/task-comment.js

@@ -0,0 +1,75 @@
+import { client } from '../client.js';
+import { handleError, ValidationError } from '../utils/errors.js';
+import { printJson, printList } from '../utils/output.js';
+import { readStdin } from '../utils/stdin.js';
+import { validateId, validateString } from '../utils/validate.js';
+export async function listCommentsAction(taskId, options) {
+    validateId(taskId, 'taskId');
+    const query = {};
+    if (options.cursor)
+        query['cursor'] = options.cursor;
+    const comments = await client.get(`/tasks/${taskId}/comments`, Object.keys(query).length > 0 ? query : undefined);
+    printList(comments.data, options.fields, comments.nextCursor);
+}
+export async function addCommentAction(taskId, options) {
+    validateId(taskId, 'taskId');
+    let body;
+    if (options.body === '-') {
+        if (process.stdin.isTTY) {
+            throw new ValidationError('body', 'Comment body is required — pipe input or pass --body <text>');
+        }
+        body = (await readStdin()).trim();
+        if (!body)
+            throw new ValidationError('body', 'Comment body is required (got empty input from stdin)');
+    }
+    else {
+        body = options.body;
+        if (!body)
+            throw new ValidationError('body', 'Comment body is required (body cannot be empty)');
+    }
+    validateString(body, 'body');
+    if (options.dryRun) {
+        printJson({
+            dryRun: true,
+            method: 'POST',
+            path: `/tasks/${taskId}/comments`,
+            payload: { body },
+        });
+        return;
+    }
+    const result = await client.post(`/tasks/${taskId}/comments`, { body });
+    printJson(result);
+}
+export function registerTaskCommentCommand(taskCommand, program) {
+    const comment = taskCommand.command('comment').description('Manage task comments');
+    comment
+        .command('list <task-id>')
+        .description('List comments on a task')
+        .option('--cursor <token>', 'Pagination cursor from previous response')
+        .action(async (taskId, options) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await listCommentsAction(taskId, { fields: globalOpts.fields, cursor: options.cursor });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    comment
+        .command('add <task-id>')
+        .description('Add a comment to a task')
+        .option('--body <text>', 'Comment body; use - to read from stdin')
+        .option('--dry-run', 'Preview without adding', false)
+        .action(async (taskId, options) => {
+        try {
+            if (options.body === undefined) {
+                handleError(new ValidationError('body', 'Comment body is required (--body <text> or --body -)'));
+            }
+            await addCommentAction(taskId, { body: options.body, dryRun: options.dryRun });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=task-comment.js.map

package/dist/commands/task.js

@@ -0,0 +1,245 @@
+import { readFile, stat } from 'node:fs/promises';
+import { basename, extname } from 'node:path';
+import { client } from '../client.js';
+import { handleError, ValidationError } from '../utils/errors.js';
+import { filterSingle, printJson, printList } from '../utils/output.js';
+import { parseJson, validateId } from '../utils/validate.js';
+const IMAGE_MIME_TYPES = {
+    '.avif': 'image/avif',
+    '.gif': 'image/gif',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+};
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const TASK_PRIORITIES = ['critical', 'high', 'medium', 'low'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export async function listTasksAction(options) {
+    validateId(options.projectId, 'projectId');
+    const limit = Number.parseInt(options.limit ?? '20', 10);
+    if (!Number.isInteger(limit) ||
+        String(limit) !== (options.limit ?? '20') ||
+        limit < 1 ||
+        limit > 100) {
+        throw new ValidationError('--limit', '--limit must be an integer between 1 and 100');
+    }
+    if (options.priority &&
+        !TASK_PRIORITIES.includes(options.priority)) {
+        throw new ValidationError('--priority', `--priority must be one of: ${TASK_PRIORITIES.join(', ')}`);
+    }
+    const query = {};
+    if (options.stateId)
+        query['stateId'] = options.stateId;
+    if (options.assigneeId)
+        query['assigneeId'] = options.assigneeId;
+    if (options.priority)
+        query['priority'] = options.priority;
+    if (options.limit)
+        query['limit'] = options.limit;
+    if (options.cursor)
+        query['cursor'] = options.cursor;
+    const response = await client.get(`/projects/${options.projectId}/tasks`, Object.keys(query).length > 0 ? query : undefined);
+    const filtered = response.data.filter((task) => (!options.stateId || task['stateId'] === options.stateId) &&
+        (!options.assigneeId || task['assigneeId'] === options.assigneeId) &&
+        (!options.priority || task['priority'] === options.priority));
+    // Current production returns the complete project task set and ignores list query parameters.
+    // Preserve server pagination when it is available, otherwise enforce the CLI contract locally.
+    if (response.nextCursor !== undefined) {
+        printList(filtered, options.fields, response.nextCursor);
+        return;
+    }
+    let startIndex = 0;
+    if (options.cursor) {
+        const cursorIndex = filtered.findIndex((task) => task['id'] === options.cursor);
+        if (cursorIndex === -1) {
+            throw new ValidationError('--cursor', 'Cursor does not match a task in this result set');
+        }
+        startIndex = cursorIndex + 1;
+    }
+    const page = filtered.slice(startIndex, startIndex + limit);
+    const hasMore = startIndex + page.length < filtered.length;
+    const nextCursor = hasMore ? String(page.at(-1)?.['id']) : undefined;
+    printList(page, options.fields, nextCursor);
+}
+export async function viewTaskAction(taskId, options) {
+    validateId(taskId, 'taskId');
+    const response = await client.get(`/tasks/${taskId}`);
+    const task = 'data' in response && isRecord(response.data) ? response.data : response;
+    printJson(filterSingle(task, options.fields));
+}
+export async function createTaskAction(options) {
+    validateId(options.projectId, 'projectId');
+    const payload = parseJson(options.json);
+    if (options.dryRun) {
+        printJson({
+            dryRun: true,
+            method: 'POST',
+            path: `/projects/${options.projectId}/tasks`,
+            payload,
+        });
+        return;
+    }
+    const result = await client.post(`/projects/${options.projectId}/tasks`, payload);
+    printJson(result);
+}
+export async function updateTaskAction(taskId, options) {
+    validateId(taskId, 'taskId');
+    const payload = parseJson(options.json);
+    if (options.dryRun) {
+        printJson({ dryRun: true, method: 'PATCH', path: `/tasks/${taskId}`, payload });
+        return;
+    }
+    const result = await client.patch(`/tasks/${taskId}`, payload);
+    printJson(result);
+}
+export async function deleteTaskAction(taskId, options) {
+    validateId(taskId, 'taskId');
+    if (options.dryRun) {
+        printJson({ dryRun: true, method: 'DELETE', path: `/tasks/${taskId}` });
+        return;
+    }
+    await client.delete(`/tasks/${taskId}`);
+    printJson({ deleted: true, taskId });
+}
+export async function moveTaskAction(taskId, options) {
+    validateId(taskId, 'taskId');
+    validateId(options.projectId, 'projectId');
+    const payload = options.stateName?.trim() ? { stateName: options.stateName.trim() } : {};
+    const path = `/projects/${options.projectId}/tasks/${taskId}/move`;
+    if (options.dryRun) {
+        printJson({ dryRun: true, method: 'POST', path, payload });
+        return;
+    }
+    printJson(await client.post(path, payload));
+}
+export async function uploadTaskAttachmentAction(taskId, filePath) {
+    validateId(taskId, 'taskId');
+    const mimeType = IMAGE_MIME_TYPES[extname(filePath).toLowerCase()];
+    if (!mimeType) {
+        throw new ValidationError('file', 'Only image files are supported');
+    }
+    let fileSize;
+    try {
+        fileSize = (await stat(filePath)).size;
+    }
+    catch {
+        throw new ValidationError('file', `Unable to read image file: ${filePath}`);
+    }
+    if (fileSize > MAX_IMAGE_BYTES) {
+        throw new ValidationError('file', 'Image too large — max 10 MB');
+    }
+    let contents;
+    try {
+        contents = await readFile(filePath);
+    }
+    catch {
+        throw new ValidationError('file', `Unable to read image file: ${filePath}`);
+    }
+    const form = new FormData();
+    const imageBytes = new Uint8Array(contents);
+    form.append('file', new Blob([imageBytes], { type: mimeType }), basename(filePath));
+    printJson(await client.postForm(`/tasks/${taskId}/attachments`, form));
+}
+export function registerTaskCommand(program) {
+    const task = program.command('task').description('Manage tasks');
+    task
+        .command('list')
+        .description('List tasks in a project')
+        .requiredOption('--project-id <id>', 'Project ID')
+        .option('--state-id <id>', 'Filter by state ID')
+        .option('--assignee-id <id>', 'Filter by assignee ID')
+        .option('--priority <level>', 'Filter by priority: critical|high|medium|low')
+        .option('--limit <n>', 'Max results (default 20, max 100)', '20')
+        .option('--cursor <token>', 'Pagination cursor from previous response')
+        .action(async (options) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await listTasksAction({ ...options, fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    task
+        .command('view <task-id>')
+        .description('View a task by ID')
+        .action(async (taskId) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await viewTaskAction(taskId, { fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    task
+        .command('create')
+        .description('Create a task')
+        .requiredOption('--project-id <id>', 'Project ID')
+        .requiredOption('--json <payload>', 'Task fields as JSON (see: zl schema task)')
+        .option('--dry-run', 'Preview without creating', false)
+        .action(async (options) => {
+        try {
+            await createTaskAction(options);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    task
+        .command('update <task-id>')
+        .description('Update a task')
+        .requiredOption('--json <payload>', 'Fields to update as JSON (see: zl schema task)')
+        .option('--dry-run', 'Preview without updating', false)
+        .action(async (taskId, options) => {
+        try {
+            await updateTaskAction(taskId, options);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    task
+        .command('delete <task-id>')
+        .description('Delete a task')
+        .option('--dry-run', 'Preview without deleting', false)
+        .action(async (taskId, options) => {
+        try {
+            await deleteTaskAction(taskId, options);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    task
+        .command('move <task-id>')
+        .description('Move a task to another project')
+        .requiredOption('--project-id <id>', 'Target project ID')
+        .option('--state-name <name>', 'Target state name (defaults to an equivalent state)')
+        .option('--dry-run', 'Preview without moving', false)
+        .action(async (taskId, options) => {
+        try {
+            await moveTaskAction(taskId, options);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    const attachment = task.command('attachment').description('Manage task image attachments');
+    attachment
+        .command('upload <task-id> <file>')
+        .description('Upload an image attachment to a task')
+        .action(async (taskId, filePath) => {
+        try {
+            await uploadTaskAttachmentAction(taskId, filePath);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=task.js.map

package/dist/commands/team.js

@@ -0,0 +1,88 @@
+import { client, revokeCurrentHumanToken } from '../client.js';
+import { readProfile, writeProfile } from '../credentials.js';
+import { currentEnvironment } from '../environments.js';
+import { AuthError } from '../utils/errors.js';
+import { action, dataRow, dataRows, fields, isRow, printPage, resourceId, } from '../utils/product-api.js';
+import { printJson } from '../utils/output.js';
+export async function listTeamsAction(options) {
+    const path = options.allTeams ? '/developer/teams' : '/auth/cli-token/teams';
+    printPage(dataRows(await client.get(path)), options);
+}
+function metadata(value, name) {
+    if (!isRow(value) || typeof value.id !== 'string' || typeof value.name !== 'string')
+        throw new AuthError(`Invalid ${name} metadata returned by server`);
+    return {
+        id: value.id,
+        ...(typeof value.publicId === 'string' ? { publicId: value.publicId } : {}),
+        name: value.name,
+    };
+}
+export async function switchTeamAction(teamReference) {
+    if (process.env.ZL_API_TOKEN)
+        throw new AuthError('Team switching requires a persisted human profile; unset ZL_API_TOKEN');
+    const profileName = process.env.ZL_PROFILE ?? 'default';
+    const profile = readProfile(profileName);
+    if (!profile)
+        throw new AuthError('Not authenticated. Run: zl auth login');
+    const environment = currentEnvironment(profile.environment);
+    if (profile.apiUrl !== environment.apiUrl)
+        throw new AuthError('Profile API origin mismatch; log in to this origin again');
+    const selectedTeamReference = resourceId(teamReference);
+    if (profile.team?.id === selectedTeamReference ||
+        profile.team?.publicId === selectedTeamReference) {
+        printJson({
+            switched: false,
+            message: 'Team already selected',
+            profile: profileName,
+            team: profile.team,
+        });
+        return;
+    }
+    const result = dataRow(await client.post('/auth/cli-token/switch', { teamId: selectedTeamReference }, { detailedAuthErrors: true }));
+    if (typeof result.token !== 'string' ||
+        !result.token ||
+        typeof result.tokenId !== 'string' ||
+        !result.tokenId ||
+        typeof result.expiresAt !== 'string' ||
+        result.expiresAt !== profile.expiresAt)
+        throw new AuthError('Invalid replacement token returned by server');
+    const organization = metadata(result.organization, 'organization');
+    const team = metadata(result.team, 'team');
+    writeProfile(profileName, {
+        ...profile,
+        token: result.token,
+        tokenId: result.tokenId,
+        expiresAt: result.expiresAt,
+        organization,
+        team,
+    });
+    try {
+        await revokeCurrentHumanToken(profile.token);
+    }
+    catch {
+        process.stderr.write('Warning: team switched, but the previous token could not be revoked and remains valid until expiry.\n');
+    }
+    printJson({
+        switched: true,
+        profile: profileName,
+        environment: profile.environment,
+        expiresAt: result.expiresAt,
+        organization,
+        team,
+    });
+}
+export function registerTeamCommand(program) {
+    const command = program.command('team').description('Inspect and select regional teams');
+    command
+        .command('list')
+        .option('--all-teams', 'List every team in the selected region (internal human only)')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (options) => action(() => listTeamsAction({ ...options, ...fields(program) })));
+    command
+        .command('switch')
+        .description('Switch the selected human profile to an accessible team')
+        .argument('<team-ref>', 'Target public ID (preferred) or UUID from zl team list')
+        .action(async (teamReference) => action(() => switchTeamAction(teamReference)));
+}
+//# sourceMappingURL=team.js.map

package/dist/commands/template.js

@@ -0,0 +1,21 @@
+import { client } from '../client.js';
+import { filterSingle, printJson } from '../utils/output.js';
+import { action, dataRow, dataRows, fields, printPage, resourceId, } from '../utils/product-api.js';
+export async function listTemplatesAction(options) {
+    printPage(dataRows(await client.get('/templates')), options);
+}
+export async function viewTemplateAction(id, options) {
+    printJson(filterSingle(dataRow(await client.get(`/templates/${resourceId(id)}`)), options.fields));
+}
+export function registerTemplateCommand(program) {
+    const cmd = program.command('template');
+    cmd
+        .command('list')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (o) => action(() => listTemplatesAction({ ...o, ...fields(program) })));
+    cmd
+        .command('view <id>')
+        .action(async (id) => action(() => viewTemplateAction(id, fields(program))));
+}
+//# sourceMappingURL=template.js.map