@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-CDTYP6bN.js

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { EntityCard, MutationResult, React, render, useEffect, useState } from "./chunk-CoAWdSiE.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { Command, InvalidArgumentError } from "commander";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+// ../shared/dist/batch-execution-status.mjs
+/**
+* Lifecycle of a batch execution as the API writes it: `batch_executions.status` and the
+* BatchExecutionDO state. Every SDK, CLI and MCP consumer classifies batch status through this list.
+*/
+const BATCH_EXECUTION_STATUSES = [
+	"queued",
+	"processing",
+	"completed",
+	"failed",
+	"cancelled"
+];
+const TERMINAL_BATCH_EXECUTION_STATUSES = [
+	"completed",
+	"failed",
+	"cancelled"
+];
+function isBatchExecutionStatus(value) {
+	return BATCH_EXECUTION_STATUSES.includes(value);
+}
+/** False for an unknown status: a value this list does not name must never read as finished. */
+function isTerminalBatchExecutionStatus(status) {
+	return TERMINAL_BATCH_EXECUTION_STATUSES.includes(status);
+}
+// src/lib/wait-for-status.ts
+const MAX_WAIT_DURATION_MS = 2147483647;
+/** Poll read-only status until terminal, timeout, or caller abort; never cancel the remote task. */
+async function waitForStatus(options) {
+	for (const duration of [options.timeoutMs, options.intervalMs]) if (!Number.isInteger(duration) || duration <= 0 || duration > 2147483647) throw new RangeError(`Wait durations must be integers between 1 and ${MAX_WAIT_DURATION_MS} ms`);
+	options.signal?.throwIfAborted();
+	const controller = new AbortController();
+	const timeout = /* @__PURE__ */ new Error("Status wait timed out");
+	const abort = () => controller.abort(options.signal?.reason);
+	options.signal?.addEventListener("abort", abort, { once: true });
+	const deadlineTimer = setTimeout(() => controller.abort(timeout), options.timeoutMs);
+	let sleepTimer;
+	let value;
+	let rejectAborted = () => {};
+	const aborted = new Promise((_resolve, reject) => {
+		rejectAborted = () => reject(controller.signal.reason);
+		controller.signal.addEventListener("abort", rejectAborted, { once: true });
+	});
+	try {
+		for (;;) {
+			controller.signal.throwIfAborted();
+			value = await Promise.race([options.read(controller.signal), aborted]);
+			controller.signal.throwIfAborted();
+			const terminal = options.isTerminal(value);
+			options.onStatus?.(value);
+			if (terminal) return {
+				timedOut: false,
+				value
+			};
+			await Promise.race([new Promise((resolve) => {
+				sleepTimer = setTimeout(resolve, options.intervalMs);
+			}), aborted]);
+		}
+	} catch (error) {
+		if (controller.signal.aborted && controller.signal.reason === timeout) return {
+			timedOut: true,
+			value
+		};
+		throw error;
+	} finally {
+		clearTimeout(deadlineTimer);
+		clearTimeout(sleepTimer);
+		options.signal?.removeEventListener("abort", abort);
+		controller.signal.removeEventListener("abort", rejectAborted);
+		controller.abort();
+	}
+}
+// src/commands/batch.ts
+function parseWatchDuration(value) {
+	const duration = Number(value);
+	if (!/^\d+$/.test(value) || !Number.isInteger(duration) || duration <= 0 || duration > 2147483647) throw new InvalidArgumentError(`Expected an integer between 1 and ${MAX_WAIT_DURATION_MS} ms`);
+	return duration;
+}
+/** Unknown statuses keep polling with one warning each, so a newer API state never ends a watch early. */
+function createBatchTerminalCheck(warn) {
+	const warnedStatuses = /* @__PURE__ */ new Set();
+	return (data) => {
+		if (!isBatchExecutionStatus(data.status) && !warnedStatuses.has(data.status)) {
+			warnedStatuses.add(data.status);
+			warn(`Unknown batch status "${data.status}"; continuing to poll until a terminal status`);
+		}
+		return isTerminalBatchExecutionStatus(data.status);
+	};
+}
+function parseBatchStatusResponse(value) {
+	if (!value || typeof value !== "object" || !("status" in value) || typeof value.status !== "string") throw new Error("Invalid batch status response: expected an object with a status string");
+	for (const key of [
+		"processedRecords",
+		"totalRecords",
+		"failedRecords"
+	]) {
+		if (!(key in value)) throw new Error(`Invalid batch status response: missing ${key}`);
+		const count = value[key];
+		if (typeof count !== "number" || !Number.isInteger(count) || count < 0) throw new Error(`Invalid batch status response: ${key} must be a non-negative integer`);
+	}
+	return value;
+}
+const batchCommand = new Command("batch").description("Manage batch operations");
+batchCommand.command("submit").description("Submit a batch job").requiredOption("-f, --flow <id>", "Flow ID to execute").requiredOption("-r, --records <file>", "JSON file with record IDs").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	let recordIds;
+	try {
+		const content = readFileSync(options.records, "utf-8");
+		const parsed = JSON.parse(content);
+		recordIds = Array.isArray(parsed) ? parsed : parsed.recordIds || parsed.records || [];
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to read records file: ${msg}`));
+		process.exit(1);
+	}
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/batch/flow", {
+				flowId: options.flow,
+				recordIds
+			});
+			if (options.json) printJson(data);
+			else {
+				console.log(chalk.green("Batch submitted"));
+				console.log(`  Batch ID: ${chalk.green(data.batchExecutionId)}`);
+				console.log(`  Status: ${data.status}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to submit batch"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.post("/batch/flow", {
+						flowId: options.flow,
+						recordIds
+					});
+					setResultNode(React.createElement(EntityCard, { fields: [{
+						label: "Batch ID",
+						value: data.batchExecutionId,
+						color: "green"
+					}, {
+						label: "Status",
+						value: data.status
+					}] }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: `Submitting batch with ${recordIds.length} records...`,
+			success,
+			successMessage: "Batch submitted",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+batchCommand.command("status <id>").description("Check batch job status").option("--watch", "Poll until terminal status; stop locally after the timeout without cancelling the batch").option("--timeout <ms>", "Watch deadline in ms (1–2147483647; default: 300000); requires --watch", parseWatchDuration).option("--interval <ms>", "Watch poll interval in ms (1–2147483647; default: 2000); requires --watch", parseWatchDuration).option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (batchId, options, command) => {
+	if (!options.watch && (options.timeout !== void 0 || options.interval !== void 0)) command.error("--timeout and --interval require --watch");
+	if (options.watch) {
+		try {
+			const apiKey = await ensureAuth({
+				exitOnFailure: false,
+				interactive: false
+			});
+			if (!apiKey) throw Object.assign(/* @__PURE__ */ new Error("Authentication required. Run \"runtype auth login\" first."), { code: "AUTH_REQUIRED" });
+			const client = createCliClient(apiKey);
+			const timeoutMs = options.timeout ?? 3e5;
+			const result = await waitForStatus({
+				read: async (signal) => {
+					return parseBatchStatusResponse(await (await client.requestStream(`/batch/status/${batchId}`, {
+						method: "GET",
+						signal
+					})).json());
+				},
+				isTerminal: createBatchTerminalCheck((message) => console.error(message)),
+				timeoutMs,
+				intervalMs: options.interval ?? 2e3,
+				onStatus: (data) => {
+					console.error(`Batch ${batchId}: ${data.status} (${data.processedRecords}/${data.totalRecords}, ${data.failedRecords} failed)`);
+				}
+			});
+			if (result.timedOut) {
+				const message = `Timed out watching batch ${batchId} after ${timeoutMs} ms. The server batch was not cancelled.`;
+				if (options.json) printJson({
+					success: false,
+					batchExecutionId: batchId,
+					status: "timeout",
+					lastStatus: result.value ?? null,
+					error: {
+						code: "BATCH_WATCH_TIMEOUT",
+						message
+					}
+				});
+				console.error(message);
+				process.exitCode = 1;
+				return;
+			}
+			const data = result.value;
+			if (options.json) printJson(data);
+			else console.log(`Batch Job: ${batchId}\n  Status: ${data.status}\n  Progress: ${data.processedRecords}/${data.totalRecords}\n  Failed: ${data.failedRecords}`);
+			if (data.status !== "completed" || data.failedRecords > 0) process.exitCode = 1;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "BATCH_WATCH_ERROR";
+			if (options.json) printJson({
+				success: false,
+				batchExecutionId: batchId,
+				error: {
+					code,
+					message
+				}
+			});
+			console.error(`Failed to watch batch status: ${message}`);
+			process.exitCode = 1;
+		}
+		return;
+	}
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(`/batch/status/${batchId}`);
+			if (options.json) printJson(data);
+			else {
+				console.log(chalk.cyan(`Batch Job: ${batchId}`));
+				console.log(`  Status: ${chalk.green(data.status)}`);
+				console.log(`  Progress: ${data.processedRecords}/${data.totalRecords}`);
+				if (data.failedRecords > 0) console.log(`  Failed: ${chalk.red(data.failedRecords)}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch batch status"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get(`/batch/status/${batchId}`);
+					const fields = [
+						{
+							label: "Batch ID",
+							value: batchId
+						},
+						{
+							label: "Status",
+							value: data.status,
+							color: data.status === "completed" ? "green" : "yellow"
+						},
+						{
+							label: "Progress",
+							value: `${data.processedRecords}/${data.totalRecords}`
+						}
+					];
+					if (data.failedRecords > 0) fields.push({
+						label: "Failed",
+						value: data.failedRecords,
+						color: "red"
+					});
+					setResultNode(React.createElement(EntityCard, { fields }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Fetching batch status...",
+			success,
+			successMessage: "Batch Status",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+batchCommand.command("cancel <id>").description("Cancel a batch job").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (batchId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options)) {
+		try {
+			await client.post(`/batch/cancel/${batchId}`);
+			console.log(chalk.green("Batch job cancelled"));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to cancel batch job"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					await client.post(`/batch/cancel/${batchId}`);
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Cancelling batch job...",
+			success,
+			successMessage: "Batch job cancelled",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+batchCommand.command("summary").description("Show a summary of active and recently completed batch jobs").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/batch/summary");
+			if (options.json) printJson(data);
+			else {
+				console.log(chalk.cyan("Batch Summary"));
+				console.log(`  Active: ${chalk.green(data.activeBatches)}`);
+				console.log(`  Recently completed: ${data.recentlyCompleted}`);
+				if (data.batches.length > 0) {
+					console.log(chalk.cyan("\nActive Batches:"));
+					for (const b of data.batches) console.log(`  ${chalk.green(b.id)} ${b.flowName ?? ""} — ${b.status} (${b.processedRecords}/${b.totalRecords}, ${b.progress}%)`);
+				}
+				if (data.recent.length > 0) {
+					console.log(chalk.cyan("\nRecently Completed:"));
+					for (const b of data.recent) {
+						const statusColor = b.status === "completed" ? chalk.green(b.status) : chalk.red(b.status);
+						console.log(`  ${chalk.green(b.id)} ${b.flowName ?? ""} — ${statusColor} (${b.processedRecords}/${b.totalRecords})`);
+					}
+				}
+				if (data.batches.length === 0 && data.recent.length === 0) console.log(chalk.gray("\nNo active or recent batch jobs"));
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch batch summary"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get("/batch/summary");
+					const fields = [{
+						label: "Active",
+						value: data.activeBatches,
+						color: "green"
+					}, {
+						label: "Recently completed",
+						value: data.recentlyCompleted
+					}];
+					for (const b of data.batches) fields.push({
+						label: b.id,
+						value: `${b.flowName ?? ""} — ${b.status} (${b.processedRecords}/${b.totalRecords}, ${b.progress}%)`,
+						color: "yellow"
+					});
+					for (const b of data.recent) fields.push({
+						label: b.id,
+						value: `${b.flowName ?? ""} — ${b.status} (${b.processedRecords}/${b.totalRecords})`,
+						color: b.status === "completed" ? "green" : "red"
+					});
+					setResultNode(React.createElement(EntityCard, { fields }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Fetching batch summary...",
+			success,
+			successMessage: "Batch Summary",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+function printCostBreakdown(data) {
+	console.log(`  Total (blended): ${chalk.green(`$${data.totalCostUsd.toFixed(6)}`)}`);
+	console.log(`  Runtype-funded: ${data.billedCostUsd == null ? chalk.dim("unavailable") : chalk.green(`$${data.billedCostUsd.toFixed(6)}`)}`);
+	if (data.selfReportedCostUsd > 0) console.log(`  Self-reported: ${chalk.yellow(`$${data.selfReportedCostUsd.toFixed(6)}`)}`);
+	if (data.unpricedExecutions > 0) console.log(`  Unpriced executions: ${chalk.yellow(String(data.unpricedExecutions))}`);
+}
+batchCommand.command("cost <id>").description("Show the total cost of a batch job (or a single record with --record)").option("--record <recordId>", "Show cost for a specific record within the batch").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (batchId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const recordId = options.record;
+	if (!isTTY(options) || options.json) {
+		try {
+			if (recordId) {
+				const data = await client.get(`/batch/${batchId}/records/${recordId}/cost`);
+				if (options.json) printJson(data);
+				else {
+					console.log(chalk.cyan(`Record Cost: ${batchId} / ${recordId}`));
+					printCostBreakdown(data);
+				}
+			} else {
+				const data = await client.get(`/batch/${batchId}/cost`);
+				if (options.json) printJson(data);
+				else {
+					console.log(chalk.cyan(`Batch Cost: ${batchId}`));
+					printCostBreakdown(data);
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch batch cost"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					if (recordId) {
+						const data = await client.get(`/batch/${batchId}/records/${recordId}/cost`);
+						setResultNode(React.createElement(EntityCard, { fields: [
+							{
+								label: "Batch ID",
+								value: data.batchExecutionId,
+								color: "green"
+							},
+							{
+								label: "Record ID",
+								value: data.recordId
+							},
+							{
+								label: "Total (blended)",
+								value: `$${data.totalCostUsd.toFixed(6)}`,
+								color: "green"
+							},
+							{
+								label: "Runtype-funded",
+								value: data.billedCostUsd == null ? "Unavailable" : `$${data.billedCostUsd.toFixed(6)}`
+							}
+						] }));
+					} else {
+						const data = await client.get(`/batch/${batchId}/cost`);
+						setResultNode(React.createElement(EntityCard, { fields: [
+							{
+								label: "Batch ID",
+								value: data.batchExecutionId,
+								color: "green"
+							},
+							{
+								label: "Total (blended)",
+								value: `$${data.totalCostUsd.toFixed(6)}`,
+								color: "green"
+							},
+							{
+								label: "Runtype-funded",
+								value: data.billedCostUsd == null ? "Unavailable" : `$${data.billedCostUsd.toFixed(6)}`
+							}
+						] }));
+					}
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Fetching batch cost...",
+			success,
+			successMessage: "Batch Cost",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+export { batchCommand };
+

package/dist/chunk-CGDQoqDC.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import React from "react";
+import { render } from "ink";
+import SelectInput from "ink-select-input";
+// src/ink/shared/account-picker.ts
+/** Interactive picker over stored logins; resolves undefined if the user exits without choosing. */
+async function promptForAccount(accounts) {
+	let chosen;
+	const { waitUntilExit, unmount } = render(React.createElement(SelectInput, {
+		items: accounts.map((account) => ({
+			key: account.id,
+			label: `${account.orgId ?? "Personal"}  ${account.apiUrl}`,
+			value: account.id
+		})),
+		onSelect: (item) => {
+			chosen = accounts.find((account) => account.id === item.value);
+			unmount();
+		}
+	}));
+	await waitUntilExit();
+	return chosen;
+}
+export { promptForAccount };
+