contentrain 0.3.2 → 0.3.4

package/dist/status-ts5FvDEZ.mjs

@@ -0,0 +1,128 @@
+import { i as pc, r as formatTable, t as formatCount } from "./ui-B5mXontH.mjs";
+import { n as resolveStudioClient } from "./client-D4xW8aLz.mjs";
+import { t as resolveStudioContext } from "./resolve-context-BMV7JwCw.mjs";
+import { defineCommand } from "citty";
+import { intro, log, outro, spinner } from "@clack/prompts";
+//#region src/studio/commands/status.ts
+var status_default = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show project overview from Studio"
+	},
+	args: {
+		workspace: {
+			type: "string",
+			description: "Workspace ID",
+			required: false
+		},
+		project: {
+			type: "string",
+			description: "Project ID",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output",
+			required: false
+		}
+	},
+	async run({ args }) {
+		if (!args.json) intro(pc.bold("contentrain studio status"));
+		try {
+			const client = await resolveStudioClient();
+			const ctx = await resolveStudioContext(client, args);
+			if (!ctx) {
+				log.warning("No workspace or project found.");
+				outro("");
+				return;
+			}
+			const { workspaceId, projectId } = ctx;
+			const s = args.json ? null : spinner();
+			s?.start("Fetching project status...");
+			const [workspaces, projects, branches] = await Promise.all([
+				client.listWorkspaces(),
+				client.listProjects(workspaceId),
+				client.listBranches(workspaceId, projectId).catch(() => [])
+			]);
+			const workspace = workspaces.find((w) => w.id === workspaceId);
+			const project = projects.find((p) => p.id === projectId);
+			let cdnBuilds;
+			try {
+				cdnBuilds = await client.listCdnBuilds(workspaceId, projectId, { limit: "1" });
+			} catch {}
+			s?.stop("Status loaded");
+			if (args.json) {
+				process.stdout.write(JSON.stringify({
+					workspace: workspace ? {
+						id: workspace.id,
+						name: workspace.name,
+						plan: workspace.plan
+					} : null,
+					project: project ? {
+						id: project.id,
+						name: project.name,
+						stack: project.stack
+					} : null,
+					branches: {
+						total: branches.length,
+						items: branches
+					},
+					cdn: cdnBuilds?.data[0] ? { lastBuild: {
+						status: cdnBuilds.data[0].status,
+						fileCount: cdnBuilds.data[0].fileCount,
+						createdAt: cdnBuilds.data[0].createdAt
+					} } : null
+				}, null, 2));
+				return;
+			}
+			log.info(pc.bold("Project"));
+			if (project) {
+				log.message(`  Name:      ${pc.cyan(project.name)}`);
+				log.message(`  Stack:     ${project.stack}`);
+				log.message(`  Members:   ${project.memberCount}`);
+			}
+			if (workspace) {
+				log.info(pc.bold("\nWorkspace"));
+				log.message(`  Name:      ${pc.cyan(workspace.name)}`);
+				log.message(`  Plan:      ${workspace.plan}`);
+			}
+			if (branches.length > 0) {
+				log.info(pc.bold(`\nPending branches (${branches.length})`));
+				const rows = branches.slice(0, 10).map((b) => [
+					b.name,
+					`+${b.ahead}`,
+					b.author ?? "—",
+					timeAgo(b.lastCommitDate)
+				]);
+				log.message(formatTable([
+					"Branch",
+					"Ahead",
+					"Author",
+					"Updated"
+				], rows));
+				if (branches.length > 10) log.message(pc.dim(`  ... and ${formatCount(branches.length - 10, "more branch", "more branches")}`));
+			} else log.message("\nNo pending branches.");
+			const lastBuild = cdnBuilds?.data[0];
+			if (lastBuild) {
+				log.info(pc.bold("\nCDN"));
+				const statusColor = lastBuild.status === "success" ? pc.green : lastBuild.status === "failed" ? pc.red : pc.yellow;
+				log.message(`  Last build: ${statusColor(lastBuild.status)} (${formatCount(lastBuild.fileCount, "file")}, ${timeAgo(lastBuild.createdAt)})`);
+			}
+		} catch (error) {
+			log.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}
+		if (!args.json) outro("");
+	}
+});
+function timeAgo(dateStr) {
+	const diff = Date.now() - new Date(dateStr).getTime();
+	const minutes = Math.floor(diff / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+//#endregion
+export { status_default as default };

package/dist/studio-BmXS_bCq.mjs

@@ -0,0 +1,23 @@
+import { defineCommand } from "citty";
+//#region src/studio/index.ts
+var studio_default = defineCommand({
+	meta: {
+		name: "studio",
+		description: "Interact with Contentrain Studio"
+	},
+	subCommands: {
+		login: () => import("./login-CO0hxICh.mjs").then((m) => m.default),
+		logout: () => import("./logout-CRM4fCSH.mjs").then((m) => m.default),
+		whoami: () => import("./whoami-D8NyFKs_.mjs").then((m) => m.default),
+		status: () => import("./status-ts5FvDEZ.mjs").then((m) => m.default),
+		activity: () => import("./activity-CtOcAA4X.mjs").then((m) => m.default),
+		usage: () => import("./usage-BAb4q7Pz.mjs").then((m) => m.default),
+		branches: () => import("./branches-C_kgqSv9.mjs").then((m) => m.default),
+		"cdn-init": () => import("./cdn-init-DXQ-3V_c.mjs").then((m) => m.default),
+		"cdn-build": () => import("./cdn-build-CDv_yM15.mjs").then((m) => m.default),
+		webhooks: () => import("./webhooks-C39IItU1.mjs").then((m) => m.default),
+		submissions: () => import("./submissions-6_OCrUNF.mjs").then((m) => m.default)
+	}
+});
+//#endregion
+export { studio_default as default };

package/dist/submissions-6_OCrUNF.mjs

@@ -0,0 +1,169 @@
+import { i as pc, r as formatTable, t as formatCount } from "./ui-B5mXontH.mjs";
+import { n as resolveStudioClient } from "./client-D4xW8aLz.mjs";
+import { t as resolveStudioContext } from "./resolve-context-BMV7JwCw.mjs";
+import { defineCommand } from "citty";
+import { confirm, intro, isCancel, log, outro, select, spinner } from "@clack/prompts";
+//#region src/studio/commands/submissions.ts
+var submissions_default = defineCommand({
+	meta: {
+		name: "submissions",
+		description: "Manage form submissions on Studio"
+	},
+	args: {
+		workspace: {
+			type: "string",
+			description: "Workspace ID",
+			required: false
+		},
+		project: {
+			type: "string",
+			description: "Project ID",
+			required: false
+		},
+		form: {
+			type: "string",
+			description: "Form model ID",
+			required: false
+		},
+		status: {
+			type: "string",
+			description: "Filter by status (pending, approved, rejected)",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output",
+			required: false
+		}
+	},
+	async run({ args }) {
+		if (!args.json) intro(pc.bold("contentrain studio submissions"));
+		try {
+			const client = await resolveStudioClient();
+			const ctx = await resolveStudioContext(client, args);
+			if (!ctx) {
+				log.warning("No workspace or project found.");
+				outro("");
+				return;
+			}
+			const { workspaceId, projectId } = ctx;
+			const formId = args.form ?? await resolveFormId(args.json);
+			if (!formId) {
+				if (!args.json) outro("");
+				return;
+			}
+			const s = args.json ? null : spinner();
+			s?.start("Fetching submissions...");
+			const query = {};
+			if (args.status) query["status"] = args.status;
+			const result = await client.listSubmissions(workspaceId, projectId, formId, query);
+			s?.stop(`${formatCount(result.data.length, "submission")}`);
+			if (args.json) {
+				process.stdout.write(JSON.stringify(result, null, 2));
+				return;
+			}
+			if (result.data.length === 0) {
+				log.info("No submissions found.");
+				outro("");
+				return;
+			}
+			const rows = result.data.map((sub) => {
+				const preview = summarizeData(sub.data);
+				const statusColor = sub.status === "approved" ? pc.green : sub.status === "rejected" ? pc.red : sub.status === "spam" ? pc.dim : pc.yellow;
+				return [
+					sub.id.slice(0, 8),
+					preview,
+					statusColor(sub.status),
+					timeAgo(sub.submittedAt)
+				];
+			});
+			log.message(formatTable([
+				"ID",
+				"Preview",
+				"Status",
+				"Submitted"
+			], rows));
+			const pendingSubs = result.data.filter((sub) => sub.status === "pending");
+			if (pendingSubs.length === 0) {
+				outro("");
+				return;
+			}
+			const action = await select({
+				message: `${formatCount(pendingSubs.length, "pending submission")}. What would you like to do?`,
+				options: [
+					{
+						value: "approve",
+						label: "Approve a submission"
+					},
+					{
+						value: "reject",
+						label: "Reject a submission"
+					},
+					{
+						value: "cancel",
+						label: pc.dim("Done")
+					}
+				]
+			});
+			if (isCancel(action) || action === "cancel") {
+				outro("");
+				return;
+			}
+			const subChoice = await select({
+				message: "Select submission",
+				options: pendingSubs.map((sub) => ({
+					value: sub.id,
+					label: `${sub.id.slice(0, 8)} — ${summarizeData(sub.data)}`
+				}))
+			});
+			if (isCancel(subChoice)) {
+				outro("");
+				return;
+			}
+			const targetStatus = action === "approve" ? "approved" : "rejected";
+			const confirmed = await confirm({ message: `${action === "approve" ? "Approve" : "Reject"} submission ${subChoice.slice(0, 8)}?` });
+			if (isCancel(confirmed) || !confirmed) {
+				outro(pc.dim("Cancelled"));
+				return;
+			}
+			const ms = spinner();
+			ms.start(`${action === "approve" ? "Approving" : "Rejecting"}...`);
+			await client.updateSubmissionStatus(workspaceId, projectId, formId, subChoice, targetStatus);
+			ms.stop(`Submission ${targetStatus}`);
+			log.success(`Submission ${pc.cyan(subChoice.slice(0, 8))} ${targetStatus}.`);
+		} catch (error) {
+			log.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}
+		if (!args.json) outro("");
+	}
+});
+async function resolveFormId(isJson) {
+	if (isJson) {
+		const { log: l } = await import("@clack/prompts");
+		l.error("--form is required for JSON output.");
+		process.exitCode = 1;
+		return null;
+	}
+	const { text: textPrompt, isCancel: isCancelled } = await import("@clack/prompts");
+	const input = await textPrompt({ message: "Form model ID" });
+	if (isCancelled(input)) return null;
+	return input;
+}
+function summarizeData(data) {
+	return Object.entries(data).slice(0, 2).map(([k, v]) => {
+		const val = typeof v === "string" ? v : JSON.stringify(v);
+		return `${k}: ${val.length > 20 ? val.slice(0, 17) + "..." : val}`;
+	}).join(", ") || "(empty)";
+}
+function timeAgo(dateStr) {
+	const diff = Date.now() - new Date(dateStr).getTime();
+	const minutes = Math.floor(diff / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+//#endregion
+export { submissions_default as default };

package/dist/usage-BAb4q7Pz.mjs

@@ -0,0 +1,81 @@
+import { i as pc, n as formatPercent, r as formatTable } from "./ui-B5mXontH.mjs";
+import { n as resolveStudioClient } from "./client-D4xW8aLz.mjs";
+import { t as resolveStudioContext } from "./resolve-context-BMV7JwCw.mjs";
+import { defineCommand } from "citty";
+import { intro, log, outro, spinner } from "@clack/prompts";
+//#region src/studio/commands/usage.ts
+var usage_default = defineCommand({
+	meta: {
+		name: "usage",
+		description: "Show workspace usage metrics"
+	},
+	args: {
+		workspace: {
+			type: "string",
+			description: "Workspace ID",
+			required: false
+		},
+		project: {
+			type: "string",
+			description: "Project ID (for context resolution)",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output",
+			required: false
+		}
+	},
+	async run({ args }) {
+		if (!args.json) intro(pc.bold("contentrain studio usage"));
+		try {
+			const client = await resolveStudioClient();
+			const ctx = await resolveStudioContext(client, args);
+			if (!ctx) {
+				log.warning("No workspace found.");
+				outro("");
+				return;
+			}
+			const s = args.json ? null : spinner();
+			s?.start("Fetching usage metrics...");
+			const usage = await client.getWorkspaceUsage(ctx.workspaceId);
+			s?.stop("Usage loaded");
+			if (args.json) {
+				process.stdout.write(JSON.stringify(usage, null, 2));
+				return;
+			}
+			const rows = [
+				metricRow("AI messages", usage.aiMessages),
+				metricRow("Form submissions", usage.formSubmissions),
+				metricRow("CDN bandwidth", usage.cdnBandwidthGb, "GB"),
+				metricRow("Media storage", usage.mediaStorageGb, "GB")
+			];
+			log.message(formatTable([
+				"Metric",
+				"Used",
+				"Limit",
+				"%"
+			], rows));
+		} catch (error) {
+			log.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}
+		if (!args.json) outro("");
+	}
+});
+function metricRow(name, metric, unit) {
+	const suffix = unit ? ` ${unit}` : "";
+	return [
+		name,
+		formatNumber(metric.current) + suffix,
+		metric.limit < 0 ? "unlimited" : formatNumber(metric.limit) + suffix,
+		metric.limit < 0 ? pc.dim("—") : formatPercent(metric.current, metric.limit)
+	];
+}
+function formatNumber(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+	return String(n);
+}
+//#endregion
+export { usage_default as default };

package/dist/webhooks-C39IItU1.mjs

@@ -0,0 +1,235 @@
+import { i as pc, o as statusIcon, r as formatTable } from "./ui-B5mXontH.mjs";
+import { n as resolveStudioClient } from "./client-D4xW8aLz.mjs";
+import { t as resolveStudioContext } from "./resolve-context-BMV7JwCw.mjs";
+import { defineCommand } from "citty";
+import { confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+//#region src/studio/commands/webhooks.ts
+const ALL_EVENTS = [
+	{
+		value: "content.saved",
+		label: "Content saved"
+	},
+	{
+		value: "content.deleted",
+		label: "Content deleted"
+	},
+	{
+		value: "model.saved",
+		label: "Model updated"
+	},
+	{
+		value: "branch.merged",
+		label: "Branch merged"
+	},
+	{
+		value: "branch.rejected",
+		label: "Branch rejected"
+	},
+	{
+		value: "cdn.build_complete",
+		label: "CDN build complete"
+	},
+	{
+		value: "media.uploaded",
+		label: "Media uploaded"
+	},
+	{
+		value: "form.submitted",
+		label: "Form submitted"
+	}
+];
+var webhooks_default = defineCommand({
+	meta: {
+		name: "webhooks",
+		description: "Manage webhooks on Studio"
+	},
+	args: {
+		workspace: {
+			type: "string",
+			description: "Workspace ID",
+			required: false
+		},
+		project: {
+			type: "string",
+			description: "Project ID",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output",
+			required: false
+		}
+	},
+	async run({ args }) {
+		if (!args.json) intro(pc.bold("contentrain studio webhooks"));
+		try {
+			const client = await resolveStudioClient();
+			const ctx = await resolveStudioContext(client, args);
+			if (!ctx) {
+				log.warning("No workspace or project found.");
+				outro("");
+				return;
+			}
+			const { workspaceId, projectId } = ctx;
+			const s = args.json ? null : spinner();
+			s?.start("Fetching webhooks...");
+			const webhooks = await client.listWebhooks(workspaceId, projectId);
+			s?.stop(`${webhooks.length} webhook(s)`);
+			if (args.json) {
+				process.stdout.write(JSON.stringify(webhooks, null, 2));
+				return;
+			}
+			if (webhooks.length > 0) {
+				const rows = webhooks.map((w) => [
+					w.name,
+					w.url.length > 40 ? w.url.slice(0, 37) + "..." : w.url,
+					w.events.join(", "),
+					statusIcon(w.active)
+				]);
+				log.message(formatTable([
+					"Name",
+					"URL",
+					"Events",
+					"Active"
+				], rows));
+			} else log.info("No webhooks configured.");
+			const action = await select({
+				message: "What would you like to do?",
+				options: [
+					{
+						value: "create",
+						label: "Create new webhook"
+					},
+					...webhooks.length > 0 ? [
+						{
+							value: "test",
+							label: "Test a webhook"
+						},
+						{
+							value: "delete",
+							label: "Delete a webhook"
+						},
+						{
+							value: "deliveries",
+							label: "View delivery history"
+						}
+					] : [],
+					{
+						value: "cancel",
+						label: pc.dim("Done")
+					}
+				]
+			});
+			if (isCancel(action) || action === "cancel") {
+				outro("");
+				return;
+			}
+			if (action === "create") await createWebhook(client, workspaceId, projectId);
+			else if (action === "test") await testWebhook(client, workspaceId, projectId, webhooks);
+			else if (action === "delete") await deleteWebhook(client, workspaceId, projectId, webhooks);
+			else if (action === "deliveries") await viewDeliveries(client, workspaceId, projectId, webhooks);
+		} catch (error) {
+			log.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}
+		if (!args.json) outro("");
+	}
+});
+async function createWebhook(client, wid, pid) {
+	const name = await text({ message: "Webhook name" });
+	if (isCancel(name)) return;
+	const url = await text({
+		message: "Endpoint URL",
+		validate: (v) => {
+			if (!v.startsWith("https://")) return "URL must start with https://";
+		}
+	});
+	if (isCancel(url)) return;
+	const events = await multiselect({
+		message: "Events to subscribe to",
+		options: ALL_EVENTS,
+		required: true
+	});
+	if (isCancel(events)) return;
+	const s = spinner();
+	s.start("Creating webhook...");
+	const webhook = await client.createWebhook(wid, pid, {
+		name,
+		url,
+		events
+	});
+	s.stop("Webhook created");
+	log.success(`${pc.cyan(webhook.name)} → ${webhook.url}`);
+}
+async function testWebhook(client, wid, pid, webhooks) {
+	const choice = await select({
+		message: "Select webhook to test",
+		options: webhooks.map((w) => ({
+			value: w.id,
+			label: w.name
+		}))
+	});
+	if (isCancel(choice)) return;
+	const s = spinner();
+	s.start("Sending test event...");
+	const result = await client.testWebhook(wid, pid, choice);
+	s.stop(result.success ? "Test succeeded" : "Test failed");
+	if (result.httpStatus) log.message(`  HTTP status: ${result.httpStatus}`);
+}
+async function deleteWebhook(client, wid, pid, webhooks) {
+	const choice = await select({
+		message: "Select webhook to delete",
+		options: webhooks.map((w) => ({
+			value: w.id,
+			label: w.name
+		}))
+	});
+	if (isCancel(choice)) return;
+	const confirmed = await confirm({ message: `Delete webhook "${webhooks.find((w) => w.id === choice)?.name}"? This cannot be undone.` });
+	if (isCancel(confirmed) || !confirmed) return;
+	const s = spinner();
+	s.start("Deleting...");
+	await client.deleteWebhook(wid, pid, choice);
+	s.stop("Webhook deleted");
+}
+async function viewDeliveries(client, wid, pid, webhooks) {
+	const choice = await select({
+		message: "Select webhook",
+		options: webhooks.map((w) => ({
+			value: w.id,
+			label: w.name
+		}))
+	});
+	if (isCancel(choice)) return;
+	const s = spinner();
+	s.start("Fetching deliveries...");
+	const result = await client.listWebhookDeliveries(wid, pid, choice);
+	s.stop(`${result.data.length} deliveries`);
+	if (result.data.length === 0) {
+		log.info("No deliveries yet.");
+		return;
+	}
+	const rows = result.data.map((d) => [
+		d.event,
+		d.status === "success" ? pc.green(d.status) : d.status === "failed" ? pc.red(d.status) : pc.yellow(d.status),
+		d.httpStatus ? String(d.httpStatus) : "—",
+		timeAgo(d.createdAt)
+	]);
+	log.message(formatTable([
+		"Event",
+		"Status",
+		"HTTP",
+		"Time"
+	], rows));
+}
+function timeAgo(dateStr) {
+	const diff = Date.now() - new Date(dateStr).getTime();
+	const minutes = Math.floor(diff / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+//#endregion
+export { webhooks_default as default };

package/dist/whoami-D8NyFKs_.mjs

@@ -0,0 +1,65 @@
+import { i as pc } from "./ui-B5mXontH.mjs";
+import { i as checkPermissions, n as resolveStudioClient, r as AuthExpiredError } from "./client-D4xW8aLz.mjs";
+import { defineCommand } from "citty";
+import { intro, log, outro } from "@clack/prompts";
+//#region src/studio/commands/whoami.ts
+var whoami_default = defineCommand({
+	meta: {
+		name: "whoami",
+		description: "Show current Studio authentication status"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "JSON output",
+		required: false
+	} },
+	async run({ args }) {
+		if (!args.json) intro(pc.bold("contentrain studio whoami"));
+		try {
+			const client = await resolveStudioClient();
+			const user = await client.me();
+			if (args.json) {
+				const workspaces = await client.listWorkspaces();
+				process.stdout.write(JSON.stringify({
+					user: {
+						id: user.id,
+						email: user.email,
+						name: user.name,
+						provider: user.provider
+					},
+					workspaces: workspaces.map((w) => ({
+						id: w.id,
+						name: w.name,
+						slug: w.slug,
+						plan: w.plan,
+						role: w.role
+					}))
+				}, null, 2));
+				return;
+			}
+			log.info(pc.bold("Profile"));
+			log.message(`  Email:    ${pc.cyan(user.email)}`);
+			if (user.name) log.message(`  Name:     ${user.name}`);
+			log.message(`  Provider: ${user.provider}`);
+			const workspaces = await client.listWorkspaces();
+			if (workspaces.length > 0) {
+				log.info(pc.bold(`\nWorkspaces (${workspaces.length})`));
+				for (const ws of workspaces) log.message(`  ${pc.cyan(ws.name)} (${ws.plan}) — ${pc.dim(ws.role)}`);
+			}
+			const permWarning = await checkPermissions();
+			if (permWarning) log.warning(`\n${permWarning}`);
+		} catch (error) {
+			if (error instanceof AuthExpiredError) {
+				if (args.json) process.stdout.write(JSON.stringify({ error: "not_authenticated" }));
+				else log.error(error.message);
+				process.exitCode = 1;
+			} else {
+				if (!args.json) log.error(error instanceof Error ? error.message : String(error));
+				process.exitCode = 1;
+			}
+		}
+		if (!args.json) outro("");
+	}
+});
+//#endregion
+export { whoami_default as default };