@atls/raijin 0.2.0 → 0.2.2

package/dist/initializer/index.js

@@ -1,7 +1,7 @@
 import { RaijinInitializerUsageException } from './exceptions/usage.js';
 import { installRaijinRuntime } from '../runtime/installer.js';
 import { runYarnCommand } from '../yarn/command.js';
-import { ensurePackageJson } from './project.js';
+import { ensurePackageManifest } from './project.js';
 import { ensureYarnLock } from './project.js';
 const CODE_RUNTIME_PACKAGE = '@atls/code-runtime@latest';
 export const runRaijinInitializer = async ({ argv = [], cwd = process.cwd(), fetchImpl = fetch, runYarnCommand: runCommand = runYarnCommand, } = {}) => {
@@ -9,9 +9,9 @@ export const runRaijinInitializer = async ({ argv = [], cwd = process.cwd(), fet
     if (argv.length > 1 || (command && command !== 'init')) {
         throw new RaijinInitializerUsageException();
     }
-    await ensurePackageJson(cwd);
+    const runtimeManifest = await installRaijinRuntime({ cwd, fetchImpl });
+    await ensurePackageManifest(cwd, runtimeManifest.packageManager);
     await ensureYarnLock(cwd);
-    await installRaijinRuntime({ cwd, fetchImpl });
     await runCommand(['add', '-D', CODE_RUNTIME_PACKAGE], cwd);
     await runCommand(['generate', 'project'], cwd);
     await runCommand(['tools', 'sync'], cwd);

package/dist/initializer/project.d.ts

@@ -1,5 +1,5 @@
 export declare const getPackageName: (cwd: string) => string;
 export declare const hasPackageJson: (cwd: string) => Promise<boolean>;
 export declare const hasYarnLock: (cwd: string) => Promise<boolean>;
-export declare const ensurePackageJson: (cwd: string) => Promise<void>;
+export declare const ensurePackageManifest: (cwd: string, packageManager: string) => Promise<void>;
 export declare const ensureYarnLock: (cwd: string) => Promise<void>;

package/dist/initializer/project.js

@@ -1,4 +1,5 @@
 import { access } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { writeFile } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { join } from 'node:path';
@@ -28,11 +29,25 @@ const hasProjectFile = async (cwd, fileName) => {
 };
 export const hasPackageJson = async (cwd) => hasProjectFile(cwd, PACKAGE_JSON);
 export const hasYarnLock = async (cwd) => hasProjectFile(cwd, YARN_LOCK);
-export const ensurePackageJson = async (cwd) => {
-    if (await hasPackageJson(cwd)) {
+const writePackageManifest = async (cwd, manifest) => {
+    await writeFile(join(cwd, PACKAGE_JSON), `${JSON.stringify(manifest, null, 2)}\n`);
+};
+export const ensurePackageManifest = async (cwd, packageManager) => {
+    if (!(await hasPackageJson(cwd))) {
+        await writePackageManifest(cwd, {
+            name: getPackageName(cwd),
+            packageManager,
+        });
+        return;
+    }
+    const manifest = JSON.parse(await readFile(join(cwd, PACKAGE_JSON), 'utf-8'));
+    if (manifest.packageManager === packageManager) {
         return;
     }
-    await writeFile(join(cwd, PACKAGE_JSON), `${JSON.stringify({ name: getPackageName(cwd) }, null, 2)}\n`);
+    await writePackageManifest(cwd, {
+        ...manifest,
+        packageManager,
+    });
 };
 export const ensureYarnLock = async (cwd) => {
     if (await hasYarnLock(cwd)) {

package/dist/runtime/index.d.ts

@@ -11,3 +11,4 @@ export { RAIJIN_RUNTIME_ASSET_NAME } from './manifest.js';
 export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from './manifest.js';
 export { RAIJIN_RUNTIME_MANIFEST_URL } from './manifest.js';
 export { RAIJIN_RUNTIME_PACKAGE_NAME } from './manifest.js';
+export { RAIJIN_RUNTIME_YARN_PATH } from './manifest.js';

package/dist/runtime/index.js

@@ -8,3 +8,4 @@ export { RAIJIN_RUNTIME_ASSET_NAME } from "./manifest.js";
 export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from "./manifest.js";
 export { RAIJIN_RUNTIME_MANIFEST_URL } from "./manifest.js";
 export { RAIJIN_RUNTIME_PACKAGE_NAME } from "./manifest.js";
+export { RAIJIN_RUNTIME_YARN_PATH } from "./manifest.js";

package/dist/runtime/installer.js

@@ -1,4 +1,7 @@
+import { randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
+import { rename } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { join } from 'node:path';
@@ -8,6 +11,18 @@ import { downloadRaijinRuntime } from './download.js';
 import { fetchRaijinRuntimeManifest } from './download.js';
 import { createSha256Digest } from './manifest.js';
 import { getRaijinRuntimeYarnPath } from './manifest.js';
+const TEMPORARY_RUNTIME_FILE_EXTENSION = '.tmp';
+const writeRuntimeFileAtomically = async (runtimePath, runtime) => {
+    const temporaryRuntimePath = `${runtimePath}.${process.pid}.${randomUUID()}${TEMPORARY_RUNTIME_FILE_EXTENSION}`;
+    try {
+        await writeFile(temporaryRuntimePath, runtime);
+        await rename(temporaryRuntimePath, runtimePath);
+    }
+    catch (error) {
+        await rm(temporaryRuntimePath, { force: true });
+        throw error;
+    }
+};
 export const installRaijinRuntime = async ({ cwd, fetchImpl, }) => {
     const manifest = await fetchRaijinRuntimeManifest(fetchImpl);
     const runtime = await downloadRaijinRuntime(fetchImpl, manifest);
@@ -15,10 +30,10 @@ export const installRaijinRuntime = async ({ cwd, fetchImpl, }) => {
     if (digest !== manifest.sha256) {
         throw new RaijinRuntimeDigestMismatchException(manifest.sha256, digest);
     }
-    const yarnPath = getRaijinRuntimeYarnPath(manifest);
+    const yarnPath = getRaijinRuntimeYarnPath();
     const runtimePath = join(cwd, yarnPath);
     await mkdir(dirname(runtimePath), { recursive: true });
-    await writeFile(runtimePath, runtime);
+    await writeRuntimeFileAtomically(runtimePath, runtime);
     await writeBootstrapConfiguration(cwd, yarnPath);
     return manifest;
 };

package/dist/runtime/manifest.d.ts

@@ -2,6 +2,7 @@ export interface RaijinRuntimeManifest {
     assetName: string;
     assetUrl: string;
     packageName: string;
+    packageManager: string;
     schemaVersion: number;
     sha256: string;
     tagName: string;
@@ -10,7 +11,8 @@ export interface RaijinRuntimeManifest {
 export declare const RAIJIN_RUNTIME_MANIFEST_URL = "https://raw.githubusercontent.com/atls/raijin/master/.yarn/releases/raijin-runtime.json";
 export declare const RAIJIN_RUNTIME_PACKAGE_NAME = "@atls/yarn-cli";
 export declare const RAIJIN_RUNTIME_ASSET_NAME = "yarn.mjs";
+export declare const RAIJIN_RUNTIME_YARN_PATH = ".yarn/releases/yarn.mjs";
 export declare const RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION = 1;
 export declare const parseRaijinRuntimeManifest: (value: unknown) => RaijinRuntimeManifest;
 export declare const createSha256Digest: (data: Buffer) => string;
-export declare const getRaijinRuntimeYarnPath: (manifest: RaijinRuntimeManifest) => string;
+export declare const getRaijinRuntimeYarnPath: () => string;

package/dist/runtime/manifest.js

@@ -3,6 +3,7 @@ import { InvalidRaijinRuntimeManifestException } from './exceptions/invalid-mani
 export const RAIJIN_RUNTIME_MANIFEST_URL = 'https://raw.githubusercontent.com/atls/raijin/master/.yarn/releases/raijin-runtime.json';
 export const RAIJIN_RUNTIME_PACKAGE_NAME = '@atls/yarn-cli';
 export const RAIJIN_RUNTIME_ASSET_NAME = 'yarn.mjs';
+export const RAIJIN_RUNTIME_YARN_PATH = '.yarn/releases/yarn.mjs';
 export const RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION = 1;
 const SHA256_PATTERN = /^[a-f0-9]{64}$/;
 const isRecord = (value) => typeof value === 'object' && value !== null;
@@ -36,6 +37,7 @@ export const parseRaijinRuntimeManifest = (value) => {
         assetName,
         assetUrl: assertManifestString(value, 'assetUrl'),
         packageName,
+        packageManager: assertManifestString(value, 'packageManager'),
         schemaVersion: RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION,
         sha256,
         tagName: assertManifestString(value, 'tagName'),
@@ -43,4 +45,4 @@ export const parseRaijinRuntimeManifest = (value) => {
     };
 };
 export const createSha256Digest = (data) => createHash('sha256').update(data).digest('hex');
-export const getRaijinRuntimeYarnPath = (manifest) => `.yarn/releases/raijin-yarn-${manifest.version}.mjs`;
+export const getRaijinRuntimeYarnPath = () => RAIJIN_RUNTIME_YARN_PATH;

package/dist/runtime.d.ts

@@ -6,3 +6,4 @@ export { RAIJIN_RUNTIME_ASSET_NAME } from './runtime/manifest.js';
 export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from './runtime/manifest.js';
 export { RAIJIN_RUNTIME_MANIFEST_URL } from './runtime/manifest.js';
 export { RAIJIN_RUNTIME_PACKAGE_NAME } from './runtime/manifest.js';
+export { RAIJIN_RUNTIME_YARN_PATH } from './runtime/manifest.js';

package/dist/runtime.js

@@ -5,3 +5,4 @@ export { RAIJIN_RUNTIME_ASSET_NAME } from "./runtime/manifest.js";
 export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from "./runtime/manifest.js";
 export { RAIJIN_RUNTIME_MANIFEST_URL } from "./runtime/manifest.js";
 export { RAIJIN_RUNTIME_PACKAGE_NAME } from "./runtime/manifest.js";
+export { RAIJIN_RUNTIME_YARN_PATH } from "./runtime/manifest.js";

package/dist/yarn/command.d.ts

@@ -1,3 +1,3 @@
 import type { YarnCommandRunner } from './runner.js';
-export declare const createYarnCommandEnvironment: (environment?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const createYarnCommandEnvironment: (cwd: string, environment?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
 export declare const runYarnCommand: YarnCommandRunner;

package/dist/yarn/command.js

@@ -1,14 +1,121 @@
 import { spawn } from 'node:child_process';
+import { delimiter } from 'node:path';
 import { RaijinYarnCommandException } from './exceptions/command.js';
-export const createYarnCommandEnvironment = (environment = process.env) => {
+const PATH_ENVIRONMENT_NAME = /^path$/i;
+const TEMPORARY_YARN_BIN_PATH = /[\\/]xfs-[^\\/]*(?:[\\/]|$)/;
+const PNP_NODE_OPTION = /(?:^|[\\/])\.pnp\.(?:cjs|loader\.mjs)$/;
+const NODE_OPTIONS_WITH_VALUE = new Set(['--experimental-loader', '--loader', '--require', '-r']);
+const isPnPNodeOptionValue = (value) => PNP_NODE_OPTION.test(value);
+const splitNodeOptions = (nodeOptions) => {
+    const tokens = [];
+    let raw = '';
+    let value = '';
+    let quote;
+    for (let index = 0; index < nodeOptions.length; index += 1) {
+        const char = nodeOptions[index];
+        if (quote) {
+            raw += char;
+            if (char === '\\' && nodeOptions[index + 1] === quote) {
+                index += 1;
+                raw += nodeOptions[index];
+                value += nodeOptions[index];
+                continue;
+            }
+            if (char === quote) {
+                quote = undefined;
+                continue;
+            }
+            value += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            raw += char;
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (raw) {
+                tokens.push({ raw, value });
+                raw = '';
+                value = '';
+            }
+            continue;
+        }
+        raw += char;
+        value += char;
+    }
+    if (raw) {
+        tokens.push({ raw, value });
+    }
+    return tokens;
+};
+const removePnPNodeOptions = (nodeOptions) => {
+    const options = splitNodeOptions(nodeOptions);
+    const filtered = [];
+    for (let index = 0; index < options.length; index += 1) {
+        const option = options[index];
+        const [name, value] = option.value.split('=', 2);
+        if (value && NODE_OPTIONS_WITH_VALUE.has(name) && isPnPNodeOptionValue(value)) {
+            continue;
+        }
+        if (NODE_OPTIONS_WITH_VALUE.has(option.value)) {
+            const next = options.at(index + 1);
+            if (next && isPnPNodeOptionValue(next.value)) {
+                index += 1;
+                continue;
+            }
+        }
+        filtered.push(option.raw);
+    }
+    return filtered.join(' ');
+};
+const isTemporaryYarnBinPath = (value) => TEMPORARY_YARN_BIN_PATH.test(value);
+const sanitizePathEnvironment = (value) => value
+    .split(delimiter)
+    .filter((item) => item && !isTemporaryYarnBinPath(item))
+    .join(delimiter);
+const setPathEnvironment = (environment) => {
+    const pathName = Object.keys(environment).find((name) => PATH_ENVIRONMENT_NAME.test(name));
+    if (!pathName) {
+        return;
+    }
+    const pathValue = environment[pathName];
+    if (!pathValue) {
+        return;
+    }
+    const sanitizedPathValue = sanitizePathEnvironment(pathValue);
+    if (sanitizedPathValue) {
+        environment[pathName] = sanitizedPathValue;
+    }
+    else {
+        Reflect.deleteProperty(environment, pathName);
+    }
+};
+export const createYarnCommandEnvironment = (cwd, environment = process.env) => {
     const yarnEnvironment = { ...environment };
+    const nodeOptions = yarnEnvironment.NODE_OPTIONS;
+    delete yarnEnvironment.BERRY_BIN_FOLDER;
+    delete yarnEnvironment.npm_config_user_agent;
+    delete yarnEnvironment.npm_execpath;
     delete yarnEnvironment.YARN_IGNORE_PATH;
+    if (nodeOptions) {
+        const sanitizedNodeOptions = removePnPNodeOptions(nodeOptions);
+        if (sanitizedNodeOptions) {
+            yarnEnvironment.NODE_OPTIONS = sanitizedNodeOptions;
+        }
+        else {
+            delete yarnEnvironment.NODE_OPTIONS;
+        }
+    }
+    setPathEnvironment(yarnEnvironment);
+    yarnEnvironment.INIT_CWD = cwd;
+    yarnEnvironment.PROJECT_CWD = cwd;
     return yarnEnvironment;
 };
 export const runYarnCommand = async (args, cwd) => {
     const child = spawn('yarn', args, {
         cwd,
-        env: createYarnCommandEnvironment(),
+        env: createYarnCommandEnvironment(cwd),
         shell: process.platform === 'win32',
         stdio: 'inherit',
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atls/raijin",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "license": "BSD-3-Clause",
   "type": "module",
   "exports": {