@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-DK4FbWVK.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { S as selectAccount, _ as projectLinkPath, a as getCliConfig, b as CredentialStore, c as loadEffectiveContext, g as parseProjectLink, h as isFirstPartyApiUrl, l as normalizeApiUrl, m as findProjectLink, n as CliContextError, p as ProjectLinkError, s as getInvocationOptions, t as isTTY, v as removeProjectLink, y as writeProjectLink } from "./index.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+// src/commands/link.ts
+const PRODUCTION_API_URL = "https://api.runtype.com";
+async function chooseOrganization(orgArgument, options) {
+	if (orgArgument) return { orgId: orgArgument };
+	const accounts = (await new CredentialStore().listAccounts()).filter((account) => account.orgId);
+	const requestedOrgId = getInvocationOptions().org || process.env.RUNTYPE_ORG?.trim();
+	if (requestedOrgId) {
+		const explicitApiUrl = options.apiUrl || getInvocationOptions().apiUrl || process.env.RUNTYPE_API_URL || getCliConfig().get("apiUrl") || void 0;
+		return {
+			orgId: requestedOrgId,
+			apiUrl: selectAccount(accounts, {
+				orgId: requestedOrgId,
+				apiUrl: explicitApiUrl
+			})?.apiUrl
+		};
+	}
+	if (accounts.length > 1 && isTTY(options) && !options.json) {
+		console.log(chalk.cyan("Which organization should this directory use?"));
+		const { promptForAccount } = await import("./chunk-CGDQoqDC.js");
+		const chosen = await promptForAccount(accounts);
+		if (!chosen?.orgId) throw new CliContextError("No organization selected.");
+		return {
+			orgId: chosen.orgId,
+			apiUrl: chosen.apiUrl
+		};
+	}
+	const context = await loadEffectiveContext();
+	const orgId = context.credentials?.orgId ?? (accounts.length === 1 ? accounts[0].orgId : null);
+	if (!orgId) throw new CliContextError("Pass the organization to link (runtype link <orgId>), or log in first with: runtype login");
+	return {
+		orgId,
+		apiUrl: context.credentials?.orgId ? context.credentials.apiUrl : accounts[0]?.apiUrl
+	};
+}
+const linkCommand = new Command("link").description("Link this directory to an organization: writes .runtype/project.json (no secrets; commit it)").argument("[orgId]", "Organization ID (defaults to a stored login)").option("--api-url <url>", "Also pin the API URL for this directory").option("--dir <path>", "Directory to link (default: current directory)").option("--force", "Replace an existing link in that directory").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (orgArgument, options) => {
+	const directory = path.resolve(options.dir ?? process.cwd());
+	const existingPath = projectLinkPath(directory);
+	let existingApiUrl;
+	if (fs.existsSync(existingPath) && !options.force) {
+		let existingOrg = null;
+		try {
+			const existing = parseProjectLink(fs.readFileSync(existingPath, "utf8"), existingPath);
+			existingOrg = existing.orgId;
+			existingApiUrl = existing.apiUrl;
+		} catch {
+			existingOrg = null;
+		}
+		if (existingOrg !== orgArgument || !orgArgument) throw new CliContextError(`${existingPath} already links ${existingOrg ?? "an unreadable organization"}. Pass --force to replace it.`);
+	}
+	const chosen = await chooseOrganization(orgArgument, options);
+	const candidateApiUrl = options.apiUrl ?? getInvocationOptions().apiUrl ?? existingApiUrl ?? chosen.apiUrl;
+	const apiUrl = candidateApiUrl && normalizeApiUrl(candidateApiUrl) !== PRODUCTION_API_URL ? normalizeApiUrl(candidateApiUrl) : void 0;
+	if (apiUrl && !isFirstPartyApiUrl(apiUrl)) throw new CliContextError(`${apiUrl} is not a Runtype API host, so it cannot be pinned in a committed link. Use --api-url or RUNTYPE_API_URL for it instead.`);
+	const filePath = writeProjectLink(directory, {
+		orgId: chosen.orgId,
+		apiUrl
+	});
+	const hasLogin = (await new CredentialStore().listAccounts()).some((account) => account.orgId === chosen.orgId && account.apiUrl === (apiUrl ?? account.apiUrl));
+	const next = hasLogin ? null : `No stored login for ${chosen.orgId} yet. Run: runtype login`;
+	if (options.json || !isTTY(options)) {
+		console.log(JSON.stringify({
+			status: "linked",
+			path: filePath,
+			orgId: chosen.orgId,
+			apiUrl: apiUrl ?? null,
+			hasLogin,
+			...next ? { next } : {}
+		}, null, 2));
+		return;
+	}
+	console.log(chalk.green(`Linked ${directory} to ${chosen.orgId}${apiUrl ? ` (${apiUrl})` : ""}.`));
+	console.log(chalk.gray(`Wrote ${filePath}. It holds no secrets; commit it so teammates use the same org.`));
+	if (next) console.log(chalk.yellow(next));
+});
+const unlinkCommand = new Command("unlink").description("Remove the nearest .runtype/project.json so commands use the default login again").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	let root = null;
+	try {
+		root = findProjectLink()?.root ?? null;
+	} catch (error) {
+		if (!(error instanceof ProjectLinkError)) throw error;
+		root = path.dirname(path.dirname(error.path));
+	}
+	const removedPath = root && removeProjectLink(root) ? projectLinkPath(root) : null;
+	if (options.json || !isTTY(options)) {
+		console.log(JSON.stringify(removedPath ? {
+			status: "unlinked",
+			path: removedPath
+		} : { status: "not_linked" }, null, 2));
+		return;
+	}
+	console.log(removedPath ? chalk.green(`Removed ${removedPath}. Commands here now use the default login.`) : chalk.yellow("No .runtype/project.json found in this directory or its parents."));
+});
+export { linkCommand, unlinkCommand };
+