@zalosai/zalos-cli 0.2.13

package/dist/commands/credential.js

@@ -0,0 +1,15 @@
+import { client } from '../client.js';
+import { filterSingle } from '../utils/output.js';
+import { action, dataRows, fields, printPage } from '../utils/product-api.js';
+export async function listCredentialsAction(options) {
+    printPage(dataRows(await client.get('/credentials')).map((row) => filterSingle(row, 'id,name,type,createdAt,updatedAt')), options);
+}
+export function registerCredentialCommand(program) {
+    const cmd = program.command('credential');
+    cmd
+        .command('list')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (o) => action(() => listCredentialsAction({ ...o, ...fields(program) })));
+}
+//# sourceMappingURL=credential.js.map

package/dist/commands/cycle.js

@@ -0,0 +1,47 @@
+import { client } from '../client.js';
+import { handleError } from '../utils/errors.js';
+import { filterSingle, printJson, printList } from '../utils/output.js';
+import { validateId } from '../utils/validate.js';
+export async function listCyclesAction(options) {
+    validateId(options.projectId, 'projectId');
+    const query = {};
+    if (options.cursor)
+        query['cursor'] = options.cursor;
+    const response = await client.get(`/projects/${options.projectId}/cycles`, Object.keys(query).length > 0 ? query : undefined);
+    printList(response.data, options.fields, response.nextCursor);
+}
+export async function viewCycleAction(cycleId, options) {
+    validateId(cycleId, 'cycleId');
+    const cycle = await client.get(`/cycles/${cycleId}`);
+    printJson(filterSingle(cycle, options.fields));
+}
+export function registerCycleCommand(program) {
+    const cycle = program.command('cycle').description('Manage cycles');
+    cycle
+        .command('list')
+        .description('List cycles 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 listCyclesAction({ ...options, fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    cycle
+        .command('view <cycle-id>')
+        .description('View a cycle by ID')
+        .action(async (cycleId) => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await viewCycleAction(cycleId, { fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=cycle.js.map

package/dist/commands/doctor.js

@@ -0,0 +1,106 @@
+import { readFileSync } from 'node:fs';
+import { currentEnvironment, resolveEnvironment } from '../environments.js';
+import { DATABASE_INSTALL, DatabaseToolError, runDatabaseTool } from '../utils/developer-db.js';
+import { handleError } from '../utils/errors.js';
+import { printJson } from '../utils/output.js';
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function metadata(value, fields) {
+    const source = object(value);
+    return Object.fromEntries(fields
+        .filter((key) => typeof source[key] === 'string' ||
+        typeof source[key] === 'number' ||
+        source[key] === null)
+        .map((key) => [key, source[key]]));
+}
+export async function buildDoctorReport(environment, deps) {
+    const selected = currentEnvironment(undefined, environment);
+    let api;
+    try {
+        const status = await deps.authStatus();
+        api =
+            status.environment !== environment
+                ? { ok: false, code: 'ENVIRONMENT_MISMATCH' }
+                : {
+                    ok: status.authenticated === true,
+                    ...metadata(status, ['expiresAt', 'remainingSeconds', 'profile']),
+                    user: metadata(status.user, ['id', 'email', 'name']),
+                    team: metadata(status.team, ['id', 'name']),
+                    organization: metadata(status.organization, ['id', 'name']),
+                };
+    }
+    catch {
+        api = {
+            ok: false,
+            code: 'AUTH_CHECK_FAILED',
+            action: `zl --environment ${environment} auth login`,
+        };
+    }
+    let database;
+    try {
+        const result = object(await deps.run(['doctor', '--environment', environment]));
+        database =
+            result.environment !== environment
+                ? { ok: false, code: 'ENVIRONMENT_MISMATCH' }
+                : {
+                    ok: result.ok === true,
+                    installed: true,
+                    environment,
+                    awsSso: result.ok === true ? 'ready' : 'unknown',
+                    ...(result.ok === true ? {} : { code: 'CHECK_FAILED' }),
+                };
+    }
+    catch (error) {
+        const code = error instanceof DatabaseToolError
+            ? error.code
+            : object(error).code === 'ENOENT'
+                ? 'NOT_INSTALLED'
+                : 'CHECK_FAILED';
+        database = {
+            ok: false,
+            code,
+            installed: code !== 'NOT_INSTALLED',
+            awsSso: ['aws_session', 'aws_identity', 'sso_login'].includes(code)
+                ? 'unavailable'
+                : 'unknown',
+            action: code === 'NOT_INSTALLED'
+                ? `Obtain the immutable wheel URL from Platform, then run: ${DATABASE_INSTALL}`
+                : `zalos-db login --environment ${environment}; zalos-db doctor --environment ${environment}`,
+        };
+    }
+    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    return {
+        ok: api.ok && database.ok,
+        environment,
+        apiUrl: selected.apiUrl,
+        nodeVersion: process.version,
+        cliVersion: pkg.version,
+        api,
+        database,
+    };
+}
+export async function doctorReport(environment) {
+    const { authStatus } = await import('./auth.js');
+    return buildDoctorReport(environment, { authStatus, run: runDatabaseTool });
+}
+export function registerDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('Check regional product and database access')
+        .action(async () => {
+        try {
+            const selected = resolveEnvironment({ env: process.env.ZL_ENVIRONMENT });
+            const report = await doctorReport(selected.name);
+            printJson(report);
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/execution.js

@@ -0,0 +1,117 @@
+import { client } from '../client.js';
+import { writeFile } from 'node:fs/promises';
+import { currentEnvironment } from '../environments.js';
+import { downloadToNewFile } from '../utils/download-file.js';
+import { ApiError, ValidationError } from '../utils/errors.js';
+import { filterFields, filterSingle, printJson } from '../utils/output.js';
+import { action, dataRow, fields, integer, isRow, resourceId, } from '../utils/product-api.js';
+export async function inspectRecoveryAction(id, options) {
+    const executionId = resourceId(id);
+    const bundle = dataRow(await client.get(`/executions/${executionId}/recovery/inspect`));
+    if (bundle.schemaVersion !== 1 ||
+        bundle.executionId !== executionId ||
+        typeof bundle.sha256 !== 'string' ||
+        !isRow(bundle.evidence) ||
+        !Array.isArray(bundle.evidence.entries) ||
+        !bundle.evidence.entries.every(isRow))
+        throw new ApiError(502, 'Invalid recovery evidence bundle');
+    const encoded = `${JSON.stringify(bundle, null, 2)}\n`;
+    if (Buffer.byteLength(encoded) > 4 * 1024 * 1024)
+        throw new ApiError(502, 'Recovery evidence bundle exceeds the size limit');
+    if (options.output)
+        await writeFile(options.output, encoded, { flag: 'wx', mode: 0o600 });
+    if (options.json) {
+        printJson(bundle);
+        return;
+    }
+    const timeline = bundle.evidence.entries.map((entry) => {
+        const data = isRow(entry.data) ? entry.data : {};
+        const outcome = data.outcome ?? data.stage ?? data.status ?? '';
+        return `${entry.sequence}. ${entry.at}  ${entry.kind}: ${outcome}`;
+    });
+    // Terminal control characters from remote text must never be interpreted by the terminal.
+    const text = [
+        `Recovery evidence for ${executionId}`,
+        ...timeline,
+        `Bundle SHA-256: ${bundle.sha256}`,
+        ...(options.output ? [`Saved to ${options.output}`] : []),
+    ]
+        .join('\n')
+        // oxlint-disable-next-line no-control-regex -- intentional terminal output sanitization
+        .replace(/[\u0000-\u0008\u000b-\u001f\u007f\u202a-\u202e\u2066-\u2069]/g, '');
+    process.stdout.write(`${text}\n`);
+}
+export async function downloadExecutionArtifactAction(artifactId, options) {
+    const id = resourceId(artifactId);
+    const download = dataRow(await client.get(`/execution-artifacts/${id}/download`));
+    if (typeof download.url !== 'string') {
+        throw new ValidationError('download', 'The execution artifact API response did not include a download URL');
+    }
+    const downloaded = await downloadToNewFile(download.url, options.output, {
+        allowDataUrl: options.allowDataUrl,
+    });
+    printJson({ artifactId: id, ...downloaded });
+}
+export async function listExecutionsAction(options) {
+    const filter = {};
+    if (options.workflowId)
+        filter.workflowId = resourceId(options.workflowId);
+    if (options.status)
+        filter.status = options.status.split(',');
+    const query = {
+        limit: String(integer(options.limit, 20, 1, 100)),
+        offset: String(integer(options.offset, 0)),
+        ...(Object.keys(filter).length ? { filter: JSON.stringify(filter) } : {}),
+    };
+    const response = await client.get('/executions', query);
+    if (!isRow(response) ||
+        !Array.isArray(response.results) ||
+        !response.results.every(isRow) ||
+        typeof response.count !== 'number')
+        throw new ApiError(502, 'Expected execution results and count');
+    printJson({
+        data: filterFields(response.results, options.fields),
+        count: response.count,
+        ...(Number(query.offset) + response.results.length < response.count
+            ? { nextOffset: Number(query.offset) + response.results.length }
+            : {}),
+    });
+}
+export async function viewExecutionAction(id, options, summary = false) {
+    printJson(filterSingle(dataRow(await client.get(`/executions/${resourceId(id)}${summary ? '/summary' : ''}`)), options.fields));
+}
+export function registerExecutionCommand(program) {
+    const cmd = program.command('execution').description('Inspect workflow executions');
+    cmd
+        .command('recovery')
+        .description('Owner/internal recovery evidence')
+        .command('inspect <execution-id>')
+        .description('Read the durable recovery timeline without contacting the provider or sandbox')
+        .option('--output <path>', 'Save the evidence bundle to a new private JSON file')
+        .option('--json', 'Print the full evidence bundle as JSON')
+        .action(async (id, options) => action(() => inspectRecoveryAction(id, options)));
+    cmd
+        .command('list')
+        .option('--workflow-id <id>', 'Workflow ID')
+        .option('--status <statuses>', 'Comma-separated statuses')
+        .option('--limit <n>', 'Maximum results', '20')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (o) => action(() => listExecutionsAction({ ...o, ...fields(program) })));
+    for (const verb of ['view', 'summary'])
+        cmd
+            .command(`${verb} <id>`)
+            .action(async (id) => action(() => viewExecutionAction(id, fields(program), verb === 'summary')));
+    const artifact = cmd.command('artifact').description('Access immutable execution artifacts');
+    artifact
+        .command('download <artifact-id>')
+        .description('Download an immutable execution artifact through the authenticated API')
+        .requiredOption('--output <path>', 'Write content to a new file')
+        .action(async (artifactId, options) => action(() => {
+        const hostname = new URL(currentEnvironment().apiUrl).hostname;
+        return downloadExecutionArtifactAction(artifactId, {
+            ...options,
+            allowDataUrl: ['localhost', '127.0.0.1', '[::1]'].includes(hostname),
+        });
+    }));
+}
+//# sourceMappingURL=execution.js.map

package/dist/commands/file.js

@@ -0,0 +1,257 @@
+import { writeFile } from 'node:fs/promises';
+import { client } from '../client.js';
+import { currentEnvironment } from '../environments.js';
+import { ValidationError } from '../utils/errors.js';
+import { downloadToNewFile } from '../utils/download-file.js';
+import { filterSingle, printJson } from '../utils/output.js';
+import { action, dataRow, dataRows, fields, isRow, printPage, resourceId, } from '../utils/product-api.js';
+const FILE_FIELDS = 'id,name,fileName,mimeType,size,fileSize,folderId,createdAt,updatedAt';
+async function files(options) {
+    return dataRows(await client.get('/team-files', {
+        folderId: options.folderId ? resourceId(options.folderId) : 'root',
+    })).map((row) => filterSingle(row, FILE_FIELDS));
+}
+export async function listFilesAction(options) {
+    printPage(await files(options), options);
+}
+export async function treeFilesAction(options) {
+    printPage(dataRows(await client.get('/developer/team-files/tree', { teamId: resourceId(options.teamId) })), options);
+}
+export async function viewFileAction(id, options) {
+    const response = options.path
+        ? await client.get('/team-files/by-path', { path: id })
+        : await client.get(`/team-files/${resourceId(id)}`);
+    printJson(filterSingle(filterSingle(dataRow(response), FILE_FIELDS), options.fields));
+}
+export async function findFilesAction(query, options) {
+    if (!query.trim())
+        throw new ValidationError('query', 'query must not be empty');
+    if (options.teamId) {
+        printPage(dataRows(await client.get('/developer/team-files/search', {
+            teamId: resourceId(options.teamId),
+            query,
+        })), options);
+        return;
+    }
+    printPage((await files(options)).filter((row) => String(row.name ?? row.fileName ?? '')
+        .toLowerCase()
+        .includes(query.toLowerCase())), options);
+}
+export async function inspectFileAction(id, options) {
+    printJson(filterSingle(dataRow(await client.get(`/developer/team-files/${resourceId(id)}`, {
+        teamId: resourceId(options.teamId),
+    })), options.fields));
+}
+export async function downloadFileAction(idOrPath, options) {
+    if (options.path && options.teamId) {
+        throw new ValidationError('path', '--path cannot be combined with --team-id');
+    }
+    let fileId;
+    if (options.path) {
+        const file = dataRow(await client.get('/team-files/by-path', { path: idOrPath }));
+        if (typeof file.id !== 'string') {
+            throw new ValidationError('file', 'The file API response did not include a file ID');
+        }
+        fileId = resourceId(file.id);
+    }
+    else {
+        fileId = resourceId(idOrPath);
+    }
+    const response = options.teamId
+        ? await client.get(`/developer/team-files/${fileId}/download`, {
+            teamId: resourceId(options.teamId),
+        })
+        : await client.get(`/team-files/${fileId}/download`);
+    const download = dataRow(response);
+    if (typeof download.url !== 'string') {
+        throw new ValidationError('download', 'The file API response did not include a download URL');
+    }
+    printJson(await downloadToNewFile(download.url, options.output, {
+        allowDataUrl: options.allowDataUrl,
+    }));
+}
+export async function snapshotFilesAction(options) {
+    if (options.teamId) {
+        const snapshot = {
+            ...dataRow(await client.get('/developer/team-files/snapshot', {
+                teamId: resourceId(options.teamId),
+            })),
+            ...(options.environment ? { environment: options.environment } : {}),
+            command: 'zl file snapshot',
+        };
+        if (options.output) {
+            await writeFile(options.output, `${JSON.stringify(snapshot, null, 2)}\n`, {
+                flag: 'wx',
+                mode: 0o600,
+            });
+            printJson({
+                output: options.output,
+                items: Array.isArray(snapshot.items) ? snapshot.items.length : 0,
+            });
+            return;
+        }
+        printJson(snapshot);
+        return;
+    }
+    if (options.output)
+        throw new ValidationError('output', '--output requires an explicit --team-id');
+    const rows = await files(options);
+    printJson({
+        folderId: options.folderId ?? null,
+        data: rows.map((row) => filterSingle(row, options.fields)),
+        count: rows.length,
+    });
+}
+export async function seedFilesAction(options) {
+    if (options.apply && !options.dryRun && !options.expectedChecksum) {
+        throw new ValidationError('expectedChecksum', 'Preview the seed plan, then pass its checksum with --expected-checksum and --apply');
+    }
+    const sourceScope = options.sourceScope ?? 'files';
+    if (sourceScope !== 'files' && sourceScope !== 'generated-outputs') {
+        throw new ValidationError('sourceScope', 'sourceScope must be files or generated-outputs');
+    }
+    const payload = {
+        sourceTeamId: resourceId(options.sourceTeamId),
+        sourceScope,
+        sourcePath: options.sourcePath ?? '/',
+        targetPath: options.targetPath ?? '/',
+    };
+    const plan = dataRow(await client.post('/developer/team-files/seed-plan', payload));
+    if (!['ready', 'blocked'].includes(String(plan.status)) || !Array.isArray(plan.operations)) {
+        throw new ValidationError('plan', 'Invalid Team Files seed plan response');
+    }
+    if (!options.apply || options.dryRun) {
+        printJson(plan);
+        return;
+    }
+    if (plan.status !== 'ready') {
+        throw new ValidationError('plan', 'Cannot apply a blocked Team Files seed plan');
+    }
+    if (plan.checksum !== options.expectedChecksum) {
+        throw new ValidationError('expectedChecksum', 'Team Files changed after preview; review the current plan and checksum');
+    }
+    printJson({
+        applied: true,
+        plan,
+        data: dataRow(await client.post('/developer/team-files/seed', {
+            ...payload,
+            expectedChecksum: options.expectedChecksum,
+        })),
+    });
+}
+export async function moveFileAction(id, options) {
+    const path = `/team-files/${resourceId(id)}/move`;
+    if (options.to !== undefined) {
+        if (options.folderId || options.root || !options.to.trim())
+            throw new ValidationError('to', '--to must be a nonempty path and cannot be combined with --folder-id or --root');
+        const plan = dataRow(await client.post(`/team-files/${id}/move-plan`, { to: options.to }));
+        if (!['ready', 'blocked'].includes(String(plan.status)) || !Array.isArray(plan.operations))
+            throw new ValidationError('plan', 'Invalid move plan response');
+        if (!options.apply || options.dryRun) {
+            printJson(plan);
+            return;
+        }
+        if (plan.status !== 'ready' || plan.operations.length !== 1)
+            throw new ValidationError('plan', 'Cannot apply blocked or invalid move plan');
+        const operation = plan.operations[0];
+        if (!isRow(operation) ||
+            operation.fileId !== id ||
+            operation.status !== 'ready' ||
+            (operation.targetFolderId !== null && typeof operation.targetFolderId !== 'string'))
+            throw new ValidationError('plan', 'Move plan does not match the requested file');
+        const folderId = operation.targetFolderId === null ? null : resourceId(operation.targetFolderId);
+        printJson({
+            applied: true,
+            plan,
+            data: filterSingle(dataRow(await client.patch(path, { folderId })), FILE_FIELDS),
+        });
+        return;
+    }
+    if (Boolean(options.folderId) === Boolean(options.root))
+        throw new ValidationError('folderId', 'Choose exactly one of --folder-id or --root');
+    const payload = {
+        folderId: options.folderId ? resourceId(options.folderId) : null,
+    };
+    if (!options.apply || options.dryRun) {
+        printJson({ dryRun: true, method: 'PATCH', path, payload });
+        return;
+    }
+    printJson(filterSingle(dataRow(await client.patch(path, payload)), FILE_FIELDS));
+}
+export function registerFileCommand(program) {
+    const cmd = program.command('file').description('Inspect, download, and move Team Files');
+    cmd
+        .command('list')
+        .option('--folder-id <id>', 'Folder ID (defaults to root)')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (o) => action(() => listFilesAction({ ...o, ...fields(program) })));
+    cmd
+        .command('tree')
+        .description('List enriched Team Files metadata recursively for an explicit team')
+        .requiredOption('--team-id <ref>', 'Team public ID (preferred) or UUID; internal human only')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (o) => action(() => treeFilesAction({ ...o, ...fields(program) })));
+    cmd
+        .command('view <id-or-path>')
+        .option('--path', 'Resolve an exact Team Files path')
+        .action(async (id, o) => action(() => viewFileAction(id, { ...o, ...fields(program) })));
+    cmd
+        .command('find <query>')
+        .description('Search file names within a folder')
+        .option('--folder-id <id>', 'Folder ID (defaults to root)')
+        .option('--team-id <ref>', 'Search an explicit team by public ID or UUID (internal human only)')
+        .option('--limit <n>', 'Maximum results', '100')
+        .option('--offset <n>', 'Result offset', '0')
+        .action(async (q, o) => action(() => findFilesAction(q, { ...o, ...fields(program) })));
+    cmd
+        .command('inspect <id>')
+        .description('Inspect enriched metadata for a Team File in an explicit team')
+        .requiredOption('--team-id <ref>', 'Team public ID (preferred) or UUID; internal human only')
+        .action(async (id, o) => action(() => inspectFileAction(id, { ...o, ...fields(program) })));
+    cmd
+        .command('download <id-or-path>')
+        .description('Download a Team File through the authenticated API')
+        .requiredOption('--output <path>', 'Write content to a new file')
+        .option('--path', 'Resolve an exact Team Files path in the selected team')
+        .option('--team-id <ref>', 'Download from a team by public ID or UUID (internal human only)')
+        .action(async (id, o) => action(() => {
+        const hostname = new URL(currentEnvironment().apiUrl).hostname;
+        return downloadFileAction(id, {
+            ...o,
+            allowDataUrl: ['localhost', '127.0.0.1', '[::1]'].includes(hostname),
+        });
+    }));
+    cmd
+        .command('snapshot')
+        .description('Snapshot metadata within a folder')
+        .option('--folder-id <id>', 'Folder ID (defaults to root)')
+        .option('--team-id <ref>', 'Snapshot a team by public ID or UUID (internal human only)')
+        .option('--output <path>', 'Write JSON to a new file')
+        .action(async (o) => action(() => snapshotFilesAction({
+        ...o,
+        ...fields(program),
+        environment: currentEnvironment().name,
+    })));
+    cmd
+        .command('seed')
+        .description('Copy a Team Files subtree from another team into the selected team')
+        .requiredOption('--source-team-id <ref>', 'Readable source team public ID (preferred) or UUID; internal human only')
+        .option('--source-scope <scope>', 'Source scope: files or generated-outputs', 'files')
+        .option('--source-path <path>', 'Source file or folder path', '/')
+        .option('--target-path <path>', 'Destination folder path in the selected team', '/')
+        .option('--apply', 'Apply the copy plan')
+        .option('--expected-checksum <sha256>', 'Checksum printed by the reviewed seed plan')
+        .option('--dry-run', 'Preview the copy plan')
+        .action(async (o) => action(() => seedFilesAction(o)));
+    cmd
+        .command('move <id>')
+        .option('--to <path>', 'Plan a move to a destination folder path')
+        .option('--folder-id <id>', 'Destination folder')
+        .option('--root', 'Move to root folder')
+        .option('--apply', 'Apply move')
+        .option('--dry-run', 'Preview move')
+        .action(async (id, o) => action(() => moveFileAction(id, o)));
+}
+//# sourceMappingURL=file.js.map

package/dist/commands/label.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 listLabelsAction(options) {
+    validateId(options.projectId, 'projectId');
+    const query = {};
+    if (options.cursor)
+        query['cursor'] = options.cursor;
+    const response = await client.get(`/projects/${options.projectId}/labels`, Object.keys(query).length > 0 ? query : undefined);
+    printList(response.data, options.fields, response.nextCursor);
+}
+export function registerLabelCommand(program) {
+    const label = program.command('label').description('Manage labels');
+    label
+        .command('list')
+        .description('List labels 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 listLabelsAction({ ...options, fields: globalOpts.fields });
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=label.js.map

package/dist/commands/member.js

@@ -0,0 +1,23 @@
+import { client } from '../client.js';
+import { handleError } from '../utils/errors.js';
+import { printList } from '../utils/output.js';
+export async function listMembersAction(options) {
+    const response = await client.get('/team/members');
+    printList(response.data, options.fields, undefined);
+}
+export function registerMemberCommand(program) {
+    const member = program.command('member').description('Manage team members');
+    member
+        .command('list')
+        .description('List members of the current team')
+        .action(async () => {
+        try {
+            const globalOpts = program.optsWithGlobals();
+            await listMembersAction(globalOpts);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}
+//# sourceMappingURL=member.js.map