contentrain 0.3.1 → 0.3.3

package/dist/client-D4xW8aLz.mjs

@@ -0,0 +1,275 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { chmod, mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+//#region src/studio/auth/credential-store.ts
+const DIR_NAME = ".contentrain";
+const FILE_NAME = "credentials.json";
+const FILE_MODE = 384;
+const DIR_MODE = 448;
+const DEFAULT_STUDIO_URL = "https://studio.contentrain.io";
+/** Absolute path to the credentials file. */
+function getCredentialsPath() {
+	return join(homedir(), DIR_NAME, FILE_NAME);
+}
+/** Absolute path to the credentials directory. */
+function getCredentialsDir() {
+	return join(homedir(), DIR_NAME);
+}
+/**
+* Load Studio credentials.
+*
+* Resolution order:
+*   1. CONTENTRAIN_STUDIO_TOKEN env var  (CI/CD — no file I/O)
+*   2. ~/.contentrain/credentials.json   (developer workstation)
+*   3. null                              (not authenticated)
+*/
+async function loadCredentials() {
+	const envToken = process.env["CONTENTRAIN_STUDIO_TOKEN"];
+	if (envToken) return {
+		studioUrl: process.env["CONTENTRAIN_STUDIO_URL"] ?? DEFAULT_STUDIO_URL,
+		accessToken: envToken,
+		refreshToken: "",
+		expiresAt: new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3).toISOString()
+	};
+	const filePath = getCredentialsPath();
+	try {
+		const raw = await readFile(filePath, "utf-8");
+		const config = JSON.parse(raw);
+		if (config.version !== 1 || !config.credentials?.accessToken) return null;
+		return config.credentials;
+	} catch {
+		return null;
+	}
+}
+/**
+* Persist credentials to ~/.contentrain/credentials.json.
+*
+* Always enforces 0o600 file + 0o700 directory permissions on POSIX.
+*/
+async function saveCredentials(credentials) {
+	const dirPath = getCredentialsDir();
+	const filePath = getCredentialsPath();
+	await mkdir(dirPath, { recursive: true });
+	const config = {
+		version: 1,
+		credentials
+	};
+	await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", {
+		encoding: "utf-8",
+		mode: FILE_MODE
+	});
+	await enforcePermissions(dirPath, filePath);
+}
+/**
+* Securely remove stored credentials.
+*
+* Defence in depth: overwrites file content with zeros before unlinking
+* to reduce the risk of recovery from filesystem snapshots.
+*/
+async function clearCredentials() {
+	const filePath = getCredentialsPath();
+	try {
+		const info = await stat(filePath);
+		await writeFile(filePath, Buffer.alloc(info.size), { encoding: "utf-8" });
+		await unlink(filePath);
+	} catch {}
+}
+/**
+* Update only the default workspace/project IDs without touching tokens.
+*/
+async function saveDefaults(workspaceId, projectId) {
+	const credentials = await loadCredentials();
+	if (!credentials) return;
+	credentials.defaultWorkspaceId = workspaceId;
+	credentials.defaultProjectId = projectId;
+	await saveCredentials(credentials);
+}
+/**
+* Check whether the credentials file has secure permissions.
+*
+* Returns a warning message if permissions are too open, or null if secure.
+* On Windows this always returns null (chmod is a no-op there).
+*/
+async function checkPermissions() {
+	if (process.platform === "win32") return null;
+	const filePath = getCredentialsPath();
+	try {
+		const mode = (await stat(filePath)).mode & 511;
+		if (mode !== FILE_MODE) return `Credentials file has insecure permissions (${modeToString(mode)}). Expected ${modeToString(FILE_MODE)}. Run: chmod 600 ${filePath}`;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Check whether the stored token is expired.
+*/
+function isTokenExpired(credentials) {
+	if (!credentials.expiresAt) return false;
+	return Date.now() >= new Date(credentials.expiresAt).getTime();
+}
+async function enforcePermissions(dirPath, filePath) {
+	if (process.platform === "win32") return;
+	try {
+		await chmod(dirPath, DIR_MODE);
+		await chmod(filePath, FILE_MODE);
+	} catch {}
+}
+function modeToString(mode) {
+	return `0o${mode.toString(8)}`;
+}
+//#endregion
+//#region src/studio/types.ts
+var StudioApiError = class extends Error {
+	constructor(statusCode, statusText, message) {
+		super(message);
+		this.statusCode = statusCode;
+		this.statusText = statusText;
+		this.name = "StudioApiError";
+	}
+};
+var AuthExpiredError = class extends StudioApiError {
+	constructor() {
+		super(401, "Unauthorized", "Session expired. Run `contentrain studio login` to re-authenticate.");
+		this.name = "AuthExpiredError";
+	}
+};
+//#endregion
+//#region src/studio/client.ts
+var StudioApiClient = class {
+	baseUrl;
+	credentials;
+	constructor(credentials) {
+		this.baseUrl = credentials.studioUrl.replace(/\/+$/, "");
+		this.credentials = credentials;
+	}
+	async request(method, path, options) {
+		if (isTokenExpired(this.credentials) && this.credentials.refreshToken) await this.refreshToken();
+		const url = new URL(`${this.baseUrl}${path}`);
+		if (options?.query) for (const [key, value] of Object.entries(options.query)) url.searchParams.set(key, value);
+		const headers = {
+			"Authorization": `Bearer ${this.credentials.accessToken}`,
+			"Accept": "application/json"
+		};
+		if (options?.body !== void 0) headers["Content-Type"] = "application/json";
+		const res = await globalThis.fetch(url.toString(), {
+			method,
+			headers,
+			body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+		});
+		if (res.status === 401) {
+			if (this.credentials.refreshToken) try {
+				await this.refreshToken();
+				const retryHeaders = {
+					...headers,
+					"Authorization": `Bearer ${this.credentials.accessToken}`
+				};
+				const retry = await globalThis.fetch(url.toString(), {
+					method,
+					headers: retryHeaders,
+					body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+				});
+				if (retry.ok) return retry.status === 204 ? void 0 : await retry.json();
+			} catch {}
+			throw new AuthExpiredError();
+		}
+		if (!res.ok) {
+			let message;
+			try {
+				message = (await res.json()).message ?? res.statusText;
+			} catch {
+				message = res.statusText;
+			}
+			throw new StudioApiError(res.status, res.statusText, message);
+		}
+		if (res.status === 204) return void 0;
+		return await res.json();
+	}
+	async refreshToken() {
+		const res = await globalThis.fetch(`${this.baseUrl}/api/auth/refresh`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken: this.credentials.refreshToken })
+		});
+		if (!res.ok) throw new AuthExpiredError();
+		const data = await res.json();
+		this.credentials.accessToken = data.accessToken;
+		this.credentials.refreshToken = data.refreshToken;
+		this.credentials.expiresAt = data.expiresAt;
+		await saveCredentials(this.credentials);
+	}
+	async me() {
+		return this.request("GET", "/api/auth/me");
+	}
+	async logout() {
+		await this.request("POST", "/api/auth/logout");
+	}
+	async listWorkspaces() {
+		return this.request("GET", "/api/workspaces");
+	}
+	async getWorkspaceUsage(workspaceId) {
+		return this.request("GET", `/api/workspaces/${workspaceId}/usage`);
+	}
+	async listProjects(workspaceId) {
+		return this.request("GET", `/api/workspaces/${workspaceId}/projects`);
+	}
+	async listBranches(wid, pid) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/branches`);
+	}
+	async mergeBranch(wid, pid, branch) {
+		await this.request("POST", `/api/workspaces/${wid}/projects/${pid}/branches/${encodeURIComponent(branch)}/merge`);
+	}
+	async rejectBranch(wid, pid, branch) {
+		await this.request("POST", `/api/workspaces/${wid}/projects/${pid}/branches/${encodeURIComponent(branch)}/reject`);
+	}
+	async listCdnKeys(wid, pid) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/cdn/keys`);
+	}
+	async createCdnKey(wid, pid, name) {
+		return this.request("POST", `/api/workspaces/${wid}/projects/${pid}/cdn/keys`, { body: { name } });
+	}
+	async getCdnSettings(wid, pid) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/cdn/settings`);
+	}
+	async triggerCdnBuild(wid, pid) {
+		return this.request("POST", `/api/workspaces/${wid}/projects/${pid}/cdn/builds/trigger`);
+	}
+	async listCdnBuilds(wid, pid, query) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/cdn/builds`, { query });
+	}
+	async listWebhooks(wid, pid) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/webhooks`);
+	}
+	async createWebhook(wid, pid, config) {
+		return this.request("POST", `/api/workspaces/${wid}/projects/${pid}/webhooks`, { body: config });
+	}
+	async deleteWebhook(wid, pid, webhookId) {
+		await this.request("DELETE", `/api/workspaces/${wid}/projects/${pid}/webhooks/${webhookId}`);
+	}
+	async testWebhook(wid, pid, webhookId) {
+		return this.request("POST", `/api/workspaces/${wid}/projects/${pid}/webhooks/${webhookId}/test`);
+	}
+	async listWebhookDeliveries(wid, pid, webhookId) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/webhooks/${webhookId}/deliveries`);
+	}
+	async listSubmissions(wid, pid, modelId, query) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/forms/${modelId}/submissions`, { query });
+	}
+	async updateSubmissionStatus(wid, pid, modelId, submissionId, status) {
+		await this.request("PATCH", `/api/workspaces/${wid}/projects/${pid}/forms/${modelId}/submissions/${submissionId}`, { body: { status } });
+	}
+	async getActivity(wid, pid, query) {
+		return this.request("GET", `/api/workspaces/${wid}/projects/${pid}/activity`, { query });
+	}
+};
+/**
+* Load credentials and return an authenticated StudioApiClient.
+* Throws if the user is not logged in.
+*/
+async function resolveStudioClient() {
+	const credentials = await loadCredentials();
+	if (!credentials) throw new Error("Not logged in. Run `contentrain studio login` first.");
+	return new StudioApiClient(credentials);
+}
+//#endregion
+export { clearCredentials as a, saveDefaults as c, checkPermissions as i, resolveStudioClient as n, loadCredentials as o, AuthExpiredError as r, saveCredentials as s, StudioApiClient as t };

package/dist/{diff-otz0kGqT.mjs → diff-Cq6iSnaD.mjs}

@@ -4,6 +4,10 @@ import { defineCommand } from "citty";
 import { confirm, intro, isCancel, log, outro, select } from "@clack/prompts";
 import { simpleGit } from "simple-git";
 import { readConfig } from "@contentrain/mcp/core/config";
+import { CONTENTRAIN_BRANCH } from "@contentrain/types";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
 //#region src/commands/diff.ts
 var diff_default = defineCommand({
 	meta: {
@@ -19,17 +23,16 @@ var diff_default = defineCommand({
 		const projectRoot = await resolveProjectRoot(args.root);
 		const git = simpleGit(projectRoot);
 		intro(pc.bold("contentrain diff"));
-		const branches = await git.branch(["--list", "contentrain/*"]);
-		if (branches.all.length === 0) {
+		const featureBranches = (await git.branch(["--list", "cr/*"])).all.filter((b) => b !== CONTENTRAIN_BRANCH);
+		if (featureBranches.length === 0) {
 			log.message("No pending contentrain branches.");
 			outro("");
 			return;
 		}
-		log.info(pc.bold(`Pending branches (${branches.all.length})`));
-		const config = await readConfig(projectRoot);
-		const baseBranch = process.env["CONTENTRAIN_BRANCH"] ?? config?.repository?.default_branch ?? ((await git.raw(["branch", "--show-current"])).trim() || "main");
+		log.info(pc.bold(`Pending branches (${featureBranches.length})`));
+		const baseBranch = (await readConfig(projectRoot))?.repository?.default_branch ?? ((await git.raw(["branch", "--show-current"])).trim() || "main");
 		const branchInfos = [];
-		for (const branch of branches.all) try {
+		for (const branch of featureBranches) try {
 			const diffStat = await git.diffSummary([`${baseBranch}...${branch}`]);
 			branchInfos.push({
 				name: branch,
@@ -92,13 +95,42 @@ var diff_default = defineCommand({
 		}
 		if (action === "merge") {
 			const confirmMerge = await confirm({ message: `Merge ${selectedBranch} into ${baseBranch}?` });
-			if (!isCancel(confirmMerge) && confirmMerge) try {
-				await git.checkout(baseBranch);
-				await git.merge([selectedBranch, "--no-edit"]);
-				await git.deleteLocalBranch(selectedBranch, true);
-				log.success(`Merged and deleted ${selectedBranch}`);
-			} catch (error) {
-				log.error(`Merge failed: ${error instanceof Error ? error.message : String(error)}`);
+			if (!isCancel(confirmMerge) && confirmMerge) {
+				const mergePath = join(tmpdir(), `cr-merge-${randomUUID()}`);
+				try {
+					if (!(await git.branchLocal()).all.includes(CONTENTRAIN_BRANCH)) await git.branch([CONTENTRAIN_BRANCH, baseBranch]);
+					await git.raw([
+						"worktree",
+						"add",
+						mergePath,
+						CONTENTRAIN_BRANCH
+					]);
+					const mergeGit = simpleGit(mergePath);
+					await mergeGit.merge([baseBranch, "--no-edit"]).catch(() => {});
+					await mergeGit.merge([selectedBranch, "--no-edit"]);
+					const tip = (await mergeGit.raw(["rev-parse", "HEAD"])).trim();
+					await git.raw([
+						"update-ref",
+						`refs/heads/${baseBranch}`,
+						tip
+					]);
+					if ((await git.raw(["branch", "--show-current"])).trim() === baseBranch) await git.checkout([
+						tip,
+						"--",
+						".contentrain/"
+					]);
+					await git.deleteLocalBranch(selectedBranch, true);
+					log.success(`Merged and deleted ${selectedBranch}`);
+				} catch (error) {
+					log.error(`Merge failed: ${error instanceof Error ? error.message : String(error)}`);
+				} finally {
+					await git.raw([
+						"worktree",
+						"remove",
+						mergePath,
+						"--force"
+					]).catch(() => {});
+				}
 			}
 		} else if (action === "delete") {
 			const confirmDelete = await confirm({ message: `Delete ${selectedBranch}? This cannot be undone.` });

package/dist/index.mjs

@@ -5,17 +5,18 @@ import { defineCommand, runMain } from "citty";
 runMain(defineCommand({
 	meta: {
 		name: "contentrain",
-		version: "0.3.1",
+		version: "0.3.3",
 		description: "Contentrain CLI — AI content governance infrastructure"
 	},
 	subCommands: {
 		init: () => import("./init-BARgfYUV.mjs").then((m) => m.default),
-		status: () => import("./status-kF5miVty.mjs").then((m) => m.default),
+		status: () => import("./status-Bi9HYgcA.mjs").then((m) => m.default),
 		doctor: () => import("./doctor-DyKjAIKH.mjs").then((m) => m.default),
 		validate: () => import("./validate-DnVamp3p.mjs").then((m) => m.default),
-		serve: () => import("./serve-CaCZMeHF.mjs").then((m) => m.default),
+		serve: () => import("./serve-DL4LhWxl.mjs").then((m) => m.default),
 		generate: () => import("./generate-DDEDRLdy.mjs").then((m) => m.default),
-		diff: () => import("./diff-otz0kGqT.mjs").then((m) => m.default)
+		diff: () => import("./diff-Cq6iSnaD.mjs").then((m) => m.default),
+		studio: () => import("./studio-BmXS_bCq.mjs").then((m) => m.default)
 	}
 }));
 //#endregion

package/dist/login-CO0hxICh.mjs

@@ -0,0 +1,243 @@
+import { i as pc } from "./ui-B5mXontH.mjs";
+import { i as checkPermissions, o as loadCredentials, s as saveCredentials, t as StudioApiClient } from "./client-D4xW8aLz.mjs";
+import { defineCommand } from "citty";
+import { confirm, intro, isCancel, log, outro, select, spinner } from "@clack/prompts";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+//#region src/studio/auth/oauth-server.ts
+const PORT_RANGE_START = 9876;
+const PORT_RANGE_END = 9899;
+const DEFAULT_TIMEOUT_MS = 12e4;
+const SUCCESS_HTML = `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Contentrain CLI</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#fafafa}
+.box{text-align:center;padding:2rem;border-radius:12px;background:#fff;box-shadow:0 2px 8px rgba(0,0,0,.08)}
+h1{font-size:1.5rem;margin:0 0 .5rem}p{color:#666;margin:0}</style></head>
+<body><div class="box"><h1>Authenticated</h1><p>You can close this tab and return to your terminal.</p></div></body></html>`;
+/**
+* Start an ephemeral OAuth callback server.
+*
+* Tries ports in the 9876-9899 range until one is available.
+* The server shuts down automatically after a callback or timeout.
+*/
+async function startOAuthServer(timeoutMs = DEFAULT_TIMEOUT_MS) {
+	const state = randomUUID();
+	const server = createServer();
+	const port = await listenOnAvailablePort(server);
+	const callbackUrl = `http://127.0.0.1:${port}/callback`;
+	let settled = false;
+	let resolveCallback;
+	let rejectCallback;
+	const callbackPromise = new Promise((resolve, reject) => {
+		resolveCallback = resolve;
+		rejectCallback = reject;
+	});
+	callbackPromise.catch(() => {});
+	const timer = setTimeout(() => {
+		if (!settled) {
+			settled = true;
+			closeServer(server);
+			rejectCallback(/* @__PURE__ */ new Error(`OAuth callback timed out after ${Math.round(timeoutMs / 1e3)}s. Please try again.`));
+		}
+	}, timeoutMs);
+	server.on("request", (req, res) => {
+		if (!req.url?.startsWith("/callback")) {
+			res.writeHead(404, { "Content-Type": "text/plain" });
+			res.end("Not found");
+			return;
+		}
+		const url = new URL(req.url, `http://127.0.0.1:${port}`);
+		const code = url.searchParams.get("code");
+		const returnedState = url.searchParams.get("state");
+		const error = url.searchParams.get("error");
+		res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+		res.end(SUCCESS_HTML);
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		setTimeout(() => closeServer(server), 500);
+		if (error) {
+			rejectCallback(/* @__PURE__ */ new Error(`OAuth provider returned an error: ${error}`));
+			return;
+		}
+		if (!code || !returnedState) {
+			rejectCallback(/* @__PURE__ */ new Error("OAuth callback missing code or state parameter."));
+			return;
+		}
+		resolveCallback({
+			code,
+			state: returnedState
+		});
+	});
+	const close = () => {
+		if (!settled) {
+			settled = true;
+			clearTimeout(timer);
+			rejectCallback(/* @__PURE__ */ new Error("OAuth flow cancelled."));
+		}
+		closeServer(server);
+	};
+	return {
+		callbackUrl,
+		state,
+		waitForCallback: () => callbackPromise,
+		close
+	};
+}
+function listenOnAvailablePort(server) {
+	return new Promise((resolve, reject) => {
+		let port = PORT_RANGE_START;
+		const tryPort = () => {
+			if (port > PORT_RANGE_END) {
+				reject(/* @__PURE__ */ new Error(`Could not find an available port in range ${PORT_RANGE_START}-${PORT_RANGE_END}. Close other processes or try again.`));
+				return;
+			}
+			server.once("error", (err) => {
+				if (err.code === "EADDRINUSE") {
+					port++;
+					tryPort();
+				} else reject(err);
+			});
+			server.listen(port, "127.0.0.1", () => {
+				resolve(port);
+			});
+		};
+		tryPort();
+	});
+}
+function closeServer(server) {
+	try {
+		server.close();
+		server.closeAllConnections();
+	} catch {}
+}
+//#endregion
+//#region src/studio/commands/login.ts
+const DEFAULT_STUDIO_URL = "https://studio.contentrain.io";
+var login_default = defineCommand({
+	meta: {
+		name: "login",
+		description: "Authenticate with Contentrain Studio"
+	},
+	args: {
+		url: {
+			type: "string",
+			description: "Studio instance URL",
+			required: false
+		},
+		provider: {
+			type: "string",
+			description: "OAuth provider (github or google)",
+			required: false
+		}
+	},
+	async run({ args }) {
+		intro(pc.bold("contentrain studio login"));
+		try {
+			const studioUrl = (args.url ?? process.env["CONTENTRAIN_STUDIO_URL"] ?? DEFAULT_STUDIO_URL).replace(/\/+$/, "");
+			if (await loadCredentials()) {
+				const reAuth = await confirm({ message: "You are already logged in. Re-authenticate?" });
+				if (isCancel(reAuth) || !reAuth) {
+					outro(pc.dim("Cancelled"));
+					return;
+				}
+			}
+			let provider = args.provider;
+			if (!provider) {
+				const choice = await select({
+					message: "Sign in with",
+					options: [{
+						value: "github",
+						label: "GitHub"
+					}, {
+						value: "google",
+						label: "Google"
+					}]
+				});
+				if (isCancel(choice)) {
+					outro(pc.dim("Cancelled"));
+					return;
+				}
+				provider = choice;
+			}
+			const s = spinner();
+			s.start("Starting authentication...");
+			const oauth = await startOAuthServer();
+			const loginUrl = `${studioUrl}/api/auth/login?provider=${provider}&redirect_uri=${encodeURIComponent(oauth.callbackUrl)}&state=${oauth.state}`;
+			s.stop("Opening browser...");
+			log.info(`If the browser doesn't open, visit:\n  ${pc.cyan(loginUrl)}`);
+			await openBrowser(loginUrl);
+			const s2 = spinner();
+			s2.start("Waiting for authentication...");
+			let result;
+			try {
+				result = await oauth.waitForCallback();
+			} catch (error) {
+				s2.stop("Failed");
+				oauth.close();
+				log.error(error instanceof Error ? error.message : String(error));
+				process.exitCode = 1;
+				outro("");
+				return;
+			}
+			if (result.state !== oauth.state) {
+				s2.stop("Failed");
+				log.error("OAuth state mismatch. This could be a CSRF attack. Please try again.");
+				process.exitCode = 1;
+				outro("");
+				return;
+			}
+			s2.stop("Exchanging token...");
+			const s3 = spinner();
+			s3.start("Completing authentication...");
+			const verifyRes = await globalThis.fetch(`${studioUrl}/api/auth/verify`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					code: result.code,
+					state: result.state,
+					redirectUri: oauth.callbackUrl
+				})
+			});
+			if (!verifyRes.ok) {
+				s3.stop("Failed");
+				log.error("Token exchange failed. Please try again.");
+				process.exitCode = 1;
+				outro("");
+				return;
+			}
+			const tokenData = await verifyRes.json();
+			await saveCredentials({
+				studioUrl,
+				accessToken: tokenData.accessToken,
+				refreshToken: tokenData.refreshToken,
+				expiresAt: tokenData.expiresAt
+			});
+			const user = await new StudioApiClient({
+				studioUrl,
+				accessToken: tokenData.accessToken,
+				refreshToken: tokenData.refreshToken,
+				expiresAt: tokenData.expiresAt
+			}).me();
+			s3.stop("Authenticated");
+			log.success(`Logged in as ${pc.bold(user.email)}`);
+			const permWarning = await checkPermissions();
+			if (permWarning) log.warning(permWarning);
+		} catch (error) {
+			log.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}
+		outro("");
+	}
+});
+async function openBrowser(url) {
+	const { exec } = await import("node:child_process");
+	const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+	return new Promise((resolve) => {
+		exec(command, () => {
+			resolve();
+		});
+	});
+}
+//#endregion
+export { login_default as default };

package/dist/logout-CRM4fCSH.mjs

@@ -0,0 +1,29 @@
+import { i as pc } from "./ui-B5mXontH.mjs";
+import { a as clearCredentials, o as loadCredentials, t as StudioApiClient } from "./client-D4xW8aLz.mjs";
+import { defineCommand } from "citty";
+import { intro, log, outro } from "@clack/prompts";
+//#region src/studio/commands/logout.ts
+var logout_default = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Log out from Contentrain Studio"
+	},
+	args: {},
+	async run() {
+		intro(pc.bold("contentrain studio logout"));
+		const credentials = await loadCredentials();
+		if (!credentials) {
+			log.info("Not currently logged in.");
+			outro("");
+			return;
+		}
+		try {
+			await new StudioApiClient(credentials).logout();
+		} catch {}
+		await clearCredentials();
+		log.success("Logged out successfully.");
+		outro("");
+	}
+});
+//#endregion
+export { logout_default as default };