[codex] Enforce canonical Node namespace imports (#3238)

Julius Marminge committed 4 months ago

Commit 2fa37ec1 parent db2750271 files · +1205 −952Browse files

Showing the changes to apps/desktop/scripts (7 of 71 files). Show all

Unified · Split

7 files

apps/desktop/scripts/build-preview-annotation-css.mjs +16 −16
apps/desktop/scripts/dev-electron.mjs +13 −9
apps/desktop/scripts/electron-launcher.mjs +89 −73
apps/desktop/scripts/ensure-electron-runtime.mjs +34 −32
apps/desktop/scripts/smoke-test.mjs +7 −7
apps/desktop/scripts/start-electron.mjs +2 −2
apps/desktop/scripts/wait-for-resources.mjs +8 −8

apps/desktop/scripts/build-preview-annotation-css.mjs+16−16

@@ -1,23 +1,23 @@
1	import { readFile, writeFile } from "node:fs/promises";	1	import * as NodeFSP from "node:fs/promises";
2	import { createRequire } from "node:module";	2	import * as NodeModule from "node:module";
3	import { dirname, join } from "node:path";	3	import * as NodePath from "node:path";
4	import { fileURLToPath } from "node:url";	4	import * as NodeURL from "node:url";
5		5
6	import { compile } from "tailwindcss";	6	import { compile } from "tailwindcss";
7		7
8	const directory = dirname(fileURLToPath(import.meta.url));	8	const directory = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));
9	const appRoot = join(directory, "..");	9	const appRoot = NodePath.join(directory, "..");
10	const sourcePath = join(appRoot, "src", "preview", "Annotation.css");	10	const sourcePath = NodePath.join(appRoot, "src", "preview", "Annotation.css");
11	const preloadPath = join(appRoot, "src", "preview", "PickPreload.ts");	11	const preloadPath = NodePath.join(appRoot, "src", "preview", "PickPreload.ts");
12	const outputPath = join(appRoot, "src", "preview", "AnnotationStyles.generated.ts");	12	const outputPath = NodePath.join(appRoot, "src", "preview", "AnnotationStyles.generated.ts");
13	const require = createRequire(import.meta.url);	13	const require = NodeModule.createRequire(import.meta.url);
14	const tailwindRoot = dirname(require.resolve("tailwindcss/package.json"));	14	const tailwindRoot = NodePath.dirname(require.resolve("tailwindcss/package.json"));
15		15
16	const [annotationSource, preloadSource, themeSource, preflightSource] = await Promise.all([	16	const [annotationSource, preloadSource, themeSource, preflightSource] = await Promise.all([
17	readFile(sourcePath, "utf8"),	17	NodeFSP.readFile(sourcePath, "utf8"),
18	readFile(preloadPath, "utf8"),	18	NodeFSP.readFile(preloadPath, "utf8"),
19	readFile(join(tailwindRoot, "theme.css"), "utf8"),	19	NodeFSP.readFile(NodePath.join(tailwindRoot, "theme.css"), "utf8"),
20	readFile(join(tailwindRoot, "preflight.css"), "utf8"),	20	NodeFSP.readFile(NodePath.join(tailwindRoot, "preflight.css"), "utf8"),
21	]);	21	]);
22		22
23	const candidates = new Set(	23	const candidates = new Set(
@@ -37,4 +37,4 @@ const encodedCss = `'${css · 13 unmodified lines
37	.replaceAll("\n", "\\n")}'`;	37	.replaceAll("\n", "\\n")}'`;
38	const moduleSource = `// Generated by scripts/build-preview-annotation-css.mjs. Do not edit.\nexport const previewAnnotationStyles =\n ${encodedCss};\n`;	38	const moduleSource = `// Generated by scripts/build-preview-annotation-css.mjs. Do not edit.\nexport const previewAnnotationStyles =\n ${encodedCss};\n`;
39		39
40	await writeFile(outputPath, moduleSource);	40	await NodeFSP.writeFile(outputPath, moduleSource);

apps/desktop/scripts/dev-electron.mjs+13−9

-import { spawn, spawnSync } from "node:child_process";
+import * as NodeChildProcess from "node:child_process";
-import { watch } from "node:fs";
+import * as NodeFS from "node:fs";
 import * as NodeOS from "node:os";
-import { join } from "node:path";
+import * as NodePath from "node:path";
 import {
   desktopDir,
     return;
   }
-  spawnSync("pkill", [`-${signal}`, "-P", String(pid)], { stdio: "ignore" });
+  NodeChildProcess.spawnSync("pkill", [`-${signal}`, "-P", String(pid)], { stdio: "ignore" });
 }
 function cleanupStaleDevApps() {
     return;
   }
