@tailor-platform/sdk 1.2.6 → 1.3.0

package/dist/cli/index.mjs

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 import "../chunk-CIV_ash9.mjs";
 import "../config-BmQRlW1j.mjs";
-import { $ as withCommonArgs, B as loadWorkspaceId, D as tokenCommand, F as loadConfig, G as initOAuth2Client, H as writePlatformConfig, J as PATScope, K as initOperatorClient, L as apiCommand, N as applyCommand, O as listCommand$5, Q as jsonArgs, R as fetchLatestToken, S as listCommand$6, U as fetchAll, V as readPlatformConfig, W as fetchUserInfo, X as confirmationArgs, Y as commonArgs, Z as deploymentArgs, a as createCommand$3, d as listCommand$7, et as workspaceArgs, h as executionsCommand, j as generateCommand, l as startCommand, p as getCommand$2, q as readPackageJson, r as deleteCommand$3, s as resumeCommand, t as listCommand$8, tt as logger, w as getCommand$1, x as removeCommand, y as showCommand, z as loadAccessToken } from "../list-WMFoshbx.mjs";
-import { register } from "node:module";
+import { $ as withCommonArgs, B as loadWorkspaceId, D as tokenCommand, F as loadConfig, G as initOAuth2Client, H as writePlatformConfig, J as PATScope, K as initOperatorClient, L as apiCommand, N as applyCommand, O as listCommand$5, Q as jsonArgs, R as fetchLatestToken, S as listCommand$6, U as fetchAll, V as readPlatformConfig, W as fetchUserInfo, X as confirmationArgs, Y as commonArgs, Z as deploymentArgs, a as createCommand$3, d as listCommand$7, et as workspaceArgs, h as executionsCommand, j as generateCommand, l as startCommand, p as getCommand$2, q as readPackageJson, r as deleteCommand$3, s as resumeCommand, t as listCommand$8, tt as logger, w as getCommand$1, x as removeCommand, y as showCommand, z as loadAccessToken } from "../list-BCl3ViG0.mjs";
+import { createRequire, register } from "node:module";
 import { defineCommand, runCommand, runMain } from "citty";
+import * as fs$1 from "node:fs";
+import * as path from "pathe";
 import { generateCodeVerifier } from "@badgateway/oauth2-client";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 import { Code, ConnectError } from "@connectrpc/connect";
+import { findUpSync } from "find-up-simple";
 import ml from "multiline-ts";
-import * as path from "path";
-import * as fs from "fs";
+import * as fs$2 from "fs";
 import pLimit from "p-limit";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as http from "node:http";
 import open from "open";
