@tailor-platform/sdk 1.35.1 → 1.36.0

package/dist/cli/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
-import { D as FunctionExecution_Type, P as AuthInvokerSchema, V as PATScope, i as fetchAll, l as initOAuth2Client, m as userAgent, n as closeConnectionPool, o as fetchPlatformMachineUserToken, s as fetchUserInfo, u as initOperatorClient } from "../client-CA2NM_4R.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-CN15WgW2.mjs";
 import { n as logger, r as styles } from "../logger-qz-Y4sBV.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-D4O-RfcH.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-C7RRDaB3.mjs";
 import { t as readPackageJson } from "../package-json-CfUqjJaQ.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-BnJRroGX.mjs";
-import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crash-report-CPkI2-cp.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-BwboBFcU.mjs";
+import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crash-report-CdxPj_SW.mjs";
 import { createRequire } from "node:module";
 import { arg, defineCommand, runCommand, runMain } from "politty";
 import { withCompletionCommand } from "politty/completion";
@@ -23,6 +23,7 @@ import ml from "multiline-ts";
 import * as rolldown from "rolldown";
 import { create } from "@bufbuild/protobuf";
 import open from "open";
+import { TraceMap, generatedPositionFor, originalPositionFor } from "@jridgewell/trace-mapping";
 import { spawn, spawnSync } from "node:child_process";
 import * as fs from "fs";
 import { lookup } from "mime-types";
