@falldownthesystem/devtool 0.5.0 → 0.6.1

package/src/config/store.js

@@ -1,213 +1,249 @@
 import Conf from 'conf';
-import * as p from '@clack/prompts';
-import pc from 'picocolors';
 
-export const schema = {
+export function validateGraphId(value) {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value?.trim() || '')
+		? undefined
+		: 'Enter the ID as a UUID from the Entra application Overview page.';
+}
+
+export function validateGraphSite(value) {
+	if (!value?.trim()) return undefined;
+	try {
+		const url = new URL(value.trim());
+		if (url.protocol === 'https:' && url.hostname.endsWith('.sharepoint.com') && !url.username && !url.password && !url.port && !url.search && !url.hash) {
+			decodeURIComponent(url.pathname);
+			return undefined;
+		}
+	} catch {}
+	return 'Enter a SharePoint Online site URL without a query or fragment.';
+}
+
+// A field's `validate` returns a problem message for a non-empty value; `normalize` runs on every save.
+export const types = {
 	bitbucket: {
-		type: 'object',
 		title: 'Bitbucket',
-		properties: {
-			workspace: { type: 'string', title: 'Workspace' },
-			defaultRepo: { type: 'string', title: 'Default repo' },
-			email: { type: 'string', title: 'Email' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
+		fields: {
+			workspace: { title: 'Workspace', message: 'Bitbucket workspace slug', placeholder: 'my-workspace', required: true },
+			defaultRepo: { title: 'Default repo', message: 'Bitbucket default repo slug', placeholder: 'my-repo' },
+			email: { title: 'Email', message: 'Bitbucket account email', placeholder: 'you@company.com', required: true },
+			token: { title: 'Token', message: 'Bitbucket API token', secret: true, required: true },
 		},
 	},
 	jira: {
-		type: 'object',
 		title: 'Jira',
-		properties: {
-			baseUrl: { type: 'string', title: 'Base URL' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
-			defaultProject: { type: 'string', title: 'Default project' },
+		fields: {
+			baseUrl: { title: 'Base URL', message: 'Jira Server base URL', placeholder: 'https://jira.company.com', required: true },
+			token: { title: 'Token', message: 'Jira Personal Access Token', secret: true, required: true },
+			defaultProject: { title: 'Default project', message: 'Jira default project key', placeholder: 'PROJ' },
 		},
 	},
 	confluence: {
-		type: 'object',
 		title: 'Confluence',
-		properties: {
-			baseUrl: { type: 'string', title: 'Base URL' },
-			email: { type: 'string', title: 'Email' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
-			defaultSpace: { type: 'string', title: 'Default space' },
+		fields: {
+			baseUrl: { title: 'Base URL', message: 'Confluence base URL (Cloud or Server/Data Center)', placeholder: 'https://company.atlassian.net', required: true },
+			email: { title: 'Email', message: 'Confluence account email (Server/Data Center: username, or empty for a personal access token)', placeholder: 'you@company.com' },
+			token: { title: 'Token', message: 'Confluence API token (Server/Data Center: personal access token or password)', secret: true, required: true },
+			defaultSpace: { title: 'Default space', message: 'Confluence default space key', placeholder: 'DEV' },
 		},
 	},
 	serviceDesk: {
-		type: 'object',
 		title: 'Service Desk',
-		properties: {
-			baseUrl: { type: 'string', title: 'Base URL' },
-			email: { type: 'string', title: 'Email' },
-			token: { type: 'string', title: 'Token', writeOnly: true },
-			defaultProject: { type: 'string', title: 'Default project' },
+		fields: {
+			baseUrl: { title: 'Base URL', message: 'Jira Service Desk Cloud base URL (use canonical *.atlassian.net, not a vanity domain)', placeholder: 'https://company.atlassian.net', required: true },
+			email: { title: 'Email', message: 'Service Desk account email', placeholder: 'you@company.com', required: true },
+			token: { title: 'Token', message: 'Service Desk API token', secret: true, required: true },
+			defaultProject: { title: 'Default project', message: 'Service Desk default project key', placeholder: 'TUKI' },
+		},
+	},
+	graph: {
+		title: 'Microsoft Graph',
+		note: 'Teams, email, calendars, and SharePoint share this application. No client secret is needed.\nRegister http://localhost under Mobile and desktop applications.\nDelegated permissions: User.Read, Chat.Read, Mail.Read, Sites.Read.All.\nOptional: Calendars.Read.Shared and Calendars.ReadBasic for calendars/free-busy; Mail.Read.Shared for shared email.\nAfter saving, run dev graph login (--all for one sign-in with every supported permission).',
+		fields: {
+			tenantId: { title: 'Tenant ID', message: 'Directory (tenant) ID', required: true, validate: validateGraphId, normalize: (v) => v.trim().toLowerCase() },
+			clientId: { title: 'Client ID', message: 'Application (client) ID', required: true, validate: validateGraphId, normalize: (v) => v.trim().toLowerCase() },
+			defaultSite: { title: 'Default site', message: 'Default SharePoint site URL (optional)', placeholder: 'https://company.sharepoint.com/sites/MySite', validate: validateGraphSite, normalize: (v) => v.trim().replace(/\/+$/, '') },
 		},
 	},
 };
 
+export function fieldProblem(type, key, value) {
+	const field = types[type].fields[key];
+	return value && field.validate ? field.validate(value) : undefined;
+}
+
 const config = new Conf({
 	projectName: 'devtool',
-	schema,
-	defaults: {
-		bitbucket: { workspace: '', defaultRepo: '', email: '', token: '' },
-		jira: { baseUrl: '', token: '', defaultProject: '' },
-		confluence: { baseUrl: '', email: '', token: '', defaultSpace: '' },
-		serviceDesk: { baseUrl: '', email: '', token: '', defaultProject: '' },
+	schema: {
+		connections: {
+			type: 'array',
+			items: {
+				type: 'object',
+				properties: {
+					type: { type: 'string', enum: Object.keys(types) },
+					name: { type: 'string' },
+					default: { type: 'boolean' },
+				},
+				required: ['type'],
+				additionalProperties: { type: 'string' },
+			},
+		},
 	},
+	defaults: { connections: [] },
 });
 
-export function get(key) {
-	return config.get(key);
+migrateLegacySections();
+
+// Older versions stored exactly one connection per type as a top-level section.
+function migrateLegacySections() {
+	const { connections = [], ...rest } = config.store;
+	const legacy = Object.keys(rest).filter((key) => types[key]);
+	if (!legacy.length) return;
+	for (const type of legacy) {
+		const connection = clean({ type, ...rest[type] });
+		const hasValues = Object.keys(connection).length > 1;
+		if (hasValues && !connections.some((c) => c.type === type && !c.name)) connections.push(connection);
+		delete rest[type];
+	}
+	config.store = { ...rest, connections };
+}
+
+function clean(connection) {
+	const result = { type: connection.type };
+	if (connection.name) result.name = connection.name;
+	if (connection.default) result.default = true;
+	for (const [key, field] of Object.entries(types[connection.type].fields)) {
+		if (typeof connection[key] !== 'string') continue;
+		const value = field.normalize ? field.normalize(connection[key]) : connection[key];
+		if (value !== '') result[key] = value;
+	}
+	return result;
 }
 
-export function set(key, value) {
-	config.set(key, value);
+function write(connections) {
+	config.set('connections', connections.map(clean));
 }
 
-export function getAll() {
-	return config.store;
+// An unnamed connection is addressed by its type, so labels stay unique across all connections.
+export function label(connection) {
+	return connection.name || connection.type;
 }
 
-export function isConfigured() {
-	const bb = config.get('bitbucket');
-	const jira = config.get('jira');
-	return !!(bb.workspace && bb.token && jira.baseUrl && jira.token);
+export function listConnections() {
+	return config.get('connections');
 }
 
-export function configPath() {
-	return config.path;
+function defaultIndex(connections, type) {
+	const flagged = connections.findIndex((c) => c.type === type && c.default);
+	return flagged !== -1 ? flagged : connections.findIndex((c) => c.type === type);
 }
 
-export async function runSetup() {
-	p.intro(pc.cyan('DevTool Setup'));
-
-	const bb = await p.group({
-		workspace: () => p.text({
-			message: 'Bitbucket workspace slug',
-			placeholder: 'my-workspace',
-			initialValue: config.get('bitbucket.workspace') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		defaultRepo: () => p.text({
-			message: 'Bitbucket default repo slug',
-			placeholder: 'my-repo',
-			initialValue: config.get('bitbucket.defaultRepo') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		email: () => p.text({
-			message: 'Bitbucket account email',
-			placeholder: 'you@company.com',
-			initialValue: config.get('bitbucket.email') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		token: () => p.password({
-			message: 'Bitbucket API token',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
-
-	const jira = await p.group({
-		baseUrl: () => p.text({
-			message: 'Jira Server base URL',
-			placeholder: 'https://jira.company.com',
-			initialValue: config.get('jira.baseUrl') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		token: () => p.password({
-			message: 'Jira Personal Access Token',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-		defaultProject: () => p.text({
-			message: 'Jira default project key',
-			placeholder: 'PROJ',
-			initialValue: config.get('jira.defaultProject') || '',
-			validate: (v) => !v ? 'Required' : undefined,
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
-
-	const confluence = await p.group({
-		baseUrl: () => p.text({
-			message: 'Confluence base URL (Cloud or Server/Data Center)',
-			placeholder: 'https://company.atlassian.net',
-			initialValue: config.get('confluence.baseUrl') || '',
-		}),
-		email: () => p.text({
-			message: 'Confluence account email (Server/Data Center: username, or empty for a personal access token)',
-			placeholder: 'you@company.com',
-			initialValue: config.get('confluence.email') || '',
-		}),
-		token: () => p.password({
-			message: 'Confluence API token (Server/Data Center: personal access token or password)',
-		}),
-		defaultSpace: () => p.text({
-			message: 'Confluence default space key',
-			placeholder: 'DEV',
-			initialValue: config.get('confluence.defaultSpace') || '',
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
-
-	const reuseConfluenceCreds = confluence.email && confluence.token
-		? await p.confirm({
-			message: 'Reuse Confluence email/token for Jira Service Desk Cloud?',
-			initialValue: true,
-		})
-		: false;
-
-	if (p.isCancel(reuseConfluenceCreds)) {
-		p.cancel('Setup cancelled.');
-		process.exit(0);
+export function isDefault(connections, index) {
+	return defaultIndex(connections, connections[index].type) === index;
+}
+
+// A reference is a connection label; a bare type falls back to that type's default connection.
+function findIndex(connections, ref) {
+	const byLabel = connections.findIndex((c) => label(c) === ref);
+	if (byLabel !== -1 || !types[ref]) return byLabel;
+	return defaultIndex(connections, ref);
+}
+
+function requireIndex(connections, ref) {
+	const index = findIndex(connections, ref);
+	if (index === -1) throw new Error(`No connection named "${ref}". Run \`dev config show\` to list connections.`);
+	return index;
+}
+
+export function getConnection(type, ref) {
+	const connections = listConnections();
+	const { title } = types[type];
+	if (ref) {
+		const connection = connections[requireIndex(connections, ref)];
+		if (connection.type !== type) {
+			throw new Error(`Connection "${ref}" is a ${types[connection.type].title} connection, not ${title}.`);
+		}
+		return connection;
 	}
+	const index = defaultIndex(connections, type);
+	if (index === -1) throw new Error(`No ${title} connection configured. Run \`dev config add ${type}\` to add one.`);
+	return connections[index];
+}
 
-	const serviceDesk = await p.group({
-		baseUrl: () => p.text({
-			message: 'Jira Service Desk Cloud base URL (use canonical *.atlassian.net, not a vanity domain)',
-			placeholder: 'https://company.atlassian.net',
-			initialValue: config.get('serviceDesk.baseUrl') || '',
-		}),
-		email: () => reuseConfluenceCreds
-			? Promise.resolve(confluence.email)
-			: p.text({
-				message: 'Service Desk account email',
-				placeholder: 'you@company.com',
-				initialValue: config.get('serviceDesk.email') || '',
-			}),
-		token: () => reuseConfluenceCreds
-			? Promise.resolve(confluence.token)
-			: p.password({
-				message: 'Service Desk API token',
-			}),
-		defaultProject: () => p.text({
-			message: 'Service Desk default project key',
-			placeholder: 'TUKI',
-			initialValue: config.get('serviceDesk.defaultProject') || '',
-		}),
-	}, {
-		onCancel: () => {
-			p.cancel('Setup cancelled.');
-			process.exit(0);
-		},
-	});
+export function resolveIndex(ref) {
+	return requireIndex(listConnections(), ref);
+}
 
-	config.set('bitbucket', bb);
-	config.set('jira', jira);
-	config.set('confluence', confluence);
-	config.set('serviceDesk', serviceDesk);
+export function validateName(connections, connection, index = -1) {
+	const { name, type } = connection;
+	if (name) {
+		if (!/^[A-Za-z0-9][\w-]*$/.test(name)) {
+			return 'Use only letters, digits, "-" and "_", starting with a letter or digit';
+		}
+		if (Object.keys(types).some((t) => t.toLowerCase() === name.toLowerCase())) {
+			return `"${name}" is a connection type and cannot be a name`;
+		}
+	}
+	const clash = connections.some((c, i) => i !== index && label(c) === label(connection));
+	if (clash) {
+		return name
+			? `A connection named "${name}" already exists`
+			: `A ${types[type].title} connection without a name already exists; give this one a name`;
+	}
+	return undefined;
+}
 
-	p.outro(pc.green('Configuration saved!'));
+// Without an index the connection is appended.
+export function saveConnection(connection, index = -1) {
+	const connections = listConnections();
+	const problem = validateName(connections, connection, index);
+	if (problem) throw new Error(problem);
+	if (index === -1) connections.push(connection);
+	else connections[index] = connection;
+	write(connections);
+}
+
+export function removeConnection(ref) {
+	const connections = listConnections();
+	const [removed] = connections.splice(requireIndex(connections, ref), 1);
+	write(connections);
+	return removed;
+}
+
+export function setDefault(ref) {
+	const connections = listConnections();
+	const target = connections[requireIndex(connections, ref)];
+	for (const c of connections) {
+		if (c.type === target.type) c.default = c === target;
+	}
+	write(connections);
+	return target;
+}
+
+// A bare type with no connection yet creates one, so `config set jira.baseUrl ...` works on a fresh install.
+export function setField(ref, field, value) {
+	const connections = listConnections();
+	let index = findIndex(connections, ref);
+	if (index === -1) {
+		if (!types[ref]) throw new Error(`No connection named "${ref}". Run \`dev config show\` to list connections.`);
+		connections.push({ type: ref });
+		index = connections.length - 1;
+	}
+	const connection = connections[index];
+	const fields = Object.keys(types[connection.type].fields);
+	if (field !== 'name' && !fields.includes(field)) {
+		throw new Error(`Invalid field "${field}" for a ${types[connection.type].title} connection. Valid fields: name, ${fields.join(', ')}`);
+	}
+	connection[field] = value;
+	const problem = field === 'name'
+		? validateName(connections, connection, index)
+		: fieldProblem(connection.type, field, value);
+	if (problem) throw new Error(problem);
+	write(connections);
+	return connection;
+}
+
+export function configPath() {
+	return config.path;
 }
 
 export default config;

package/src/formatters/graph.js

@@ -0,0 +1,220 @@
+import { stripVTControlCharacters } from 'node:util';
+import { createRequire } from 'node:module';
+import { table, heading, field } from '../utils/output.js';
+import { outputJson } from '../utils/mode.js';
+
+const require = createRequire(import.meta.url);
+let convert;
+
+export function graphText(value) {
+	return stripVTControlCharacters(String(value ?? '')).replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '');
+}
+
+function bodyText(body) {
+	if (!body) return '';
+	if (body.contentType?.toLowerCase() !== 'html') return graphText(body.content);
+	convert ||= require('html-to-text').convert;
+	return graphText(convert(body.content || '', { wordwrap: false, selectors: [{ selector: 'img', format: 'skip' }] }));
+}
+
+function person(recipient) {
+	return recipient ? { name: recipient.emailAddress?.name || null, address: recipient.emailAddress?.address || null } : null;
+}
+
+function people(recipients) {
+	return (recipients || []).map(person);
+}
+
+export function curateCalendarJson(calendar) {
+	return {
+		id: calendar.id,
+		name: calendar.name || '',
+		owner: calendar.owner || null,
+		isDefault: calendar.isDefaultCalendar ?? false,
+		canViewPrivateItems: calendar.canViewPrivateItems ?? false,
+	};
+}
+
+export function curateEventJson(event) {
+	return {
+		id: event.id,
+		subject: event.subject || '',
+		start: event.start || null,
+		end: event.end || null,
+		isAllDay: event.isAllDay ?? false,
+		isCancelled: event.isCancelled ?? false,
+		response: event.responseStatus?.response || null,
+		organizer: person(event.organizer),
+		attendees: (event.attendees || []).map((a) => ({ ...person(a), type: a.type || null, response: a.status?.response || null })),
+		location: event.location?.displayName || null,
+		type: event.type || null,
+		seriesId: event.seriesMasterId || null,
+		body: bodyText(event.body),
+		joinUrl: event.onlineMeeting?.joinUrl || null,
+		url: event.webLink || null,
+	};
+}
+
+export function curateNextEventJson(result) {
+	return {
+		from: result.from,
+		to: result.to,
+		event: result.event ? curateEventJson(result.event) : null,
+	};
+}
+
+export function curateAvailabilityJson(result) {
+	return {
+		from: result.from, to: result.to, intervalMinutes: result.intervalMinutes,
+		legend: { 0: 'free or working elsewhere', 1: 'tentative', 2: 'busy', 3: 'out of office' },
+		schedules: result.schedules.map((schedule) => ({
+			address: schedule.scheduleId,
+			error: schedule.error ? { code: schedule.error.responseCode || null, message: schedule.error.message || 'Availability is unknown.' } : null,
+			availabilityView: schedule.error ? null : schedule.availabilityView ?? null,
+			items: (schedule.scheduleItems || []).map((item) => ({
+				status: item.status || 'unknown', start: item.start || null, end: item.end || null,
+				subject: item.subject || null, location: item.location || null, isPrivate: item.isPrivate ?? null,
+			})),
+		})),
+	};
+}
+
+export function formatNextEvent(data, options) {
+	if (options.mode === 'json') { outputJson(data); return; }
+	formatGraph(data.event ? { from: data.from, to: data.to, ...data.event } : {
+		from: data.from, to: data.to, message: 'No upcoming event found in this calendar and date range.',
+	}, options);
+}
+
+export function formatAvailability(data, options) {
+	if (options.mode === 'json') { outputJson(data); return; }
+	console.log(`Window: ${data.from} to ${data.to} (UTC; ${data.intervalMinutes}-minute slots)`);
+	for (const schedule of data.schedules) {
+		formatGraph(schedule, { ...options, title: `Availability: ${schedule.address}` });
+	}
+	console.log('Slot codes: 0=free/working elsewhere, 1=tentative, 2=busy, 3=out of office. Errors mean unknown, not free.');
+}
+
+export function curateChatJson(chat) {
+	return {
+		id: chat.id,
+		topic: chat.topic || null,
+		type: chat.chatType || null,
+		members: (chat.members || []).map((m) => ({ id: m.userId || m.id, name: m.displayName || null, email: m.email || null })),
+		createdAt: chat.createdDateTime || null,
+		updatedAt: chat.lastUpdatedDateTime || null,
+		url: chat.webUrl || null,
+	};
+}
+
+export function curateChatMessageJson(message) {
+	return {
+		id: message.id,
+		chatId: message.chatId || null,
+		type: message.messageType || null,
+		from: message.from?.user?.displayName || message.from?.application?.displayName || null,
+		createdAt: message.createdDateTime || null,
+		editedAt: message.lastEditedDateTime || null,
+		deletedAt: message.deletedDateTime || null,
+		body: bodyText(message.body),
+		attachments: (message.attachments || []).map((a) => ({ id: a.id, name: a.name || null, type: a.contentType || null })),
+		url: message.webUrl || null,
+	};
+}
+
+export function curateMailJson(message) {
+	return {
+		id: message.id,
+		subject: message.subject || '',
+		from: person(message.from),
+		to: people(message.toRecipients),
+		...(message.ccRecipients ? { cc: people(message.ccRecipients) } : {}),
+		receivedAt: message.receivedDateTime || null,
+		sentAt: message.sentDateTime || null,
+		isRead: message.isRead ?? null,
+		hasAttachments: message.hasAttachments ?? false,
+		folderId: message.parentFolderId || null,
+		preview: message.bodyPreview || '',
+		...(message.body ? { body: bodyText(message.body) } : {}),
+		url: message.webLink || null,
+	};
+}
+
+export function curateFolderJson(folder) {
+	return { id: folder.id, name: folder.displayName || '', total: folder.totalItemCount ?? 0, unread: folder.unreadItemCount ?? 0, childFolders: folder.childFolderCount ?? 0 };
+}
+
+export function curateSiteJson(site) {
+	return { id: site.id, name: site.displayName || site.name || '', description: site.description || '', url: site.webUrl || null };
+}
+
+export function curateDriveJson(drive) {
+	return { id: drive.id, name: drive.name || '', type: drive.driveType || null, description: drive.description || '', url: drive.webUrl || null };
+}
+
+export function curateFileJson(file) {
+	return {
+		id: file.id,
+		name: file.name || '',
+		type: file.folder ? 'folder' : file.file ? 'file' : 'item',
+		size: file.size ?? null,
+		mimeType: file.file?.mimeType || null,
+		childCount: file.folder?.childCount ?? null,
+		driveId: file.parentReference?.driveId || null,
+		parentId: file.parentReference?.id || null,
+		updatedAt: file.lastModifiedDateTime || null,
+		url: file.webUrl || null,
+	};
+}
+
+export function curateListJson(list) {
+	return { id: list.id, name: list.displayName || list.name || '', description: list.description || '', template: list.list?.template || null, url: list.webUrl || null };
+}
+
+export function curateListItemJson(item) {
+	return {
+		id: item.id,
+		fields: Object.fromEntries(Object.entries(item.fields || {}).filter(([key]) => !key.startsWith('@odata.'))),
+		createdAt: item.createdDateTime || null,
+		updatedAt: item.lastModifiedDateTime || null,
+		url: item.webUrl || null,
+	};
+}
+
+function display(value) {
+	if (value === null || value === undefined) return '';
+	return graphText(typeof value === 'object' ? JSON.stringify(value) : value);
+}
+
+export function formatGraph(data, { mode, title, columns = [], records = false }) {
+	if (mode === 'json') { outputJson(data); return; }
+	const items = Array.isArray(data) ? data : [data];
+	if (!items.length) { console.log('No results found.'); return; }
+	if (mode === 'rich') heading(graphText(title));
+	if (Array.isArray(data) && !records) {
+		const rows = items.map((item) => columns.map(([, value]) => display(value(item))));
+		if (mode === 'plain') {
+			for (const row of rows) console.log(row.map((cell) => cell.replace(/\s+/g, ' ')).join('\t'));
+		} else {
+			const widths = columns.map(([, , width]) => width || 32);
+			const fits = widths.reduce((sum, width) => sum + width, columns.length + 1) <= (process.stdout.columns || 120)
+				&& rows.every((row) => row.every((cell, index) => cell.split('\n').every((line) => line.length <= widths[index] - 2)));
+			if (fits) console.log(table(columns.map(([label]) => label), rows, { colWidths: widths }));
+			else {
+				// Resource IDs must remain complete and copyable when a table would truncate them.
+				for (const row of rows) {
+					for (const [index, cell] of row.entries()) field(columns[index][0], cell);
+					console.log('');
+				}
+			}
+		}
+		return;
+	}
+	for (const [index, item] of items.entries()) {
+		if (index) console.log('');
+		for (const [key, value] of Object.entries(item)) {
+			if (mode === 'rich') field(key, display(value));
+			else console.log(`${key}: ${display(value)}`);
+		}
+	}
+}