@tailor-platform/sdk 1.37.0 → 1.38.0

package/dist/cli/index.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
-import { I as AuthInvokerSchema, U as PATScope, i as fetchAll, k as FunctionExecution_Type, l as initOAuth2Client, m as userAgent, n as closeConnectionPool, o as fetchPlatformMachineUserToken, s as fetchUserInfo, u as initOperatorClient } from "../client-DllDLYmZ.mjs";
-import { n as logger, r as styles } from "../logger-C8qBDCKO.mjs";
-import { At as functionExecutionStatusToString, B as updateCommand$3, Ct as startCommand, D as resumeCommand, Dt as executionsCommand, E as healthCommand, Ft as executeScript, I as showCommand, J as updateCommand$2, Jt as formatMigrationNumber, K as getCommand$4, L as logBetaWarning, M as truncateCommand, Mt as getCommand$1, P as generateCommand$1, Pt as apply, Q as getCommand$3, Qt as getMigrationFiles, Rt as parseMigrationLabelNumber, Tt as getCommand$5, U as treeCommand, W as listCommand$10, X as listCommand$9, Zt as getMigrationFilePath, _ as getCommand$6, _n as isVerbose, _t as listCommand$6, a as updateCommand$4, bt as jobsCommand, cn as sdkNameLabelKey, d as inviteCommand, en as isValidMigrationNumber, et as deleteCommand$3, fn as apiCommand, ft as generate, gn as deploymentArgs, h as listCommand$14, hn as confirmationArgs, ht as triggerCommand, i as isCLIError, it as listCommand$8, jt as formatKeyValueTable, k as listCommand$11, l as listCommand$13, ln as trnPrefix, lt as tokenCommand, mn as commonArgs, mt as webhookCommand, nt as createCommand$3, on as getNamespacesWithMigrations, ot as getCommand$2, p as restoreCommand, pn as defineAppCommand, r as queryCommand, s as removeCommand, sn as prompt, t as isNativeTypeScriptRuntime, tn as loadDiff, ut as listCommand$7, vn as workspaceArgs, w as listCommand$12, x as createCommand$4, y as deleteCommand$4, z as removeCommand$1 } from "../runtime-D9ejnCm6.mjs";
+import { I as AuthInvokerSchema, U as PATScope, i as fetchAll, k as FunctionExecution_Type, l as initOAuth2Client, m as userAgent, n as closeConnectionPool, o as fetchPlatformMachineUserToken, s as fetchUserInfo, u as initOperatorClient } from "../client-xzPXtc_e.mjs";
+import { n as logger, r as styles } from "../logger-5_JMzHmw.mjs";
+import { $ as deleteCommand$3, $t as isValidMigrationNumber, At as formatKeyValueTable, C as listCommand$12, E as resumeCommand, Et as executionsCommand, F as showCommand, G as getCommand$4, H as treeCommand, I as logBetaWarning, Lt as parseMigrationLabelNumber, N as generateCommand$1, Nt as apply, O as listCommand$11, Pt as executeScript, R as removeCommand$1, St as startCommand, T as healthCommand, U as listCommand$10, Xt as getMigrationFilePath, Y as listCommand$9, Z as getCommand$3, Zt as getMigrationFiles, _n as workspaceArgs, an as getNamespacesWithMigrations, at as getCommand$2, b as createCommand$4, c as listCommand$13, cn as trnPrefix, ct as tokenCommand, dn as apiCommand, dt as generate, en as loadDiff, f as restoreCommand, fn as defineAppCommand, g as getCommand$6, gn as isVerbose, gt as listCommand$6, hn as deploymentArgs, i as updateCommand$4, j as truncateCommand, jt as getCommand$1, kt as functionExecutionStatusToString, lt as listCommand$7, m as listCommand$14, mn as confirmationArgs, mt as triggerCommand, o as removeCommand, on as prompt, pn as commonArgs, pt as webhookCommand, q as updateCommand$2, qt as formatMigrationNumber, r as queryCommand, rt as listCommand$8, sn as sdkNameLabelKey, t as isNativeTypeScriptRuntime, tt as createCommand$3, u as inviteCommand, v as deleteCommand$4, wt as getCommand$5, yt as jobsCommand, z as updateCommand$3 } from "../runtime-ChpwtPut.mjs";
 import { t as readPackageJson } from "../package-json-BHViVisJ.mjs";
