@tailor-platform/sdk 0.0.1 → 0.8.1

package/dist/cli/index.mjs

@@ -0,0 +1,996 @@
+#!/usr/bin/env node
+import { PATScope, applyCommand, commonArgs, createCommand, deleteCommand, fetchAll, fetchLatestToken, formatArgs, generateCommand, initOperatorClient, listCommand as listCommand$4, listCommand$1 as listCommand, loadAccessToken, loadConfig, loadConfigPath, loadWorkspaceId, parseFormat, printWithFormat, readPlatformConfig, showCommand, tokenCommand, userAgent, withCommonArgs, writePlatformConfig } from "../token-B9YK0eTP.mjs";
+import "../auth-Di3vQUrT.mjs";
+import { register } from "node:module";
+import { defineCommand, runCommand, runMain } from "citty";
+import { z } from "zod";
+import { readPackageJSON } from "pkg-types";
+import ml from "multiline-ts";
+import { consola } from "consola";
+import { spawnSync } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as http from "node:http";
+import open from "open";
+import chalk from "chalk";
+
+//#region src/cli/init.ts
+const detectPackageManager = () => {
+	const availablePMs = [
+		"npm",
+		"yarn",
+		"pnpm"
+	];
+	const userAgent$1 = process.env.npm_config_user_agent;
+	if (!userAgent$1) return;
+	const [name] = userAgent$1.split("/");
+	if (!availablePMs.includes(name)) return;
+	return name;
+};
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize a new project using create-sdk"
+	},
+	args: {
+		...commonArgs,
+		name: {
+			type: "positional",
+			description: "Project name",
+			required: false
+		},
+		template: {
+			type: "string",
+			description: "Template name",
+			required: false,
+			alias: "t"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const packageJson$1 = await readPackageJSON(import.meta.url);
+		const version = packageJson$1.version && packageJson$1.version !== "0.0.0" ? packageJson$1.version : "latest";
+		let packageManager = detectPackageManager();
+		if (!packageManager) {
+			consola.warn("⚠️ Could not detect package manager, defaulting to npm");
+			packageManager = "npm";
+		}
+		const initArgs = [
+			"create",
+			`@tailor-platform/sdk@${version}`,
+			...args.name ? [args.name] : [],
+			...packageManager === "npm" ? ["--"] : [],
+			...args.template ? ["--template", args.template] : []
+		];
+		consola.log(`Running: ${packageManager} ${initArgs.join(" ")}`);
+		spawnSync(packageManager, initArgs, { stdio: "inherit" });
+	})
+});
+
+//#endregion
+//#region src/cli/login.ts
+const CALLBACK_PORT = 8085;
+const CALLBACK_URL = `http://tailorctl.tailor.tech:${CALLBACK_PORT}/callback`;
+const PLATFORM_AUTH_URL = "https://api.tailor.tech/auth/platform";
+const LOGIN_URL = PLATFORM_AUTH_URL + "/login";
+const TOKEN_URL = PLATFORM_AUTH_URL + "/token";
+const USER_INFO_URL = PLATFORM_AUTH_URL + "/userinfo";
+const randomState = () => {
+	return crypto.randomBytes(32).toString("base64url");
+};
+const exchangeCode = async (code) => {
+	const body = new URLSearchParams();
+	body.append("code", code);
+	body.append("redirect_uri", CALLBACK_URL);
+	const resp = await fetch(TOKEN_URL, {
+		method: "POST",
+		headers: {
+			"User-Agent": await userAgent(),
+			"Content-Type": "application/x-www-form-urlencoded"
+		},
+		body
+	});
+	if (!resp.ok) throw new Error(`Failed to exchange code: ${resp.statusText}`);
+	const rawData = await resp.json();
+	return z.object({
+		access_token: z.string(),
+		refresh_token: z.string(),
+		expires_in: z.number()
+	}).parse(rawData);
+};
+const fetchUserInfo = async (accessToken) => {
+	const resp = await fetch(USER_INFO_URL, { headers: {
+		Authorization: `Bearer ${accessToken}`,
+		"User-Agent": await userAgent()
+	} });
+	if (!resp.ok) throw new Error(`Failed to fetch user info: ${resp.statusText}`);
+	const rawData = await resp.json();
+	return z.object({ email: z.string() }).parse(rawData);
+};
+const startAuthServer = async () => {
+	return new Promise((resolve, reject) => {
+		const state = randomState();
+		const server = http.createServer(async (req, res) => {
+			try {
+				if (!req.url?.startsWith("/callback")) {
+					res.writeHead(404);
+					const msg = "Invalid callback URL";
+					res.end(msg);
+					reject(msg);
+					return;
+				}
+				const url = new URL(req.url, `http://${req.headers.host}`);
+				const receivedState = url.searchParams.get("state");
+				const code = url.searchParams.get("code");
+				if (receivedState !== state) {
+					res.writeHead(400);
+					const msg = "Invalid state parameter";
+					res.end(msg);
+					reject(msg);
+					return;
+				}
+				if (!code) {
+					res.writeHead(400);
+					const msg = "Missing authorization code";
+					res.end(msg);
+					reject(msg);
+					return;
+				}
+				const tokens = await exchangeCode(code);
+				const userInfo = await fetchUserInfo(tokens.access_token);
+				const expiresAt = /* @__PURE__ */ new Date();
+				expiresAt.setSeconds(expiresAt.getSeconds() + tokens.expires_in);
+				const pfConfig = readPlatformConfig();
+				pfConfig.users = {
+					...pfConfig.users,
+					[userInfo.email]: {
+						access_token: tokens.access_token,
+						refresh_token: tokens.refresh_token,
+						token_expires_at: expiresAt.toISOString()
+					}
+				};
+				pfConfig.current_user = userInfo.email;
+				writePlatformConfig(pfConfig);
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					status: "ok",
+					message: "Successfully authenticated. Please close this window."
+				}));
+				resolve();
+			} catch (error) {
+				res.writeHead(500);
+				res.end("Internal server error");
+				reject(error);
+			} finally {
+				server.close();
+			}
+		});
+		const timeout = setTimeout(() => {
+			server.close();
+			reject(/* @__PURE__ */ new Error("Login timeout exceeded"));
+		}, 300 * 1e3);
+		server.on("close", () => {
+			clearTimeout(timeout);
+		});
+		server.on("error", (error) => {
+			reject(error);
+		});
+		server.listen(CALLBACK_PORT, async () => {
+			const loginUrl = new URL(LOGIN_URL);
+			loginUrl.searchParams.set("redirect_uri", CALLBACK_URL);
+			loginUrl.searchParams.set("state", state);
+			consola.info(`Opening browser for login:\n\n${loginUrl.href}\n`);
+			try {
+				await open(loginUrl.href);
+			} catch {
+				consola.warn("Failed to open browser automatically. Please open the URL above manually.");
+			}
+		});
+	});
+};
+const loginCommand = defineCommand({
+	meta: {
+		name: "login",
+		description: "Login to Tailor Platform"
+	},
+	args: commonArgs,
+	run: withCommonArgs(async () => {
+		await startAuthServer();
+		consola.success("Successfully logged in to Tailor Platform.");
+	})
+});
+
+//#endregion
+//#region src/cli/logout.ts
+const LOGOUT_URL = PLATFORM_AUTH_URL + "/logout";
+const logoutCommand = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Logout from Tailor Platform"
+	},
+	args: commonArgs,
+	run: withCommonArgs(async () => {
+		const pfConfig = readPlatformConfig();
+		if (!pfConfig.current_user) {
+			consola.warn("You are not logged in.");
+			return;
+		}
+		const token = pfConfig.users[pfConfig.current_user]?.access_token;
+		if (!token) {
+			consola.warn("You are not logged in.");
+			return;
+		}
+		const resp = await fetch(LOGOUT_URL, { headers: {
+			Authorization: `Bearer ${token}`,
+			"User-Agent": await userAgent()
+		} });
+		if (!resp.ok) throw new Error(`Failed to logout: ${resp.statusText}`);
+		delete pfConfig.users[pfConfig.current_user];
+		pfConfig.current_user = null;
+		writePlatformConfig(pfConfig);
+		consola.success("Successfully logged out from Tailor Platform.");
+	})
+});
+
+//#endregion
+//#region src/cli/machineuser/index.ts
+const machineuserCommand = defineCommand({
+	meta: {
+		name: "machineuser",
+		description: "Manage machine users"
+	},
+	subCommands: {
+		list: listCommand$4,
+		token: tokenCommand
+	},
+	async run() {
+		await runCommand(listCommand$4, { rawArgs: [] });
+	}
+});
+
+//#endregion
+//#region src/cli/profile/create.ts
+const createCommand$2 = defineCommand({
+	meta: {
+		name: "create",
+		description: "Create new profile"
+	},
+	args: {
+		...commonArgs,
+		...formatArgs,
+		name: {
+			type: "positional",
+			description: "Profile name",
+			required: true
+		},
+		user: {
+			type: "string",
+			description: "User email",
+			required: true,
+			alias: "u"
+		},
+		"workspace-id": {
+			type: "string",
+			description: "Workspace ID",
+			required: true,
+			alias: "w"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parseFormat(args.format);
+		const config = readPlatformConfig();
+		if (config.profiles[args.name]) throw new Error(`Profile "${args.name}" already exists.`);
+		const token = await fetchLatestToken(config, args.user);
+		const client = await initOperatorClient(token);
+		if (!(await fetchAll(async (pageToken) => {
+			const { workspaces, nextPageToken } = await client.listWorkspaces({ pageToken });
+			return [workspaces, nextPageToken];
+		})).find((ws) => ws.id === args["workspace-id"])) throw new Error(`Workspace "${args["workspace-id"]}" not found.`);
+		config.profiles[args.name] = {
+			user: args.user,
+			workspace_id: args["workspace-id"]
+		};
+		writePlatformConfig(config);
+		if (format === "table") consola.success(`Profile "${args.name}" created successfully.`);
+		const profileInfo = {
+			name: args.name,
+			user: args.user,
+			workspaceId: args["workspace-id"]
+		};
+		printWithFormat(profileInfo, format);
+	})
+});
+
+//#endregion
+//#region src/cli/profile/delete.ts
+const deleteCommand$2 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete profile"
+	},
+	args: {
+		...commonArgs,
+		name: {
+			type: "positional",
+			description: "Profile name",
+			required: true
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const config = readPlatformConfig();
+		if (!config.profiles[args.name]) throw new Error(`Profile "${args.name}" not found.`);
+		delete config.profiles[args.name];
+		writePlatformConfig(config);
+		consola.success(`Profile "${args.name}" deleted successfully.`);
+	})
+});
+
+//#endregion
+//#region src/cli/profile/list.ts
+const listCommand$3 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all profiles"
+	},
+	args: {
+		...commonArgs,
+		...formatArgs
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parseFormat(args.format);
+		const config = readPlatformConfig();
+		const profiles = Object.entries(config.profiles);
+		if (profiles.length === 0) {
+			consola.info(ml`
+        No profiles found.
+        Please create a profile first using 'tailor-sdk profile create' command.
+      `);
+			return;
+		}
+		const profileInfos = profiles.map(([name, profile]) => ({
+			name,
+			user: profile.user,
+			workspaceId: profile.workspace_id
+		}));
+		printWithFormat(profileInfos, format);
+	})
+});
+
+//#endregion
+//#region src/cli/profile/update.ts
+const updateCommand$1 = defineCommand({
+	meta: {
+		name: "update",
+		description: "Update profile properties"
+	},
+	args: {
+		...commonArgs,
+		...formatArgs,
+		name: {
+			type: "positional",
+			description: "Profile name",
+			required: true
+		},
+		user: {
+			type: "string",
+			description: "New user email",
+			alias: "u"
+		},
+		"workspace-id": {
+			type: "string",
+			description: "New workspace ID",
+			alias: "w"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parseFormat(args.format);
+		const config = readPlatformConfig();
+		if (!config.profiles[args.name]) throw new Error(`Profile "${args.name}" not found.`);
+		if (!args.user && !args["workspace-id"]) throw new Error("Please provide at least one property to update.");
+		const profile = config.profiles[args.name];
+		const oldUser = profile.user;
+		const newUser = args.user || oldUser;
+		const oldWorkspaceId = profile.workspace_id;
+		const newWorkspaceId = args["workspace-id"] || oldWorkspaceId;
+		const token = await fetchLatestToken(config, newUser);
+		const client = await initOperatorClient(token);
+		if (!(await fetchAll(async (pageToken) => {
+			const { workspaces, nextPageToken } = await client.listWorkspaces({ pageToken });
+			return [workspaces, nextPageToken];
+		})).find((ws) => ws.id === newWorkspaceId)) throw new Error(`Workspace "${newWorkspaceId}" not found.`);
+		profile.user = newUser;
+		profile.workspace_id = newWorkspaceId;
+		writePlatformConfig(config);
+		if (format === "table") consola.success(`Profile "${args.name}" updated successfully`);
+		const profileInfo = {
+			name: args.name,
+			user: newUser,
+			workspaceId: newWorkspaceId
+		};
+		printWithFormat(profileInfo, format);
+	})
+});
+
+//#endregion
+//#region src/cli/profile/index.ts
+const profileCommand = defineCommand({
+	meta: {
+		name: "profile",
+		description: "Manage workspace profiles (user + workspace combinations)"
+	},
+	subCommands: {
+		create: createCommand$2,
+		delete: deleteCommand$2,
+		list: listCommand$3,
+		update: updateCommand$1
+	},
+	async run() {
+		await runCommand(listCommand$3, { rawArgs: [] });
+	}
+});
+
+//#endregion
+//#region src/cli/tailordb/truncate.ts
+async function truncateSingleType(options, client) {
+	await client.truncateTailorDBType({
+		workspaceId: options.workspaceId,
+		namespaceName: options.namespaceName,
+		tailordbTypeName: options.typeName
+	});
+	consola.success(`Truncated type "${options.typeName}" in namespace "${options.namespaceName}"`);
+}
+async function truncateNamespace(workspaceId, namespaceName, client) {
+	await client.truncateTailorDBTypes({
+		workspaceId,
+		namespaceName
+	});
+	consola.success(`Truncated all types in namespace "${namespaceName}"`);
+}
+async function getAllNamespaces(workspaceId, configPath) {
+	const { config } = await loadConfig(configPath);
+	const namespaces = /* @__PURE__ */ new Set();
+	if (config.db) for (const [namespaceName] of Object.entries(config.db)) namespaces.add(namespaceName);
+	return Array.from(namespaces);
+}
+async function getTypeNamespace(workspaceId, typeName, client, configPath) {
+	const namespaces = await getAllNamespaces(workspaceId, configPath);
+	for (const namespace of namespaces) try {
+		const { tailordbTypes } = await client.listTailorDBTypes({
+			workspaceId,
+			namespaceName: namespace
+		});
+		if (tailordbTypes.some((type) => type.name === typeName)) return namespace;
+	} catch {
+		continue;
+	}
+	return null;
+}
+async function truncate(options) {
+	const accessToken = await loadAccessToken({
+		useProfile: true,
+		profile: options?.profile
+	});
+	const client = await initOperatorClient(accessToken);
+	const workspaceId = loadWorkspaceId({
+		workspaceId: options?.workspaceId,
+		profile: options?.profile
+	});
+	const hasTypes = options?.types && options.types.length > 0;
+	const hasNamespace = !!options?.namespace;
+	const hasAll = !!options?.all;
+	if ([
+		hasTypes,
+		hasNamespace,
+		hasAll
+	].filter(Boolean).length > 1) throw new Error("Cannot specify multiple options: choose one of --all, --namespace, or type names");
+	if (!hasTypes && !hasNamespace && !hasAll) throw new Error("Please specify one of: --all, --namespace <name>, or type names");
+	const configPath = loadConfigPath(options?.configPath);
+	const namespaces = await getAllNamespaces(workspaceId, configPath);
+	if (hasAll) {
+		if (namespaces.length === 0) {
+			consola.warn("No namespaces found in config file.");
+			return;
+		}
+		if (!options?.yes) {
+			const namespaceList = namespaces.join(", ");
+			if (!await consola.prompt(`This will truncate ALL tables in the following namespaces: ${namespaceList}. Continue? (yes/no)`, {
+				type: "confirm",
+				initial: false
+			})) {
+				consola.info("Truncate cancelled.");
+				return;
+			}
+		}
+		for (const namespace of namespaces) await truncateNamespace(workspaceId, namespace, client);
+		consola.success("Truncated all tables in all namespaces");
+		return;
+	}
+	if (hasNamespace && options?.namespace) {
+		const namespace = options.namespace;
+		if (!namespaces.includes(namespace)) throw new Error(`Namespace "${namespace}" not found in config. Available namespaces: ${namespaces.join(", ")}`);
+		if (!options.yes) {
+			if (!await consola.prompt(`This will truncate ALL tables in namespace "${namespace}". Continue? (yes/no)`, {
+				type: "confirm",
+				initial: false
+			})) {
+				consola.info("Truncate cancelled.");
+				return;
+			}
+		}
+		await truncateNamespace(workspaceId, namespace, client);
+		return;
+	}
+	if (hasTypes && options?.types) {
+		const typeNames = options.types;
+		const typeNamespaceMap = /* @__PURE__ */ new Map();
+		const notFoundTypes = [];
+		for (const typeName of typeNames) {
+			const namespace = await getTypeNamespace(workspaceId, typeName, client, configPath);
+			if (namespace) typeNamespaceMap.set(typeName, namespace);
+			else notFoundTypes.push(typeName);
+		}
+		if (notFoundTypes.length > 0) throw new Error(`The following types were not found in any namespace: ${notFoundTypes.join(", ")}`);
+		if (!options.yes) {
+			const typeList = typeNames.join(", ");
+			if (!await consola.prompt(`This will truncate the following types: ${typeList}. Continue? (yes/no)`, {
+				type: "confirm",
+				initial: false
+			})) {
+				consola.info("Truncate cancelled.");
+				return;
+			}
+		}
+		for (const typeName of typeNames) {
+			const namespace = typeNamespaceMap.get(typeName);
+			if (!namespace) continue;
+			await truncateSingleType({
+				workspaceId,
+				namespaceName: namespace,
+				typeName
+			}, client);
+		}
+	}
+}
+const truncateCommand = defineCommand({
+	meta: {
+		name: "truncate",
+		description: "Truncate TailorDB tables"
+	},
+	args: {
+		...commonArgs,
+		types: {
+			type: "positional",
+			description: "Type names to truncate (space-separated)",
+			required: false
+		},
+		all: {
+			type: "boolean",
+			description: "Truncate all tables in all namespaces",
+			default: false,
+			alias: "a"
+		},
+		namespace: {
+			type: "string",
+			description: "Truncate all tables in specified namespace",
+			alias: "n"
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip confirmation prompt",
+			alias: "y",
+			default: false
+		},
+		"workspace-id": {
+			type: "string",
+			description: "Workspace ID",
+			alias: "w"
+		},
+		profile: {
+			type: "string",
+			description: "Workspace profile",
+			alias: "p"
+		},
+		config: {
+			type: "string",
+			description: "Path to tailor config file",
+			default: "tailor.config.ts",
+			alias: "c"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		await truncate({
+			workspaceId: args["workspace-id"],
+			profile: args.profile,
+			configPath: args.config,
+			all: args.all,
+			namespace: args.namespace,
+			types: args.types ? args.types.split(/\s+/).filter(Boolean) : void 0,
+			yes: args.yes
+		});
+	})
+});
+
+//#endregion
+//#region src/cli/tailordb/index.ts
+const tailordbCommand = defineCommand({
+	meta: {
+		name: "tailordb",
+		description: "Manage TailorDB tables and data"
+	},
+	subCommands: { truncate: truncateCommand }
+});
+
+//#endregion
+//#region src/cli/user/current.ts
+const currentCommand = defineCommand({
+	meta: {
+		name: "current",
+		description: "Show current user"
+	},
+	args: commonArgs,
+	run: withCommonArgs(async () => {
+		const config = readPlatformConfig();
+		if (!config.current_user) {
+			consola.warn(ml`
+        Current user not set.
+        Please login first using 'tailor-sdk login' command to register a user.
+      `);
+			return;
+		}
+		if (!config.users[config.current_user]) throw new Error(ml`
+        Current user '${config.current_user}' not found in registered users.
+        Please login again using 'tailor-sdk login' command to register the user.
+      `);
+		console.log(config.current_user);
+	})
+});
+
+//#endregion
+//#region src/cli/user/list.ts
+const listCommand$1 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all users"
+	},
+	args: {
+		...commonArgs,
+		...formatArgs
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parseFormat(args.format);
+		const config = readPlatformConfig();
+		const users = Object.keys(config.users);
+		if (users.length === 0) {
+			consola.info(ml`
+        No users found.
+        Please login first using 'tailor-sdk login' command to register a user.
+      `);
+			return;
+		}
+		switch (format) {
+			case "table":
+				users.forEach((user) => {
+					if (user === config.current_user) console.log(chalk.green.bold(`${user} (current)`));
+					else console.log(user);
+				});
+				break;
+			case "json":
+				console.log(JSON.stringify(users));
+				break;
+			default: throw new Error(`Format "${format}" is invalid.`);
+		}
+	})
+});
+
+//#endregion
+//#region src/cli/user/pat/transform.ts
+const patFormatSchema = z.enum(["text", "json"]);
+const patFormatArgs = { format: {
+	type: "string",
+	description: `Output format (${patFormatSchema.options.join(", ")})`,
+	alias: "f",
+	default: "text"
+} };
+function parsePATFormat(format) {
+	const parsed = patFormatSchema.safeParse(format);
+	if (!parsed.success) throw new Error(`Format "${format}" is invalid. Must be one of: ${patFormatSchema.options.join(", ")}`);
+	return parsed.data;
+}
+function patScopeToString(scope) {
+	switch (scope) {
+		case PATScope.PAT_SCOPE_READ: return "read";
+		case PATScope.PAT_SCOPE_WRITE: return "write";
+		default: return "unknown";
+	}
+}
+function transformPersonalAccessToken(pat) {
+	return {
+		name: pat.name,
+		scopes: pat.scopes.map(patScopeToString)
+	};
+}
+function getScopesFromWriteFlag(write) {
+	return write ? [PATScope.PAT_SCOPE_READ, PATScope.PAT_SCOPE_WRITE] : [PATScope.PAT_SCOPE_READ];
+}
+function getScopeStringsFromWriteFlag(write) {
+	return write ? ["read", "write"] : ["read"];
+}
+function printCreatedToken(name, token, write, format, action) {
+	const scopes = getScopeStringsFromWriteFlag(write);
+	if (format === "text") console.log(ml`
+      Personal access token ${action} successfully.
+
+        name: ${name}
+      scopes: ${scopes.join("/")}
+       token: ${token}
+
+      Please save this token in a secure location. You won't be able to see it again.
+    `);
+	else console.log(JSON.stringify({
+		name,
+		scopes,
+		token
+	}));
+}
+
+//#endregion
+//#region src/cli/user/pat/create.ts
+const createCommand$1 = defineCommand({
+	meta: {
+		name: "create",
+		description: "Create new personal access token"
+	},
+	args: {
+		...commonArgs,
+		...patFormatArgs,
+		name: {
+			type: "positional",
+			description: "Token name",
+			required: true
+		},
+		write: {
+			type: "boolean",
+			description: "Grant write permission (default: read-only)",
+			default: false,
+			alias: "w"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parsePATFormat(args.format);
+		const config = readPlatformConfig();
+		if (!config.current_user) throw new Error(ml`
+        No user logged in.
+        Please login first using 'tailor-sdk login' command.
+      `);
+		const token = await fetchLatestToken(config, config.current_user);
+		const client = await initOperatorClient(token);
+		const scopes = getScopesFromWriteFlag(args.write);
+		const result = await client.createPersonalAccessToken({
+			name: args.name,
+			scopes
+		});
+		if (!result.accessToken) throw new Error("Failed to create personal access token");
+		printCreatedToken(args.name, result.accessToken, args.write, format, "created");
+	})
+});
+
+//#endregion
+//#region src/cli/user/pat/delete.ts
+const deleteCommand$1 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete personal access token"
+	},
+	args: {
+		...commonArgs,
+		name: {
+			type: "positional",
+			description: "Token name",
+			required: true
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const config = readPlatformConfig();
+		if (!config.current_user) throw new Error(ml`
+        No user logged in.
+        Please login first using 'tailor-sdk login' command.
+      `);
+		const token = await fetchLatestToken(config, config.current_user);
+		await (await initOperatorClient(token)).deletePersonalAccessToken({ name: args.name });
+		consola.success(`Personal access token "${args.name}" deleted successfully.`);
+	})
+});
+
+//#endregion
+//#region src/cli/user/pat/list.ts
+const listCommand$2 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all personal access tokens"
+	},
+	args: {
+		...commonArgs,
+		...patFormatArgs
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parsePATFormat(args.format);
+		const config = readPlatformConfig();
+		if (!config.current_user) throw new Error(ml`
+        No user logged in.
+        Please login first using 'tailor-sdk login' command.
+      `);
+		const token = await fetchLatestToken(config, config.current_user);
+		const client = await initOperatorClient(token);
+		const pats = await fetchAll(async (pageToken) => {
+			const { personalAccessTokens, nextPageToken } = await client.listPersonalAccessTokens({ pageToken });
+			return [personalAccessTokens, nextPageToken];
+		});
+		if (pats.length === 0) {
+			consola.info(ml`
+        No personal access tokens found.
+        Please create a token using 'tailor-sdk user pat create' command.
+      `);
+			return;
+		}
+		if (format === "text") {
+			const maxNameLength = Math.max(...pats.map((pat) => pat.name.length));
+			pats.forEach((pat) => {
+				const info = transformPersonalAccessToken(pat);
+				const paddedName = info.name.padStart(maxNameLength);
+				console.log(`${paddedName}: ${info.scopes.join("/")}`);
+			});
+		} else {
+			const patInfos = pats.map(transformPersonalAccessToken);
+			console.log(JSON.stringify(patInfos));
+		}
+	})
+});
+
+//#endregion
+//#region src/cli/user/pat/update.ts
+const updateCommand = defineCommand({
+	meta: {
+		name: "update",
+		description: "Update personal access token (delete and recreate)"
+	},
+	args: {
+		...commonArgs,
+		...patFormatArgs,
+		name: {
+			type: "positional",
+			description: "Token name",
+			required: true
+		},
+		write: {
+			type: "boolean",
+			description: "Grant write permission (if not specified, keeps read-only)",
+			default: false,
+			alias: "w"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parsePATFormat(args.format);
+		const config = readPlatformConfig();
+		if (!config.current_user) throw new Error(ml`
+        No user logged in.
+        Please login first using 'tailor-sdk login' command.
+      `);
+		const token = await fetchLatestToken(config, config.current_user);
+		const client = await initOperatorClient(token);
+		await client.deletePersonalAccessToken({ name: args.name });
+		const scopes = getScopesFromWriteFlag(args.write);
+		const result = await client.createPersonalAccessToken({
+			name: args.name,
+			scopes
+		});
+		if (!result.accessToken) throw new Error("Failed to create personal access token");
+		printCreatedToken(args.name, result.accessToken, args.write, format, "updated");
+	})
+});
+
+//#endregion
+//#region src/cli/user/pat/index.ts
+const patCommand = defineCommand({
+	meta: {
+		name: "pat",
+		description: "Manage personal access tokens"
+	},
+	subCommands: {
+		create: createCommand$1,
+		delete: deleteCommand$1,
+		list: listCommand$2,
+		update: updateCommand
+	},
+	async run(context) {
+		await runCommand(listCommand$2, { rawArgs: context.rawArgs || [] });
+	}
+});
+
+//#endregion
+//#region src/cli/user/use.ts
+const useCommand = defineCommand({
+	meta: {
+		name: "use",
+		description: "Set current user"
+	},
+	args: {
+		...commonArgs,
+		user: {
+			type: "positional",
+			description: "User email",
+			required: true
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const config = readPlatformConfig();
+		if (!config.users[args.user]) throw new Error(ml`
+        User "${args.user}" not found.
+        Please login first using 'tailor-sdk login' command to register this user.
+      `);
+		config.current_user = args.user;
+		writePlatformConfig(config);
+		consola.success(`Current user set to "${args.user}" successfully.`);
+	})
+});
+
+//#endregion
+//#region src/cli/user/index.ts
+const userCommand = defineCommand({
+	meta: {
+		name: "user",
+		description: "Manage Tailor Platform users"
+	},
+	subCommands: {
+		current: currentCommand,
+		list: listCommand$1,
+		pat: patCommand,
+		use: useCommand
+	},
+	async run() {
+		await runCommand(listCommand$1, { rawArgs: [] });
+	}
+});
+
+//#endregion
+//#region src/cli/workspace/index.ts
+const workspaceCommand = defineCommand({
+	meta: {
+		name: "workspace",
+		description: "Manage Tailor Platform workspaces"
+	},
+	subCommands: {
+		create: createCommand,
+		delete: deleteCommand,
+		list: listCommand
+	},
+	async run() {
+		await runCommand(listCommand, { rawArgs: [] });
+	}
+});
+
+//#endregion
+//#region src/cli/index.ts
+register("tsx", import.meta.url, { data: {} });
+const packageJson = await readPackageJSON(import.meta.url);
+const mainCommand = defineCommand({
+	meta: {
+		name: packageJson.name,
+		version: packageJson.version,
+		description: packageJson.description || "Tailor CLI for managing Tailor Platform SDK applications"
+	},
+	subCommands: {
+		apply: applyCommand,
+		generate: generateCommand,
+		init: initCommand,
+		login: loginCommand,
+		logout: logoutCommand,
+		machineuser: machineuserCommand,
+		profile: profileCommand,
+		show: showCommand,
+		tailordb: tailordbCommand,
+		user: userCommand,
+		workspace: workspaceCommand
+	}
+});
+runMain(mainCommand);
+
+//#endregion
+export {  };