86

I have default config in launch.json. The site runs on port 8080.

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "chrome",
            "request": "launch",
            "name": "Launch Chrome against localhost",
            "url": "http://localhost:8080",
            "webRoot": "${workspaceRoot}"
        },
        {
            "type": "chrome",
            "request": "attach",
            "name": "Attach to Chrome",
            "port": 9222,
            "webRoot": "${workspaceRoot}"
        }
    ]
}

enter image description here

However, when I click on the Debug button, I get this error:

Cannot connect to the target: connect ECONNREFUSED 127.0.0.1:9222

enter image description here

Question 1: Why does VS Code assign port 9222 when creating this json?

What is so special about this port that MS decided to put it in this launch.json?

Question 2: What do I need to change to make things work?

The Launch debug always launches a new window. I am asking specifically about Attach debug option, so that it will open in a new tab instead.

Pang
  • 9,564
  • 146
  • 81
  • 122
monstro
  • 6,254
  • 10
  • 65
  • 111
  • 1
    you can follow the answers below and do this without serving using a webserver. 1. open your chrome instance with --remote-debugging-port=9222, etc. 2. navigate to the index file in webroot, for example c:\myfiles\webproject\index.html 3. set the "url" in launch.json to match that path. 4. start debugging. – Piotr Jul 22 '20 at 18:40

11 Answers11

87

When using the configuration url, vscode will search for a tab with the EXACT url and attach to it if found.

Use the configuration urlFilter, which can have wildcards like *, to attach the debugger to any sub route in your url.

e.g. "urlFilter": "http://localhost:4200/*"

The complete exacts steps to take:

  1. configure your launch.json file to looks something like this:

     {
       "version": "0.2.0",
       "configurations": [
         {
           "type": "chrome",
           "request": "attach",
           "name": "Attach to Chrome",
           "port": 9222,
           "urlFilter": "http://localhost:4200/*",
           "webRoot": "${workspaceFolder}"
         }
       ]
     }
    
  2. Close all opened chrome instances (make sure that all of them are killed using task manager in windows).

  3. Launch chrome with the following parameter: --remote-debugging-port=9222

    Make sure that the port in this parameter is the same as the one configured in 'port' property of the attache to chrome configuration in the launch.json file (like the example above)

    You can add this parameter in your chrome shortcut properties by:

    • Right click your shortcut file and select properties

    • Chain it to Target property, e.g.

      "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222

  4. Navigate to your site. In this example, http://localhost:4200

  5. Run 'Start debugging' in VS Code.

Pang
  • 9,564
  • 146
  • 81
  • 122
benshabatnoam
  • 7,161
  • 1
  • 31
  • 52
  • 5
    Adding * in the URL fixed this for me. Thanks for the pointer. – Mickers Nov 19 '18 at 21:10
  • 1
    This is the answer I have waited for a long time. Thanks. To me worked with url either. – Alexandre N. Nov 24 '18 at 14:02
  • 5
    Using `urlFilter` instead of `url` worked for me. Here is the docs on this topic https://github.com/Microsoft/vscode-chrome-debug#other-optional-launch-config-fields – amankkg Nov 29 '18 at 07:11
  • 2
    Thanks for "urlFilter"! – Marek Javůrek Jan 18 '19 at 09:51
  • (make sure that all of them are killed using task manager in windows). worked for me – Lin Sep 30 '19 at 00:32
  • Thank you! Opening Chrome with --remote-debugging-port=9222 and adding urlFilter worked!! – Roshin Jay Aug 05 '20 at 01:44
  • Not working for me. Chrome says `DevTools listening on ws://127.0.0.1:9222/devtools/browser/b5495c54-7c07-4bdf-8891-e69c37eb171a` and VSCode just hangs trying to connect. – Philip Rego Sep 22 '20 at 06:19
  • Adding * in the URL fixed this for me. Thanks for the pointer. – Dener Rocha Nov 18 '20 at 14:15
  • You've saved me SO much trouble with the restofthefuckingowl documentation from google on this. Thank you! – micomec Sep 15 '21 at 16:47
  • I am upvoting because this was the only answer that mentioned to **close all existing Chrome session**. Otherwise, when I launched chrome debugger, it would say something like *opening in existing browser session*, but then wouldn't actually launch the debug mode. Once all sessions were closed, then the new session it created triggered the debugger, which was evident in the console that I used to launch chrome.exe. – Ross Brasseaux Sep 16 '21 at 16:50
  • What if the application is running on a remote server using Tomcat instead on nodejs server? How we can do remote debugging of JavaScript in this case? – tarekahf Oct 19 '21 at 05:57
  • This answers the question perfectly. However... I personally find it easier to just use a "launch" configuration (`"request": "launch"`), which then launches a Chrome Window for you with debugging enabled in the same way - could be worth a mention. – Steve Chambers Sep 18 '22 at 19:21