-import { C as resolveTokens, S as readPlatformConfig, T as writePlatformConfig, a as loadConfig, b as loadAccessToken, g as getDistDir, i as resolveInlineSourcemap, l as ExecutorSchema, o as WorkflowJobSchema, s as ResolverSchema, v as deleteUserTokens, w as saveUserTokens, x as loadWorkspaceId, y as fetchLatestToken } from "../application-qRGMV8Tr.mjs";
-import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crash-report-CDQ2JvgR.mjs";
+import { C as resolveTokens, S as readPlatformConfig, T as writePlatformConfig, a as loadConfig, b as loadAccessToken, g as getDistDir, i as resolveInlineSourcemap, l as ExecutorSchema, o as WorkflowJobSchema, s as ResolverSchema, v as deleteUserTokens, w as saveUserTokens, x as loadWorkspaceId, y as fetchLatestToken } from "../application-DhQrXEld.mjs";
+import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crash-report-DXhPL8Ue.mjs";
+import { n as isCLIError } from "../errors-D9f2UJpT.mjs";
 import { createRequire } from "node:module";
 import { arg, defineCommand, runCommand, runMain } from "politty";
 import { withCompletionCommand } from "politty/completion";
@@ -404,125 +405,91 @@ const executorCommand = defineCommand({
 });
 
 //#endregion
-//#region src/cli/commands/function/logs.ts
-/**
-* Convert function execution type enum to string.
-* @param type - Function execution type enum value
-* @returns Type string representation
-*/
-function functionExecutionTypeToString(type) {
-	switch (type) {
-		case FunctionExecution_Type.STANDARD: return "STANDARD";
-		case FunctionExecution_Type.JOB: return "JOB";
-		default: return "UNSPECIFIED";
-	}
-}
+//#region src/cli/shared/function-script-download.ts
 /**
-* Transform FunctionExecution to FunctionExecutionListInfo for list display.
-* @param execution - FunctionExecution from proto
-* @returns Function execution list info
+* Download a deployed function script from the function registry.
+*
+* Wraps the server-streaming `downloadFunctionRegistryScript` RPC and
+* concatenates content chunks into a single UTF-8 string.
 */
