Add parameter/argument passthrough option

[MadLittleMods]

Running npm run dev -- --foo=bar will result in concurrently --raw "npm run start" "gulp watch" "--foo=bar" which doesn't properly add the parameter to any of the commands.

The double dash -- parameter passing is part of npm run so "you can use custom arguments when executing scripts", https://docs.npmjs.com/cli/run-script

{
  "scripts": {
    "dev": "concurrently --raw --parameter-passthrough \"npm run start\" \"gulp watch\""
  }
}

---

We could add an--parameter-passthrough option to concurrently that would add the last command chunk onto each command piece. The last chunk that would be considered parameters could even be separated by --.

So running npm run dev -- -- --foo=bar would result in the following after npm, concurrently --raw "npm run start" "gulp watch" "--" "--foo=bar" and then finally npm run start --foo=bar && gulp watch --foo=bar

An issue is adding the extra -- for npm run arg passing. As you can see above, for it to be effective, it would actually need to be npm run start -- --foo=bar && gulp watch --foo=bar. Perhaps the npm script should be updated to include the extra -- though: "dev": "concurrently --raw --parameter-passthrough \"npm run start --\" \"gulp watch\""

---

If we wanted to get fancier could even add separation with --0, --1 which would go to each indexed command chunk respectively, npm run dev -- --0 --foo=bar --1 --qux=dorf which would finally end up at npm run start -- --foo=bar && gulp watch --qux=dorf

[andreieftimie]

@MadLittleMods have you found any workaround for this?
I can't use concurrently because I need to pass some configs along to each invoked script.

[kimmobrunfeldt]

if someone has time to create a PR, I'll merge it. Sorry for the delayed response.

[kimmobrunfeldt]

If someone wants to implement this, let's do the simpler way first and think about the fancy tricks later. I don't like the --0 and --1 that much as it complicates the usage.

[MadLittleMods]

Implemented as --argument-passthrough option here in https://github.com/kimmobrunfeldt/concurrently/pull/68, still need to figure out testing for this new option.

[thaggie]

My PR is an alternative implementation where the arguments are either passed to the first command (default) or all the commands (--all option).

The unit test has not been tested on windows.

[gustavohenke]

Hi @thaggie and @MadLittleMods, I reviewed both PRs.
I'll place my thoughts here as well: isn't it better if we skip any option, and simply pass arguments through if we find --?

However, if you have examples of programs that work similarly, we could review the need of such option.

[thaggie]

My use case is for npm test, I run the unit tests and linting (css, js and jsx) at the same time - they're different programs that want different arguments. I want to be able to pass arguments through to just the unit test script.

[thaggie]

After a little thought it might be better to default to the last command as that's the one closest to the --.

[gustavohenke]

So isn't it better if you directly specify those args for the process that will use it?

[thaggie]

Not sure what you mean.

I want to be able to:
npm test -- --reporters progress,junit
or
npm test -- --reporters mocha
or any other commands I want to pass down to karma

and have --reporters progress,junit just go to my unit test command not my linting commands.

From package.json:

"test": "concurrently \"karma start karma.conf.js\" \"eslint src --ext js\" --" 

[csvan]

Any news on this? My use case is the same as @thaggie

[carlosasj]

An alternative would be use bash or sh to "build" the command before concurrently starts its execution. For example:

"myScript": "bash -c 'concurrently \"npm run start\" \"npm run _wait-for-server-up && npm run _run-subset-tests -- ${0} && npm run open-report\"'",

So you can use like:

npm run myScript -- --myArgument

It's not the best solution, but could help someone while we don't have an official implementation of this feature.

I read it here: npm/npm#9627

[timster]

I created a run.js file as a workaround. This lets me pass args to whichever process(es) I want.

const concurrently = require('concurrently')

const args = process.argv.slice(2).join(' ')

concurrently(
  [
    { command: 'npm:dev:server', prefixColor: 'blue', name: 'server' },
    { command: 'npm:dev:client -- ' + args, prefixColor: 'magenta', name: 'client' }
  ],
  {
    killOthers: ['failure', 'success']
  }
)

Then I can do:

node run.js --arg1=value

And as an npm script:

"scripts": {
  "dev": "node run.js",
}

npm run dev -- --arg1=value

[stocks29]

While it's not ideal, env vars are pretty easy to use as a short term workaround:

  "scripts": {
    "dev:support": " // some other proc here",
    "test:only": "truffle test $TRUFFLE_TEST",
    "test": "concurrently --kill-others --success first npm:dev:support npm:test:only"
  },

Then you can run the script as:

TRUFFLE_TEST=./test/MyTest.js npm test

[Ore4444]

When using Yarn, it works!
"watch:lint:ts": "concurrently \"yarn:client:lint:ts --watch\" \"yarn:server:lint:ts --watch\"",

[csvan]

@Ore4444 that is not a passthrough though, you are passing - -watch to each subcommand directly in the script.

[1aurabrown]

hi, just wondering if this has been implemented or not.

[LoanProKen]

well, .,.,. This has been a while, if someone sees my post please put a link to the change implementation...

[205g0]

any news on this? the env var hack is good as work-around

[kristiannotari]

The recent pr #307 looks promising. Hope to see it merged in one way or another in the near future. This would be great to have.

[nathanpovo]

You can find the documentation on the implementated passthrough functionality here.

Copy of the documentation on the "All arguments" option:

In the original build example script, you're more likely to want to pass every additional argument/flag
to your commands. This can be done with the {@} placeholder.

{
 // ...
 "scripts": {
   // ...
   "build": "concurrently -P 'npm:build:client -- {@}' 'npm:build:server -- {@}' --",
   "typecheck": "npm run build -- --watch --noEmit"
 }
}

In the above example, both --watch and --noEmit are passed to each command.