60
  1. You need to install Debugger for Chrome extension for this to work. Open extensions in VS Code and search for Debugger for Chrome

  2. You need to run a web server on the URL specified in the first configuration (default to http://localhost:8080). I use serve npm package that I installed globally. From my app folder I run serve -p 8080

  3. Select Launch Chrome against localhost option. It will launch the browser and you can set breakpoints in your code and the debugging should work.

Regarding the second configuration (Attach to Chrome). There's nothing special about the port. In order to attach to Chrome you need to run Chrome with remote debugging enabled on port specified in the config. For example chrome.exe --remote-debugging-port=9222. I personally never use this options. Just follow the three steps above and you should be fine.

Eugene
  • 1,633
  • 12
  • 7
38

The Debugger for Chrome extension is deprecated. You do not need it anymore.

I came across this question when looking for help using the "Attach to Chrome" configuration in VSCode. While the accepted answer did give me a few hints, I did have to do some more digging. Here are the steps that worked for me in case anyone else finds them useful:

  1. Install the Debugger for Chrome extension in VSCode Skip this, it's not needed anymore

  2. Serve your files with a web server of your choice

  3. Launch Chrome with remote debugging enabled

  4. In this new Chrome window navigate to the url that your web server is hosting (http://localhost:8080 for example).

  5. In VSCode, add a configuration to your launch.json file that looks like this:

    "configurations": [
      {
        "type": "chrome",
        "request": "attach",
        "port": 9222,
        "name": "Attach Chrome",
        "url": "http://localhost:8080/",
        "webRoot": "${workspaceFolder}"
      }
    ]
    
  6. Press the play button in VSCode with the 'Attach to Chrome' option selected from the drop down.

The key thing needed in the configuration file is the url field. This needs to be the URL where your files are being hosted and this URL needs to be currently open in the Chrome window that you just launched with remote debugging enabled. If you enter everything else right except this field, VSCode will give you an error message that says which urls are available. Something like Cannot connect to runtime process, timeout after 10000 ms - (reason: Can't find a valid target that matches: localhost:8080/. Available pages: ["http://localhost:8080",...

For the sake of completeness, here's how you launch Chrome with remote debugging enabled (from the Debugger for Chrome README):

Windows:

  • Right click the Chrome shortcut, and select properties
  • In the "target" field, append --remote-debugging-port=9222
  • Or in a command prompt, execute <path to chrome>/chrome.exe --remote-debugging-port=9222

MacOS:

  • In a terminal, execute /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222

Linux:

  • In a terminal, launch google-chrome --remote-debugging-port=9222
quicklikerabbit
  • 3,257
  • 6
  • 26
  • 39
  • 4
    Best answer. I should also add that the `"url"` field should be set to whatever your page address is when open. The debugger tries to find the **exact** match in your browser tab. I was working with vue.js and the default url `"http://localhost:8080/"` does not work, it should be `"http://localhost:8080/#/"`. – Edu Jun 22 '19 at 17:55
  • This isn't working for me, guessing because the website (browser address bar) uses a different port from the JS assets server, so it's a different url... Any clue how to do debugging if the JS and HTTP are served from different urls? – animatedgif Sep 14 '20 at 21:15
  • What if the application is running on a remote server using Tomcat instead on nodejs server? How we can do remote debugging of JavaScript in this case? – tarekahf Oct 19 '21 at 06:02
9

A 2020 complement answer...

VS Code has a new debug that is not stable yet but works as default on Insiders version at the moment.

It opens automatically a new Chrome instance with debugging for attached with these settings:

{
  "name": "Attach to Chrome",
  "port": 9222,
  "request": "attach",
  "type": "pwa-chrome",
  "webRoot": "${workspaceFolder}/src"
 }

Like any attached, you can run the debug any time at this new window opened by VS Code. Or you can run the Chrome as debug mode previously to avoid the VS Code to open a new debug window just like @quicklikerabbit answer https://stackoverflow.com/a/51392142/7050878 but this time without the need of the URL parameter.

Pang
  • 9,564
  • 146
  • 81
  • 122
Sheldon Oliveira
  • 915
  • 9
  • 15
4

The following procedure is for React applications created by create-react-app:

  1. Click the Extensions button in the Activity Bar and install the Debugger for Chrome extension if it's not already installed.

  2. Open a new Terminal window. cd to the client folder if necessary and install chrome-launcher:

    npm install chrome-launcher
    
  3. Switch to the Debugger panel in the Side Bar.

  4. Click the Configuration drop-down at the top of the Side Bar and choose "Add Configuration..." Alternatively, press the little gear icon at the top of the Side Bar to open launch.json and then press the big blue button labeled "Add Configuration..."

  5. From the list of configuration templates, choose Chrome: Attach. The following configuration should be added to launch.json:

    {
        "name": "Attach to Chrome",
        "port": 9222,
        "request": "attach",
        "type": "pwa-chrome",
        "webRoot": "${workspaceFolder}"
    },
    

    There's no need to change anything in this configuration.

  6. Add a new file named .env with the following content to the root folder of your project (or to the root of the client folder if it's a full-stack application):

    BROWSER=launchChrome.js
    
  7. Add a new file named launchChrome.js to the same folder, with the following content:

     const chromeLauncher = require('chrome-launcher');
     chromeLauncher.launch({
         startingUrl: process.argv[2],
         port: 9222,
     }).then(function (chrome) {
         console.info('Chrome remote debugging port:', chrome.port);
     });
    
  8. Launch your React app from the Terminal window:

    npm start
    
  9. After a few seconds, you should see the following text:

    Starting the development server...
    
    Chrome remote debugging port: 9222
    
  10. At the top of the Side Panel, choose the configuration Attach to Chrome and press the green triangle.

  11. You can now place breakpoints in your React code and the debugger will break when it hits them. You can even debug your server and your client simultaneously by adding a Node.js: Launch Program configuration to launch.json.

enter image description here

Pang
  • 9,564
  • 146
  • 81
  • 122
Ron Inbar
  • 2,044
  • 1
  • 16
  • 26
2

I will put my measly two cents in :) unfortunately or fortunately I had a similar problem and the above post pointed me in the right direction and I learned a little something along the way. Please see my notes below:

1) If you are on Linux, after starting vsCode run the following Linux command:

sudo lsof -i -P -n | grep LISTEN

this will allow you to see what ports are being used, in my case you can see code on 5500. sudo lsof -i -P -n | grep LISTEN

2) Assuming you have some test html/js code and vsCode has a server and debugger installed then the following files need to be configured as such:

code-workspace file:

/*
Workspace settings override user settings.
https://code.visualstudio.com/docs/getstarted/settings
Check to see if needed ports are listening: sudo lsof -i -P -n | grep LISTEN
*/

{
    "folders": [
        {
            "path": "."
        }
    ],
    "settings": {
        "liveServer.settings.AdvanceCustomBrowserCmdLine": "google-chrome-stable --remote-debugging-port=9222",
    }
}

launch.json:

{
/*
Workspace settings override user settings.
https://code.visualstudio.com/docs/getstarted/settings
Check to see if needed ports are listening: sudo lsof -i -P -n | grep LISTEN
*/
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch 127.0.0.1:5500",
            "type": "chrome",
            "request": "launch",
            "url": "http://127.0.0.1:5500/${relativeFileDirname}/${fileBasename}",
            "webRoot": "${workspaceFolder}/${relativeFileDirname}"
        },
        {
            "name": "Attach 127.0.0.1:5500",
            "type": "chrome",
            "request": "attach",
            "port": 9222,
            "url": "http://127.0.0.1:5500/${relativeFileDirname}/${fileBasename}",
            "webRoot": "${workspaceFolder}/${relativeFileDirname}/"
        },
    ]
  }

