How to associate Terminal opened for task with CustomExecution

[vaclavHala]

I'm implementing a vscode.CustomExecution to integrate a custom build system. I want to add some buttons to interact with a task backed by this custom implementation into the terminal toolbar. I know how to put buttons into the terminal toolbar in general and about how when clauses can be used in package.json to control when these buttons show up. My problem is I don't know how to tell which vscode.Terminal is the one opened for my vscode.CustomExecution so I can set some context keys when it is active and get back to my custom task instance from the command handlers.

Basically I want to write code like this

vscode.window.onDidChangeActiveTerminal(term => {
    void vscode.commands.executeCommand('setContext', `isMyCustomTask`, isTerminalOfMyCustomTask(term))
})

vscode.commands.registerCommand("commandForCustomTask", () => {
    const term = vscode.window.activeTerminal
    const exec = myCustomExecutionInTerminal(term)
    actOnCustomExecution(exec)
  })

but don't know how to do the isTerminalOfMyCustomTask and myCustomExecutionInTerminal.

I was hoping I could use creationOptions of the terminal

export interface Terminal {
  readonly creationOptions: Readonly<TerminalOptions | ExtensionTerminalOptions>;
}
export interface ExtensionTerminalOptions {
  pty: Pseudoterminal;
}

to correlate execution with the terminal because I expected the creationOptions to be the ExtensionTerminalOptions which would contain the reference to the vscode.Pseudoterminal I created in my custom task execution (So I could simply have a Map<vscode.Pseudoterminal, MyCustomExecution> somewhere that gets populated by the custom execution so it can be looked up later). This is not the case though, the the terminal is created with TerminalOptions (I think this because the object I see has properties shellPath and shellArgs which only exist in vscode.TerminalOptions) - not sure if this is a bug and should be reported as such on its own, an oversight or I'm missing something here...

[theReynald]

Hi vaclavHala,

To associate a vscode.Terminal with a vscode.CustomExecution and identify it later, you can maintain a mapping between custom executions and terminals using a unique identifier (e.g., a UUID) for each execution.

When creating a terminal for your custom execution, include this unique identifier in the terminal's name or environment variables.

Then, implement functions to check if an active terminal corresponds to one of your custom executions by matching this identifier in the terminal's name or environment variables.

This approach allows you to set context keys or perform actions specific to the terminal associated with your custom execution.

I got this suggestion from copilot so for more specific examples, you can have it update your code to experiment. Let me know how it goes & reopen if you have more questions.

/r

[isidorn]

I do not know. Maybe @meganrogge can help

[meganrogge]

when you create the CustomExecution, do you await the callback that will return the Pseudoterminal that task is running in? that's how you could populate the map.

[meganrogge]

https://github.com/microsoft/vscode/blob/30d42ee6c0116d7b94610938c8c95e38d0530f23/src/vscode-dts/vscode.d.ts#L8690-L8697

[vaclavHala]

@meganrogge thanks for the suggestion, but that does not solve my problem - I have the Pseudoterminal and know how to use that to control the terminal, but I don't know what vscode.Terminal instance is associated with the vscode.Pseudoterminal that I have. So this is not enough info to populate the map - I have only one half of the mapping

Let me share some more code which will hopefully make it clearer.

This is a very small extension that demonstrates my problem:

function activate(context) {
    vscode.tasks.registerTaskProvider("test", {
        provideTasks() {
            return []
        },
        resolveTask(task) {
            return new vscode.Task(task.definition, task.scope, task.name, task.source, new vscode.CustomExecution(def => {
                const _onDidWrite = new vscode.EventEmitter()
                /** @type {vscode.Pseudoterminal} */
                const pty = {
                    onDidWrite: _onDidWrite.event,
                    open(){
                        _onDidWrite.fire("Hello")
                    },
                    close(){}
                }
                // here I have the Pseudoterminal and CustomExecution, but not Terminal
                return Promise.resolve(pty)
            }))
        }
    })
    vscode.window.onDidOpenTerminal(term => {
        // here I have the Terminal but not the Pseudoterminal that controls it
        console.log(term)
    })
}

When inside the callback where I created the PTY I don't know how to get the Terminal instance associated with the PTY, in fact the associated Terminal may not even exist yet as vscode maybe only creates it using the PTY once I return it from the callback. On the other hand once I get reference to the Terminal (inside the onDidOpenTerminal listener) I don't know how to get the PTY from that Terminal instance - see screenshot from debugger below showing the Terminal instance contains shellArgs and shellPath fields instead of pty as I described in the original question

I can see the string Hello I write in my CustomExecution appear inside the terminal called my test created once I run the task so I believe I create and control the terminal correctly and the instance I'm looking at inside the listener shown in the screenshot is the Terminal instance I care about, but you can see there is no way to "know that" in code just from the data

[meganrogge]

Thanks for the info. I see what you mean. I don't think there's a way to know that at the moment.