@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-Bu0FJr6S.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { b as string, f as literal, h as object, i as _enum, m as number, v as record } from "./chunk-BOpO6xE-.js";
+// ../shared/dist/chunk-C6un8ZqB.mjs
+const HARNESS_BINDING_HEADER = "X-Runtype-Harness-Binding";
+const HARNESS_BINDING_METADATA_KEY = "runtypeHarnessBinding";
+const HARNESS_TRACE_ARTIFACT = "runtype.harness";
+const harnessCoverageSchema = record(string().min(1).max(80), object({
+	state: _enum([
+		"available",
+		"unavailable",
+		"disabled",
+		"partial",
+		"redacted",
+		"truncated"
+	]),
+	reason: string().max(240).optional()
+})).refine((fields) => Object.keys(fields).length <= 64, "Capture coverage is limited to 64 fields");
+/** A server-minted correlation capability; normal telemetry authentication is also required. */
+const harnessTurnBindingSchema = object({
+	version: literal(1),
+	token: string().min(1).max(8192),
+	traceId: string().regex(/^[0-9a-f]{32}$/),
+	executionId: string().min(1).max(200),
+	expiresAt: number().int().positive(),
+	dataPolicy: _enum([
+		"metrics",
+		"redacted",
+		"full"
+	])
+});
+/** Producer-reported versions and profile, without local paths or configuration content. */
+const harnessProvenanceSummarySchema = object({
+	cliVersion: string().max(128).optional(),
+	harness: _enum(["claude", "codex"]),
+	backend: _enum(["native", "acp"]),
+	harnessVersion: string().max(128),
+	adapterVersion: string().max(128).optional(),
+	sdkVersion: string().max(128).optional(),
+	protocolVersion: string().max(128),
+	profile: _enum(["controlled-mcp", "workspace"])
+});
+/** Bounded reference to canonical evidence; it is not an isolation or billing attestation. */
+const harnessCaptureSummarySchema = object({
+	version: literal(1),
+	traceId: string().regex(/^[0-9a-f]{32}$/),
+	executionId: string().min(1).max(200),
+	delivery: _enum([
+		"accepted",
+		"partial",
+		"failed"
+	]),
+	dataPolicy: _enum([
+		"metrics",
+		"redacted",
+		"full"
+	]),
+	coverage: harnessCoverageSchema,
+	provenance: harnessProvenanceSummarySchema.optional(),
+	observedEvents: number().int().nonnegative(),
+	deliveredEvents: number().int().nonnegative(),
+	droppedEvents: number().int().nonnegative(),
+	unresolvedTools: number().int().nonnegative()
+});
+const HARNESS_ATTRIBUTES = {
+	version: "runtype.harness.version",
+	sessionId: "runtype.harness.session_id",
+	turnId: "runtype.harness.turn_id",
+	sequence: "runtype.harness.sequence",
+	eventId: "runtype.harness.event_id",
+	nativeId: "runtype.harness.native_id",
+	nativeSessionId: "runtype.harness.native_session_id",
+	nativeTurnId: "runtype.harness.native_turn_id",
+	parentId: "runtype.harness.parent_id",
+	toolOutcome: "runtype.harness.tool_outcome",
+	toolUpdate: "runtype.harness.tool_update",
+	durationKnown: "runtype.harness.duration_known",
+	provenance: "runtype.harness.provenance",
+	coverage: "runtype.harness.coverage",
+	summary: "runtype.harness.summary",
+	usage: "runtype.harness.usage",
+	nativeContent: "runtype.harness.native"
+};
+export { harnessCaptureSummarySchema as a, HARNESS_TRACE_ARTIFACT as i, HARNESS_BINDING_HEADER as n, harnessTurnBindingSchema as o, HARNESS_BINDING_METADATA_KEY as r, HARNESS_ATTRIBUTES as t };
+

package/dist/chunk-BvEoKpN3.js