@@ -55,7 +57,7 @@ const initCommand = defineCommand({
 		const version = packageJson$1.version && packageJson$1.version !== "0.0.0" ? packageJson$1.version : "latest";
 		let packageManager = detectPackageManager();
 		if (!packageManager) {
-			logger.warn("⚠️ Could not detect package manager, defaulting to npm");
+			logger.warn("Could not detect package manager, defaulting to npm");
 			packageManager = "npm";
 		}
 		const initArgs = [
@@ -817,6 +819,15 @@ function shouldIgnoreFile(filePath) {
 	const fileName = path.basename(filePath).toLowerCase();
 	return IGNORED_FILES.has(fileName);
 }
+/**
+* Deploy a static website by creating a deployment, uploading files, and publishing it.
+* @param {OperatorClient} client - Operator client instance
+* @param {string} workspaceId - Workspace ID
+* @param {string} name - Static website name
+* @param {string} distDir - Directory containing static site files
+* @param {boolean} [showProgress=true] - Whether to show upload progress
+* @returns {Promise<DeployResult>} Deployment result with URL and skipped files
+*/
 async function deployStaticWebsite(client, workspaceId, name, distDir, showProgress = true) {
 	const { deploymentId } = await client.createDeployment({
 		workspaceId,
@@ -851,9 +862,15 @@ async function uploadDirectory(client, workspaceId, deploymentId, rootDir, showP
 	if (progress) progress.finish();
 	return skippedFiles;
 }
+/**
+* Recursively collect all deployable files under the given directory.
+* @param {string} rootDir - Root directory to scan
+* @param {string} [currentDir=""] - Current relative directory (for recursion)
+* @returns {Promise<string[]>} List of file paths relative to rootDir
+*/
 async function collectFiles(rootDir, currentDir = "") {
 	const dirPath = path.join(rootDir, currentDir);
-	const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+	const entries = await fs$2.promises.readdir(dirPath, { withFileTypes: true });
 	const files = [];
 	for (const entry of entries) {
 		const rel = path.join(currentDir, entry.name);
@@ -864,16 +881,15 @@ async function collectFiles(rootDir, currentDir = "") {
 	}
 	return files;
 }
-async function uploadSingleFile(client, workspaceId, deploymentId, rootDir, relativePath, skippedFiles) {
-	const absPath = path.join(rootDir, relativePath);
-	const filePath = relativePath.split(path.sep).join("/");
+async function uploadSingleFile(client, workspaceId, deploymentId, rootDir, filePath, skippedFiles) {
+	const absPath = path.join(rootDir, filePath);
 	const mime = lookup(filePath);
 	if (!mime) {
 		skippedFiles.push(`${filePath} (unsupported content type; no MIME mapping found)`);
 		return;
 	}
 	const contentType = mime;
-	const readStream = fs.createReadStream(absPath, { highWaterMark: CHUNK_SIZE });
+	const readStream = fs$2.createReadStream(absPath, { highWaterMark: CHUNK_SIZE });
 	async function* requestStream() {
 		yield { payload: {
 			case: "initialMetadata",
@@ -902,6 +918,11 @@ async function uploadSingleFile(client, workspaceId, deploymentId, rootDir, rela
 	}
 	await withTimeout(uploadWithLogging(), 2 * 6e4, `Upload timed out for "${filePath}"`);
 }
+/**
+* Log skipped files after a deployment, including reasons for skipping.
+* @param {string[]} skippedFiles - List of skipped file descriptions
+* @returns {void}
+*/
 function logSkippedFiles(skippedFiles) {
 	if (skippedFiles.length === 0) return;
 	logger.warn("Deployment completed, but some files failed to upload. These files may have unsupported content types or other validation issues. Please review the list below:");
@@ -941,7 +962,7 @@ const deployCommand = defineCommand({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
 		});
-		if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw new Error(`Directory not found or not a directory: ${dir}`);
+		if (!fs$2.existsSync(dir) || !fs$2.statSync(dir).isDirectory()) throw new Error(`Directory not found or not a directory: ${dir}`);
 		const { url, skippedFiles } = await withTimeout(deployStaticWebsite(client, workspaceId, name, dir, !args.json), 10 * 6e4, "Deployment timed out after 10 minutes.");
 		if (args.json) logger.out({
 			name,
@@ -1084,6 +1105,523 @@ const staticwebsiteCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/utils/resolve-cli-bin.ts
+/**
+* Resolve a CLI binary path from the caller's project dependencies.
+* @param {ResolveCliBinOptions} options - Resolution options for locating the CLI binary.
+* @returns {string} Absolute path to the CLI binary entry.
+*/
+function resolveCliBinPath({ cwd, packageName, binName, installHint }) {
+	const projectPackageJsonPath = findUpSync("package.json", { cwd });
+	if (!projectPackageJsonPath) throw new Error(`Failed to locate package.json from ${cwd}.`);
+	const requireFromProject = createRequire(projectPackageJsonPath);
+	let pkgJsonPath;
+	try {
+		pkgJsonPath = requireFromProject.resolve(`${packageName}/package.json`);
+	} catch {
+		throw new Error(`Missing optional dependency \`${packageName}\`. Install it in your project (e.g. \`${installHint}\`).`);
+	}
+	const binRelativePath = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf8")).bin?.[binName];
+	if (!binRelativePath) throw new Error(`\`${packageName}\` does not expose a \`${binName}\` binary entry.`);
+	return path.resolve(path.dirname(pkgJsonPath), binRelativePath);
+}
+
+//#endregion
+//#region src/cli/tailordb/erd/schema.ts
+/**
+* Convert TailorDB field config to tbls column definition.
+* @param {string} fieldName - Field name
+* @param {TailorDBType_FieldConfig} fieldConfig - TailorDB field configuration
+* @returns {TblsColumn} tbls column definition
+*/
+function toTblsColumn(fieldName, fieldConfig) {
+	const baseType = fieldConfig.type || "string";
+	return {
+		name: fieldName,
+		type: fieldConfig.array ? `${baseType}[]` : baseType,
+		nullable: !fieldConfig.required,
+		comment: fieldConfig.description ?? ""
+	};
+}
+/**
+* Build tbls schema JSON from TailorDB types.
+* @param {TailorDBProtoType[]} types - TailorDB types fetched from platform
+* @param {string} namespace - TailorDB namespace
+* @returns {TblsSchema} tbls-compatible schema representation
+*/
+function buildTblsSchema(types, namespace) {
+	const tables = [];
+	const relations = [];
+	const referencedByTable = {};
+	const constraintsByTable = {};
+	const enumsMap = /* @__PURE__ */ new Map();
+	for (const type of types) {
+		const tableName = type.name;
+		const schema = type.schema;
+		const columns = [];
+		const tableConstraints = [];
+		columns.push({
+			name: "id",
+			type: "uuid",
+			nullable: false,
+			comment: ""
+		});
+		tableConstraints.push({
+			name: `pk_${tableName}`,
+			type: "PRIMARY KEY",
+			def: "",
+			table: tableName,
+			columns: ["id"]
+		});
+		if (schema) for (const [fieldName, fieldConfig] of Object.entries(schema.fields ?? {})) {
+			columns.push(toTblsColumn(fieldName, fieldConfig));
+			if (fieldConfig.type === "enum" && fieldConfig.allowedValues.length > 0) {
+				const enumName = `${tableName}_${fieldName}`;
+				let values = enumsMap.get(enumName);
+				if (!values) {
+					values = /* @__PURE__ */ new Set();
+					enumsMap.set(enumName, values);
+				}
+				for (const value of fieldConfig.allowedValues) values.add(value.value);
+			}
+			if (fieldConfig.foreignKey && fieldConfig.foreignKeyType) {
+				const foreignTable = fieldConfig.foreignKeyType;
+				const foreignColumn = fieldConfig.foreignKeyField || "id";
+				const childCardinality = fieldConfig.required ? "exactly_one" : "zero_or_one";
+				relations.push({
+					table: tableName,
+					columns: [fieldName],
+					parent_table: foreignTable,
+					parent_columns: [foreignColumn],
+					cardinality: childCardinality,
+					parent_cardinality: "zero_or_more",
+					def: ""
+				});
+				tableConstraints.push({
+					name: `fk_${tableName}_${fieldName}`,
+					type: "FOREIGN KEY",
+					def: "",
+					table: tableName,
+					columns: [fieldName],
+					referenced_table: foreignTable,
+					referenced_columns: [foreignColumn]
+				});
+				if (!referencedByTable[tableName]) referencedByTable[tableName] = /* @__PURE__ */ new Set();
+				referencedByTable[tableName].add(foreignTable);
+			}
+		}
+		constraintsByTable[tableName] = tableConstraints;
+		tables.push({
+			name: tableName,
+			type: "table",
+			comment: schema?.description ?? "",
+			columns,
+			indexes: [],
+			constraints: constraintsByTable[tableName] ?? [],
+			triggers: [],
+			def: "",
+			referenced_tables: []
+		});
+	}
+	for (const table of tables) {
+		const referenced = referencedByTable[table.name];
+		table.referenced_tables = referenced ? Array.from(referenced) : [];
+	}
+	const enums = [];
+	for (const [name, values] of enumsMap.entries()) enums.push({
+		name,
+		values: Array.from(values)
+	});
+	return {
+		name: namespace,
+		tables,
+		relations,
+		enums
+	};
+}
+/**
+* Export apply-applied TailorDB schema for a namespace as tbls-compatible JSON.
+* @param {TailorDBSchemaOptions} options - Export options
+* @returns {Promise<TblsSchema>} tbls schema representation
+*/
+async function exportTailorDBSchema(options) {
+	const { client, workspaceId, namespace } = options;
+	const types = await fetchAll(async (pageToken) => {
+		try {
+			const { tailordbTypes, nextPageToken } = await client.listTailorDBTypes({
+				workspaceId,
+				namespaceName: namespace,
+				pageToken
+			});
+			return [tailordbTypes, nextPageToken];
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) return [[], ""];
+			throw error;
+		}
+	});
+	if (types.length === 0) logger.warn(`No TailorDB types found in namespace "${namespace}". Returning empty schema.`);
+	return buildTblsSchema(types, namespace);
+}
+/**
+* Writes the TailorDB schema to a file in tbls-compatible JSON format.
+* @param {WriteSchemaOptions} options - The options for writing the schema file.
+*/
+async function writeTblsSchemaToFile(options) {
+	const schema = await exportTailorDBSchema(options);
+	const json = JSON.stringify(schema, null, 2);
+	fs$1.mkdirSync(path.dirname(options.outputPath), { recursive: true });
+	fs$1.writeFileSync(options.outputPath, json, "utf8");
+	const relativePath = path.relative(process.cwd(), options.outputPath);
+	logger.success(`Wrote ERD schema to ${relativePath}`);
+}
+
+//#endregion
+//#region src/cli/utils/beta.ts
+/**
+* Warn that the ERD CLI is a beta feature.
+*/
+function logErdBetaWarning() {
+	logger.warn("The ERD command is a beta feature and may introduce breaking changes in future releases.");
+	logger.newline();
+}
+
+//#endregion
+//#region src/cli/tailordb/erd/utils.ts
+/**
+* Initialize shared ERD command context.
+* @param {{ profile?: string; workspaceId?: string; config?: string }} args - CLI arguments.
+* @param {string | undefined} args.profile - Workspace profile.
+* @param {string | undefined} args.workspaceId - Workspace ID override.
+* @param {string | undefined} args.config - Config path override.
+* @returns {Promise<ErdCommandContext>} Initialized context.
+*/
+async function initErdContext(args) {
+	logErdBetaWarning();
+	const client = await initOperatorClient(await loadAccessToken({
+		useProfile: true,
+		profile: args.profile
+	}));
+	const workspaceId = loadWorkspaceId({
+		workspaceId: args.workspaceId,
+		profile: args.profile
+	});
+	const { config } = await loadConfig(args.config);
+	return {
+		client,
+		workspaceId,
+		config
+	};
+}
+
+//#endregion
+//#region src/cli/tailordb/erd/export.ts
+const DEFAULT_ERD_BASE_DIR = ".tailor-sdk/erd";
+/**
+* Resolve TailorDB config and namespace.
+* @param {AppConfig} config - Loaded Tailor SDK config.
+* @param {string | undefined} explicitNamespace - Namespace override.
+* @returns {{ namespace: string; erdSite: string | undefined }} Resolved namespace and erdSite.
+*/
+function resolveDbConfig(config, explicitNamespace) {
+	const namespace = explicitNamespace ?? Object.keys(config.db ?? {})[0];
+	if (!namespace) throw new Error("No TailorDB namespaces found in config. Please define db services in tailor.config.ts or pass --namespace.");
+	const dbConfig = config.db?.[namespace];
+	if (!dbConfig || typeof dbConfig !== "object" || "external" in dbConfig) throw new Error(`TailorDB namespace "${namespace}" not found in config.db.`);
+	return {
+		namespace,
+		erdSite: dbConfig.erdSite
+	};
+}
+/**
+* Get all namespaces with erdSite configured.
+* @param {AppConfig} config - Loaded Tailor SDK config.
+* @returns {Array<{ namespace: string; erdSite: string }>} Namespaces with erdSite.
+*/
+function resolveAllErdSites(config) {
+	const results = [];
+	for (const [namespace, dbConfig] of Object.entries(config.db ?? {})) if (dbConfig && typeof dbConfig === "object" && !("external" in dbConfig) && dbConfig.erdSite) results.push({
+		namespace,
+		erdSite: dbConfig.erdSite
+	});
+	return results;
+}
+/**
+* Run the liam CLI to build an ERD static site from a schema file.
+* @param {string} schemaPath - Path to the ERD schema JSON file
+* @param {string} cwd - Working directory where liam will run (dist is created here)
+* @returns {Promise<void>} Resolves when the build completes successfully
+*/
+async function runLiamBuild(schemaPath, cwd) {
+	fs$1.mkdirSync(cwd, { recursive: true });
+	return await new Promise((resolve, reject) => {
+		let liamBinPath;
+		try {
+			liamBinPath = resolveCliBinPath({
+				cwd,
+				packageName: "@liam-hq/cli",
+				binName: "liam",
+				installHint: "npm i -D @liam-hq/cli"
+			});
+		} catch (error) {
+			logger.error(String(error));
+			reject(error);
+			return;
+		}
+		const child = spawn(process.execPath, [
+			liamBinPath,
+			"erd",
+			"build",
+			"--format",
+			"tbls",
+			"--input",
+			schemaPath
+		], {
+			stdio: "inherit",
+			cwd
+		});
+		child.on("error", (error) => {
+			logger.error("Failed to run `@liam-hq/cli`. Ensure it is installed in your project.");
+			reject(error);
+		});
+		child.on("exit", (code) => {
+			if (code === 0) resolve();
+			else {
+				logger.error("liam CLI exited with a non-zero code. Ensure `@liam-hq/cli erd build --format tbls --input schema.json` works in your project.");
+				reject(/* @__PURE__ */ new Error(`liam CLI exited with code ${code ?? 1}`));
+			}
+		});
+	});
+}
+/**
+* Export TailorDB schema and build ERD artifacts via liam.
+* @param {TailorDBSchemaOptions & { outputPath: string; erdDir: string }} options - Build options.
+*/
+async function prepareErdBuild(options) {
+	await writeTblsSchemaToFile(options);
+	await runLiamBuild(options.outputPath, options.erdDir);
+}
+/**
+* Prepare ERD builds for one or more namespaces.
+* @param {{ client: OperatorClient; workspaceId: string; config: AppConfig; namespace?: string; outputDir?: string }} options - Build options.
+* @param {OperatorClient} options.client - Operator client.
+* @param {string} options.workspaceId - Workspace ID.
+* @param {AppConfig} options.config - Loaded Tailor config.
+* @param {string | undefined} options.namespace - Namespace override.
+* @param {string | undefined} options.outputDir - Output directory override.
+* @returns {Promise<ErdBuildResult[]>} Build results by namespace.
+*/
+async function prepareErdBuilds(options) {
+	const { client, workspaceId, config } = options;
+	const baseDir = options.outputDir ?? path.resolve(process.cwd(), DEFAULT_ERD_BASE_DIR);
+	let targets;
+	if (options.namespace) {
+		const { namespace, erdSite } = resolveDbConfig(config, options.namespace);
+		const erdDir = path.join(baseDir, namespace);
+		targets = [{
+			namespace,
+			erdSite,
+			schemaOutputPath: path.join(erdDir, "schema.json"),
+			distDir: path.join(erdDir, "dist"),
+			erdDir
+		}];
+	} else {
+		const erdSites = resolveAllErdSites(config);
+		if (erdSites.length === 0) throw new Error("No namespaces with erdSite configured found. Add erdSite: \"<static-website-name>\" to db.<namespace> in tailor.config.ts.");
+		logger.info(`Found ${erdSites.length} namespace(s) with erdSite configured.`);
+		targets = erdSites.map(({ namespace, erdSite }) => {
+			const erdDir = path.join(baseDir, namespace);
+			return {
+				namespace,
+				erdSite,
+				schemaOutputPath: path.join(erdDir, "schema.json"),
+				distDir: path.join(erdDir, "dist"),
+				erdDir
+			};
+		});
+	}
+	await Promise.all(targets.map((target) => prepareErdBuild({
+		namespace: target.namespace,
+		client,
+		workspaceId,
+		outputPath: target.schemaOutputPath,
+		erdDir: target.erdDir
+	})));
+	return targets;
+}
+const erdExportCommand = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export Liam ERD dist from applied TailorDB schema (beta)"
+	},
+	args: {
+		...commonArgs,
+		...deploymentArgs,
+		...jsonArgs,
+		namespace: {
+			type: "string",
+			description: "TailorDB namespace name (optional if only one namespace is defined in config)",
+			alias: "n"
+		},
+		output: {
+			type: "string",
+			description: "Output directory path for tbls-compatible ERD JSON (writes to <outputDir>/<namespace>/schema.json)",
+			alias: "o",
+			default: DEFAULT_ERD_BASE_DIR
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const { client, workspaceId, config } = await initErdContext(args);
+		const outputDir = path.resolve(process.cwd(), String(args.output));
+		const results = await prepareErdBuilds({
+			client,
+			workspaceId,
+			config,
+			namespace: args.namespace,
+			outputDir
+		});
+		if (args.json) logger.out(results.map((result) => ({
+			namespace: result.namespace,
+			distDir: result.distDir,
+			schemaOutputPath: result.schemaOutputPath
+		})));
+		else for (const result of results) {
+			logger.out(`Exported ERD for namespace "${result.namespace}"`);
+			logger.out(`  - Liam ERD dist: ${result.distDir}`);
+			logger.out(`  - tbls schema.json: ${result.schemaOutputPath}`);
+		}
+	})
+});
+
+//#endregion
+//#region src/cli/tailordb/erd/deploy.ts
+const erdDeployCommand = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Deploy ERD static website for TailorDB namespace(s) (beta)"
+	},
+	args: {
+		...commonArgs,
+		...deploymentArgs,
+		...jsonArgs,
+		namespace: {
+			type: "string",
+			description: "TailorDB namespace name (optional - deploys all namespaces with erdSite if omitted)",
+			alias: "n"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const { client, workspaceId, config } = await initErdContext(args);
+		const buildResults = await prepareErdBuilds({
+			client,
+			workspaceId,
+			config,
+			namespace: args.namespace
+		});
+		const deployResults = await Promise.all(buildResults.map(async (result) => {
+			if (!result.erdSite) throw new Error(`No erdSite configured for namespace "${result.namespace}". Add erdSite: "<static-website-name>" to db.${result.namespace} in tailor.config.ts.`);
+			if (!args.json) logger.info(`Deploying ERD for namespace "${result.namespace}" to site "${result.erdSite}"...`);
+			const { url, skippedFiles } = await deployStaticWebsite(client, workspaceId, result.erdSite, result.distDir, !args.json);
+			return {
+				namespace: result.namespace,
+				erdSite: result.erdSite,
+				url,
+				skippedFiles
+			};
+		}));
+		if (args.json) logger.out(deployResults);
+		else for (const result of deployResults) {
+			logger.success(`ERD site "${result.erdSite}" deployed successfully.`);
+			logger.out(result.url);
+			logSkippedFiles(result.skippedFiles);
+		}
+	})
+});
+
+//#endregion
+//#region src/cli/tailordb/erd/serve.ts
+function formatServeCommand(namespace) {
+	return `tailor-sdk tailordb erd serve --namespace ${namespace}`;
+}
+async function runServeDist(results) {
+	if (results.length === 0) throw new Error("No ERD build results found.");
+	const [primary, ...rest] = results;
+	logger.info(`Serving ERD for namespace "${primary.namespace}".`);
+	if (rest.length > 0) {
+		const commands = rest.map((result) => `  - ${formatServeCommand(result.namespace)}`).join("\n");
+		logger.warn(`Multiple namespaces found. To serve another namespace, run:\n${commands}`);
+	}
+	fs$1.mkdirSync(primary.erdDir, { recursive: true });
+	return await new Promise((resolve, reject) => {
+		let serveBinPath;
+		try {
+			serveBinPath = resolveCliBinPath({
+				cwd: primary.erdDir,
+				packageName: "serve",
+				binName: "serve",
+				installHint: "npm i -D serve"
+			});
+		} catch (error) {
+			logger.error(String(error));
+			reject(error);
+			return;
+		}
+		const child = spawn(process.execPath, [serveBinPath, "dist"], {
+			stdio: "inherit",
+			cwd: primary.erdDir
+		});
+		child.on("error", (error) => {
+			logger.error("Failed to run `serve dist`. Ensure `serve` is installed in your project.");
+			reject(error);
+		});
+		child.on("exit", (code) => {
+			if (code === 0) resolve();
+			else {
+				logger.error("serve CLI exited with a non-zero code. Ensure `serve dist` works in your project.");
+				reject(/* @__PURE__ */ new Error(`serve CLI exited with code ${code ?? 1}`));
+			}
+		});
+	});
+}
+const erdServeCommand = defineCommand({
+	meta: {
+		name: "serve",
+		description: "Generate and serve ERD (liam build + `serve dist`) (beta)"
+	},
+	args: {
+		...commonArgs,
+		...deploymentArgs,
+		namespace: {
+			type: "string",
+			description: "TailorDB namespace name (uses first namespace in config if not specified)",
+			alias: "n"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const { client, workspaceId, config } = await initErdContext(args);
+		await runServeDist(await prepareErdBuilds({
+			client,
+			workspaceId,
+			config,
+			namespace: args.namespace
+		}));
+	})
+});
+
+//#endregion
+//#region src/cli/tailordb/erd/index.ts
+const erdCommand = defineCommand({
+	meta: {
+		name: "erd",
+		description: "ERD utilities for TailorDB (beta)"
+	},
+	subCommands: {
+		export: erdExportCommand,
+		serve: erdServeCommand,
+		deploy: erdDeployCommand
+	}
+});
+
 //#endregion
 //#region src/cli/tailordb/truncate.ts
 async function truncateSingleType(options, client) {
@@ -1262,7 +1800,10 @@ const tailordbCommand = defineCommand({
 		name: "tailordb",
 		description: "Manage TailorDB tables and data"
 	},
-	subCommands: { truncate: truncateCommand }
+	subCommands: {
+		erd: erdCommand,
+		truncate: truncateCommand
+	}
 });
 
 //#endregion