setting.json:

/*
Workspace settings override user settings.
https://code.visualstudio.com/docs/getstarted/settings
Check to see if needed ports are listening: sudo lsof -i -P -n | grep LISTEN
    */

    {
        "cSpell.language": "en",
        "git.enableSmartCommit": true,
        "git.autofetch": true,
        "[html]": {
            "editor.defaultFormatter": "vscode.html-language-features"
        },
        "liveServer.settings.donotShowInfoMsg": true,
        "cSpell.userWords": [
            "lsof",
            "readonly"
        ],
        "[javascript]": {
            "editor.defaultFormatter": "esbenp.prettier-vscode"
        },
        "cSpell.enabledLanguageIds": [
            "asciidoc",
            "c",
            "cpp",
            "csharp",
            "css",
            "git-commit",
            "go",
            "handlebars",
            "haskell",
            "html",
            "jade",
            "java",
            "javascript",
            "javascriptreact",
            "json",
            "jsonc",
            "latex",
            "less",
            "markdown",
            "php",
            "plaintext",
            "pug",
            "python",
            "restructuredtext",
            "rust",
            "scala",
            "scss",
            "text",
            "typescript",
            "typescriptreact",
            "yaml",
            "yml"
        ],
    }

3) NOTE make sure all browsers are closed before starting up the 'Live Server'. Spin-up your server 'Live Server'to open the file you would like to debug as per the configuration for the chrome browser stipulated in the vsCode File>Preferences>Settings, NOTE use 127.0.0.1 I had no luck with localhost, also the default port is 5500. The browser is now launched as per the vsCode-workspace file setting "liveServer.settings.AdvanceCustomBrowserCmdLine": "google-chrome-stable --remote-debugging-port=9222", this is where the debug magic takes place. NOTE make sure all browsers are closed before starting up the 'Live Server'. Especially check to make sure there are no chrome extension like Hangouts running, this will also prevent Chrome from opening port 9222, I had to click the Exit option on the task to kill all Chrome extension in my example: enter image description here