-  spawnSync("pkill", ["-f", "--", `--t3code-dev-root=${desktopDir}`], { stdio: "ignore" });
+  NodeChildProcess.spawnSync("pkill", ["-f", "--", `--t3code-dev-root=${desktopDir}`], {
+    stdio: "ignore",
+  });
 }
 function startApp() {
     ? electronArgs
     : [...electronArgs, `--t3code-dev-root=${desktopDir}`, "dist-electron/main.cjs"];
   const electronCommand = resolveElectronLaunchCommand(launchArgs);
-  const app = spawn(electronCommand.electronPath, electronCommand.args, {
+  const app = NodeChildProcess.spawn(electronCommand.electronPath, electronCommand.args, {
     cwd: desktopDir,
     env: childEnv,
     stdio: "inherit",
 function startWatchers() {
   for (const { directory, files } of watchedDirectories) {
-    const watcher = watch(
+    const watcher = NodeFS.watch(
-      join(desktopDir, directory),
+      NodePath.join(desktopDir, directory),
       { persistent: true },
       (_eventType, filename) => {
         if (typeof filename !== "string" || !files.has(filename)) {
   }
   // Kill direct children as a final fallback in case normal shutdown leaves stragglers.
-  spawnSync("pkill", [`-${signal}`, "-P", String(process.pid)], { stdio: "ignore" });
+  NodeChildProcess.spawnSync("pkill", [`-${signal}`, "-P", String(process.pid)], {
+    stdio: "ignore",
+  });
 }
 async function shutdown(exitCode) {

apps/desktop/scripts/electron-launcher.mjs+89−73

 // This file mostly exists because we want dev mode to say "T3 Code (Dev)" instead of "electron"
-import { spawnSync } from "node:child_process";
+import * as NodeChildProcess from "node:child_process";
-import {
+import * as NodeFS from "node:fs";
-  copyFileSync,
+import * as NodeModule from "node:module";
-  chmodSync,
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { createRequire } from "node:module";
 import * as NodeOS from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import * as NodePath from "node:path";
-import { fileURLToPath } from "node:url";
+import * as NodeURL from "node:url";
 import { ensureElectronRuntime } from "./ensure-electron-runtime.mjs";
 const isDevelopment = Boolean(process.env.VITE_DEV_SERVER_URL);
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));
-export const desktopDir = resolve(__dirname, "..");
+export const desktopDir = NodePath.resolve(__dirname, "..");
-const repoRoot = resolve(desktopDir, "..", "..");
+const repoRoot = NodePath.resolve(desktopDir, "..", "..");
-const devBundleIdSuffix = basename(repoRoot)
+const devBundleIdSuffix = NodePath.basename(repoRoot)
   .toLowerCase()
   .replaceAll(/[^a-z0-9]+/g, "");
 export const APP_DISPLAY_NAME = isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)";
   : "com.t3tools.t3code";
 const APP_PROTOCOL_SCHEMES = isDevelopment ? ["t3code-dev"] : ["t3code"];
 const LAUNCHER_VERSION = 12;
-const defaultIconPath = join(desktopDir, "resources", "icon.icns");
+const defaultIconPath = NodePath.join(desktopDir, "resources", "icon.icns");
-const developmentMacIconPngPath = join(repoRoot, "assets", "dev", "blueprint-macos-1024.png");
+const developmentMacIconPngPath = NodePath.join(
+  repoRoot,
+  "assets",
+  "dev",
+  "blueprint-macos-1024.png",
+);
 // oxlint-disable-next-line t3code/no-global-process-runtime -- Standalone launcher script has no Effect runtime.
 const hostPlatform = NodeOS.platform();
 function setPlistString(plistPath, key, value) {
-  const replaceResult = spawnSync("plutil", ["-replace", key, "-string", value, plistPath], {
+  const replaceResult = NodeChildProcess.spawnSync(
-    encoding: "utf8",
+    "plutil",
-  });
+    ["-replace", key, "-string", value, plistPath],
+    {
+      encoding: "utf8",
+    },
+  );
   if (replaceResult.status === 0) {
     return;
   }
-  const insertResult = spawnSync("plutil", ["-insert", key, "-string", value, plistPath], {
+  const insertResult = NodeChildProcess.spawnSync(
-    encoding: "utf8",
+    "plutil",
-  });
+    ["-insert", key, "-string", value, plistPath],
+    {
+      encoding: "utf8",
+    },
+  );
   if (insertResult.status === 0) {
     return;
   }
 function setPlistJson(plistPath, key, value) {
   const serialized = JSON.stringify(value);
-  const replaceResult = spawnSync("plutil", ["-replace", key, "-json", serialized, plistPath], {
+  const replaceResult = NodeChildProcess.spawnSync(
-    encoding: "utf8",
+    "plutil",
-  });
+    ["-replace", key, "-json", serialized, plistPath],
+    {
+      encoding: "utf8",
+    },
+  );
   if (replaceResult.status === 0) {
     return;
   }
-  const insertResult = spawnSync("plutil", ["-insert", key, "-json", serialized, plistPath], {
+  const insertResult = NodeChildProcess.spawnSync(
-    encoding: "utf8",
+    "plutil",
-  });
+    ["-insert", key, "-json", serialized, plistPath],
+    {
+      encoding: "utf8",
+    },
+  );
   if (insertResult.status === 0) {
     return;
   }
 }
 function runChecked(command, args) {
-  const result = spawnSync(command, args, { encoding: "utf8" });
+  const result = NodeChildProcess.spawnSync(command, args, { encoding: "utf8" });
   if (result.status === 0) {
     return;
   }
 }
 function writeDevelopmentLauncherScript(targetBinaryPath, electronBinaryPath) {
-  const mainEntryPath = join(desktopDir, "dist-electron", "main.cjs");
+  const mainEntryPath = NodePath.join(desktopDir, "dist-electron", "main.cjs");
   const envEntries = [
     ["VITE_DEV_SERVER_URL", process.env.VITE_DEV_SERVER_URL],
     ["T3CODE_PORT", process.env.T3CODE_PORT],
     ["T3CODE_OTLP_EXPORT_INTERVAL_MS", process.env.T3CODE_OTLP_EXPORT_INTERVAL_MS],
     ["T3CODE_DESKTOP_APP_USER_MODEL_ID", APP_BUNDLE_ID],
   ].filter((entry) => typeof entry[1] === "string" && entry[1].trim().length > 0);
-  writeFileSync(
+  NodeFS.writeFileSync(
     targetBinaryPath,
     [
       "#!/bin/sh",
       "",
     ].join("\n"),
   );
-  chmodSync(targetBinaryPath, 0o755);
+  NodeFS.chmodSync(targetBinaryPath, 0o755);
 }
 function registerMacLauncherBundle(appBundlePath) {
 }
 function ensureDevelopmentIconIcns(runtimeDir) {
-  const generatedIconPath = join(runtimeDir, "icon-dev.icns");
+  const generatedIconPath = NodePath.join(runtimeDir, "icon-dev.icns");
-  mkdirSync(runtimeDir, { recursive: true });
+  NodeFS.mkdirSync(runtimeDir, { recursive: true });
-  if (!existsSync(developmentMacIconPngPath)) {
+  if (!NodeFS.existsSync(developmentMacIconPngPath)) {
     return defaultIconPath;
   }
-  const sourceMtimeMs = statSync(developmentMacIconPngPath).mtimeMs;
+  const sourceMtimeMs = NodeFS.statSync(developmentMacIconPngPath).mtimeMs;
-  if (existsSync(generatedIconPath) && statSync(generatedIconPath).mtimeMs >= sourceMtimeMs) {
+  if (
+    NodeFS.existsSync(generatedIconPath) &&
+    NodeFS.statSync(generatedIconPath).mtimeMs >= sourceMtimeMs
+  ) {
     return generatedIconPath;
   }
-  const iconsetRoot = mkdtempSync(join(runtimeDir, "dev-iconset-"));
+  const iconsetRoot = NodeFS.mkdtempSync(NodePath.join(runtimeDir, "dev-iconset-"));
-  const iconsetDir = join(iconsetRoot, "icon.iconset");
+  const iconsetDir = NodePath.join(iconsetRoot, "icon.iconset");
-  mkdirSync(iconsetDir, { recursive: true });
+  NodeFS.mkdirSync(iconsetDir, { recursive: true });
   try {
     for (const size of [16, 32, 128, 256, 512]) {
         String(size),
         developmentMacIconPngPath,
         "--out",
-        join(iconsetDir, `icon_${size}x${size}.png`),
+        NodePath.join(iconsetDir, `icon_${size}x${size}.png`),
       ]);
       const retinaSize = size * 2;
         String(retinaSize),
         developmentMacIconPngPath,
         "--out",
-        join(iconsetDir, `icon_${size}x${size}@2x.png`),
+        NodePath.join(iconsetDir, `icon_${size}x${size}@2x.png`),
       ]);
     }
     );
     return defaultIconPath;
   } finally {
-    rmSync(iconsetRoot, { recursive: true, force: true });
+    NodeFS.rmSync(iconsetRoot, { recursive: true, force: true });
   }
 }
 function patchMainBundleInfoPlist(appBundlePath, iconPath) {
-  const infoPlistPath = join(appBundlePath, "Contents", "Info.plist");
+  const infoPlistPath = NodePath.join(appBundlePath, "Contents", "Info.plist");
   setPlistString(infoPlistPath, "CFBundleDisplayName", APP_DISPLAY_NAME);
   setPlistString(infoPlistPath, "CFBundleName", APP_DISPLAY_NAME);
   setPlistString(infoPlistPath, "CFBundleIdentifier", APP_BUNDLE_ID);
     },
   ]);
-  const resourcesDir = join(appBundlePath, "Contents", "Resources");
+  const resourcesDir = NodePath.join(appBundlePath, "Contents", "Resources");
-  copyFileSync(iconPath, join(resourcesDir, "icon.icns"));
+  NodeFS.copyFileSync(iconPath, NodePath.join(resourcesDir, "icon.icns"));
-  copyFileSync(iconPath, join(resourcesDir, "electron.icns"));
+  NodeFS.copyFileSync(iconPath, NodePath.join(resourcesDir, "electron.icns"));
 }
 function patchHelperBundleInfoPlists(appBundlePath) {
   ];
   for (const [bundleName, bundleIdentifierSuffix, bundleDisplayName] of helperBundleNames) {
-    const infoPlistPath = join(
+    const infoPlistPath = NodePath.join(
       appBundlePath,
       "Contents",
       "Frameworks",
       "Contents",
       "Info.plist",
     );
-    if (!existsSync(infoPlistPath)) {
+    if (!NodeFS.existsSync(infoPlistPath)) {
       continue;
     }
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
+    return JSON.parse(NodeFS.readFileSync(path, "utf8"));
   } catch {
     return null;
   }
 }
 function buildMacLauncher(electronBinaryPath) {
-  const sourceAppBundlePath = resolve(dirname(electronBinaryPath), "../..");
+  const sourceAppBundlePath = NodePath.resolve(NodePath.dirname(electronBinaryPath), "../..");
-  const runtimeDir = join(desktopDir, ".electron-runtime");
+  const runtimeDir = NodePath.join(desktopDir, ".electron-runtime");
-  const targetAppBundlePath = join(runtimeDir, `${APP_DISPLAY_NAME}.app`);
+  const targetAppBundlePath = NodePath.join(runtimeDir, `${APP_DISPLAY_NAME}.app`);
-  const targetBinaryPath = join(targetAppBundlePath, "Contents", "MacOS", "Electron");
+  const targetBinaryPath = NodePath.join(targetAppBundlePath, "Contents", "MacOS", "Electron");
   const iconPath = isDevelopment ? ensureDevelopmentIconIcns(runtimeDir) : defaultIconPath;
-  const metadataPath = join(runtimeDir, "metadata.json");
+  const metadataPath = NodePath.join(runtimeDir, "metadata.json");
-  mkdirSync(runtimeDir, { recursive: true });
+  NodeFS.mkdirSync(runtimeDir, { recursive: true });
   const expectedMetadata = {
     launcherVersion: LAUNCHER_VERSION,
     sourceAppBundlePath,
-    sourceAppMtimeMs: statSync(sourceAppBundlePath).mtimeMs,
+    sourceAppMtimeMs: NodeFS.statSync(sourceAppBundlePath).mtimeMs,
-    iconMtimeMs: statSync(iconPath).mtimeMs,
+    iconMtimeMs: NodeFS.statSync(iconPath).mtimeMs,
     appBundleId: APP_BUNDLE_ID,
     appProtocolSchemes: APP_PROTOCOL_SCHEMES,
   };
   const currentMetadata = readJson(metadataPath);
   if (
-    existsSync(targetBinaryPath) &&
+    NodeFS.existsSync(targetBinaryPath) &&
     currentMetadata &&
     JSON.stringify(currentMetadata) === JSON.stringify(expectedMetadata)
   ) {
     return targetBinaryPath;
   }
-  rmSync(targetAppBundlePath, { recursive: true, force: true });
+  NodeFS.rmSync(targetAppBundlePath, { recursive: true, force: true });
   // verbatimSymlinks keeps the framework's relative symlinks intact
   // (e.g. Resources -> Versions/Current/Resources). Without it cpSync
   // rewrites them to absolute paths into node_modules, which escape the
   // bundle and crash sandboxed helper processes (icudtl.dat not found).
-  cpSync(sourceAppBundlePath, targetAppBundlePath, { recursive: true, verbatimSymlinks: true });
+  NodeFS.cpSync(sourceAppBundlePath, targetAppBundlePath, {
+    recursive: true,
+    verbatimSymlinks: true,
+  });
   patchMainBundleInfoPlist(targetAppBundlePath, iconPath);
   patchHelperBundleInfoPlists(targetAppBundlePath);
   if (isDevelopment) {
     writeDevelopmentLauncherScript(targetBinaryPath, electronBinaryPath);
   }
-  writeFileSync(metadataPath, `${JSON.stringify(expectedMetadata, null, 2)}\n`);
+  NodeFS.writeFileSync(metadataPath, `${JSON.stringify(expectedMetadata, null, 2)}\n`);
   registerMacLauncherBundle(targetAppBundlePath);
   return targetBinaryPath;
     return true;
   }
-  const sandboxPath = join(dirname(electronBinaryPath), "chrome-sandbox");
+  const sandboxPath = NodePath.join(NodePath.dirname(electronBinaryPath), "chrome-sandbox");
   try {
-    const sandboxStat = statSync(sandboxPath);
+    const sandboxStat = NodeFS.statSync(sandboxPath);
     return sandboxStat.uid === 0 && (sandboxStat.mode & 0o4777) === 0o4755;
   } catch {
     return false;
 export function resolveElectronPath() {
   ensureElectronRuntime();
-  const require = createRequire(import.meta.url);
+  const require = NodeModule.createRequire(import.meta.url);
   const electronBinaryPath = require("electron");
   if (hostPlatform !== "darwin") {
     return null;
   }
-  const require = createRequire(import.meta.url);
+  const require = NodeModule.createRequire(import.meta.url);
   const electronBinaryPath = require("electron");
   const launcherBinaryPath = buildMacLauncher(electronBinaryPath);
   return {
-    appBundlePath: resolve(launcherBinaryPath, "..", "..", ".."),
+    appBundlePath: NodePath.resolve(launcherBinaryPath, "..", "..", ".."),
     appBundleId: APP_BUNDLE_ID,
   };
 }

apps/desktop/scripts/ensure-electron-runtime.mjs+34−32

-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import * as NodeFS from "node:fs";
-import { createRequire } from "node:module";
+import * as NodeModule from "node:module";
-import { arch, platform, tmpdir } from "node:os";
+import * as NodeOS from "node:os";
-import { dirname, join } from "node:path";
+import * as NodePath from "node:path";
-import { spawnSync } from "node:child_process";
+import * as NodeChildProcess from "node:child_process";
-const require = createRequire(import.meta.url);
+const require = NodeModule.createRequire(import.meta.url);
 // oxlint-disable-next-line t3code/no-global-process-runtime -- Standalone repair script has no Effect runtime.
-const hostPlatform = platform();
+const hostPlatform = NodeOS.platform();
 // oxlint-disable-next-line t3code/no-global-process-runtime -- Standalone repair script has no Effect runtime.
-const hostArch = arch();
+const hostArch = NodeOS.arch();
 function getPlatformPath() {
   switch (hostPlatform) {
 function ensureExecutable(filePath) {
   if (hostPlatform !== "win32") {
-    chmodSync(filePath, 0o755);
+    NodeFS.chmodSync(filePath, 0o755);
   }
 }
 function repairPathFile(electronDir, platformPath) {
-  const pathFile = join(electronDir, "path.txt");
+  const pathFile = NodePath.join(electronDir, "path.txt");
-  const currentPath = existsSync(pathFile) ? readFileSync(pathFile, "utf8") : undefined;
+  const currentPath = NodeFS.existsSync(pathFile)
+    ? NodeFS.readFileSync(pathFile, "utf8")
+    : undefined;
   if (currentPath !== platformPath) {
-    writeFileSync(pathFile, platformPath);
+    NodeFS.writeFileSync(pathFile, platformPath);
   }
 }
 function getRequiredRuntimePaths(electronDir, platformPath) {
-  const paths = [join(electronDir, "dist", platformPath)];
+  const paths = [NodePath.join(electronDir, "dist", platformPath)];
   if (hostPlatform === "darwin") {
     paths.push(
-      join(electronDir, "dist", "Electron.app", "Contents", "Info.plist"),
+      NodePath.join(electronDir, "dist", "Electron.app", "Contents", "Info.plist"),
-      join(
+      NodePath.join(
         electronDir,
         "dist",
         "Electron.app",
     return true;
   }
-  const result = spawnSync("file", ["-b", filePath], {
+  const result = NodeChildProcess.spawnSync("file", ["-b", filePath], {
     encoding: "utf8",
   });
 function missingRuntimePaths(electronDir, platformPath) {
   return getRequiredRuntimePaths(electronDir, platformPath).filter((runtimePath) => {
-    return !existsSync(runtimePath);
+    return !NodeFS.existsSync(runtimePath);
   });
 }
   }
   return [
-    join(electronDir, "dist", platformPath),
+    NodePath.join(electronDir, "dist", platformPath),
-    join(
+    NodePath.join(
       electronDir,
       "dist",
       "Electron.app",
       "Electron Framework.framework",
       "Electron Framework",
     ),
-  ].filter((runtimePath) => existsSync(runtimePath) && !isMachO(runtimePath));
+  ].filter((runtimePath) => NodeFS.existsSync(runtimePath) && !isMachO(runtimePath));
 }
 function runChecked(command, args) {
-  const result = spawnSync(command, args, {
+  const result = NodeChildProcess.spawnSync(command, args, {
     encoding: "utf8",
     stdio: "inherit",
   });
 }
 function installElectronRuntime(electronDir, version) {
-  const tempDir = mkdtempSync(join(tmpdir(), "t3-electron-"));
+  const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-electron-"));
-  const zipPath = join(tempDir, `electron-v${version}-${hostPlatform}-${hostArch}.zip`);
+  const zipPath = NodePath.join(tempDir, `electron-v${version}-${hostPlatform}-${hostArch}.zip`);
   try {
     runChecked("curl", [
       zipPath,
     ]);
     if (hostPlatform === "darwin") {
-      runChecked("ditto", ["-x", "-k", zipPath, join(electronDir, "dist")]);
+      runChecked("ditto", ["-x", "-k", zipPath, NodePath.join(electronDir, "dist")]);
     } else {
       runChecked("python3", [
         "-c",
         "import os, sys, zipfile; os.makedirs(sys.argv[2], exist_ok=True); zipfile.ZipFile(sys.argv[1]).extractall(sys.argv[2])",
         zipPath,
-        join(electronDir, "dist"),
+        NodePath.join(electronDir, "dist"),
       ]);
     }
   } finally {
-    rmSync(tempDir, { recursive: true, force: true });
+    NodeFS.rmSync(tempDir, { recursive: true, force: true });
   }
 }
 export function ensureElectronRuntime() {
   const electronPackageJsonPath = require.resolve("electron/package.json");
-  const electronPackageJson = JSON.parse(readFileSync(electronPackageJsonPath, "utf8"));
+  const electronPackageJson = JSON.parse(NodeFS.readFileSync(electronPackageJsonPath, "utf8"));
-  const electronDir = dirname(electronPackageJsonPath);
+  const electronDir = NodePath.dirname(electronPackageJsonPath);
   const platformPath = getPlatformPath();
-  const electronPath = join(electronDir, "dist", platformPath);
+  const electronPath = NodePath.join(electronDir, "dist", platformPath);
   const missingBeforeInstall = missingRuntimePaths(electronDir, platformPath);
   const invalidBeforeInstall = invalidRuntimePaths(electronDir, platformPath);
   if (missingBeforeInstall.length > 0 || invalidBeforeInstall.length > 0) {
-    if (existsSync(join(electronDir, "dist"))) {
+    if (NodeFS.existsSync(NodePath.join(electronDir, "dist"))) {
-      rmSync(join(electronDir, "dist"), { recursive: true, force: true });
+      NodeFS.rmSync(NodePath.join(electronDir, "dist"), { recursive: true, force: true });
     }
-    rmSync(join(electronDir, "path.txt"), { force: true });
+    NodeFS.rmSync(NodePath.join(electronDir, "path.txt"), { force: true });
     installElectronRuntime(electronDir, electronPackageJson.version);
   }

apps/desktop/scripts/smoke-test.mjs+7−7

@@ -1,16 +1,16 @@
1	import { spawn } from "node:child_process";	1	import * as NodeChildProcess from "node:child_process";
2	import { dirname, resolve } from "node:path";	2	import * as NodePath from "node:path";
3	import { fileURLToPath } from "node:url";	3	import * as NodeURL from "node:url";
4	import { resolveElectronLaunchCommand } from "./electron-launcher.mjs";	4	import { resolveElectronLaunchCommand } from "./electron-launcher.mjs";
5		5
6	const __dirname = dirname(fileURLToPath(import.meta.url));	6	const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));
7	const desktopDir = resolve(__dirname, "..");	7	const desktopDir = NodePath.resolve(__dirname, "..");
8	const mainJs = resolve(desktopDir, "dist-electron/main.cjs");	8	const mainJs = NodePath.resolve(desktopDir, "dist-electron/main.cjs");
9		9
10	console.log("\nLaunching Electron smoke test...");	10	console.log("\nLaunching Electron smoke test...");
11		11
12	const electronCommand = resolveElectronLaunchCommand([mainJs]);	12	const electronCommand = resolveElectronLaunchCommand([mainJs]);
13	const child = spawn(electronCommand.electronPath, electronCommand.args, {	13	const child = NodeChildProcess.spawn(electronCommand.electronPath, electronCommand.args, {
14	stdio: ["pipe", "pipe", "pipe"],	14	stdio: ["pipe", "pipe", "pipe"],
15	env: {	15	env: {
16	...process.env,	16	...process.env,

apps/desktop/scripts/start-electron.mjs+2−2

@@ -1,4 +1,4 @@
1	import { spawn } from "node:child_process";	1	import * as NodeChildProcess from "node:child_process";
2		2
3	import { desktopDir, resolveElectronLaunchCommand } from "./electron-launcher.mjs";	3	import { desktopDir, resolveElectronLaunchCommand } from "./electron-launcher.mjs";
4		4
@@ -6,7 +6,7 @@ const childEnv = { ...process.env }; · 1 unmodified line
6	delete childEnv.ELECTRON_RUN_AS_NODE;	6	delete childEnv.ELECTRON_RUN_AS_NODE;
7		7
8	const electronCommand = resolveElectronLaunchCommand(["dist-electron/main.cjs"]);	8	const electronCommand = resolveElectronLaunchCommand(["dist-electron/main.cjs"]);
9	const child = spawn(electronCommand.electronPath, electronCommand.args, {	9	const child = NodeChildProcess.spawn(electronCommand.electronPath, electronCommand.args, {
10	stdio: "inherit",	10	stdio: "inherit",
11	cwd: desktopDir,	11	cwd: desktopDir,
12	env: childEnv,	12	env: childEnv,

apps/desktop/scripts/wait-for-resources.mjs+8−8

@@ -1,13 +1,13 @@
1	import * as FileSystem from "node:fs/promises";	1	import * as NodeFSP from "node:fs/promises";
2	import * as Net from "node:net";	2	import * as NodeNet from "node:net";
3	import * as Path from "node:path";	3	import * as NodePath from "node:path";
4	import * as Timers from "node:timers/promises";	4	import * as NodeTimersPromises from "node:timers/promises";
5		5
6	const defaultTcpHosts = ["127.0.0.1", "localhost", "::1"];	6	const defaultTcpHosts = ["127.0.0.1", "localhost", "::1"];
7		7
8	async function fileExists(filePath) {	8	async function fileExists(filePath) {
9	try {	9	try {
10	await FileSystem.access(filePath);	10	await NodeFSP.access(filePath);
11	return true;	11	return true;
12	} catch {	12	} catch {
13	return false;	13	return false;
@@ -16,7 +16,7 @@ async function fileExists(filePath) { · 2 unmodified lines
16		16
17	function tcpPortIsReady({ host, port, connectTimeoutMs = 500 }) {	17	function tcpPortIsReady({ host, port, connectTimeoutMs = 500 }) {
18	return new Promise((resolveReady) => {	18	return new Promise((resolveReady) => {
19	const socket = Net.createConnection({ host, port });	19	const socket = NodeNet.createConnection({ host, port });
20	let settled = false;	20	let settled = false;
21		21
22	const finish = (ready) => {	22	const finish = (ready) => {
@@ -47,7 +47,7 @@ async function resolvePendingResources({ baseDir, files, tcpPort, tcpHosts, conn · 24 unmodified lines
47	const pendingFiles = [];	47	const pendingFiles = [];
48		48
49	for (const relativeFilePath of files) {	49	for (const relativeFilePath of files) {
50	const ready = await fileExists(Path.resolve(baseDir, relativeFilePath));	50	const ready = await fileExists(NodePath.resolve(baseDir, relativeFilePath));
51	if (!ready) {	51	if (!ready) {
52	pendingFiles.push(relativeFilePath);	52	pendingFiles.push(relativeFilePath);
53	}	53	}
@@ -114,6 +114,6 @@ export async function waitForResources({ · 60 unmodified lines
114	);	114	);
115	}	115	}
116		116
117	await Timers.setTimeout(intervalMs);	117	await NodeTimersPromises.setTimeout(intervalMs);
118	}	118	}
119	}	119	}