@taqueria/plugin-ligo 0.28.4 → 0.28.6

package/common.ts

@@ -25,7 +25,7 @@ export type IntersectionOpts = LigoOpts & CompileOpts & CompileAllOpts & TestOpt
 type UnionOpts = LigoOpts | CompileOpts | CompileAllOpts | TestOpts;
 
 // Should point to the latest stable version, so it needs to be updated as part of our release process.
-const LIGO_DEFAULT_IMAGE = 'ligolang/ligo:0.57.0';
+const LIGO_DEFAULT_IMAGE = 'ligolang/ligo:0.63.2';
 
 const LIGO_IMAGE_ENV_VAR = 'TAQ_LIGO_IMAGE';
 

package/compile-all.ts

@@ -5,25 +5,129 @@ import { join } from 'path';
 import { CompileAllOpts as Opts, CompileOpts, getInputFilenameAbsPath } from './common';
 import { compileContractWithStorageAndParameter, TableRow } from './compile';
 
-const isMainContract = (parsedArgs: Opts, contactFilename: string): Promise<boolean> =>
-	readFile(getInputFilenameAbsPath(parsedArgs, contactFilename), 'utf8')
-		.then(data => /(const|let|function)\s+main/.test(data));
+const isMainContract = async (parsedArgs: Opts, contractFilename: string): Promise<boolean> => {
+	const fileContent = await readFile(getInputFilenameAbsPath(parsedArgs, contractFilename), 'utf8');
+	const entryOrMainFunctionRegex = /@entry|((const|let|function)\s+main)/g;
+	return entryOrMainFunctionRegex.test(fileContent);
+};
+
+// Helper function to parse includes from a LIGO file
+const parseIncludes = async (parsedArgs: Opts, contractFilename: string): Promise<string[]> => {
+	const fileContent = await readFile(getInputFilenameAbsPath(parsedArgs, contractFilename), 'utf8');
+	const includeRegex = /#include\s+"([^"]+\.m?ligo)"/g;
+	let match;
+	const includes: string[] = [];
+
+	while ((match = includeRegex.exec(fileContent)) !== null) {
+		includes.push(match[1]);
+	}
+
+	return includes;
+};
+
+// Helper function to build the dependency graph
+const buildDependencyGraph = async (
+	parsedArgs: Opts,
+	contractFilenames: string[],
+): Promise<Map<string, Set<string>>> => {
+	const graph = new Map<string, Set<string>>();
+
+	for (const filename of contractFilenames) {
+		const includes = await parseIncludes(parsedArgs, filename);
+		graph.set(filename, new Set(includes));
+	}
+
+	return graph;
+};
+
+const visit = (
+	node: string,
+	graph: Map<string, Set<string>>,
+	visited: Set<string>,
+	stack: Set<string>,
+): [boolean, Set<string>] => {
+	if (stack.has(node)) return [true, visited]; // Circular dependency detected
+
+	if (!visited.has(node)) {
+		const newVisited = new Set(visited).add(node);
+		const newStack = new Set(stack).add(node);
+
+		const [circular, updatedVisited] = Array.from(graph.get(node) || []).reduce<[boolean, Set<string>]>(
+			([circularFound, vSet], dependency) => {
+				const [result, v] = visit(dependency, graph, vSet, newStack);
+				return [circularFound || result, v];
+			},
+			[false, newVisited],
+		);
+
+		if (!circular) return [false, updatedVisited];
+	}
+
+	return [false, visited];
+};
+
+const detectCircularDependencies = (
+	graph: Map<string, Set<string>>,
+): { safeFiles: string[]; circularFiles: string[] } => {
+	const { safeFiles, circularFiles, visited } = Array.from(graph.keys()).reduce<{
+		safeFiles: string[];
+		circularFiles: string[];
+		visited: Set<string>;
+	}>(
+		(acc, filename) => {
+			const [isCircular, updatedVisited] = visit(
+				filename,
+				graph,
+				acc.visited,
+				new Set<string>(),
+			);
+			if (isCircular) {
+				acc.circularFiles.push(filename);
+			} else {
+				acc.safeFiles.push(filename);
+			}
+			acc.visited = updatedVisited;
+			return acc;
+		},
+		{ safeFiles: [], circularFiles: [], visited: new Set<string>() },
+	);
+
+	return { safeFiles, circularFiles };
+};
 
 const compileAll = async (parsedArgs: Opts): Promise<void> => {
 	let p: Promise<TableRow[]>[] = [];
 
 	const contractFilenames = await glob(
 		['**/*.ligo', '**/*.religo', '**/*.mligo', '**/*.jsligo'],
-		{ cwd: join(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? 'contracts'), absolute: false },
+		{
+			cwd: join(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? 'contracts'),
+			absolute: false,
+		},
 	);
 
-	for (const filename of contractFilenames) {
+	const dependencyGraph = await buildDependencyGraph(parsedArgs, contractFilenames);
+	const { safeFiles, circularFiles } = detectCircularDependencies(dependencyGraph);
+
+	for (const filename of safeFiles) {
 		if (await isMainContract(parsedArgs, filename)) {
 			p.push(compileContractWithStorageAndParameter(parsedArgs as CompileOpts, filename));
 		}
 	}
 
-	return Promise.all(p).then(tables => tables.flat()).then(sendJsonRes).catch(err => sendErr(err, false));
+	return Promise.all(p)
+		.then(tables => tables.flat())
+		.then(table => {
+			if (circularFiles.length > 0) {
+				console.warn(
+					'Warning: Circular dependencies detected in the following files. They have been skipped:',
+				);
+				console.warn(circularFiles.join(', '));
+			}
+			return table;
+		})
+		.then(sendJsonRes)
+		.catch(err => sendErr(err, false));
 };
 
 export default compileAll;

package/compile.ts

@@ -28,6 +28,15 @@ const isParameterListFile = (sourceFile: string): boolean =>
 const isContractFile = (sourceFile: string): boolean =>
 	isLIGOFile(sourceFile) && !isStorageListFile(sourceFile) && !isParameterListFile(sourceFile);
 
+const getModuleName = async (parsedArgs: Opts, sourceFile: string): Promise<string | undefined> => {
+	const fileContent = await readFile(getInputFilenameAbsPath(parsedArgs, sourceFile), 'utf8');
+	if (fileContent.includes('@entry') && fileContent.includes('module')) {
+		const match = fileContent.match(/module ([^\s]+)/);
+		return match ? match[1] : undefined;
+	}
+	return undefined;
+};
+
 const extractExt = (path: string): string => {
 	const matchResult = path.match(/\.(ligo|religo|mligo|jsligo)$/);
 	return matchResult ? matchResult[0] : '';
@@ -68,7 +77,7 @@ const getOutputExprFilename = (parsedArgs: Opts, sourceFile: string, exprKind: E
 	return join(getArtifactsDir(parsedArgs), `${outputFile}`);
 };
 
-const getCompileContractCmd = (parsedArgs: Opts, sourceFile: string): string => {
+const getCompileContractCmd = async (parsedArgs: Opts, sourceFile: string): Promise<string> => {
 	const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
 	if (!projectDir) throw `No project directory provided`;
 	const baseCmd =
@@ -76,7 +85,9 @@ const getCompileContractCmd = (parsedArgs: Opts, sourceFile: string): string =>
 	const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
 	const outputFile = `-o ${getOutputContractFilename(parsedArgs, sourceFile)}`;
 	const flags = isOutputFormatJSON(parsedArgs) ? ' --michelson-format json ' : '';
-	const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}`;
+	const moduleName = await getModuleName(parsedArgs, sourceFile);
+	const entryFlag = moduleName ? `-m ${moduleName}` : '';
+	const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}${entryFlag}`;
 	return cmd;
 };
 
@@ -93,24 +104,24 @@ const getCompileExprCmd = (parsedArgs: Opts, sourceFile: string, exprKind: ExprK
 	return cmd;
 };
 
-const compileContract = (parsedArgs: Opts, sourceFile: string): Promise<TableRow> =>
-	getArch()
-		.then(() => getCompileContractCmd(parsedArgs, sourceFile))
-		.then(execCmd)
-		.then(({ stderr }) => {
-			if (stderr.length > 0) sendWarn(stderr);
-			return {
-				contract: sourceFile,
-				artifact: getOutputContractFilename(parsedArgs, sourceFile),
-			};
-		})
-		.catch(err => {
-			emitExternalError(err, sourceFile);
-			return {
-				contract: sourceFile,
-				artifact: COMPILE_ERR_MSG,
-			};
-		});
+const compileContract = async (parsedArgs: Opts, sourceFile: string): Promise<TableRow> => {
+	try {
+		await getArch();
+		const cmd = await getCompileContractCmd(parsedArgs, sourceFile);
+		const { stderr } = await execCmd(cmd);
+		if (stderr.length > 0) sendWarn(stderr);
+		return {
+			contract: sourceFile,
+			artifact: getOutputContractFilename(parsedArgs, sourceFile),
+		};
+	} catch (err) {
+		emitExternalError(err, sourceFile);
+		return {
+			contract: sourceFile,
+			artifact: COMPILE_ERR_MSG,
+		};
+	}
+};
 
 const compileExpr = (parsedArgs: Opts, sourceFile: string, exprKind: ExprKind) =>
 	(exprName: string): Promise<TableRow> =>
@@ -119,9 +130,10 @@ const compileExpr = (parsedArgs: Opts, sourceFile: string, exprKind: ExprKind) =
 			.then(execCmd)
 			.then(({ stderr }) => {
 				if (stderr.length > 0) sendWarn(stderr);
+				const artifactName = getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName);
 				return {
 					contract: sourceFile,
-					artifact: getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName),
+					artifact: artifactName,
 				};
 			})
 			.catch(err => {
@@ -152,9 +164,15 @@ const compileExprs = (parsedArgs: Opts, sourceFile: string, exprKind: ExprKind):
 			emitExternalError(err, sourceFile);
 			return [{
 				contract: sourceFile,
-				artifact: `No ${isStorageKind(exprKind) ? 'storage' : 'parameter'} values compiled`,
+				artifact: `No ${isStorageKind(exprKind) ? 'storage' : 'parameter'} expressions compiled`,
 			}];
 		})