4) Now if you run sudo lsof -i -P -n | grep LISTEN you will see vsCode 'Live Server' serving on port 127.0.0.1:5500 and the debugger doing its thing on port 127.0.0.1:9222; If you do not see both ports opened then something is not correct and you will need to confirm STEP 3) listed above. serving on port 5500 and the debugger doing its thing on port 9222

5) You can check the web interface for the debugger by entering http://127.0.0.1:9222/ in a empty browser tab, this url will display links to every tab and extensions open and allow you to poke around with the debugger, click on the link to the file you want to debug, in my case 127.0.0.1:5500/Leason_66/index.html, this is the port and link vsCode will communicate with and re-render in the IDE Debugger.

http://127.0.0.1:9222/ 127.0.0.1:5500/Leason_66/index.html

6) Note: Make sure you are on the file you want to debug. We are almost there, now just click on the Debug Icon then go to the GREEN Play Button and select the attach option from the drop down, please note the information configured in the launch.js file is what will appear in the drop down.

Time for some action!

7) Time for some action! Now all you have to do is click on the GREEN Play Button and the Debugger will now attach to tab you have open at 127.0.0.1:5500/<path you your file> and do its debug on port 127.0.0.1:9222 enter image description here

8) Happy Engineering :)

PrimeTime
  • 121
  • 1
  • 6
1

For me, the problem was actually the host my angular application was pointing to. In particular, the command ng serve was serving it on localhost by default, but the vs code remote debugger tries to connect to 127.0.0.1 and gets ECONNREFUSED because the app was being served on localhost.

Apparently there is a difference, even if your hosts file has 127.0.0.1 localhost in it.

The solution was to serve the angular application on 127.0.0.1

ng serve --host 127.0.0.1

0

Peek into Task Manager. You may have Chrome instances hanging there. Only after killing them will you be able to run the remote and successfully start the debugger.

Pang
  • 9,564
  • 146
  • 81
  • 122
0

Try this:

"type": "edge",
"request": "launch",
"name": "Launch Edge",
"url": "http://localhost:8080",
"webRoot": "${workspaceFolder}"
"file": "${workspaceFolder}/index.html"
Pang
  • 9,564
  • 146
  • 81
  • 122
Faisal
  • 1
  • 1
0

Run Chrome on macOS without command lines.

We'll create a shortcut of Chrome that will run --remote-debugging-port=9222 for us.

Steps

  1. Open the native application called Automator.

  2. It opens a selector. Our goal is to create an application, hence we choose Application. enter image description here

  3. Look for shell. enter image description here

  4. Add the next script /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222 enter image description here

  5. Then save it with your desire. Our application shortcut is done. enter image description here

  6. Run the Spotlight with CMD + Space and type your app name, mine starts with Chrome Debug. Open it and voilà

  7. Add the launch.json this configuration (you can edit the localhost's port):

{
      "name": "Chrome lh:4200",
      "type": "chrome",
      "request": "attach",
      "urlFilter": "http://localhost:4200/*",
      "port": 9222,
      "webRoot": "${workspaceFolder}"
}
  1. Run that debug configuration. VSCode is waiting. Open your localhost URL on the Chrome, VSCode debugger will show this state: enter image description here
Guillem Puche
  • 1,199
  • 13
  • 16
0

Linux users must have Chrome deb file installed from Google official website. Flat/Snap doesn't work!

Reza Taba
  • 1,151
  • 11
  • 15