Need help using shebang to alter program before executing it

[Zirunis]

I'm stuck with my project and would appreciate some help.
As the title says, what I'm trying to do is create an 'interpreter' that alters a program before executing it. This means it should be possible to take a working cc program, add #! myInterpreter and it should run as it normally would. Imagine myInterpreter doing something like automatically adding print statements for logging for example.

Currently, I see two ways of doing this:

1. Copy all contents of the program except for the first line (the shebang) into a new file programName-copy.lua, then call shell.run(programName-copy.lua) and finally delete the copy again. While this is super simple, I don't like creating a copy for two reasons. The first is that I can't guarantee that it will be deleted again (any termination of the program for example caused by a reboot caused by a chunk reload will lead to the copy remaining on disk), the second is that it is a waste of disk space which is quite precious in CC (in the extreme case of the program running in an infinite loop we'd forever have two copies of the program for no obvious reason)
2. Do the same thing shell.execute_program does (without the handling of shebangs) manually. This means creating the environment and calling load. Trying this I got stuck figuring out how much of shell I'd have to copy. I found cc.require and how to import it and use it to make packages for the environment but I don't know what to do with shell itself. How do I make shell and add it to the environment?

If you could help me figure out 2 or provide me with a simpler alternative option I'd be very happy.
While staring at the code for shell I had another idea: The simplest option would be if there was a function shell.load(contents) which simply takes a files' contents and executes them like shell.run(pathToContents). This could be achieved by essentially extracting the second half of shell.execute_program into its own function shell.load. This would be line 157 to 190 in shell.lua. I'm not sure about how viable this is. Even if it is maybe the functionality is too niche to warrant adding it to the API but I think it would at least fit quite nicely into it.

[SquidDev]

For custom shebang programs, you don't probably don't need some of the fancier things shell does (like fancy error reporting), so can probably get away with something like this:

local function execute(path, contents)
  -- Shift arg left one, so replacing { [0] = "shebang-program", "program", "arg1" }
  -- with { [-1] = "shebang-program", [0] = "program", "arg1" }.
  local new_arg = {}
  local i = #arg while arg[i] do new_arg[i - 1] = arg[i] i = i - 1 end

  -- Create a new environment and require instance.
  -- You could probably overwrite _ENV.{arg,require,package}, rather than creating a new env,
  -- but this feels cleaner.
  local env = setmetatable({ arg = new_arg, shell = shell, multishell = multishell } , {__index = _G})
  env.require, env.package = require "cc.require".make(env, fs.getDir(path))

  -- Load the file and run it.
  local func, err = load(contents, "@/" .. path, nil, env)
  if not func then error(err, 0) end
  return func(table.unpack(new_arg))
end

local path = arg[1]
local handle = fs.open(path, "r")
local contents = handle.readAll()
handle.close()

execute(path, contents:gsub("[hH]ello", "hi"))

That said, if you're trying to instrument the program, you might want a custom require implementation too, that also rewrites the included modules.

[Zirunis]

oooh it took me a while to understand your last sentence (non native here had never heard instrument used in this context) but now that I got it that is actually a very helpful tip! I had planned to parse the program and in doing so to go through all dependencies but modifying require is way cleaner and less compute intensive! Thank you!

What do you think of shell.load() though? No good?