@@ -523,6 +524,238 @@ const logsCommand = defineAppCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/shared/stack-trace.ts
+/**
+* Stack trace parsing, sourcemap-based source identification, and
+* formatted error display for the test-run command.
+*
+* The platform runtime automatically applies inline sourcemaps to V8
+* stack traces, so frame positions are already original source positions.
+* This module identifies which source file each frame belongs to via
+* reverse lookup (generatedPositionFor), then produces human-readable
+* output with file paths and code snippets.
+*/
+const STACK_FRAME_REGEX = /^\s+at\s+(?:(.+?)\s+\()?(file:\/\/\/.+?):(\d+):(\d+)\)?$/;
+const RPC_ERROR_PREFIX = "rpc error: code = Aborted desc = ";
+/**
+* Parse a V8 stack trace string into structured frames.
+* Only frames with `file:///` URLs are included (eval frames are skipped).
+* @param error - Raw error string potentially containing a V8 stack trace
+* @returns Parsed error message and stack frames
+*/
+function parseStackTrace(error) {
+	const lines = error.split("\n");
+	const messageLines = [];
+	const frameLines = [];
+	for (const line of lines) if (/^\s+at\s+/.test(line)) frameLines.push(line);
+	else if (frameLines.length === 0) messageLines.push(line);
+	let errorMessage = messageLines.join("\n");
+	if (errorMessage.startsWith(RPC_ERROR_PREFIX)) errorMessage = errorMessage.slice(33);
+	const frames = [];
+	for (const line of frameLines) {
+		const match = STACK_FRAME_REGEX.exec(line);
+		if (match) frames.push({
+			functionName: match[1] || "<anonymous>",
+			file: match[2],
+			line: Number(match[3]),
+			column: Number(match[4])
+		});
+	}
+	return {
+		errorMessage,
+		frames
+	};
+}
+const INLINE_SOURCEMAP_REGEX = /\/\/[#@]\s*sourceMappingURL=data:application\/json[^,]*;base64,(.+)$/m;
+/**
+* Extract an inline sourcemap from bundled code and return a TraceMap.
+* @param bundledCode - Bundled JavaScript code potentially containing an inline sourcemap
+* @returns TraceMap instance, or null if no valid inline sourcemap is found
+*/
+function extractInlineSourcemap(bundledCode) {
+	const match = INLINE_SOURCEMAP_REGEX.exec(bundledCode);
+	if (!match) return null;
+	try {
+		const decoded = Buffer.from(match[1], "base64").toString("utf-8");
+		return new TraceMap(JSON.parse(decoded));
+	} catch {
+		return null;
+	}
+}
+/**
+* Map parsed stack frames to their source files using a TraceMap.
+*
+* The platform runtime applies inline sourcemaps automatically, so V8
+* reports already-mapped original source positions in stack traces.
+* This function uses generatedPositionFor to reverse-lookup which source
+* file each frame's line:column belongs to.
+* @param frames - Parsed stack frames (positions are already original source positions)
+* @param traceMap - TraceMap from inline sourcemap, or null
+* @returns Frames with identified source files
+*/
+function mapStackFrames(frames, traceMap) {
+	return frames.map((frame) => {
+		if (!traceMap) return {
+			original: frame,
+			mapped: null
+		};
+		try {
+			for (let i = traceMap.sources.length - 1; i >= 0; i--) {
+				const source = traceMap.sources[i];
+				if (source == null) continue;
+				const genPos = generatedPositionFor(traceMap, {
+					source,
+					line: frame.line,
+					column: frame.column - 1
+				});
+				if (genPos.line == null) continue;
+				const origPos = originalPositionFor(traceMap, {
+					line: genPos.line,
+					column: genPos.column
+				});
+				if (origPos.source !== source || origPos.line !== frame.line || origPos.column !== frame.column - 1) continue;
+				return {
+					original: frame,
+					mapped: {
+						source,
+						line: frame.line,
+						column: frame.column,
+						name: null
+					}
+				};
+			}
+			return {
+				original: frame,
+				mapped: null
+			};
+		} catch {
+			return {
+				original: frame,
+				mapped: null
+			};
+		}
+	});
+}
+/**
+* Detect the URI scheme for opening files based on VISUAL/EDITOR env vars.
+* @returns "vscode" if the editor looks like VS Code, otherwise null (use file://)
+*/
+function detectEditorScheme() {
+	const editor = process.env.VISUAL || process.env.EDITOR || "";
+	if (/\bcode\b/.test(editor)) return "vscode";
+	return null;
+}
+/**
+* Wrap text in an OSC 8 terminal hyperlink.
+* @param uri - URI to open when the link is clicked
+* @param text - Visible text displayed in the terminal
+* @returns Escaped string with OSC 8 sequences
+*/
+function osc8Link(uri, text) {
+	return `\x1b]8;;${uri}\x07${text}\x1b]8;;\x07`;
+}
+/**
+* Build a clickable terminal link for a source location.
+* Uses vscode:// URI if the editor is VS Code, otherwise file:// URI.
+* @param displayPath - Path to display in the terminal
+* @param absolutePath - Absolute file path for the URI
+* @param line - 1-based line number
+* @param column - 1-based column number
+* @returns OSC 8 hyperlinked location string
+*/
+function buildSourceLink(displayPath, absolutePath, line, column) {
+	const location = `${displayPath}:${line}:${column}`;
+	if (detectEditorScheme() === "vscode") return osc8Link(`vscode://file${absolutePath}:${line}:${column}`, location);
+	return osc8Link(`file://${absolutePath}`, location);
+}
+const SNIPPET_CONTEXT_LINES = 2;
+/**
+* Build a code snippet around a target line from source content.
+* Shows SNIPPET_CONTEXT_LINES above and below with line numbers.
+* The target line is marked with `>` and highlighted.
+* @param content - Full source file content
+* @param targetLine - 1-based line number to highlight
+* @returns Formatted snippet string
+*/
+function buildCodeSnippet(content, targetLine) {
+	const lines = content.split("\n");
+	const start = Math.max(0, targetLine - 1 - SNIPPET_CONTEXT_LINES);
+	const end = Math.min(lines.length, targetLine + SNIPPET_CONTEXT_LINES);
+	const gutterWidth = String(end).length;
+	const snippetLines = [];
+	for (let i = start; i < end; i++) {
+		const lineNum = i + 1;
+		const gutter = String(lineNum).padStart(gutterWidth);
+		const lineContent = lines[i];
+		if (lineNum === targetLine) snippetLines.push(`  ${styles.error(">")} ${styles.error(`${gutter} | ${lineContent}`)}`);
+		else snippetLines.push(`    ${styles.dim(`${gutter} | ${lineContent}`)}`);
+	}
+	return snippetLines.join("\n");
+}
+/**
+* Format mapped stack frames into a human-readable error display.
+* Includes file paths (clickable in terminals), code snippets, and
+* falls back to raw frame info for unmapped frames.
+* @param errorMessage - Cleaned error message
+* @param frames - Mapped stack frames
+* @param traceMap - TraceMap for retrieving source content (may be null)
+* @param bundleDir - Absolute path to bundle output directory for resolving source paths
+* @returns Formatted error string for display
+*/
+function formatMappedError(errorMessage, frames, traceMap, bundleDir) {
+	const parts = [`  ${styles.error(errorMessage)}`];
+	for (const frame of frames) if (frame.mapped) {
+		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 fnName = name ?? frame.original.functionName;
+		const link = buildSourceLink(displaySource, absolutePath, line, column);
+		parts.push(`\n  at ${fnName} (${link})`);
+		if (traceMap) {
+			const sourceIndex = traceMap.sources.indexOf(source);
+			if (sourceIndex !== -1) {
+				const content = traceMap.sourcesContent?.[sourceIndex];
+				if (content) parts.push(buildCodeSnippet(content, line));
+			}
+		}
+	} else {
+		const location = `${frame.original.file.replace(/^file:\/\/\//, "")}:${frame.original.line}:${frame.original.column}`;
+		parts.push(`\n  ${styles.dim(`at ${frame.original.functionName} (${location})`)}`);
+	}
+	return parts.join("\n");
+}
+/**
+* Format an error string with sourcemap-based source locations.
+* This is the main entry point for test-run error display.
+*
+* The platform runtime applies inline sourcemaps automatically, so V8
+* stack frames already contain original source positions. This function
+* identifies which source file each frame belongs to and formats the
+* error with file paths, line numbers, and code snippets.
+*
+* Returns null if sourcemap processing is not possible (no inline
+* sourcemap, no stack trace, or processing error).
+* @param error - Raw error string from script execution (may contain V8 stack trace)
+* @param bundledCode - Bundled JavaScript code (may contain inline sourcemap)
+* @param bundleDir - Absolute path to the bundle output directory (sourcemap paths are relative to this)
+* @returns Formatted error string, or null to fall back to default display
+*/
+function formatErrorWithSourcemap(error, bundledCode, bundleDir) {
+	try {
+		const { errorMessage, frames } = parseStackTrace(error);
+		if (frames.length === 0) return null;
+		const traceMap = extractInlineSourcemap(bundledCode);
+		if (!traceMap) return null;
+		const mappedFrames = mapStackFrames(frames, traceMap);
+		if (mappedFrames.some((f) => f.mapped !== null)) return formatMappedError(errorMessage, mappedFrames, traceMap, bundleDir);
+		return null;
+	} catch {
+		return null;
+	}
+}
+
 //#endregion
 //#region src/cli/commands/function/bundle.ts
 /**
@@ -604,13 +837,11 @@ function generateEntry(detected, sourceFile, env, machineUser, workspaceId) {
         const _user = ${userExpr};
 
         const $tailor_resolver_body = async (context) => {
-          const enrichedContext = { ...context, env: _env, user: _user };
-
           if (_internalResolver.input) {
             const result = t.object(_internalResolver.input).parse({
-              value: enrichedContext.input,
-              data: enrichedContext.input,
-              user: enrichedContext.user,
+              value: context,
+              data: context,
+              user: _user,
             });
 
             if (result.issues) {
@@ -621,6 +852,7 @@ function generateEntry(detected, sourceFile, env, machineUser, workspaceId) {
             }
           }
 
+          const enrichedContext = { input: context, env: _env, user: _user };
           return _internalResolver.body(enrichedContext);
         };
 
@@ -704,10 +936,20 @@ async function detectFunctionType(options) {
 	const { filePath, jobName } = options;
 	const module = await import(pathToFileURL(filePath).href);
 	const resolverResult = ResolverSchema.safeParse(module.default);
-	if (resolverResult.success) return {
-		type: "resolver",
-		name: resolverResult.data.name
-	};
+	if (resolverResult.success) {
+		const rawInput = module.default.input;
+		let inputSchema;
+		if (rawInput) {
+			const { t } = await import("@tailor-platform/sdk");
+			inputSchema = t.object(rawInput);
+		}
+		return {
+			type: "resolver",
+			name: resolverResult.data.name,
+			hasInput: rawInput != null,
+			inputSchema
+		};
+	}
 	const executorResult = ExecutorSchema.safeParse(module.default);
 	if (executorResult.success) {
 		const { operation } = executorResult.data;
@@ -825,7 +1067,7 @@ When a \`.js\` file is provided, detection and bundling are skipped and the file
 > Triggered jobs are not executed; only the target job's \`body\` function runs in isolation.`,
 	examples: [
 		{
-			cmd: "resolvers/add.ts --arg '{\"input\":{\"a\":1,\"b\":2}}'",
+			cmd: "resolvers/add.ts --arg '{\"a\":1,\"b\":2}'",
 			desc: "Run a resolver with input arguments"
 		},
 		{
@@ -833,7 +1075,7 @@ When a \`.js\` file is provided, detection and bundling are skipped and the file
 			desc: "Run a specific workflow job by name"
 		},
 		{
-			cmd: "build/resolvers/add.js --arg '{\"input\":{\"a\":1,\"b\":2}}'",
+			cmd: "build/resolvers/add.js --arg '{\"a\":1,\"b\":2}'",
 			desc: "Run a pre-bundled .js file directly"
 		}
 	],
@@ -877,6 +1119,12 @@ When a \`.js\` file is provided, detection and bundling are skipped and the file
 			functionType = detected.type;
 			functionName = detected.name;
 			logger.info(`Detected: ${styles.bold(detected.type)} ${styles.info(`"${detected.name}"`)}`);
+			if (detected.type === "resolver" && args.arg) {
+				if (!detected.hasInput) {
+					logger.warn("--arg is ignored because this resolver has no input schema. Define \"input\" in your resolver to use --arg.");
+					args.arg = void 0;
+				} else if (detected.inputSchema) args.arg = resolveResolverArg(args.arg, detected.inputSchema, machineUser, workspaceId);
+			}
 			logger.info("Bundling...");
 			({bundledCode, scriptName} = await bundleForTestRun({
 				detected,
@@ -928,7 +1176,9 @@ When a \`.js\` file is provided, detection and bundling are skipped and the file
 			}
 			if (result.error && !result.success) {
 				logger.log(styles.bold("\nError:"));
-				logger.log(`  ${styles.error(result.error)}`);
+				const formatted = formatErrorWithSourcemap(result.error, bundledCode, process.cwd());
+				if (formatted) logger.log(formatted);
+				else logger.log(`  ${styles.error(result.error)}`);
 			}
 		}
 		if (!result.success) process.exit(1);
@@ -993,6 +1243,42 @@ async function resolveMachineUser(options) {
 		attributeList
 	};
 }
+/**
+* Resolve resolver arg format: detect and unwrap deprecated {"input":{...}} wrapper.
+* Tries new format (arg = input fields) first via schema parse.
+* If that fails and arg looks like old format, tries unwrapping.
+* @param argStr - JSON string of the arg
+* @param inputSchema - Pre-built schema object from detect (has .parse())
+* @param machineUser - Resolved machine user info
+* @param workspaceId - Workspace ID
+* @returns Resolved JSON string (unwrapped if old format)
+*/
+function resolveResolverArg(argStr, inputSchema, machineUser, workspaceId) {
+	const parsed = JSON.parse(argStr);
+	const user = {
+		id: machineUser.id,
+		type: "machine_user",
+		workspaceId,
+		attributes: machineUser.attributes ?? null,
+		attributeList: machineUser.attributeList ?? []
+	};
+	if (!inputSchema.parse({
+		value: parsed,
+		data: parsed,
+		user
+	}).issues) return argStr;
+	if (Object.keys(parsed).length === 1 && parsed.input != null && typeof parsed.input === "object" && !Array.isArray(parsed.input)) {
+		if (!inputSchema.parse({
+			value: parsed.input,
+			data: parsed.input,
+			user
+		}).issues) {
+			logger.warn("[DEPRECATED] Wrapping args with \"input\" key (e.g. {\"input\":{...}}) is deprecated. Pass input fields directly (e.g. {\"a\":1}). The \"input\" wrapper will be removed in v2.");
+			return JSON.stringify(parsed.input);
+		}
+	}
+	return argStr;
+}
 
 //#endregion
 //#region src/cli/commands/function/index.ts
@@ -3488,7 +3774,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-Bd2T8BhU.mjs");
+				const { reportCrash } = await import("../crash-report-CB1UtT3O.mjs");
 				await reportCrash(error, "handledError");
 			}
 		}