@keystrokehq/cli 0.0.1

package/dist/list.handler-lq3ZGAn4.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import { h as toErrorMessage, m as isNetworkError, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+import { t as getIntegrationCatalog } from "./integration-catalog-Bt-L3GjF.mjs";
+import Table from "cli-table3";
+//#region src/commands/integrations/list.handler.ts
+function summarizeConnections(entry, connections) {
+	const matches = connections.filter((c) => c.integrationPublicId === entry.publicId);
+	if (matches.length === 0) return {
+		total: 0,
+		defaultStatus: null
+	};
+	const preferred = matches.find((c) => c.isDefault) ?? matches[0];
+	return {
+		total: matches.length,
+		defaultStatus: preferred?.connectionStatus ?? null
+	};
+}
+function formatStatusCell(summary) {
+	if (summary.total === 0) return style("—", ANSI.dim);
+	const { defaultStatus } = summary;
+	const statusLabel = defaultStatus === "connected" ? style("connected", ANSI.green) : defaultStatus === "broken" ? style("broken", ANSI.red) : defaultStatus === "needs_reconnect" ? style("needs reconnect", ANSI.yellow) : defaultStatus === "disconnected" ? style("disconnected", ANSI.dim) : defaultStatus === "pending" ? style("pending", ANSI.dim) : defaultStatus ?? style("(unknown)", ANSI.dim);
+	return summary.total > 1 ? `${statusLabel} (+${summary.total - 1} more)` : statusLabel;
+}
+/**
+* Optionally fetches the caller's connections for join. Tolerates missing
+* org context (the `/integrations` endpoint works without an org, but
+* `/connections` requires one — so we skip the join gracefully rather than
+* failing the whole command).
+*/
+async function loadConnectionsOrEmpty(ctx) {
+	if (!ctx.organizationId) return [];
+	try {
+		return (await requireClient(ctx).connections.list()).connections;
+	} catch (error) {
+		if (isNetworkError(error)) throw error;
+		ui.warn(`Could not load connections for status join: ${toErrorMessage(error)}`);
+		return [];
+	}
+}
+async function handleIntegrationsList(options, ctx) {
+	let entries = [...(await getIntegrationCatalog(ctx)).integrations];
+	if (options.kind) entries = entries.filter((entry) => entry.connectionKind === options.kind);
+	if (options.search) {
+		const needle = options.search.trim().toLowerCase();
+		if (needle.length > 0) entries = entries.filter((entry) => {
+			return [
+				entry.publicId,
+				entry.name,
+				...entry.aliases
+			].join("\n").toLowerCase().includes(needle);
+		});
+	}
+	const connections = await loadConnectionsOrEmpty(ctx);
+	if (options.connected) {
+		const connectedIds = new Set(connections.map((c) => c.integrationPublicId).filter((id) => id !== null));
+		entries = entries.filter((entry) => connectedIds.has(entry.publicId));
+	}
+	if (ctx.jsonMode) {
+		writeJson(entries.map((entry) => ({
+			...entry,
+			connections: connections.filter((c) => c.integrationPublicId === entry.publicId)
+		})));
+		return;
+	}
+	if (entries.length === 0) {
+		const filters = [];
+		if (options.kind) filters.push(`kind=${options.kind}`);
+		if (options.search) filters.push(`search=${options.search}`);
+		if (options.connected) filters.push("connected=true");
+		const filterSuffix = filters.length > 0 ? ` matching ${filters.join(", ")}` : "";
+		ui.hint(`No integrations${filterSuffix}.`);
+		return;
+	}
+	const table = new Table({
+		head: [
+			"ID",
+			"Kind",
+			"Name",
+			"Status",
+			"Aliases"
+		],
+		style: { head: [] }
+	});
+	for (const entry of entries) {
+		const summary = summarizeConnections(entry, connections);
+		const otherAliases = entry.aliases.filter((alias) => alias !== entry.publicId);
+		table.push([
+			style(entry.publicId, `${ANSI.bold}${ANSI.cyan}`),
+			entry.connectionKind,
+			entry.name,
+			formatStatusCell(summary),
+			otherAliases.length > 0 ? otherAliases.join(", ") : style("—", ANSI.dim)
+		]);
+	}
+	ui.text(table.toString());
+	const connectedCount = entries.reduce((acc, entry) => summarizeConnections(entry, connections).total > 0 ? acc + 1 : acc, 0);
+	ui.hint(`\n${entries.length} integration${entries.length === 1 ? "" : "s"}` + (connections.length > 0 ? ` · ${connectedCount} with active connections` : "") + (options.kind || options.search || options.connected ? " (filtered)" : ""));
+	if (connections.length === 0 && !ctx.organizationId) ui.hint("Sign in and select an organization to see per-integration connection status.");
+}
+//#endregion
+export { handleIntegrationsList };

package/dist/logs-BEg9L5l8.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/logs/logs.command.ts
+const LogsOptionsSchema = z.object({ count: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of log entries to display") });
+const LOGS_OPTIONS_CONFIG = { count: {
+	flag: "--count <n>",
+	description: "Number of log entries to display (default: 100)"
+} };
+function createLogsCommand() {
+	return createTypedCommand({
+		name: "logs",
+		description: "Display recent CLI log entries",
+		schema: LogsOptionsSchema,
+		optionsConfig: LOGS_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./logs.handler-6hoMBzqw.mjs")).handleLogs,
+		subcommands: [createTypedCommand({
+			name: "clear",
+			description: "Delete the CLI log file",
+			schema: z.object({}),
+			optionsConfig: {},
+			loadHandler: async () => (await import("./clear.handler-BydlX-zE.mjs")).handleLogsClear
+		})]
+	});
+}
+//#endregion
+export { createLogsCommand };

package/dist/logs.handler-6hoMBzqw.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { a as originalConsole, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { o as readLogFile } from "./dist-CUK7yBM0.mjs";
+//#region src/commands/logs/logs.handler.ts
+const LEVEL_STYLES = {
+	debug: ANSI.dim,
+	info: ANSI.cyan,
+	warn: ANSI.yellow,
+	error: ANSI.red
+};
+function formatEntry(line) {
+	let entry;
+	try {
+		entry = JSON.parse(line);
+	} catch {
+		return line;
+	}
+	const ts = style(entry.timestamp, ANSI.dim);
+	const levelStyled = style(`[${entry.level.toUpperCase()}]`, LEVEL_STYLES[entry.level] ?? "");
+	const meta = entry.meta !== void 0 ? ` ${style(JSON.stringify(entry.meta), ANSI.dim)}` : "";
+	return `${ts} ${levelStyled} ${entry.message}${meta}`;
+}
+async function handleLogs(options, _ctx) {
+	const lines = await readLogFile(options.count);
+	if (lines.length === 0) {
+		ui.hint("No log entries found.");
+		return;
+	}
+	for (const line of lines) originalConsole.info(formatEntry(line));
+	ui.br();
+	ui.hint(`Showing ${lines.length} log ${lines.length === 1 ? "entry" : "entries"}.`);
+}
+//#endregion
+export { handleLogs };

package/dist/logs.handler-BD_dXiL1.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+import { n as sleep, t as TERMINAL_STATUSES } from "./run-polling-CAgFRdK3.mjs";
+import Table from "cli-table3";
+//#region src/commands/workflows/_shared/run-query.ts
+async function listRunsByWorkflowRef(client, options) {
+	const byAuthoredId = await client.runs.listRuns({
+		authoredWorkflowId: options.workflowRef,
+		status: options.status,
+		limit: options.limit
+	});
+	if (byAuthoredId.runs.length > 0) return {
+		kind: "authoredId",
+		runs: byAuthoredId.runs
+	};
+	return {
+		kind: "name",
+		runs: (await client.runs.listRuns({
+			workflowName: options.workflowRef,
+			status: options.status,
+			limit: options.limit
+		})).runs
+	};
+}
+//#endregion
+//#region src/commands/workflows/logs/run-log-display.ts
+const LOG_LEVEL_STYLES = {
+	debug: ANSI.dim,
+	info: ANSI.cyan,
+	warn: ANSI.yellow,
+	error: ANSI.red
+};
+function formatTimestamp(timestamp) {
+	return (typeof timestamp === "string" ? new Date(timestamp) : timestamp).toISOString().replace("T", " ").replace("Z", "").substring(0, 23);
+}
+/**
+* Formats a single run log entry as a terminal-ready string.
+* When verbose is true, includes metadata JSON on a second line.
+*/
+function formatRunLogLine(log, verbose) {
+	const ts = style(formatTimestamp(log.timestamp), ANSI.dim);
+	const source = style(`[${log.source}]`, ANSI.dim);
+	const levelStyle = LOG_LEVEL_STYLES[log.level] ?? ANSI.reset;
+	const levelTag = style(`[${log.level.toUpperCase()}]`, levelStyle);
+	const stepHint = log.correlationId ? style(` <${log.correlationId}>`, ANSI.dim) : "";
+	const meta = verbose && log.metadata ? `\n  ${style(JSON.stringify(log.metadata), ANSI.dim)}` : "";
+	return `${ts} ${source}${stepHint} ${levelTag} ${log.message}${meta}`;
+}
+//#endregion
+//#region src/commands/workflows/logs/logs.handler.ts
+function formatDuration(createdAt, completedAt) {
+	const start = new Date(createdAt).getTime();
+	const ms = (completedAt ? new Date(completedAt).getTime() : Date.now()) - start;
+	if (ms < 1e3) return `${ms}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+	return `${Math.floor(ms / 6e4)}m ${Math.floor(ms % 6e4 / 1e3)}s`;
+}
+function formatStatus(status) {
+	return style(status, {
+		completed: ANSI.green,
+		failed: ANSI.red,
+		running: ANSI.cyan,
+		pending: ANSI.dim,
+		cancelled: ANSI.dim
+	}[status] ?? ANSI.reset);
+}
+function resolveLogsMode(options) {
+	if (options.runId) return "run";
+	if (options.latest) return "latest";
+	return "list";
+}
+async function handleWorkflowsLogs(options, ctx) {
+	const client = requireClient(ctx);
+	const jsonMode = ctx.jsonMode;
+	const mode = resolveLogsMode(options);
+	if (mode === "run") {
+		await showRunLogs(client, options.runId, options, jsonMode);
+		return;
+	}
+	if (mode === "latest") {
+		await showLatestRunLogs(client, options, jsonMode);
+		return;
+	}
+	await listRecentRuns(client, options, jsonMode);
+}
+async function listRecentRuns(client, options, jsonMode) {
+	try {
+		const result = await listRunsByWorkflowRef(client, {
+			workflowRef: options.workflow,
+			status: options.status,
+			limit: options.limit
+		});
+		const { runs } = result;
+		if (jsonMode) {
+			writeJson(runs.map((run) => ({
+				id: run.id,
+				authoredWorkflowId: run.authoredWorkflowId,
+				workflowName: run.workflowName,
+				status: run.status,
+				createdAt: run.createdAt,
+				completedAt: run.completedAt ?? null,
+				duration: formatDuration(run.createdAt, run.completedAt)
+			})));
+			return;
+		}
+		if (runs.length === 0) {
+			ui.hint(`No runs found for workflow "${options.workflow}".`);
+			return;
+		}
+		const table = new Table({
+			head: [
+				"Run ID",
+				"Workflow ID",
+				"Workflow",
+				"Status",
+				"Created",
+				"Duration"
+			],
+			style: { head: [] }
+		});
+		for (const run of runs) table.push([
+			run.id,
+			run.authoredWorkflowId,
+			run.workflowName,
+			formatStatus(run.status),
+			new Date(run.createdAt).toLocaleString(),
+			formatDuration(run.createdAt, run.completedAt)
+		]);
+		ui.text(table.toString());
+		ui.hint(result.kind === "authoredId" ? `${runs.length} run(s) matched workflow id "${options.workflow}". Use --latest to view the newest run's logs, or --run-id <id> to pin a specific run.` : `${runs.length} run(s) matched workflow name "${options.workflow}". Use --latest to view the newest run's logs, or --run-id <id> to pin a specific run.`);
+	} catch (error) {
+		const message = toErrorMessage(error);
+		ui.error(`Failed to list runs: ${message}`);
+		throwReportedCliExit(`Failed to list runs: ${message}`, { cause: error });
+	}
+}
+async function showLatestRunLogs(client, options, jsonMode) {
+	try {
+		const result = await listRunsByWorkflowRef(client, {
+			workflowRef: options.workflow,
+			limit: 1
+		});
+		const latestRun = result.runs[0];
+		if (!latestRun) {
+			ui.hint(`No runs found for workflow "${options.workflow}".`);
+			return;
+		}
+		if (!jsonMode) ui.hint(result.kind === "authoredId" ? `Showing logs for the latest run of workflow id "${options.workflow}". Use --run-id ${latestRun.id} to pin this run.` : `Showing logs for the latest run of workflow name "${options.workflow}". Use --run-id ${latestRun.id} to pin this run.`);
+		await showRunLogs(client, latestRun.id, options, jsonMode);
+	} catch (error) {
+		const message = toErrorMessage(error);
+		ui.error(`Failed to resolve latest run: ${message}`);
+		throwReportedCliExit(`Failed to resolve latest run: ${message}`, { cause: error });
+	}
+}
+async function showRunLogs(client, runId, options, jsonMode) {
+	const logFetchLimit = 200;
+	try {
+		const { run } = await client.runs.getRun(runId);
+		const { logs } = await client.runs.listLogs(runId, {
+			level: options.level,
+			limit: logFetchLimit,
+			offset: 0
+		});
+		if (jsonMode) {
+			const visibleLogs = options.tail ? logs.slice(-options.tail) : logs;
+			writeJson({
+				run: {
+					id: run.id,
+					authoredWorkflowId: run.authoredWorkflowId,
+					workflowName: run.workflowName,
+					status: run.status,
+					createdAt: run.createdAt,
+					completedAt: run.completedAt ?? null
+				},
+				logs: visibleLogs.map((log) => ({
+					id: log.id,
+					level: log.level,
+					message: log.message,
+					timestamp: log.timestamp,
+					metadata: log.metadata ?? null,
+					correlationId: log.correlationId ?? null
+				}))
+			});
+			return;
+		}
+		ui.hint(`Run: ${run.id} | Workflow: ${run.workflowName} | Status: ${formatStatus(run.status)}`);
+		const seenIds = new Set(logs.map((log) => log.id));
+		const visibleLogs = options.tail ? logs.slice(-options.tail) : logs;
+		for (const log of visibleLogs) ui.text(formatRunLogLine({
+			...log,
+			metadata: log.metadata ?? void 0,
+			correlationId: log.correlationId ?? void 0
+		}, options.verbose));
+		if (!options.follow || TERMINAL_STATUSES.has(run.status)) {
+			if (visibleLogs.length === 0) ui.hint("No logs found for this run.");
+			return;
+		}
+		let currentStatus = run.status;
+		while (!TERMINAL_STATUSES.has(currentStatus)) {
+			await sleep(2e3);
+			try {
+				const { run: freshRun } = await client.runs.getRun(runId);
+				currentStatus = freshRun.status;
+				const { logs: newLogs } = await client.runs.listLogs(runId, {
+					level: options.level,
+					limit: logFetchLimit,
+					offset: 0
+				});
+				for (const log of newLogs) if (!seenIds.has(log.id)) {
+					seenIds.add(log.id);
+					ui.text(formatRunLogLine({
+						...log,
+						metadata: log.metadata ?? void 0,
+						correlationId: log.correlationId ?? void 0
+					}, options.verbose));
+				}
+			} catch {}
+		}
+		ui.hint(`Run ${runId} finished with status: ${formatStatus(currentStatus)}`);
+	} catch (error) {
+		const message = toErrorMessage(error);
+		ui.error(`Failed to get run logs: ${message}`);
+		throwReportedCliExit(`Failed to get run logs: ${message}`, { cause: error });
+	}
+}
+//#endregion
+export { handleWorkflowsLogs };