+		.then(results =>
+			results.length > 0 ? results : [{
+				contract: sourceFile,
+				artifact: `No ${isStorageKind(exprKind) ? 'storage' : 'parameter'} expressions found`,
+			}]
+		)
 		.then(mergeArtifactsOutput(sourceFile));
 
 // TODO: Just for backwards compatibility. Can be deleted in the future.

package/index.d.ts

@@ -1 +1,2 @@
 
+export { }

package/index.js

@@ -14,12 +14,16 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
 
 // index.ts
-var import_node_sdk8 = require("@taqueria/node-sdk");
+var import_node_sdk9 = require("@taqueria/node-sdk");
 
 // createContract.ts
 var import_node_sdk = require("@taqueria/node-sdk");
@@ -171,12 +175,12 @@ var createContract = (args) => {
 var createContract_default = createContract;
 
 // main.ts
-var import_node_sdk7 = require("@taqueria/node-sdk");
+var import_node_sdk8 = require("@taqueria/node-sdk");
 
 // common.ts
 var import_node_sdk2 = require("@taqueria/node-sdk");
 var import_path = require("path");
-var LIGO_DEFAULT_IMAGE = "ligolang/ligo:0.57.0";
+var LIGO_DEFAULT_IMAGE = "ligolang/ligo:0.63.2";
 var LIGO_IMAGE_ENV_VAR = "TAQ_LIGO_IMAGE";
 var getLigoDockerImage = () => (0, import_node_sdk2.getDockerImage)(LIGO_DEFAULT_IMAGE, LIGO_IMAGE_ENV_VAR);
 var getInputFilenameAbsPath = (parsedArgs, sourceFile) => (0, import_path.join)(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts", sourceFile);
@@ -199,6 +203,14 @@ var isLIGOFile = (sourceFile) => /.+\.(ligo|religo|mligo|jsligo)$/.test(sourceFi
 var isStorageListFile = (sourceFile) => /.+\.(storageList|storages)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
 var isParameterListFile = (sourceFile) => /.+\.(parameterList|parameters)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
 var isContractFile = (sourceFile) => isLIGOFile(sourceFile) && !isStorageListFile(sourceFile) && !isParameterListFile(sourceFile);
+var getModuleName = async (parsedArgs, sourceFile) => {
+  const fileContent = await (0, import_promises2.readFile)(getInputFilenameAbsPath(parsedArgs, sourceFile), "utf8");
+  if (fileContent.includes("@entry") && fileContent.includes("module")) {
+    const match = fileContent.match(/module ([^\s]+)/);
+    return match ? match[1] : void 0;
+  }
+  return void 0;
+};
 var extractExt = (path) => {
   const matchResult = path.match(/\.(ligo|religo|mligo|jsligo)$/);
   return matchResult ? matchResult[0] : "";
@@ -226,7 +238,7 @@ var getOutputExprFilename = (parsedArgs, sourceFile, exprKind, exprName) => {
   const outputFile = exprKind === "default_storage" ? `${contractName}.default_storage${ext}` : `${contractName}.${exprKind}.${exprName}${ext}`;
   return (0, import_path2.join)((0, import_node_sdk3.getArtifactsDir)(parsedArgs), `${outputFile}`);
 };
-var getCompileContractCmd = (parsedArgs, sourceFile) => {
+var getCompileContractCmd = async (parsedArgs, sourceFile) => {
   const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
   if (!projectDir)
     throw `No project directory provided`;
@@ -234,7 +246,9 @@ var getCompileContractCmd = (parsedArgs, sourceFile) => {
   const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
   const outputFile = `-o ${getOutputContractFilename(parsedArgs, sourceFile)}`;
   const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
-  const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}`;
+  const moduleName = await getModuleName(parsedArgs, sourceFile);
+  const entryFlag = moduleName ? `-m ${moduleName}` : "";
+  const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}${entryFlag}`;
   return cmd;
 };
 var getCompileExprCmd = (parsedArgs, sourceFile, exprKind, exprName) => {
@@ -249,26 +263,32 @@ var getCompileExprCmd = (parsedArgs, sourceFile, exprKind, exprName) => {
   const cmd = `${baseCmd} ${inputFile} ${exprName} ${outputFile} ${flags}`;
   return cmd;
 };
-var compileContract = (parsedArgs, sourceFile) => (0, import_node_sdk3.getArch)().then(() => getCompileContractCmd(parsedArgs, sourceFile)).then(import_node_sdk3.execCmd).then(({ stderr }) => {
-  if (stderr.length > 0)
-    (0, import_node_sdk3.sendWarn)(stderr);
-  return {
-    contract: sourceFile,
-    artifact: getOutputContractFilename(parsedArgs, sourceFile)
-  };
-}).catch((err) => {
-  emitExternalError(err, sourceFile);
-  return {
-    contract: sourceFile,
-    artifact: COMPILE_ERR_MSG
-  };
-});
+var compileContract = async (parsedArgs, sourceFile) => {
+  try {
+    await (0, import_node_sdk3.getArch)();
+    const cmd = await getCompileContractCmd(parsedArgs, sourceFile);
+    const { stderr } = await (0, import_node_sdk3.execCmd)(cmd);
+    if (stderr.length > 0)
+      (0, import_node_sdk3.sendWarn)(stderr);
+    return {
+      contract: sourceFile,
+      artifact: getOutputContractFilename(parsedArgs, sourceFile)
+    };
+  } catch (err) {
+    emitExternalError(err, sourceFile);
+    return {
+      contract: sourceFile,
+      artifact: COMPILE_ERR_MSG
+    };
+  }
+};
 var compileExpr = (parsedArgs, sourceFile, exprKind) => (exprName) => (0, import_node_sdk3.getArch)().then(() => getCompileExprCmd(parsedArgs, sourceFile, exprKind, exprName)).then(import_node_sdk3.execCmd).then(({ stderr }) => {
   if (stderr.length > 0)
     (0, import_node_sdk3.sendWarn)(stderr);
+  const artifactName = getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName);
   return {
     contract: sourceFile,
-    artifact: getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName)
+    artifact: artifactName
   };
 }).catch((err) => {
   emitExternalError(err, sourceFile);
@@ -292,9 +312,14 @@ var compileExprs = (parsedArgs, sourceFile, exprKind) => getExprNames(parsedArgs
   emitExternalError(err, sourceFile);
   return [{
     contract: sourceFile,
-    artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} values compiled`
+    artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions compiled`
   }];
-}).then(mergeArtifactsOutput(sourceFile));
+}).then(
+  (results) => results.length > 0 ? results : [{
+    contract: sourceFile,
+    artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions found`
+  }]
+).then(mergeArtifactsOutput(sourceFile));
 var tryLegacyStorageNamingConvention = (parsedArgs, sourceFile) => {
   const storageListFile = `${removeExt(sourceFile)}.storages${extractExt(sourceFile)}`;
   const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
@@ -414,29 +439,106 @@ var import_node_sdk4 = require("@taqueria/node-sdk");
 var import_fast_glob = __toESM(require("fast-glob"));
 var import_promises3 = require("fs/promises");
 var import_path3 = require("path");
-var isMainContract = (parsedArgs, contactFilename) => (0, import_promises3.readFile)(getInputFilenameAbsPath(parsedArgs, contactFilename), "utf8").then((data) => /(const|let|function)\s+main/.test(data));
+var isMainContract = async (parsedArgs, contractFilename) => {
+  const fileContent = await (0, import_promises3.readFile)(getInputFilenameAbsPath(parsedArgs, contractFilename), "utf8");
+  const entryOrMainFunctionRegex = /@entry|((const|let|function)\s+main)/g;
+  return entryOrMainFunctionRegex.test(fileContent);
+};
+var parseIncludes = async (parsedArgs, contractFilename) => {
+  const fileContent = await (0, import_promises3.readFile)(getInputFilenameAbsPath(parsedArgs, contractFilename), "utf8");
+  const includeRegex = /#include\s+"([^"]+\.m?ligo)"/g;
+  let match;
+  const includes = [];
+  while ((match = includeRegex.exec(fileContent)) !== null) {
+    includes.push(match[1]);
+  }
+  return includes;
+};
+var buildDependencyGraph = async (parsedArgs, contractFilenames) => {
+  const graph = /* @__PURE__ */ new Map();
+  for (const filename of contractFilenames) {
+    const includes = await parseIncludes(parsedArgs, filename);
+    graph.set(filename, new Set(includes));
+  }
+  return graph;
+};
+var visit = (node, graph, visited, stack) => {
+  if (stack.has(node))
+    return [true, visited];
+  if (!visited.has(node)) {
+    const newVisited = new Set(visited).add(node);
+    const newStack = new Set(stack).add(node);
+    const [circular, updatedVisited] = Array.from(graph.get(node) || []).reduce(
+      ([circularFound, vSet], dependency) => {
+        const [result, v] = visit(dependency, graph, vSet, newStack);
+        return [circularFound || result, v];
+      },
+      [false, newVisited]
+    );
+    if (!circular)
+      return [false, updatedVisited];
+  }
+  return [false, visited];
+};
+var detectCircularDependencies = (graph) => {
+  const { safeFiles, circularFiles, visited } = Array.from(graph.keys()).reduce(
+    (acc, filename) => {
+      const [isCircular, updatedVisited] = visit(
+        filename,
+        graph,
+        acc.visited,
+        /* @__PURE__ */ new Set()
+      );
+      if (isCircular) {
+        acc.circularFiles.push(filename);
+      } else {
+        acc.safeFiles.push(filename);
+      }
+      acc.visited = updatedVisited;
+      return acc;
+    },
+    { safeFiles: [], circularFiles: [], visited: /* @__PURE__ */ new Set() }
+  );
+  return { safeFiles, circularFiles };
+};
 var compileAll = async (parsedArgs) => {
   let p = [];
   const contractFilenames = await (0, import_fast_glob.default)(
     ["**/*.ligo", "**/*.religo", "**/*.mligo", "**/*.jsligo"],
-    { cwd: (0, import_path3.join)(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts"), absolute: false }
+    {
+      cwd: (0, import_path3.join)(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts"),
+      absolute: false
+    }
   );
-  for (const filename of contractFilenames) {
+  const dependencyGraph = await buildDependencyGraph(parsedArgs, contractFilenames);
+  const { safeFiles, circularFiles } = detectCircularDependencies(dependencyGraph);
+  for (const filename of safeFiles) {
     if (await isMainContract(parsedArgs, filename)) {
       p.push(compileContractWithStorageAndParameter(parsedArgs, filename));
     }
   }
-  return Promise.all(p).then((tables) => tables.flat()).then(import_node_sdk4.sendJsonRes).catch((err) => (0, import_node_sdk4.sendErr)(err, false));
+  return Promise.all(p).then((tables) => tables.flat()).then((table) => {
+    if (circularFiles.length > 0) {
+      console.warn(
+        "Warning: Circular dependencies detected in the following files. They have been skipped:"
+      );
+      console.warn(circularFiles.join(", "));
+    }
+    return table;
+  }).then(import_node_sdk4.sendJsonRes).catch((err) => (0, import_node_sdk4.sendErr)(err, false));
 };
 var compile_all_default = compileAll;
 
 // ligo.ts
 var import_node_sdk5 = require("@taqueria/node-sdk");
-var getArbitraryLigoCmd = (parsedArgs, userArgs) => {
+var import_node_sdk6 = require("@taqueria/node-sdk");
+var import_path4 = require("path");
+var getArbitraryLigoCmd = (parsedArgs, uid, gid, userArgs) => {
   const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
   if (!projectDir)
     throw `No project directory provided`;
-  const owner = process.env.GID ? `${process.env.UID}:${process.env.GID}` : process.env.UID;
+  const userMap = uid && gid ? `${uid}:${gid}` : uid;
+  const userMapArgs = uid ? ["-u", userMap] : [];
   const binary = "docker";
   const baseArgs = [
     "run",
@@ -445,8 +547,7 @@ var getArbitraryLigoCmd = (parsedArgs, userArgs) => {
     `${projectDir}:/project`,
     "-w",
     "/project",
-    "-u",
-    owner,
+    ...userMapArgs,
     getLigoDockerImage()
   ];
   const processedUserArgs = userArgs.split(" ").map((arg) => arg.startsWith("\\-") ? arg.substring(1) : arg).filter(
@@ -459,7 +560,19 @@ var getArbitraryLigoCmd = (parsedArgs, userArgs) => {
     envVars
   ];
 };
-var runArbitraryLigoCmd = (parsedArgs, cmd) => (0, import_node_sdk5.getArch)().then(() => getArbitraryLigoCmd(parsedArgs, cmd)).then(([cmd2, envVars]) => (0, import_node_sdk5.spawnCmd)(cmd2, envVars)).then(
+var ensureEsyExists = async (parsedArgs) => {
+  const esyJsonPath = (0, import_path4.join)(parsedArgs.projectDir, "esy.json");
+  try {
+    return await (0, import_node_sdk6.readJsonFile)(esyJsonPath);
+  } catch {
+    return await (0, import_node_sdk6.writeJsonFile)(esyJsonPath)({});
+  }
+};
+var runArbitraryLigoCmd = (parsedArgs, cmd) => ensureEsyExists(parsedArgs).then(import_node_sdk5.getArch).then(async () => {
+  const uid = await (0, import_node_sdk5.execCmd)("id -u");
+  const gid = await (0, import_node_sdk5.execCmd)("id -g");
+  return [uid.stdout.trim(), gid.stdout.trim()];
+}).then(([uid, gid]) => getArbitraryLigoCmd(parsedArgs, uid, gid, cmd)).then(([cmd2, envVars]) => (0, import_node_sdk5.spawnCmd)(cmd2, envVars)).then(
   (code) => code !== null && code === 0 ? `Command "${cmd}" ran successfully by LIGO` : `Command "${cmd}" failed. Please check your command`
 ).catch((err) => (0, import_node_sdk5.sendAsyncErr)(`An internal error has occurred: ${err.message}`));
 var ligo = (parsedArgs) => {
@@ -469,7 +582,7 @@ var ligo = (parsedArgs) => {
 var ligo_default = ligo;
 
 // test.ts
-var import_node_sdk6 = require("@taqueria/node-sdk");
+var import_node_sdk7 = require("@taqueria/node-sdk");
 var getTestContractCmd = (parsedArgs, sourceFile) => {
   const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
   if (!projectDir)
@@ -479,9 +592,9 @@ var getTestContractCmd = (parsedArgs, sourceFile) => {
   const cmd = `${baseCmd} ${inputFile}`;
   return cmd;
 };
-var testContract = (parsedArgs, sourceFile) => (0, import_node_sdk6.getArch)().then(() => getTestContractCmd(parsedArgs, sourceFile)).then(import_node_sdk6.execCmd).then(({ stdout, stderr }) => {
+var testContract = (parsedArgs, sourceFile) => (0, import_node_sdk7.getArch)().then(() => getTestContractCmd(parsedArgs, sourceFile)).then(import_node_sdk7.execCmd).then(({ stdout, stderr }) => {
   if (stderr.length > 0)
-    (0, import_node_sdk6.sendWarn)(stderr);
+    (0, import_node_sdk7.sendWarn)(stderr);
   const result = "\u{1F389} All tests passed \u{1F389}";
   return {
     contract: sourceFile,
@@ -498,9 +611,9 @@ ${result}` : result
 var test = (parsedArgs) => {
   const sourceFile = parsedArgs.sourceFile;
   if (!sourceFile)
-    return (0, import_node_sdk6.sendAsyncErr)(`No source file provided`);
-  return testContract(parsedArgs, sourceFile).then((result) => [result]).then(import_node_sdk6.sendJsonRes).catch(
-    (err) => (0, import_node_sdk6.sendAsyncErr)(err, false)
+    return (0, import_node_sdk7.sendAsyncErr)(`No source file provided`);
+  return testContract(parsedArgs, sourceFile).then((result) => [result]).then(import_node_sdk7.sendJsonRes).catch(
+    (err) => (0, import_node_sdk7.sendAsyncErr)(err, false)
   );
 };
 var test_default = test;
@@ -518,25 +631,25 @@ var main = (parsedArgs) => {
     case "test":
       return test_default(parsedArgs);
     case "get-image":
-      return (0, import_node_sdk7.sendAsyncRes)(getLigoDockerImage());
+      return (0, import_node_sdk8.sendAsyncRes)(getLigoDockerImage());
     default:
-      return (0, import_node_sdk7.sendAsyncErr)(`${unsafeOpts.task} is not an understood task by the LIGO plugin`);
+      return (0, import_node_sdk8.sendAsyncErr)(`${unsafeOpts.task} is not an understood task by the LIGO plugin`);
   }
 };
 var main_default = main;
 
 // index.ts
-import_node_sdk8.Plugin.create((i18n) => ({
+import_node_sdk9.Plugin.create((i18n) => ({
   schema: "1.0",
   version: "0.1",
   alias: "ligo",
   tasks: [
-    import_node_sdk8.Task.create({
+    import_node_sdk9.Task.create({
       task: "ligo",
       command: "ligo",
       description: "This task allows you to run arbitrary LIGO native commands. Note that they might not benefit from the abstractions provided by Taqueria",
       options: [
-        import_node_sdk8.Option.create({
+        import_node_sdk9.Option.create({
           shortFlag: "c",
           flag: "command",
           type: "string",
@@ -547,13 +660,13 @@ import_node_sdk8.Plugin.create((i18n) => ({
       handler: "proxy",
       encoding: "none"
     }),
-    import_node_sdk8.Task.create({
+    import_node_sdk9.Task.create({
       task: "compile",
       command: "compile <sourceFile>",
       aliases: ["c", "compile-ligo"],
       description: "Compile a smart contract written in a LIGO syntax to Michelson code, along with its associated storage/parameter list files if they are found",
       options: [
-        import_node_sdk8.Option.create({
+        import_node_sdk9.Option.create({
           flag: "json",
           boolean: true,
           description: "Emit JSON-encoded Michelson"
@@ -562,12 +675,12 @@ import_node_sdk8.Plugin.create((i18n) => ({
       handler: "proxy",
       encoding: "json"
     }),
-    import_node_sdk8.Task.create({
+    import_node_sdk9.Task.create({
       task: "compile-all",
       command: "compile-all",
       description: "Compile all main smart contracts written in a LIGO syntax to Michelson code, along with their associated storage/parameter list files if they are found",
       options: [
-        import_node_sdk8.Option.create({
+        import_node_sdk9.Option.create({
           flag: "json",
           boolean: true,
           description: "Emit JSON-encoded Michelson"
@@ -576,14 +689,14 @@ import_node_sdk8.Plugin.create((i18n) => ({
       handler: "proxy",
       encoding: "json"
     }),
-    import_node_sdk8.Task.create({
+    import_node_sdk9.Task.create({
       task: "test",
       command: "test <sourceFile>",
       description: "Test a smart contract written in LIGO",
       handler: "proxy",
       encoding: "json"
     }),
-    import_node_sdk8.Task.create({
+    import_node_sdk9.Task.create({
       task: "get-image",
       command: "get-image",
       description: "Gets the name of the image to be used",
@@ -592,19 +705,19 @@ import_node_sdk8.Plugin.create((i18n) => ({
     })
   ],
   templates: [
-    import_node_sdk8.Template.create({
+    import_node_sdk9.Template.create({
       template: "contract",
       command: "contract <sourceFileName>",
       description: "Create a LIGO contract with boilerplate code",
       positionals: [
-        import_node_sdk8.PositionalArg.create({
+        import_node_sdk9.PositionalArg.create({
           placeholder: "sourceFileName",
           type: "string",
           description: "The name of the LIGO contract to generate"
         })
       ],
       options: [
-        import_node_sdk8.Option.create({
+        import_node_sdk9.Option.create({
           shortFlag: "s",
           flag: "syntax",
           type: "string",