@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-BirUxTtH.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+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 { t as readJsonFile } from "./chunk-DGv7X9S_.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { writeFileSync } from "fs";
+import { ClientTokensNamespace, EvalsNamespace, FlowsNamespace, ProductsNamespace, SkillsNamespace, SurfacesNamespace, ToolsNamespace, defineEval, defineFlow, defineFpo, defineProduct, defineSkill, defineSurface, defineTool } from "@runtypelabs/sdk";
+// src/lib/ensure-output.ts
+/**
+* Emit a pulled definition as JSON: to `out` when given, otherwise to stdout so
+* `runtype <entity> pull <name> > file.json` works. Hash and warnings go to stderr.
+*/
+function writePulledDefinition(data, meta) {
+	const json = `${JSON.stringify(data, null, 2)}\n`;
+	if (meta.out) {
+		writeFileSync(meta.out, json);
+		console.error(chalk.green(`Wrote ${meta.out}`));
+	} else process.stdout.write(json);
+	if (meta.contentHash) console.error(chalk.gray(`contentHash ${meta.contentHash}`));
+	for (const warning of meta.warnings ?? []) console.error(chalk.yellow(`warning: ${warning}`));
+}
+// src/commands/entity-ensure.ts
+function namespaceTransport(client) {
+	const transport = {
+		get: (path, params) => client.get(path, params),
+		post: (path, body) => client.post(path, body)
+	};
+	return () => transport;
+}
+/** The SDK ensure options these flags ask for, shared by every entity. */
+function buildEntityEnsureOptions(flags, support) {
+	if (flags.release !== void 0 && !["none", "publish"].includes(flags.release)) throw new Error("--release must be none or publish");
+	const version = support.version && (flags.label || flags.notes) ? {
+		...flags.label ? { label: flags.label } : {},
+		...flags.notes ? { notes: flags.notes } : {}
+	} : void 0;
+	return {
+		...flags.dryRun ? { dryRun: true } : {},
+		...flags.expectNoChanges ? { expectNoChanges: true } : {},
+		...flags.overwriteManaged ? { onConflict: "overwrite" } : {},
+		...flags.expectedRemoteHash ? { expectedRemoteHash: flags.expectedRemoteHash } : {},
+		...support.release && flags.release ? { release: flags.release } : {},
+		...version ? { version } : {}
+	};
+}
+const define = (fn, definition) => fn(definition);
+const SKILL_ENSURE_SPEC = {
+	noun: "skill",
+	idKey: "skillId",
+	release: true,
+	version: true,
+	productScoped: false,
+	ensure: async (t, def, options) => new SkillsNamespace(t).ensure(define(defineSkill, def), options),
+	pull: (t, name) => new SkillsNamespace(t).pull(name)
+};
+const FLOW_ENSURE_SPEC = {
+	noun: "flow",
+	idKey: "flowId",
+	release: true,
+	version: true,
+	productScoped: false,
+	ensure: async (t, def, options) => new FlowsNamespace(t).ensure(define(defineFlow, def), options),
+	pull: (t, name) => new FlowsNamespace(t).pull(name)
+};
+const TOOL_ENSURE_SPEC = {
+	noun: "tool",
+	idKey: "toolId",
+	release: false,
+	version: false,
+	productScoped: false,
+	ensure: async (t, def, options) => new ToolsNamespace(t).ensure(define(defineTool, def), options),
+	pull: (t, name) => new ToolsNamespace(t).pull(name)
+};
+const PRODUCT_ENSURE_SPEC = {
+	noun: "product",
+	idKey: "productId",
+	release: false,
+	version: false,
+	productScoped: false,
+	ensure: async (t, def, options) => new ProductsNamespace(t).ensure(define(defineProduct, def), options),
+	pull: (t, name) => new ProductsNamespace(t).pull(name)
+};
+const SURFACE_ENSURE_SPEC = {
+	noun: "surface",
+	idKey: "surfaceId",
+	release: false,
+	version: false,
+	productScoped: true,
+	ensure: async (t, def, options, productId) => new SurfacesNamespace(t).ensure(productId, define(defineSurface, def), options),
+	pull: (t, name, productId) => new SurfacesNamespace(t).pull(productId, name)
+};
+const EVAL_ENSURE_SPEC = {
+	noun: "eval",
+	idKey: "suiteId",
+	release: false,
+	version: false,
+	productScoped: false,
+	ensure: async (t, def, options) => new EvalsNamespace(t).ensure(define(defineEval, def), options),
+	pull: (t, name) => new EvalsNamespace(t).pull(name)
+};
+function isDriftError(error) {
+	return error instanceof Error && error.name.endsWith("DriftError") && "plan" in error;
+}
+function printEnsureOutcome(spec, name, result) {
+	if (result.result === "plan") {
+		console.log(chalk.cyan(`Plan for ${spec.noun} "${name}": ${result.changes ?? "n/a"}`));
+		for (const key of result.changedKeys ?? []) console.log(`  ${key}`);
+		if (result.remoteHash) console.log(chalk.gray(`Apply this plan with --expected-remote-hash ${result.remoteHash}`));
+		return;
+	}
+	const id = typeof result[spec.idKey] === "string" ? ` (${result[spec.idKey]})` : "";
+	console.log(chalk.green(`${spec.noun[0].toUpperCase()}${spec.noun.slice(1)} "${name}" ${result.result}${id}`));
+	if (result.versionId) console.log(chalk.gray(`Version ${result.versionId}`));
+}
+function fail(message, detail) {
+	console.error(chalk.red(message));
+	if (detail !== void 0) console.error(chalk.red(detail instanceof Error ? detail.message : String(detail)));
+	process.exit(1);
+}
+/** `ensure <file>`: converge a definition file (a pull's output, or its `definition`). */
+function buildEntityEnsureCommand(spec) {
+	const command = new Command("ensure").description(`Converge a ${spec.noun} definition from a JSON file (config-as-code)`).argument("<file>", `${spec.noun} definition JSON file, or - to read from stdin`);
+	if (spec.productScoped) command.requiredOption("--product <productId>", "Product the surface belongs to");
+	command.option("--dry-run", "Plan without writing").option("--expect-no-changes", "Plan and exit 1 on any drift (the CI gate)").option("--overwrite-managed", "Converge even when the last write came from the dashboard").option("--expected-remote-hash <hash>", "Apply only if the remote still hashes to this value (the remoteHash a dry run printed)");
+	if (spec.release) command.option("--release <mode>", "none or publish");
+	if (spec.version) command.option("--label <text>", "Version label recorded on the version this converge appends").option("--notes <text>", "Version notes recorded on the version this converge appends");
+	command.option("--json", "Output as JSON").action(async (file, flags) => {
+		let options;
+		let definition;
+		try {
+			options = buildEntityEnsureOptions(flags, spec);
+			definition = readJsonFile(file, {
+				label: `${spec.noun} definition`,
+				unwrapKey: "definition"
+			});
+		} catch (error) {
+			fail(error instanceof Error ? error.message : String(error));
+		}
+		const name = typeof definition.name === "string" ? definition.name : "";
+		const apiKey = await ensureAuth();
+		if (!apiKey) return;
+		const transport = namespaceTransport(createCliClient(apiKey));
+		try {
+			const result = await spec.ensure(transport, definition, options, flags.product);
+			if (flags.json) printJson(result);
+			else printEnsureOutcome(spec, name, result);
+		} catch (error) {
+			if (isDriftError(error)) {
+				if (flags.json) printJson({
+					drift: true,
+					plan: error.plan
+				});
+				else console.error(chalk.yellow(error.message));
+				process.exit(1);
+			}
+			fail(`Failed to converge the ${spec.noun}`, error);
+		}
+	});
+	return command;
+}
+/** `pull <name>`: print the definition file `ensure` reads back (dashboard wins). */
+function buildEntityPullCommand(spec) {
+	const command = new Command("pull").description(`Print a ${spec.noun} as the definition file \`ensure\` reads (dashboard wins)`).argument("<name>", `${spec.noun} name`);
+	if (spec.productScoped) command.requiredOption("--product <productId>", "Product the surface belongs to");
+	command.option("-o, --out <file>", "Write the definition file here instead of stdout").option("--json", "Print the full pull response (definition, contentHash, provenance)").action(async (name, flags) => {
+		const apiKey = await ensureAuth();
+		if (!apiKey) return;
+		const transport = namespaceTransport(createCliClient(apiKey));
+		try {
+			const pulled = await spec.pull(transport, name, flags.product);
+			writePulledDefinition(flags.json ? pulled : pulled.definition, {
+				out: flags.out,
+				contentHash: pulled.contentHash,
+				warnings: pulled.warnings
+			});
+		} catch (error) {
+			fail(`Failed to pull ${spec.noun} "${name}"`, error);
+		}
+	});
+	return command;
+}
+function buildFpoEnsureOptions(flags) {
+	if (flags.release !== void 0 && !["none", "publish"].includes(flags.release)) throw new Error("--release must be none or publish");
+	return {
+		...flags.dryRun ? { dryRun: true } : {},
+		...flags.expectNoChanges ? { expectNoChanges: true } : {},
+		...flags.overwriteManaged ? { onConflict: "overwrite" } : {},
+		...flags.expectedRemoteHash ? { expectedRemoteHash: flags.expectedRemoteHash } : {},
+		...flags.prune ? { prune: true } : {},
+		...flags.hashProbe ? { hashProbe: true } : {},
+		...flags.release ? { release: flags.release } : {}
+	};
+}
+/** `ensure-fpo <file>`: converge a whole Full Product Object. */
+const productEnsureFpoCommand = new Command("ensure-fpo").description("Converge a whole Full Product Object (product, capabilities, surfaces, ...) from a JSON file").argument("<file>", "FPO JSON file (a pull-fpo output, or its fpo), or - to read from stdin").option("--dry-run", "Plan without writing").option("--expect-no-changes", "Plan and exit 1 when any entity would change (the CI gate)").option("--overwrite-managed", "Converge over dashboard/API edits").option("--expected-remote-hash <hash>", "Apply only if the live product still hashes to this value (the remoteHash a dry run printed)").option("--prune", "Remove product-scoped capabilities and surfaces absent from the FPO").option("--release <mode>", "publish (default: converged agents and flows go live) or none (save drafts)").option("--hash-probe", "With --release none, skip the upload when the live product already matches (best for pulled FPOs)").option("--json", "Output as JSON").action(async (file, flags) => {
+	let fpo;
+	try {
+		fpo = defineFpo(readJsonFile(file, {
+			label: "FPO",
+			unwrapKey: "fpo"
+		}));
+	} catch (error) {
+		fail(error instanceof Error ? error.message : String(error));
+	}
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const products = new ProductsNamespace(namespaceTransport(createCliClient(apiKey)));
+	try {
+		const result = await products.ensureFpo(fpo, buildFpoEnsureOptions(flags));
+		if (flags.json) printJson(result);
+		else {
+			console.log(chalk.cyan(`Product FPO ${result.result}${result.productId ? ` (${result.productId})` : ""}`));
+			for (const entity of result.entities) {
+				const line = `  ${entity.kind}:${entity.name} ${entity.result}`;
+				console.log(entity.result === "failed" ? chalk.red(`${line} — ${entity.error ?? ""}`) : line);
+				for (const warning of entity.warnings ?? []) console.warn(chalk.yellow(`    Warning: ${warning}`));
+			}
+			if (result.remoteHash) console.log(chalk.gray(`Apply this plan with --expected-remote-hash ${result.remoteHash}`));
+		}
+		if (result.hasFailures) process.exit(1);
+	} catch (error) {
+		if (isDriftError(error)) {
+			if (flags.json) printJson({
+				drift: true,
+				plan: error.plan
+			});
+			else console.error(chalk.yellow(error.message));
+			process.exit(1);
+		}
+		fail("Failed to converge the product FPO", error);
+	}
+});
+/** Runtype Agent Skills live under `agents` because `runtype skills` installs coding-agent skills. */
+const agentSkillsCommand = new Command("skills").description("Runtype Agent Skills: context bundles deployed agents load (for coding-agent skills see `runtype skills`)");
+agentSkillsCommand.addCommand(buildEntityEnsureCommand(SKILL_ENSURE_SPEC));
+agentSkillsCommand.addCommand(buildEntityPullCommand(SKILL_ENSURE_SPEC));
+/** `pull-fpo <name>`: print the whole product as the FPO `ensure-fpo` reads. */
+const productPullFpoCommand = new Command("pull-fpo").description("Print a product graph as the FPO `ensure-fpo` reads (dashboard wins)").argument("<name>", "Product name").option("-o, --out <file>", "Write the FPO here instead of stdout").option("--json", "Print the full pull response (fpo, contentHash, warnings)").action(async (name, flags) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const products = new ProductsNamespace(namespaceTransport(createCliClient(apiKey)));
+	try {
+		const pulled = await products.pullFpo(name);
+		writePulledDefinition(flags.json ? pulled : pulled.fpo, {
+			out: flags.out,
+			contentHash: pulled.contentHash,
+			warnings: pulled.warnings
+		});
+	} catch (error) {
+		fail(`Failed to pull product "${name}"`, error);
+	}
+});
+/** Converge a client token file through the SDK; it keys on `name` and never deletes or regenerates. */
+async function ensureClientTokenFromFile(client, definition, flags) {
+	const getClient = (() => client);
+	return new ClientTokensNamespace(getClient).ensure(definition, {
+		...flags.dryRun ? { dryRun: true } : {},
+		...flags.expectNoChanges ? { expectNoChanges: true } : {}
+	});
+}
+/** `client-tokens ensure <file>`: the widget token step of the agent-plus-token workflow. */
+const clientTokenEnsureCommand = new Command("ensure").description("Converge a client token definition from a JSON file, keyed by its name").argument("<file>", "Client token definition JSON file, or - to read from stdin").option("--dry-run", "Plan without writing").option("--expect-no-changes", "Plan and exit 1 on any drift (the CI gate)").option("--json", "Output as JSON").action(async (file, flags) => {
+	let definition;
+	try {
+		definition = readJsonFile(file, { label: "client token definition" });
+	} catch (error) {
+		fail(error instanceof Error ? error.message : String(error));
+	}
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	try {
+		const result = await ensureClientTokenFromFile(createCliClient(apiKey), definition, flags);
+		if (flags.json) printJson(result);
+		else if (result.result === "plan") {
+			console.log(chalk.cyan(`Plan for client token "${String(definition.name)}": ${result.changes}`));
+			for (const key of result.changedKeys) console.log(`  ${key}`);
+		} else {
+			console.log(chalk.green(`Client token "${result.clientToken.name}" ${result.result} (${result.clientToken.id})`));
+			if (result.token) console.log(`Token ${result.token}`);
+		}
+	} catch (error) {
+		if (isDriftError(error)) {
+			if (flags.json) printJson({
+				drift: true,
+				plan: error.plan
+			});
+			else console.error(chalk.yellow(error.message));
+			process.exit(1);
+		}
+		fail("Failed to converge the client token", error);
+	}
+});
+export { TOOL_ENSURE_SPEC as a, buildEntityPullCommand as c, productPullFpoCommand as d, writePulledDefinition as f, SURFACE_ENSURE_SPEC as i, clientTokenEnsureCommand as l, FLOW_ENSURE_SPEC as n, agentSkillsCommand as o, PRODUCT_ENSURE_SPEC as r, buildEntityEnsureCommand as s, EVAL_ENSURE_SPEC as t, productEnsureFpoCommand as u };
+