@@ -0,0 +1,255 @@
+#!/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, i as printDetail } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import open from "open";
+// src/commands/billing.ts
+/**
+* Render the execution count from `GET /v1/billing/status`.
+* No plan bounds an account by execution count, so this is a plain number, never a fraction.
+* `executionsToday` is the honest field; `executionsThisMonth` is its deprecated fallback alias.
+* A failed read reports "unavailable" rather than a confident zero.
+*/
+function formatExecutionsToday(usage) {
+	if (usage.executionsThisMonthAvailable === false) return "unavailable";
+	const used = usage.executionsToday ?? usage.executionsThisMonth;
+	return typeof used === "number" ? used.toLocaleString() : "unavailable";
+}
+const billingCommand = new Command("billing").description("View billing and subscription info");
+billingCommand.command("status").description("Show current plan and usage").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("/billing/status");
+			if (options.json) printJson(data);
+			else {
+				printDetail("Billing Status", [
+					{
+						label: "Plan",
+						value: data.planName || data.plan
+					},
+					{
+						label: "Status",
+						value: data.status
+					},
+					{
+						label: "Period start",
+						value: data.currentPeriodStart
+					},
+					{
+						label: "Period end",
+						value: data.currentPeriodEnd
+					}
+				]);
+				if (data.usage) {
+					console.log();
+					printDetail("Usage", [{
+						label: "Executions today",
+						value: formatExecutionsToday(data.usage)
+					}]);
+				}
+				if (data.limits) {
+					console.log();
+					printDetail("Limits", [
+						{
+							label: "Daily",
+							value: data.limits.dailyLimit
+						},
+						{
+							label: "Monthly",
+							value: data.limits.monthlyLimit
+						},
+						{
+							label: "Rate limit",
+							value: data.limits.rateLimit
+						}
+					]);
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch billing 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("/billing/status");
+					const fields = [
+						{
+							label: "Plan",
+							value: data.planName || data.plan
+						},
+						{
+							label: "Status",
+							value: data.status,
+							color: data.status === "active" ? "green" : void 0
+						},
+						{
+							label: "Period start",
+							value: data.currentPeriodStart
+						},
+						{
+							label: "Period end",
+							value: data.currentPeriodEnd
+						}
+					];
+					if (data.usage) fields.push({
+						label: "Executions today",
+						value: formatExecutionsToday(data.usage)
+					});
+					if (data.limits) {
+						if (data.limits.dailyLimit) fields.push({
+							label: "Daily limit",
+							value: data.limits.dailyLimit
+						});
+						if (data.limits.monthlyLimit) fields.push({
+							label: "Monthly limit",
+							value: data.limits.monthlyLimit
+						});
+						if (data.limits.rateLimit) fields.push({
+							label: "Rate limit",
+							value: data.limits.rateLimit
+						});
+					}
+					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 billing status...",
+			success,
+			successMessage: "Billing Status",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+billingCommand.command("portal").description("Open the billing portal in your browser").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)) {
+		try {
+			const data = await client.post("/billing/portal");
+			if (data.url) {
+				console.log("Opening billing portal...");
+				console.log(data.url);
+				await open(data.url);
+			} else console.log("No portal URL returned. You may need to set up billing first.");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to open billing portal"));
+			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 [msg, setMsg] = useState("Opening billing portal...");
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.post("/billing/portal");
+					if (data.url) {
+						await open(data.url);
+						setMsg("Billing portal opened in browser");
+						setSuccess(true);
+					} else {
+						setMsg("No portal URL returned. You may need to set up billing first.");
+						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: "Generating portal link...",
+			success,
+			successMessage: msg,
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+billingCommand.command("refresh").description("Refresh plan data from billing provider").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)) {
+		try {
+			await client.post("/billing/refresh");
+			console.log(chalk.green("Plan data refreshed"));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to refresh plan data"));
+			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("/billing/refresh");
+					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: "Refreshing plan data...",
+			success,
+			successMessage: "Plan data refreshed",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+export { billingCommand };
+

package/dist/chunk-BxNJgYbE.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// src/lib/agent-version-selector.ts
+var AgentVersionSelectorConflictError = class extends Error {
+	name = "AgentVersionSelectorConflictError";
+	constructor() {
+		super("Provide at most one of --alias or --version-id.");
+	}
+};
+/** The selector the flags name, or nothing when neither was given. */
+function buildAgentVersionSelector(flags) {
+	if (flags.alias && flags.versionId) throw new AgentVersionSelectorConflictError();
+	if (!flags.alias && !flags.versionId) return null;
+	return {
+		...flags.alias ? { alias: flags.alias } : {},
+		...flags.versionId ? { versionId: flags.versionId } : {}
+	};
+}
+/**
+* The selector nested under `agent`, the shape `/eval/run`, `/eval/suites/:id/run`
+* and `/dispatch` all read. Returns an empty object when no flag was given, so it
+* spreads into a body without adding a key.
+*/
+function buildNestedAgentSelector(flags) {
+	const selector = buildAgentVersionSelector(flags);
+	return selector ? { agent: selector } : {};
+}
+export { buildNestedAgentSelector as n, buildAgentVersionSelector as t };
+