"""Isolated production wrapper generation and launch routing; no user systemd calls.""" import json import os from pathlib import Path import shutil import subprocess import sys import tempfile MODULES = Path(__file__).resolve().parents[1] / "modules" NU = shutil.which("nu") assert NU, "nu is required" # Resolve a version-manager shim before replacing HOME/PATH. NU = subprocess.check_output([NU, "--no-config-file", "-c", "$nu.current-exe"], text=True).strip() with tempfile.TemporaryDirectory(prefix="nushell-work-scope-") as temporary: root = Path(temporary) config = root / "config" modules = config / "modules" modules.mkdir(parents=True) for name in ["commands.nu", "work_scope.nu", "pi.nu", "lib.nu"]: shutil.copy2(MODULES / name, modules / name) bin_dir = root / "bin" bin_dir.mkdir() scope_log = root / "scope.json" session_root = root / "sessions" session_root.mkdir() env = dict(os.environ, HOME=str(root), USERPROFILE=str(root), PATH=str(bin_dir), XDG_CONFIG_HOME=str(root / "xdg-config"), XDG_DATA_HOME=str(root / "data"), XDG_DATA_DIRS=str(root / "data"), XDG_CACHE_HOME=str(root / "cache"), PI_CODING_AGENT_SESSION_DIR=str(session_root), SCOPE_TEST_LOG=str(scope_log)) def executable(name, body): path = bin_dir / name path.write_text(f"#!{sys.executable}\n" + body) path.chmod(0o700) return path for name in ["bun", "pi"]: executable(name, "import json, os, sys\nprint(json.dumps(sys.argv[1:]))\nsys.exit(int(os.environ.get('SCOPE_TEST_EXIT', '0')))\n") systemd = executable("systemd-run", "import json, os, pathlib, sys\nargs = sys.argv[1:]\npathlib.Path(os.environ['SCOPE_TEST_LOG']).write_text(json.dumps(args))\nwhile args and args[0].startswith('--'): args.pop(0)\nos.execvp(args[0], args)\n") def nu(code, expected=0): result = subprocess.run([NU, "--no-config-file", "--config-home", str(config), "-c", code], env=env, text=True, capture_output=True, timeout=15) assert result.returncode == expected, (result.returncode, result.stdout, result.stderr) if expected == 0: assert not result.stderr, result.stderr return result imports = f"use '{modules / 'commands.nu'}' *; use '{modules / 'pi.nu'}'; " nu(imports + "generate-scoped-externals") generated = config / "autoload" / "90-work-scope.nu" assert generated.exists() stamp = generated.stat().st_mtime_ns nu(imports + "generate-scoped-externals") assert generated.stat().st_mtime_ns == stamp, "unchanged wrappers must not be rewritten" # Source, rather than merely inspect, the generated production definitions. launch = f"source '{generated}'; use '{modules / 'pi.nu'}'; " args = "install 'npm:example' --help -- 'a b' 0001 true" expected_args = ["install", "npm:example", "--help", "--", "a b", "0001", "true"] prefix = ["--user", "--scope", "--same-dir", "--collect", "--quiet", "--slice=work.slice"] for name in ["bun", "pi"]: result = nu(launch + name + " " + args) assert json.loads(result.stdout) == expected_args assert json.loads(scope_log.read_text()) == prefix + [name] + expected_args env["SCOPE_TEST_EXIT"] = "17" nu(launch + name + " " + args, expected=17) del env["SCOPE_TEST_EXIT"] # Native Pi subcommands never launch the external executable or enter a scope. scope_log.unlink() browser = "def 'tui run' [] { tui debug --size [80 8] --keys [enter] | ignore }; " nu(browser + launch + "pi sessions") assert not scope_log.exists() # Fail closed on both custom subcommands and aliases before replacing output. before = generated.read_bytes() for conflict in ["def 'bun custom' [] {}", "alias bun = ^bun"]: failed = nu(imports + conflict + "; generate-scoped-externals", expected=1) assert "Refusing to wrap bun" in failed.stderr assert generated.read_bytes() == before # Exercise Nu's real login/autoload ordering, including a stale Pi wrapper # from the previous generator. Never source the user's real login or secrets. # Full historical autoload snapshot: all 17 wrappers, not only Pi. legacy = (Path(__file__).parent / "fixtures" / "legacy-work-scope.nu").read_text() generated.write_text(legacy) (config / "config.nu").write_text("$env.config.show_banner = false\n") (config / "login.nu").write_text(browser + imports + "generate-scoped-externals\n") def startup(code): result = subprocess.run([NU, "--config-home", str(config), "--login", "--execute", code + "; exit"], env=env, text=True, capture_output=True, timeout=15) assert result.returncode == 0, (result.returncode, result.stdout, result.stderr) assert not result.stderr, result.stderr return result for cycle in [1, 2]: scope_log.unlink(missing_ok=True) assert json.loads(startup("pi " + args).stdout) == expected_args assert json.loads(scope_log.read_text()) == prefix + ["pi"] + expected_args assert generated.read_bytes() == before, f"startup {cycle} failed to regenerate production wrappers" scope_log.unlink() startup("pi sessions") assert not scope_log.exists(), "autoload overrode the native session browser" assert json.loads(startup("bun " + args).stdout) == expected_args assert json.loads(scope_log.read_text()) == prefix + ["bun"] + expected_args scope_log.unlink() # A genuine collision must still abort login before stale autoload can run. generated.write_text(legacy) (config / "login.nu").write_text(browser + imports + "def 'bun custom' [] {}; generate-scoped-externals\n") marker = root / "LOGIN_MUST_NOT_CONTINUE" rejected = subprocess.run( [NU, "--config-home", str(config), "--login", "--execute", f"'unexpected' | save '{marker}'; exit"], env=env, text=True, capture_output=True, timeout=15, ) assert rejected.returncode == 1, (rejected.returncode, rejected.stdout, rejected.stderr) assert "Refusing to wrap bun" in rejected.stderr assert not marker.exists() assert generated.read_text() == legacy (config / "login.nu").write_text(browser + imports + "generate-scoped-externals\n") startup("pi sessions") assert generated.read_bytes() == before # No systemd on PATH: same argument and exit semantics, without a scope. systemd.unlink() for name in ["bun", "pi"]: assert json.loads(nu(launch + name + " " + args).stdout) == expected_args env["SCOPE_TEST_EXIT"] = "17" nu(launch + name + " " + args, expected=17) del env["SCOPE_TEST_EXIT"] assert not scope_log.exists() print("PASS: generated + custom commands, scope argv, literal argv, exit codes, collision guard, idempotence, local Pi browser, legacy migration across actual login/autoload cycles, no-systemd fallback")