From 9a02ee09c5088047e506d62c56764a45650a0f35 Mon Sep 17 00:00:00 2001 From: Ryan Day Date: Wed, 11 Sep 2019 08:27:38 -0700 Subject: [PATCH] fix: add golden file --- internal/linker/index.js | 167 ++++++++++++++++++++++++--------------- 1 file changed, 103 insertions(+), 64 deletions(-) diff --git a/internal/linker/index.js b/internal/linker/index.js index c5fca5a105..6ff8f4275f 100644 --- a/internal/linker/index.js +++ b/internal/linker/index.js @@ -1,4 +1,12 @@ -/* THIS FILE GENERATED FROM .ts; see BUILD.bazel */ /* clang-format off */(function (factory) { +/* THIS FILE GENERATED FROM .ts; see BUILD.bazel */ /* clang-format off */var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +(function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; @@ -33,25 +41,31 @@ Include as much of the build output as you can without disclosing anything confi `); } function symlink(target, path) { - if (fs.existsSync(path)) { - // We assume here that the path is already linked to the correct target. - // Could add some logic that asserts it here, but we want to avoid an extra - // filesystem access so we should only do it under some kind of strict mode. - return; - } - log_verbose(`symlink( ${path} -> ${target} )`); - // Use junction on Windows since symlinks require elevated permissions. - // We only link to directories so junctions work for us. - fs.symlinkSync(target, path, 'junction'); - if (VERBOSE_LOGS) { - // Be verbose about creating a bad symlink - // Maybe this should fail in production as well, but again we want to avoid - // any unneeded file I/O - if (!fs.existsSync(path)) { - log_verbose('ERROR\n***\nLooks like we created a bad symlink:' + - `\n pwd ${process.cwd()}\n target ${target}\n***`); + return __awaiter(this, void 0, void 0, function* () { + log_verbose(`symlink( ${path} -> ${target} )`); + // Use junction on Windows since symlinks require elevated permissions. + // We only link to directories so junctions work for us. + try { + yield fs.promises.symlink(target, path, 'junction'); } - } + catch (e) { + if (e.code !== 'ENOENT') { + throw e; + } + // We assume here that the path is already linked to the correct target. + // Could add some logic that asserts it here, but we want to avoid an extra + // filesystem access so we should only do it under some kind of strict mode. + } + if (VERBOSE_LOGS) { + // Be verbose about creating a bad symlink + // Maybe this should fail in production as well, but again we want to avoid + // any unneeded file I/O + if (!fs.existsSync(path)) { + log_verbose('ERROR\n***\nLooks like we created a bad symlink:' + + `\n pwd ${process.cwd()}\n target ${target}\n***`); + } + } + }); } /** * Resolve a root directory string to the actual location on disk @@ -150,57 +164,82 @@ Include as much of the build output as you can without disclosing anything confi } } exports.Runfiles = Runfiles; - function main(args, runfiles) { - if (!args || args.length < 1) - throw new Error('link_node_modules.js requires one argument: modulesManifest path'); - const [modulesManifest] = args; - let { root, modules, workspace } = JSON.parse(fs.readFileSync(modulesManifest)); - modules = modules || {}; - log_verbose(`module manifest: workspace ${workspace}, root ${root} with first-party packages\n`, modules); - const rootDir = resolveRoot(root, runfiles); - log_verbose('resolved root', root, 'to', rootDir); - // Bazel starts actions with pwd=execroot/my_wksp - const workspaceDir = path.resolve('.'); - // Convert from runfiles path - // this_wksp/path/to/file OR other_wksp/path/to/file - // to execroot path - // path/to/file OR external/other_wksp/path/to/file - function toWorkspaceDir(p) { - if (p.startsWith(workspace + path.sep)) { - return p.substring(workspace.length + 1); + // There is no fs.promises.exists function because + // node core is of the opinion that exists is always too racey to rely on. + function exists(p) { + return __awaiter(this, void 0, void 0, function* () { + try { + yield fs.promises.stat(p); + return true; } - return path.join('external', p); - } - // Create the $pwd/node_modules directory that node will resolve from - symlink(rootDir, 'node_modules'); - process.chdir(rootDir); - // Symlinks to packages need to reach back to the workspace/runfiles directory - const workspaceRelative = path.relative('.', workspaceDir); - const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined; - // Now add symlinks to each of our first-party packages so they appear under the node_modules tree - for (const m of Object.keys(modules)) { - let target; - // Look in the runfiles first - // TODO: this could be a method in the Runfiles class - if (runfiles.manifest) { - target = runfiles.lookupDirectory(modules[m]); + catch (e) { + if (e.code === 'ENOENT') { + return false; + } + throw e; } - else if (runfilesRelative) { - target = path.join(runfilesRelative, modules[m]); + }); + } + function main(args, runfiles) { + return __awaiter(this, void 0, void 0, function* () { + if (!args || args.length < 1) + throw new Error('link_node_modules.js requires one argument: modulesManifest path'); + const [modulesManifest] = args; + let { root, modules, workspace } = JSON.parse(fs.readFileSync(modulesManifest)); + modules = modules || {}; + log_verbose(`module manifest: workspace ${workspace}, root ${root} with first-party packages\n`, modules); + const rootDir = resolveRoot(root, runfiles); + log_verbose('resolved root', root, 'to', rootDir); + // Bazel starts actions with pwd=execroot/my_wksp + const workspaceDir = path.resolve('.'); + // Convert from runfiles path + // this_wksp/path/to/file OR other_wksp/path/to/file + // to execroot path + // path/to/file OR external/other_wksp/path/to/file + function toWorkspaceDir(p) { + if (p.startsWith(workspace + path.sep)) { + return p.substring(workspace.length + 1); + } + return path.join('external', p); } - // It sucks that we have to do a FS call here. - // TODO: could we know which packages are statically linked?? - if (!target || !fs.existsSync(target)) { - // Try the execroot - target = path.join(workspaceRelative, toWorkspaceDir(modules[m])); + // Create the $pwd/node_modules directory that node will resolve from + yield symlink(rootDir, 'node_modules'); + process.chdir(rootDir); + // Symlinks to packages need to reach back to the workspace/runfiles directory + const workspaceRelative = path.relative('.', workspaceDir); + const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined; + // Now add symlinks to each of our first-party packages so they appear under the node_modules tree + const links = []; + const linkModule = (name, modulePath) => __awaiter(this, void 0, void 0, function* () { + let target; + // Look in the runfiles first + // TODO: this could be a method in the Runfiles class + if (runfiles.manifest) { + target = runfiles.lookupDirectory(modulePath); + } + else if (runfilesRelative) { + target = path.join(runfilesRelative, modulePath); + } + // It sucks that we have to do a FS call here. + // TODO: could we know which packages are statically linked?? + if (!target || !(yield exists(target))) { + // Try the execroot + target = path.join(workspaceRelative, toWorkspaceDir(modulePath)); + } + yield symlink(target, name); + }); + for (const m of Object.keys(modules)) { + links.push(linkModule(m, modules[m])); } - symlink(target, m); - } - return 0; + yield Promise.all(links); + return 0; + }); } exports.main = main; if (require.main === module) { - process.exitCode = main(process.argv.slice(2), new Runfiles()); + (() => __awaiter(this, void 0, void 0, function* () { + process.exitCode = yield main(process.argv.slice(2), new Runfiles()); + }))(); } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link_node_modules.js","sourceRoot":"","sources":["../../../../../internal/linker/link_node_modules.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview Creates a node_modules directory in the current working directory\n * and symlinks in the node modules needed to run a program.\n * This replaces the need for custom module resolution logic inside the process.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n// Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging\nconst VERBOSE_LOGS = !!process.env['VERBOSE_LOGS'];\n\nfunction log_verbose(...m: string[]) {\n  if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m);\n}\n\nfunction panic(m: string) {\n  throw new Error(`Internal error! Please run again with\n   --define=VERBOSE_LOG=1\nand file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md\nInclude as much of the build output as you can without disclosing anything confidential.\n\n  Error:\n  ${m}\n  `);\n}\n\nfunction symlink(target: string, path: string) {\n  if (fs.existsSync(path)) {\n    // We assume here that the path is already linked to the correct target.\n    // Could add some logic that asserts it here, but we want to avoid an extra\n    // filesystem access so we should only do it under some kind of strict mode.\n    return;\n  }\n  log_verbose(`symlink( ${path} -> ${target} )`);\n  // Use junction on Windows since symlinks require elevated permissions.\n  // We only link to directories so junctions work for us.\n  fs.symlinkSync(target, path, 'junction');\n  if (VERBOSE_LOGS) {\n    // Be verbose about creating a bad symlink\n    // Maybe this should fail in production as well, but again we want to avoid\n    // any unneeded file I/O\n    if (!fs.existsSync(path)) {\n      log_verbose(\n          'ERROR\\n***\\nLooks like we created a bad symlink:' +\n          `\\n  pwd ${process.cwd()}\\n  target ${target}\\n***`);\n    }\n  }\n}\n\n/**\n * Resolve a root directory string to the actual location on disk\n * where node_modules was installed\n * @param root a string like 'npm/node_modules'\n */\nfunction resolveRoot(root: string|undefined, runfiles: Runfiles) {\n  // create a node_modules directory if no root\n  // this will be the case if only first-party modules are installed\n  if (!root) {\n    if (!fs.existsSync('node_modules')) {\n      log_verbose('no third-party packages; mkdir node_modules in ', process.cwd());\n      fs.mkdirSync('node_modules');\n    }\n    return 'node_modules';\n  }\n\n  // If we got a runfilesManifest map, look through it for a resolution\n  // This will happen if we are running a binary that had some npm packages\n  // \"statically linked\" into its runfiles\n  const fromManifest = runfiles.lookupDirectory(root);\n  if (fromManifest) return fromManifest;\n\n  // Account for Bazel --legacy_external_runfiles\n  // which look like 'my_wksp/external/npm/node_modules'\n  if (fs.existsSync(path.join('external', root))) {\n    log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root));\n    return path.join('external', root);\n  }\n\n  // The repository should be layed out in the parent directory\n  // since bazel sets our working directory to the repository where the build is happening\n  return path.join('..', root);\n}\n\nexport class Runfiles {\n  manifest: Map<string, string>|undefined;\n  dir: string|undefined;\n\n  constructor() {\n    // If Bazel sets a variable pointing to a runfiles manifest,\n    // we'll always use it.\n    // Note that this has a slight performance implication on Mac/Linux\n    // where we could use the runfiles tree already laid out on disk\n    // but this just costs one file read for the external npm/node_modules\n    // and one for each first-party module, not one per file.\n    if (!!process.env['RUNFILES_MANIFEST_FILE']) {\n      this.manifest = this.loadRunfilesManifest(process.env['RUNFILES_MANIFEST_FILE']!);\n    } else if (!!process.env['RUNFILES_DIR']) {\n      this.dir = path.resolve(process.env['RUNFILES_DIR']!);\n    } else {\n      panic(\n          'Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable');\n    }\n    // Under --noenable_runfiles (in particular on Windows)\n    // Bazel sets RUNFILES_MANIFEST_ONLY=1.\n    // When this happens, we need to read the manifest file to locate\n    // inputs\n    if (process.env['RUNFILES_MANIFEST_ONLY'] === '1' && !process.env['RUNFILES_MANIFEST_FILE']) {\n      log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994\n                 RUNFILES_MANIFEST_FILE should have been set but wasn't.\n                 falling back to using runfiles symlinks.\n                 If you want to test runfiles manifest behavior, add\n                 --spawn_strategy=standalone to the command line.`);\n    }\n  }\n\n  lookupDirectory(dir: string): string|undefined {\n    if (!this.manifest) return undefined;\n\n    for (const [k, v] of this.manifest) {\n      // Entry looks like\n      // k: npm/node_modules/semver/LICENSE\n      // v: /path/to/external/npm/node_modules/semver/LICENSE\n      // calculate l = length(`/semver/LICENSE`)\n      if (k.startsWith(dir)) {\n        const l = k.length - dir.length;\n        return v.substring(0, v.length - l);\n      }\n    }\n  }\n\n\n  /**\n   * The runfiles manifest maps from short_path\n   * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path\n   * to the actual location on disk where the file can be read.\n   *\n   * In a sandboxed execution, it does not exist. In that case, runfiles must be\n   * resolved from a symlink tree under the runfiles dir.\n   * See https://github.com/bazelbuild/bazel/issues/3726\n   */\n  loadRunfilesManifest(manifestPath: string) {\n    log_verbose(`using runfiles manifest ${manifestPath}`);\n\n    const runfilesEntries = new Map();\n    const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'});\n\n    for (const line of input.split('\\n')) {\n      if (!line) continue;\n      const [runfilesPath, realPath] = line.split(' ');\n      runfilesEntries.set(runfilesPath, realPath);\n    }\n\n    return runfilesEntries;\n  }\n}\n\n// TypeScript lib.es5.d.ts has a mistake: JSON.parse does accept Buffer.\ndeclare global {\n  interface JSON {\n    parse(b: Buffer): any;\n  }\n}\n\nexport function main(args: string[], runfiles: Runfiles) {\n  if (!args || args.length < 1)\n    throw new Error('link_node_modules.js requires one argument: modulesManifest path');\n\n  const [modulesManifest] = args;\n  let {root, modules, workspace} = JSON.parse(fs.readFileSync(modulesManifest));\n  modules = modules || {};\n  log_verbose(\n      `module manifest: workspace ${workspace}, root ${root} with first-party packages\\n`, modules);\n\n  const rootDir = resolveRoot(root, runfiles);\n  log_verbose('resolved root', root, 'to', rootDir);\n\n  // Bazel starts actions with pwd=execroot/my_wksp\n  const workspaceDir = path.resolve('.');\n\n  // Convert from runfiles path\n  // this_wksp/path/to/file OR other_wksp/path/to/file\n  // to execroot path\n  // path/to/file OR external/other_wksp/path/to/file\n  function toWorkspaceDir(p: string) {\n    if (p.startsWith(workspace + path.sep)) {\n      return p.substring(workspace.length + 1);\n    }\n    return path.join('external', p);\n  }\n\n  // Create the $pwd/node_modules directory that node will resolve from\n  symlink(rootDir, 'node_modules');\n  process.chdir(rootDir);\n\n  // Symlinks to packages need to reach back to the workspace/runfiles directory\n  const workspaceRelative = path.relative('.', workspaceDir);\n  const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined;\n\n  // Now add symlinks to each of our first-party packages so they appear under the node_modules tree\n  for (const m of Object.keys(modules)) {\n    let target: string|undefined;\n\n    // Look in the runfiles first\n    // TODO: this could be a method in the Runfiles class\n    if (runfiles.manifest) {\n      target = runfiles.lookupDirectory(modules[m]);\n    } else if (runfilesRelative) {\n      target = path.join(runfilesRelative, modules[m]);\n    }\n\n    // It sucks that we have to do a FS call here.\n    // TODO: could we know which packages are statically linked??\n    if (!target || !fs.existsSync(target)) {\n      // Try the execroot\n      target = path.join(workspaceRelative, toWorkspaceDir(modules[m]));\n    }\n    symlink(target, m);\n  }\n\n  return 0;\n}\n\nif (require.main === module) {\n  process.exitCode = main(process.argv.slice(2), new Runfiles());\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link_node_modules.js","sourceRoot":"","sources":["../../../../../internal/linker/link_node_modules.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview Creates a node_modules directory in the current working directory\n * and symlinks in the node modules needed to run a program.\n * This replaces the need for custom module resolution logic inside the process.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n// Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging\nconst VERBOSE_LOGS = !!process.env['VERBOSE_LOGS'];\n\nfunction log_verbose(...m: string[]) {\n  if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m);\n}\n\nfunction panic(m: string) {\n  throw new Error(`Internal error! Please run again with\n   --define=VERBOSE_LOG=1\nand file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md\nInclude as much of the build output as you can without disclosing anything confidential.\n\n  Error:\n  ${m}\n  `);\n}\n\nasync function symlink(target: string, path: string) {\n  log_verbose(`symlink( ${path} -> ${target} )`);\n  // Use junction on Windows since symlinks require elevated permissions.\n  // We only link to directories so junctions work for us.\n  try{\n    await fs.promises.symlink(target, path, 'junction');\n  } catch(e){\n    if(e.code !== 'ENOENT'){\n      throw e;\n    }\n    // We assume here that the path is already linked to the correct target.\n    // Could add some logic that asserts it here, but we want to avoid an extra\n    // filesystem access so we should only do it under some kind of strict mode.\n  }\n\n  if (VERBOSE_LOGS) {\n    // Be verbose about creating a bad symlink\n    // Maybe this should fail in production as well, but again we want to avoid\n    // any unneeded file I/O\n    if (!fs.existsSync(path)) {\n      log_verbose(\n          'ERROR\\n***\\nLooks like we created a bad symlink:' +\n          `\\n  pwd ${process.cwd()}\\n  target ${target}\\n***`);\n    }\n  }\n}\n\n/**\n * Resolve a root directory string to the actual location on disk\n * where node_modules was installed\n * @param root a string like 'npm/node_modules'\n */\nfunction resolveRoot(root: string|undefined, runfiles: Runfiles) {\n  // create a node_modules directory if no root\n  // this will be the case if only first-party modules are installed\n  if (!root) {\n    if (!fs.existsSync('node_modules')) {\n      log_verbose('no third-party packages; mkdir node_modules in ', process.cwd());\n      fs.mkdirSync('node_modules');\n    }\n    return 'node_modules';\n  }\n\n  // If we got a runfilesManifest map, look through it for a resolution\n  // This will happen if we are running a binary that had some npm packages\n  // \"statically linked\" into its runfiles\n  const fromManifest = runfiles.lookupDirectory(root);\n  if (fromManifest) return fromManifest;\n\n  // Account for Bazel --legacy_external_runfiles\n  // which look like 'my_wksp/external/npm/node_modules'\n  if (fs.existsSync(path.join('external', root))) {\n    log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root));\n    return path.join('external', root);\n  }\n\n  // The repository should be layed out in the parent directory\n  // since bazel sets our working directory to the repository where the build is happening\n  return path.join('..', root);\n}\n\nexport class Runfiles {\n  manifest: Map<string, string>|undefined;\n  dir: string|undefined;\n\n  constructor() {\n    // If Bazel sets a variable pointing to a runfiles manifest,\n    // we'll always use it.\n    // Note that this has a slight performance implication on Mac/Linux\n    // where we could use the runfiles tree already laid out on disk\n    // but this just costs one file read for the external npm/node_modules\n    // and one for each first-party module, not one per file.\n    if (!!process.env['RUNFILES_MANIFEST_FILE']) {\n      this.manifest = this.loadRunfilesManifest(process.env['RUNFILES_MANIFEST_FILE']!);\n    } else if (!!process.env['RUNFILES_DIR']) {\n      this.dir = path.resolve(process.env['RUNFILES_DIR']!);\n    } else {\n      panic(\n          'Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable');\n    }\n    // Under --noenable_runfiles (in particular on Windows)\n    // Bazel sets RUNFILES_MANIFEST_ONLY=1.\n    // When this happens, we need to read the manifest file to locate\n    // inputs\n    if (process.env['RUNFILES_MANIFEST_ONLY'] === '1' && !process.env['RUNFILES_MANIFEST_FILE']) {\n      log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994\n                 RUNFILES_MANIFEST_FILE should have been set but wasn't.\n                 falling back to using runfiles symlinks.\n                 If you want to test runfiles manifest behavior, add\n                 --spawn_strategy=standalone to the command line.`);\n    }\n  }\n\n  lookupDirectory(dir: string): string|undefined {\n    if (!this.manifest) return undefined;\n\n    for (const [k, v] of this.manifest) {\n      // Entry looks like\n      // k: npm/node_modules/semver/LICENSE\n      // v: /path/to/external/npm/node_modules/semver/LICENSE\n      // calculate l = length(`/semver/LICENSE`)\n      if (k.startsWith(dir)) {\n        const l = k.length - dir.length;\n        return v.substring(0, v.length - l);\n      }\n    }\n  }\n\n\n  /**\n   * The runfiles manifest maps from short_path\n   * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path\n   * to the actual location on disk where the file can be read.\n   *\n   * In a sandboxed execution, it does not exist. In that case, runfiles must be\n   * resolved from a symlink tree under the runfiles dir.\n   * See https://github.com/bazelbuild/bazel/issues/3726\n   */\n  loadRunfilesManifest(manifestPath: string) {\n    log_verbose(`using runfiles manifest ${manifestPath}`);\n\n    const runfilesEntries = new Map();\n    const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'});\n\n    for (const line of input.split('\\n')) {\n      if (!line) continue;\n      const [runfilesPath, realPath] = line.split(' ');\n      runfilesEntries.set(runfilesPath, realPath);\n    }\n\n    return runfilesEntries;\n  }\n}\n\n// TypeScript lib.es5.d.ts has a mistake: JSON.parse does accept Buffer.\ndeclare global {\n  interface JSON {\n    parse(b: {toString:()=>string}): any;\n  }\n}\n\n// There is no fs.promises.exists function because \n// node core is of the opinion that exists is always too racey to rely on.\nasync function exists(p:string){\n  try{\n    await fs.promises.stat(p)\n    return true;\n  } catch(e){\n    if(e.code === 'ENOENT'){\n      return false;\n    }\n    throw e;\n  }\n}\n\nexport async function main(args: string[], runfiles: Runfiles) {\n  if (!args || args.length < 1)\n    throw new Error('link_node_modules.js requires one argument: modulesManifest path');\n\n  const [modulesManifest] = args;\n  let {root, modules, workspace} = JSON.parse(fs.readFileSync(modulesManifest));\n  modules = modules || {};\n  log_verbose(\n      `module manifest: workspace ${workspace}, root ${root} with first-party packages\\n`, modules);\n\n  const rootDir = resolveRoot(root, runfiles);\n  log_verbose('resolved root', root, 'to', rootDir);\n\n  // Bazel starts actions with pwd=execroot/my_wksp\n  const workspaceDir = path.resolve('.');\n\n  // Convert from runfiles path\n  // this_wksp/path/to/file OR other_wksp/path/to/file\n  // to execroot path\n  // path/to/file OR external/other_wksp/path/to/file\n  function toWorkspaceDir(p: string) {\n    if (p.startsWith(workspace + path.sep)) {\n      return p.substring(workspace.length + 1);\n    }\n    return path.join('external', p);\n  }\n\n  // Create the $pwd/node_modules directory that node will resolve from\n  await symlink(rootDir, 'node_modules');\n  process.chdir(rootDir);\n\n  // Symlinks to packages need to reach back to the workspace/runfiles directory\n  const workspaceRelative = path.relative('.', workspaceDir);\n  const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined;\n\n  // Now add symlinks to each of our first-party packages so they appear under the node_modules tree\n  const links = []\n\n  const linkModule = async (name:string,modulePath:string)=>{\n    let target: string|undefined;\n\n    // Look in the runfiles first\n    // TODO: this could be a method in the Runfiles class\n    if (runfiles.manifest) {\n      target = runfiles.lookupDirectory(modulePath);\n    } else if (runfilesRelative) {\n      target = path.join(runfilesRelative, modulePath);\n    }\n\n    // It sucks that we have to do a FS call here.\n    // TODO: could we know which packages are statically linked??\n    if (!target || !await exists(target)) {\n      // Try the execroot\n      target = path.join(workspaceRelative, toWorkspaceDir(modulePath));\n    }\n\n    await symlink(target, name);\n  }\n\n  for (const m of Object.keys(modules)) {\n    links.push(linkModule(m,modules[m]))\n  }\n\n  await Promise.all(links);\n\n  return 0;\n}\n\nif (require.main === module) {\n   (async ()=>{\n    process.exitCode = await main(process.argv.slice(2), new Runfiles());\n   })();\n}\n\n"]} \ No newline at end of file