Missing option for disabling terminal restoration

[fabiospampinato]

Whenever I open a project, chances are that a terminal will automatically open because the previous time I opened that project, its window had 1 or more terminals. This doesn't work for me:

1. This "feature" is unpredictable. I may open a project 1 week or month later, who remembers if that window had a terminal?
2. It's useless. If I want a terminal I'm a shortcut away from it. If I don't need it however, I have to focus to it and close it.
3. I use my Terminals extension for managing terminals, I absolutely never need an empty terminal automatically open at startup.

What about a terminal.restoreTerminal: boolean option for disabling this?

[Tyriar]

The reason the terminal is automatically created is because the panel gets restored, which triggers the terminal being created.

@isidorn ever considered the ability to never restore a panel? This request has come before from the Powershell team.

[isidorn]

@Tyriar no. We always restore all our ux as it was in a previous session.
I do not see why the panel is a sepcial case when compared to the sidebar, activity bar, editor state and so on.

[fabiospampinato]

We always restore all our ux as it was in a previous session.

I don't think so.

You don't restore: the activity bar (global, non session-specific), status bar (global, non session specific), active activity bar section (it's always "explorer"), the "replace" input field always starts hidden (#30250) and probably other things as well.

I do not see why the panel is a sepcial case when compared to the sidebar, activity bar, editor state and so on.

The editor state and sidebar are useful, so it may be the activity bar for some people, but what use does it have a "debug" panel automatically open at startup? Or an empty terminal that automatically opens because when 2 months ago I closed that window it had a terminal visible?

[Tyriar]

@isidorn the special case is to avoid creating terminal sessions when the terminal panel is restored as some extensions want to prevent the initial terminal being created.

Allowing an empty terminal is another way to workaround the same issue, it's a pretty big change in thinking though.

[vscodebot]

This issue has been closed automatically because it needs more information and has not had recent activity. See also our issue reporting guidelines.

Happy Coding!

[fabiospampinato]

@Tyriar could you reopen this please? What kind of "more info" is needed?

[fabiospampinato]

I've tried to fix this in an extension, it didn't work. This is what I've tried:

• Running vscode.commands.executeCommand ( 'workbench.action.terminal.kill' ); inside the activate function.
  • There's no way of knowing if there's actually a terminal open (Allow extensions to access all terminals via API #13267).
  • Maybe there's another extension that opens a terminal at startup, we shouldn't just kill it.
  • There's a noticeable delay between the restored terminal opening and then closing. Maybe I could uninstall all my other extensions, or maybe I could rename my extension to "000", or something, ensuring that it's activate function will be called as soon as possible, but this is not really a solution.
• Killing all terminals upon shutdown, so that none will be restored the next time that window gets opened
  • It would actually produce the desired effect only after the second opening of that window, unless that's a completely new window.
  • I couldn't find a way to hook into the "shutdown" event, there's the deactivate function, but I believe that gets triggered after the actual window is closed, so there's no terminal to kill anymore. Even if there was a way of doing this there's no way of knowing how many terminals are open, if any (Allow extensions to access all terminals via API #13267).
• Injecting custom JS with this ensuring that the workbench.action.terminal.kill gets executed as soon as possible
  • I couldn't find a way to do it, is VSC actually exporting something to the global namespace that I can use to execute commands?

This is a bit annoying to me, and I couldn't find a way of fixing it without patching VSC itself.

Is there any update on this? Maybe an option for this could be added as part of #44302?

[fabiospampinato]

If anybody else finds those restored terminals annoying, this is what I'm currently doing for killing them:

1. Use Custom CSS and JS Loader, needed for injecting some code into VSC.
2. Use Fix VSCode Checksum to remove the [Unsupported] thing from the titlebar.
3. Add the following to your settings:

  "vscode_custom_css.imports": [
    "file:///path/to/my/vsc_custom.js"
  ]

4. Add the following code to your /path/to/my/vsc_custom.js file:

/* CLOSE RESTORED PANEL */

(function () {

  function hasEvent ( event ) {

    return _performanceEntries.includes ( event );

  }

  function close () {

    const kill = document.querySelector ( '.terminal-action.kill' );

    if ( kill ) kill.click ();

    const hide = document.querySelector ( '.panel .hide-panel-action' );

    if ( hide ) hide.click ();

    return !!kill || !!hide;

  }

  function loop () {

    if ( hasEvent ( 'extensionHostReady' ) || close () ) return;

    requestAnimationFrame ( loop );

  }

  loop ();

})();

[Tyriar]

Use Custom CSS and JS Loader, needed for injecting some code into VSC.
Use Fix VSCode Checksum to remove the [Unsupported] thing from the titlebar.

This is bad, the whole point of the unsupported message is to make it obvious that the source has been modified so the team doesn't have to chase down issues that are caused by people manipulating VS Code's source code - several team members wasted a bunch of time in the past on such problems.

const button = document.querySelector ( '.terminal-action.kill' );
if ( button ) button.click ();

In 1.26 you have a window.terminals ext API (and window.onDidOpenTerminal) which you can query at any time and kill all of them after launch.

[fabiospampinato]

This is bad, the whole point of the unsupported message is to make it obvious that the source has been modified so the team doesn't have to chase down issues that are caused by people manipulating VS Code's source code - several team members wasted a bunch of time in the past on such problems.

I understand that, but it's also very annoying to me to read that [Unsupported] message every single time, if I can remove it I'll do it. Maybe a -patched suffix could be added to the version displayed in the About window instead, maybe this way it will also be more useful because when people get asked which version they are running they'll say 1.26.1-patched instead of just forgetting to mention that they are running a patched version.

In 1.26 you have a window.terminals ext API (and window.onDidOpenTerminal) which you can query at any time and kill all of them after launch.

window.onDidOpenTerminal is not triggered for the restored terminal, or I guess maybe my extension isn't active yet when that happens.

I can't fix it with an extension because:

• I don't think there's a way of knowing if the open terminal has been uselessly restored or maybe opened manually or by another extension, in the latter cases it shouldn't be killed.
• It takes a while before my extension gets activated and can actually kill the terminal.

That piece of code I posted kills the terminal almost instantaneously and only if it's a restored terminal.

Of course I would rather just set an option in my settings for disabling panel/terminal restoration, but said option doesn't seem like is going to get implemented.

[Tyriar]

@fabiospampinato created #56929 to address the annoying part of it

[Tyriar]

Let's do a setting to prevent this which your users could enable (your extension could have a notification that helps users). The setting terminal.restoreOnStartUp (is there a better name for this?) would prevent terminals being created via TerminalPanel.setVisible during launch. I believe this is the code in question:

https://github.com/Microsoft/vscode/blob/5a2d01053c38593cd9061f42b12d25a36c5ff475/src/vs/workbench/parts/terminal/electron-browser/terminalPanel.ts#L118-L121

[fabiospampinato]

Thanks for wanting to fix this. I have a couple of questions:

• Since the thing being restored is actually the panel itself, shouldn't the setting disable that instead?
• Shouldn't this setting be enabled by default? It's difficult for me to imagine someone wanting to have the panel open at startup, unpredictably (who remembers if last time it was open or not).

Regarding the name I see there are already settings like: window.restoreFullscreen and zenMode.restore so maybe one of these would be good:

• workbench.restorePanel
• workbench.panel.restore
• terminal.restore

terminal.restoreOnStartUp is more explicit but at the expense of verbosity 🤔

[Tyriar]

Since the thing being restored is actually the panel itself, shouldn't the setting disable that instead?

@isidorn doesn't want that to be a thing for the panel. Plus it makes more sense for this to be a terminal setting as we only want the terminal not to restore, output, problems, etc. should still be restored at normal.

Shouldn't this setting be enabled by default? It's difficult for me to imagine someone wanting to have the panel open at startup, unpredictably (who remembers if last time it was open or not).

The workbench has always restored the state it was previously in, if you had a terminal open it will be open with a new shell to jump into, it's easy to hide/kill.

terminal.restoreOnStartUp is more explicit but at the expense of verbosity

I think being explicit is better here, terminal.restore is too ambiguous and is very similar for example to the setting that was just removed to restore the processes.

[fabiospampinato]

we only want the terminal not to restore

The "Debug Console" open at startup is totally useless too, even more so than the terminal.

terminal.restoreOnStartUp should not restore the panel if the active section is "Terminal", right? Or do you want the panel restored without creating a terminal in it?

[Tyriar]

@fabiospampinato the behavior I'm thinking is that a set visible on startup would not create a process and instead hide the panel immediately, allowing extensions to show it again when they activate.

[fabiospampinato]

@Tyriar I'm concerned this could cause the panel to get rendered very briefly, effectively flashing it on the screen, which is what I'm seeing with my code 🤔

[SilentFlute]

@codestothestars how do i use this "tasks" config, put it in settings.json?

[Tyriar]

@SilentFlute see https://code.visualstudio.com/Docs/editor/tasks

[SilentFlute]

@SilentFlute see https://code.visualstudio.com/Docs/editor/tasks

got it, thx

[zm-cttae]

It's been a while since our last work and the issue's been bumped already..
So when is the team's next availability to get this one On Deck?
VSC wreaks havoc when I want to use Netflix or play a videogame 😅

[Tyriar]

VSC wreaks havoc when I want to use Netflix or play a videogame 😅

@zm-cttae what do you mean by this? I wouldn't have expected this to cause performance problems.

[zm-cttae]

It's something to do with PowerShell being open that messes with other games and anything running off GPU 0 (3D)

[zm-cttae]

AFAIK the terminal does use GPU rendering also

[Tyriar]

@zm-cttae that's surprising, are you using a low spec GPU?

You can disable GPU rendering by setting "terminal.integrated.gpuAcceleration": "off", your terminals will be noticeably slower but I'd prioritize gaming performance in this case 😉

[ORBAT]

Is there any workaround for this yet? It's irritating to have the terminal always pop open on restart if I happen to close my editor when I had a Julia REPL still running.

I'd be OK with a solution that closes all terminals when I quit VSCode.

[Tyriar]

I thought about it and went with hideOnStartup in #189204. The word "restore" might confuse the user with persistent sessions but the main reason for this was that the panel still gets "restored" by the view system, it just hides almost immediately after and doesn't create a terminal.

Early feedback on the setting would be awesome. Here's the definition:

[TerminalSettingId.HideOnStartup]: {
	description: localize('terminal.integrated.hideOnStartup', "Whether to hide the terminal view on startup, avoiding creating a terminal when there are no persistent sessions."),
	type: 'string',
	enum: ['never', 'whenEmpty', 'always'],
	markdownEnumDescriptions: [
		localize('hideOnStartup.never', "Never hide the terminal view on startup."),
		localize('hideOnStartup.whenEmpty', "Only hide the terminal when there are no persistent sessions restored."),
		localize('hideOnStartup.always', "Always hide the terminal, even when there are persistent sessions restored.")
	],
	default: 'never'
},