-function toFunctionExecutionListInfo(execution) {
-	return {
-		id: execution.id,
-		scriptName: execution.scriptName,
-		status: functionExecutionStatusToString(execution.status),
-		type: functionExecutionTypeToString(execution.type),
-		startedAt: execution.startedAt ? timestampDate(execution.startedAt) : null,
-		finishedAt: execution.finishedAt ? timestampDate(execution.finishedAt) : null
-	};
-}
 /**
-* Transform FunctionExecution to FunctionExecutionDetailInfo for detail display.
-* @param execution - FunctionExecution from proto
-* @returns Function execution detail info
-*/
-function toFunctionExecutionDetailInfo(execution) {
-	return {
-		id: execution.id,
-		scriptName: execution.scriptName,
-		status: functionExecutionStatusToString(execution.status),
-		type: functionExecutionTypeToString(execution.type),
-		startedAt: execution.startedAt ? timestampDate(execution.startedAt) : null,
-		finishedAt: execution.finishedAt ? timestampDate(execution.finishedAt) : null,
-		logs: execution.logs,
-		result: execution.result
-	};
+* Translate a `FunctionExecution.scriptName` into the corresponding
+* function registry name used by `downloadFunctionRegistryScript`.
+*
+* The platform records executions under a script-name format that
+* differs from the registry name. The execution `type` is used as the
+* primary discriminator because workflow job names are unconstrained
+* strings (`WorkflowJobSchema.name: z.string()`) and may contain dots
+* that collide with the resolver / executor / hook filename suffixes.
+*
+*   JOB:                        `<jobName>`                       -> `workflow--<jobName>`
+*   STANDARD resolver:          `<namespace>.<name>.body.js`      -> `resolver--<namespace>--<name>`
+*   STANDARD executor:          `<name>.operation.js`             -> `executor--<name>`
+*   STANDARD auth hook:         `<authName>.<hookPoint>.hook.js`  -> `auth-hook--<authName>--<hookPoint>`
+*
+* For older servers that leave `type` as `UNSPECIFIED`, the same
+* filename-suffix heuristic is applied, with a bare-name fallback to
+* `workflow--<name>` for backward compatibility. Returns `null` for
+* unrecognized formats (ad-hoc test-run scripts, seed scripts, etc.
+* that are not stored in the registry).
+* @param scriptName - The `scriptName` field from a `FunctionExecution`
+* @param executionType - The `type` field from a `FunctionExecution`
+* @returns The function registry name, or null when no mapping applies
+*/
+function scriptNameToRegistryName(scriptName, executionType) {
+	if (executionType === FunctionExecution_Type.JOB) return `workflow--${scriptName}`;
+	const resolverMatch = /^([^.]+)\.(.+)\.body\.js$/.exec(scriptName);
+	if (resolverMatch) {
+		const [, namespace, name] = resolverMatch;
+		return `resolver--${namespace}--${name}`;
+	}
+	const executorMatch = /^(.+)\.operation\.js$/.exec(scriptName);
+	if (executorMatch) {
+		const [, name] = executorMatch;
+		return `executor--${name}`;
+	}
+	const authHookMatch = /^([^.]+)\.([^.]+)\.hook\.js$/.exec(scriptName);
+	if (authHookMatch) {
+		const [, authName, hookPoint] = authHookMatch;
+		return `auth-hook--${authName}--${hookPoint}`;
+	}
+	if (executionType === FunctionExecution_Type.UNSPECIFIED && !scriptName.includes(".")) return `workflow--${scriptName}`;
+	return null;
 }
 /**
-* Print function execution detail in a human-readable format.
-* @param detail - Function execution detail info
-*/
-function printFunctionExecutionDetail(detail) {
-	const formatDate = (date) => date ? date.toISOString() : "N/A";
-	const summaryData = [
-		["id", detail.id],
-		["scriptName", detail.scriptName],
-		["status", detail.status],
-		["type", detail.type],
-		["startedAt", formatDate(detail.startedAt)],
-		["finishedAt", formatDate(detail.finishedAt)]
-	];
-	logger.out(formatKeyValueTable(summaryData));
-	if (detail.logs) {
-		logger.log(styles.bold("\nLogs:"));
-		for (const line of detail.logs.split("\n")) logger.log(`  ${line}`);
-	}
-	if (detail.result) {
-		logger.log(styles.bold("\nResult:"));
-		try {
-			const parsed = JSON.parse(detail.result);
-			logger.log(`  ${JSON.stringify(parsed, null, 2).split("\n").join("\n  ")}`);
-		} catch {
-			logger.log(`  ${detail.result}`);
-		}
+* Download a deployed function script.
+*
+* Returns the bundled script content together with the registry
+* entry's `updatedAt` timestamp. Returns null when the download fails
+* (script removed, network error, etc.) or when no content chunks are
+* received; errors are swallowed so callers can fall back to a
+* non-sourcemap display.
+* @param options - Download options
+* @returns Script content plus metadata, or null on failure / empty response
+*/
+async function downloadFunctionScript(options) {
+	const { client, workspaceId, name, contentHash } = options;
+	try {
+		const chunks = [];
+		let registryUpdatedAt = null;
+		for await (const response of client.downloadFunctionRegistryScript({
+			workspaceId,
+			name,
+			contentHash
+		})) if (response.payload.case === "metadata") {
+			const updatedAt = response.payload.value.function?.updatedAt;
+			if (updatedAt) registryUpdatedAt = timestampDate(updatedAt);
+		} else if (response.payload.case === "chunk") chunks.push(response.payload.value);
+		if (chunks.length === 0) return null;
+		return {
+			code: Buffer.concat(chunks).toString("utf-8"),
+			registryUpdatedAt
+		};
+	} catch (error) {
+		logger.debug(`Failed to download function script "${options.name}": ${error}`);
+		return null;
 	}
 }
-const logsCommand = defineAppCommand({
-	name: "logs",
-	description: "List or get function execution logs.",
-	args: z.object({
-		...workspaceArgs,
-		executionId: arg(z.string().optional(), {
-			positional: true,
-			description: "Execution ID (if provided, shows details with logs)"
-		})
-	}).strict(),
-	run: async (args) => {
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
-		const workspaceId = await loadWorkspaceId({
-			workspaceId: args["workspace-id"],
-			profile: args.profile
-		});
-		if (args.executionId) {
-			const { execution } = await client.getFunctionExecution({
-				workspaceId,
-				executionId: args.executionId
-			});
-			if (!execution) throw new Error(`Function execution '${args.executionId}' not found.`);
-			const detail = toFunctionExecutionDetailInfo(execution);
-			if (args.json) logger.out(detail);
-			else printFunctionExecutionDetail(detail);
-		} else {
-			const logs = (await fetchAll(async (pageToken, maxPageSize) => {
-				const { executions, nextPageToken } = await client.listFunctionExecutions({
-					workspaceId,
-					pageToken,
-					pageSize: maxPageSize
-				});
-				return [executions, nextPageToken];
-			})).map(toFunctionExecutionListInfo);
-			if (logs.length === 0 && !args.json) {
-				logger.info("No function execution logs found.");
-				return;
-			}
-			logger.out(logs);
-		}
-	}
-});
 
 //#endregion
 //#region src/cli/shared/stack-trace.ts
@@ -709,7 +676,7 @@ function formatMappedError(errorMessage, frames, traceMap, bundleDir) {
 		const { source, line, column, name } = frame.mapped;
 		const absolutePath = bundleDir ? path.resolve(bundleDir, source) : path.resolve(source);
 		const rel = path.relative(process.cwd(), absolutePath);
-		const displaySource = rel.startsWith(".") ? rel : `./${rel}`;
+		const displaySource = rel.startsWith("..") ? rel : `./${rel}`;
 		const fnName = name ?? frame.original.functionName;
 		const link = buildSourceLink(displaySource, absolutePath, line, column);
 		parts.push(`\n  at ${fnName} (${link})`);
@@ -756,6 +723,248 @@ function formatErrorWithSourcemap(error, bundledCode, bundleDir) {
 	}
 }
 
+//#endregion
+//#region src/cli/commands/function/logs.ts
+/**
+* Convert function execution type enum to string.
+* @param type - Function execution type enum value
+* @returns Type string representation
+*/
+function functionExecutionTypeToString(type) {
+	switch (type) {
+		case FunctionExecution_Type.STANDARD: return "STANDARD";
+		case FunctionExecution_Type.JOB: return "JOB";
+		default: return "UNSPECIFIED";
+	}
+}
+/**
+* Transform FunctionExecution to FunctionExecutionListInfo for list display.
+* @param execution - FunctionExecution from proto
+* @returns Function execution list info
+*/
+function toFunctionExecutionListInfo(execution) {
+	return {
+		id: execution.id,
+		scriptName: execution.scriptName,
+		status: functionExecutionStatusToString(execution.status),
+		type: functionExecutionTypeToString(execution.type),
+		startedAt: execution.startedAt ? timestampDate(execution.startedAt) : null,
+		finishedAt: execution.finishedAt ? timestampDate(execution.finishedAt) : null
+	};
+}
+/**
+* Transform FunctionExecution to FunctionExecutionDetailInfo for detail display.
+* @param execution - FunctionExecution from proto
+* @returns Function execution detail info
+*/
+function toFunctionExecutionDetailInfo(execution) {
+	return {
+		...toFunctionExecutionListInfo(execution),
+		logs: execution.logs,
+		result: execution.result,
+		error: execution.error ? {
+			name: execution.error.name,
+			message: execution.error.message,
+			stackTrace: execution.error.stackTrace
+		} : null
+	};
+}
+/**
+* Compose a V8-style error string from a FunctionErrorInfo so that it
+* can be parsed by `parseStackTrace`.
+*
+* `Error.prototype.stack` in V8 begins with `Name: message`, but the
+* platform may store only the frame lines; in that case prepend the
+* message line. When `stackTrace` is empty, return only `Name: message`.
+* @param error - Function error info from FunctionExecution
+* @returns Error string suitable for parseStackTrace
+*/
+function composeExecutionErrorString(error) {
+	const { name, message, stackTrace } = error;
+	if (!stackTrace) return `${name}: ${message}`;
+	const firstLine = stackTrace.split("\n", 1)[0] ?? "";
+	if (/^\s+at\s+/.test(firstLine)) return `${name}: ${message}\n${stackTrace}`;
+	return stackTrace;
+}
+/**
+* Plain-text fallback used when sourcemap mapping is unavailable.
+* Shows `Name: message` then the raw stack trace lines (dimmed).
+*
+* Uses `composeExecutionErrorString` to produce a canonical
+* `Name: message\n<frames>` string first, so the header is never
+* duplicated when `stackTrace` already begins with `Name: message`.
+* @param error - Function error info from FunctionExecution
+* @returns Formatted fallback string for display
+*/
+function formatExecutionErrorFallback(error) {
+	const [headerLine, ...frameLines] = composeExecutionErrorString(error).split("\n");
+	return [`  ${styles.error(headerLine ?? "")}`, ...frameLines.map((line) => `  ${styles.dim(line)}`)].join("\n");
+}
+/**
+* Format an execution error for display, applying sourcemap mapping
+* when bundled code is available.
+* @param error - Function error info from FunctionExecution
+* @param bundledCode - Downloaded bundled script content (may be null)
+* @returns Formatted error string for display
+*/
+function formatExecutionError(error, bundledCode) {
+	if (bundledCode && error.stackTrace) {
+		const formatted = formatErrorWithSourcemap(composeExecutionErrorString(error), bundledCode, process.cwd());
+		if (formatted) return formatted;
+	}
+	return formatExecutionErrorFallback(error);
+}
+/**
+* Print function execution detail in a human-readable format.
+* @param options - Print options
+* @param options.detail - Function execution detail info
+* @param options.bundledCode - Downloaded bundled script content (used for sourcemap mapping)
+*/
+function printFunctionExecutionDetail(options) {
+	const { detail, bundledCode } = options;
+	const formatDate = (date) => date ? date.toISOString() : "N/A";
+	const summaryData = [
+		["id", detail.id],
+		["scriptName", detail.scriptName],
+		["status", detail.status],
+		["type", detail.type],
+		["startedAt", formatDate(detail.startedAt)],
+		["finishedAt", formatDate(detail.finishedAt)]
+	];
+	logger.out(formatKeyValueTable(summaryData));
+	if (detail.logs) {
+		logger.log(styles.bold("\nLogs:"));
+		for (const line of detail.logs.split("\n")) logger.log(`  ${line}`);
+	}
+	if (detail.result) {
+		logger.log(styles.bold("\nResult:"));
+		try {
+			const parsed = JSON.parse(detail.result);
+			logger.log(`  ${JSON.stringify(parsed, null, 2).split("\n").join("\n  ")}`);
+		} catch {
+			logger.log(`  ${detail.result}`);
+		}
+	}
+	if (detail.error) {
+		logger.log(styles.bold("\nError:"));
+		logger.log(formatExecutionError(detail.error, bundledCode ?? null));
+	}
+}
+/**
+* Download a deployed function script for sourcemap mapping. Logs a
+* debug message on failure but never throws. Error display falls back
+* to a plain-text format when the script cannot be retrieved or when
+* the current registry entry is stale relative to the execution.
+*
+* `FunctionExecution.scriptName` does not match the function registry
+* name directly; `scriptNameToRegistryName` translates between the two
+* formats.
+* @param options - Lookup options
+* @param options.client - Operator client instance
+* @param options.workspaceId - Workspace ID
+* @param options.scriptName - Script name (matches FunctionExecution.scriptName)
+* @param options.executionType - Execution type used to discriminate registry name translation
+* @param options.executionStartedAt - Execution start timestamp used for staleness check
+* @returns Bundled script content, or null when unavailable / stale
+*/
+async function downloadScriptForMapping(options) {
+	const { client, workspaceId, scriptName, executionType, executionStartedAt } = options;
+	const registryName = scriptNameToRegistryName(scriptName, executionType);
+	if (registryName == null) {
+		logger.debug(`Script "${scriptName}" is not a deployed registry script (e.g. test-run or seed); skipping sourcemap mapping.`);
+		return null;
+	}
+	const result = await downloadFunctionScript({
+		client,
+		workspaceId,
+		name: registryName
+	});
+	if (result == null) {
+		logger.debug(`Could not download script "${scriptName}" (registry: "${registryName}") for stack trace mapping; showing raw stack trace.`);
+		return null;
+	}
+	if (executionStartedAt != null && result.registryUpdatedAt != null && result.registryUpdatedAt.getTime() > executionStartedAt.getTime()) {
+		logger.debug(`Registry script "${registryName}" was updated at ${result.registryUpdatedAt.toISOString()} after execution started at ${executionStartedAt.toISOString()}; skipping sourcemap mapping to avoid stale source locations.`);
+		return null;
+	}
+	return result.code;
+}
+const logsCommand = defineAppCommand({
+	name: "logs",
+	description: "List or get function execution logs.",
+	notes: `When viewing a specific execution that failed, the command displays error details with the stack trace mapped back to original source files via the inline sourcemap (clickable file links and code snippets, matching \`function test-run\` output).
+
+When the deployed script cannot be downloaded or the function has been redeployed since the execution, the command falls back to a plain-text error display to avoid showing misleading source locations.`,
+	examples: [
+		{
+			cmd: "",
+			desc: "List all function execution logs"
+		},
+		{
+			cmd: "<execution-id>",
+			desc: "Get execution details with logs"
+		},
+		{
+			cmd: "--json",
+			desc: "Output as JSON"
+		},
+		{
+			cmd: "<execution-id> --json",
+			desc: "Get execution details as JSON"
+		}
+	],
+	args: z.object({
+		...workspaceArgs,
+		executionId: arg(z.string().optional(), {
+			positional: true,
+			description: "Execution ID (if provided, shows details with logs)"
+		})
+	}).strict(),
+	run: async (args) => {
+		const client = await initOperatorClient(await loadAccessToken({
+			useProfile: true,
+			profile: args.profile
+		}));
+		const workspaceId = await loadWorkspaceId({
+			workspaceId: args["workspace-id"],
+			profile: args.profile
+		});
+		if (args.executionId) {
+			const { execution } = await client.getFunctionExecution({
+				workspaceId,
+				executionId: args.executionId
+			});
+			if (!execution) throw new Error(`Function execution '${args.executionId}' not found.`);
+			const detail = toFunctionExecutionDetailInfo(execution);
+			if (args.json) logger.out(detail);
+			else printFunctionExecutionDetail({
+				detail,
+				bundledCode: detail.error ? await downloadScriptForMapping({
+					client,
+					workspaceId,
+					scriptName: detail.scriptName,
+					executionType: execution.type,
+					executionStartedAt: detail.startedAt
+				}) : null
+			});
+		} else {
+			const logs = (await fetchAll(async (pageToken, maxPageSize) => {
+				const { executions, nextPageToken } = await client.listFunctionExecutions({
+					workspaceId,
+					pageToken,
+					pageSize: maxPageSize
+				});
+				return [executions, nextPageToken];
+			})).map(toFunctionExecutionListInfo);
+			if (logs.length === 0 && !args.json) {
+				logger.info("No function execution logs found.");
+				return;
+			}
+			logger.out(logs);
+		}
+	}
+});
+
 //#endregion
 //#region src/cli/commands/function/bundle.ts
 /**
@@ -794,7 +1003,8 @@ async function bundleForTestRun(options) {
 				format: "esm",
 				sourcemap: inlineSourcemap ? "inline" : true,
 				minify: inlineSourcemap ? { mangle: { keepNames: true } } : true,
-				codeSplitting: false
+				codeSplitting: false,
+				dir: process.cwd()
 			},
 			tsconfig,
 			treeshake: {
@@ -1052,7 +1262,8 @@ const testRunCommand = defineAppCommand({
 		}),
 		"machine-user": arg(z.string().optional(), {
 			alias: "m",
-			description: "Machine user name for authentication"
+			description: "Machine user name for authentication",
+			env: "TAILOR_PLATFORM_MACHINE_USER_NAME"
 		}),
 		config: arg(z.string().default("tailor.config.ts"), {
 			alias: "c",
@@ -1446,7 +1657,8 @@ const loginCommand = defineAppCommand({
 	name: "login",
 	description: "Login to Tailor Platform.",
 	args: z.xor([z.object({}).strict().describe("User Login"), z.object({
-		machineuser: arg(z.literal(true), {
+		"machine-user": arg(z.literal(true), {
+			hiddenAlias: "machineuser",
 			description: "Login as a platform machine user.",
 			required: true
 		}),
@@ -1461,7 +1673,7 @@ const loginCommand = defineAppCommand({
 		})
 	}).strict().describe("Machine User Login")]),
 	run: async (args) => {
-		if ("machineuser" in args && args.machineuser) await loginAsMachineUser({
+		if ("machine-user" in args && args["machine-user"]) await loginAsMachineUser({
 			clientId: args.clientId,
 			clientSecret: args.clientSecret
 		});
@@ -3371,6 +3583,34 @@ const tailordbCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/upgrade/index.ts
+const upgradeCommand = defineAppCommand({
+	name: "upgrade",
+	description: "Run codemods to upgrade your project to a newer SDK version.",
+	args: z.object({
+		from: arg(z.string(), { description: "SDK version before the upgrade (e.g., 1.33.0)" }),
+		"dry-run": arg(z.boolean().default(false), {
+			alias: "d",
+			description: "Preview changes without modifying files"
+		}),
+		path: arg(z.string().default("."), {
+			description: "Project directory to upgrade",
+			completion: { type: "directory" }
+		})
+	}).strict(),
+	run: async (args) => {
+		const { initTelemetry } = await import("../telemetry-4IOPW6wE.mjs");
+		await initTelemetry();
+		const { upgrade } = await import("../service-Bcp6JB3w.mjs");
+		await upgrade({
+			from: args.from,
+			dryRun: args["dry-run"],
+			path: path.resolve(args.path)
+		});
+	}
+});
+
 //#endregion
 //#region src/cli/commands/user/current.ts
 const currentCommand = defineAppCommand({
@@ -3755,6 +3995,7 @@ const mainCommand = withCompletionCommand(defineCommand({
 		show: showCommand,
 		staticwebsite: staticwebsiteCommand,
 		tailordb: tailordbCommand,
+		upgrade: upgradeCommand,
 		user: userCommand$1,
 		workflow: workflowCommand,
 		workspace: workspaceCommand
@@ -3774,7 +4015,7 @@ runMain(mainCommand, {
 				if (isVerbose() && error.stack) logger.debug(`\nStack trace:\n${error.stack}`);
 			} else logger.error(`Unknown error: ${error}`);
 			if (!isCLIError(error) && (!(error instanceof Error) || error instanceof TypeError || error instanceof RangeError)) {
-				const { reportCrash } = await import("../crash-report-aHnky_xH.mjs");
+				const { reportCrash } = await import("../crash-report-BEAiCSCl.mjs");
 				await reportCrash(error, "handledError");
 			}
 		}