Buckets:
| """Local (never global) Node.js provisioning into <repo>/.node/. | |
| A system Node >= 20 is used when present; otherwise an official portable | |
| build is downloaded next to the repo (same approach run_mac.zsh already uses). | |
| Nothing is ever installed system-wide. | |
| """ | |
| import os | |
| import shutil | |
| import subprocess | |
| import tempfile | |
| from .util import ( | |
| IS_MAC, | |
| IS_WINDOWS, | |
| REPO_ROOT, | |
| clean_env, | |
| download, | |
| extract_archive, | |
| file_hash, | |
| info, | |
| ok, | |
| run, | |
| warn, | |
| which, | |
| ) | |
| NODE_DIR = os.path.join(REPO_ROOT, ".node") | |
| # Node 24 is the current LTS line and matches the dgx_instructions.md guidance. | |
| NODE_VERSION = "24.11.1" | |
| MIN_NODE_MAJOR = 20 | |
| UI_DIR = os.path.join(REPO_ROOT, "ui") | |
| UI_STATE_KEY = "ui_deps_hash" | |
| def node_bin_dir(): | |
| # windows zips have node.exe/npm.cmd at the archive root; unix under bin/ | |
| return NODE_DIR if IS_WINDOWS else os.path.join(NODE_DIR, "bin") | |
| def local_node_exe(): | |
| return os.path.join(node_bin_dir(), "node.exe" if IS_WINDOWS else "node") | |
| def _node_info(exe): | |
| """(major, arch) for a node executable, e.g. (24, 'x64'), or (None, None).""" | |
| try: | |
| out = subprocess.run( | |
| [exe, "-p", "process.version + ' ' + process.arch"], | |
| stdout=subprocess.PIPE, | |
| stderr=subprocess.DEVNULL, | |
| timeout=15, | |
| ) | |
| if out.returncode != 0: | |
| return None, None | |
| version, arch = out.stdout.decode().strip().split() # v24.11.1 x64 | |
| return int(version.lstrip("v").split(".")[0]), arch | |
| except (OSError, subprocess.TimeoutExpired, ValueError): | |
| return None, None | |
| def _usable_major(exe): | |
| """Version if this node can run the UI, else None. | |
| On Windows only an x64 node qualifies — the UI's native modules resolve | |
| for the node process arch and Prisma ships no windows-arm64 query engine, | |
| so a native ARM64 node loads the UI but dies on the first DB call. The | |
| x64 node runs under emulation on ARM hosts. | |
| """ | |
| major, arch = _node_info(exe) | |
| if major is None or major < MIN_NODE_MAJOR: | |
| return None | |
| if IS_WINDOWS and arch != "x64": | |
| return None | |
| return major | |
| def _dist_url(detection): | |
| arch = detection["arch"] | |
| if detection["os"] == "linux": | |
| plat = "linux-arm64" if arch == "aarch64" else "linux-x64" | |
| ext = "tar.xz" | |
| elif detection["os"] == "mac": | |
| plat = "darwin-arm64" if arch == "arm64" else "darwin-x64" | |
| ext = "tar.gz" | |
| elif detection["os"] == "windows": | |
| # win-x64 even on ARM hosts: Prisma has no windows-arm64 engine, so an | |
| # arm64 node can't run the UI (see _usable_major); x64 node emulates fine | |
| plat = "win-x64" | |
| ext = "zip" | |
| else: | |
| return None, None | |
| name = "node-v%s-%s" % (NODE_VERSION, plat) | |
| return "https://nodejs.org/dist/v%s/%s.%s" % (NODE_VERSION, name, ext), name | |
| def have_usable_node(): | |
| """(exe, major) for the best available node: local .node/ first, then system.""" | |
| local = local_node_exe() | |
| if os.path.isfile(local): | |
| major = _usable_major(local) | |
| if major is not None: | |
| return local, major | |
| system = which("node") | |
| if system: | |
| major = _usable_major(system) | |
| if major is not None: | |
| return system, major | |
| return None, None | |
| def ensure_node(detection, dry_run=False): | |
| exe, major = have_usable_node() | |
| if exe: | |
| ok("Node.js v%d found (%s)." % (major, exe)) | |
| return False | |
| system = which("node") | |
| if system: | |
| _, arch = _node_info(system) | |
| if IS_WINDOWS and arch and arch != "x64": | |
| info( | |
| "System Node.js is %s but the UI needs an x64 node on Windows " | |
| "(Prisma has no windows-arm64 engine) — installing a local x64 " | |
| "copy." % arch | |
| ) | |
| url, inner_name = _dist_url(detection) | |
| if url is None: | |
| warn( | |
| "No portable Node.js build for this platform — install Node >= %d manually." | |
| % MIN_NODE_MAJOR | |
| ) | |
| return False | |
| if dry_run: | |
| info( | |
| "[dry-run] would install portable Node.js v%s into %s" | |
| % (NODE_VERSION, NODE_DIR) | |
| ) | |
| return False | |
| tmp = tempfile.mkdtemp(prefix="aitk_node_") | |
| try: | |
| archive = os.path.join(tmp, os.path.basename(url)) | |
| download(url, archive, label="node v%s" % NODE_VERSION) | |
| extract_archive(archive, tmp) | |
| inner = os.path.join(tmp, inner_name) | |
| if not os.path.isdir(inner): | |
| warn("Unexpected Node.js archive layout — skipping node install.") | |
| return False | |
| if os.path.isdir(NODE_DIR): | |
| shutil.rmtree(NODE_DIR) | |
| shutil.move(inner, NODE_DIR) | |
| ok("Portable Node.js v%s installed at %s" % (NODE_VERSION, NODE_DIR)) | |
| return True | |
| finally: | |
| shutil.rmtree(tmp, ignore_errors=True) | |
| # ---------------------------------------------------------------- ui deps | |
| def npm_env(): | |
| """Scrubbed env with the local .node/ ahead of PATH.""" | |
| env = clean_env() | |
| if os.path.isdir(node_bin_dir()): | |
| env["PATH"] = node_bin_dir() + os.pathsep + env.get("PATH", "") | |
| return env | |
| def find_npm(env=None): | |
| """npm from the local .node/ copy when we installed one, else the system.""" | |
| path = (env or npm_env()).get("PATH") | |
| return shutil.which("npm.cmd" if IS_WINDOWS else "npm", path=path) | |
| def _ui_deps_hash(): | |
| return file_hash( | |
| [ | |
| os.path.join(UI_DIR, "package-lock.json"), | |
| os.path.join(UI_DIR, "package.json"), | |
| ] | |
| ) | |
| def ensure_ui_deps(env=None, dry_run=False): | |
| """Install ui/node_modules without ever rewriting ui/package-lock.json. | |
| A plain `npm install` treats the lockfile as writable and re-derives it for | |
| the machine doing the install: on Windows it strips the `libc` fields off | |
| the Linux-only optional binaries (@next/swc-linux-*, rollup, lightningcss), | |
| on Linux it puts them back. Since the UI installs on every launch, everyone | |
| ends up with a modified lockfile they never asked for — which then blocks | |
| `manager update`, because a dirty tree aborts the pull. | |
| `--no-save` keeps the resolution but stops the write-back, and stays an | |
| incremental install (seconds) rather than the full wipe-and-refetch of | |
| `npm ci`. The lockfile is snapshotted and restored regardless, so this | |
| holds even if a future npm changes what `--no-save` covers. | |
| Gated on a hash of the manifests so steady-state launches skip npm. | |
| """ | |
| from . import env as env_mod | |
| lock = os.path.join(UI_DIR, "package-lock.json") | |
| if not os.path.isfile(lock): | |
| warn("ui/package-lock.json is missing — skipping UI dependency install.") | |
| return False | |
| want = _ui_deps_hash() | |
| if env_mod.venv_exists() and env_mod.load_state().get(UI_STATE_KEY) == want: | |
| if os.path.isdir(os.path.join(UI_DIR, "node_modules")): | |
| ok("UI dependencies already installed.") | |
| return False | |
| if dry_run: | |
| info("[dry-run] would run: npm install --no-save (in %s)" % UI_DIR) | |
| return False | |
| env = env or npm_env() | |
| npm = find_npm(env) | |
| if npm is None: | |
| warn("npm not found — skipping UI dependency install.") | |
| return False | |
| info("Installing UI dependencies...") | |
| with open(lock, "rb") as f: | |
| before = f.read() | |
| code, _ = run( | |
| [npm, "install", "--no-save", "--no-audit", "--no-fund"], | |
| cwd=UI_DIR, | |
| env=env, | |
| stream=True, | |
| check=False, | |
| ) | |
| with open(lock, "rb") as f: | |
| after = f.read() | |
| if after != before: | |
| with open(lock, "wb") as f: | |
| f.write(before) | |
| info("Reverted npm's edit to ui/package-lock.json (managed by the repo).") | |
| if code != 0: | |
| warn("UI dependency install failed — the UI may not start.") | |
| return False | |
| if env_mod.venv_exists(): | |
| state = env_mod.load_state() | |
| state[UI_STATE_KEY] = want | |
| env_mod.save_state(state) | |
| ok("UI dependencies ready.") | |
| return True | |
Xet Storage Details
- Size:
- 8.09 kB
- Xet hash:
- 870eab74ac25439da7e89a5fa07fdb820784d42a34719523a52367aa72eb7422
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.