fix(open vscode): launch via in-bundle code CLI on macOS

`open -a <App> --args` only forwards args on a cold launch; when VS Code is already running macOS drops the args and the vscode:// URL never reaches the mssql extension, so `sqlcmd open vscode` silently no-ops.

Add a platform-specific VSCode.launch that on darwin execs <App>/Contents/Resources/app/bin/code --open-url <url> directly, bypassing /usr/bin/open. Linux and Windows continue to use tool.Run unchanged. Extract tool.runCmd so platform launchers can supply their own *exec.Cmd while keeping the early-exit / stdio handling.

Author: dlevy-msft-sql

internal/tools/tool/tool.go

@@ -73,8 +73,15 @@ func (t *tool) Run(args []string) (int, error) {
 		return 1, fmt.Errorf("internal error: Call IsInstalled before Run")
 	}
 
-	cmd := t.generateCommandLine(args)
+	return t.runCmd(t.generateCommandLine(args))
+}
 
+// runCmd starts cmd, waits briefly for an early failure, and otherwise treats
+// the launch as successful and lets the GUI tool keep running. Callers that
+// need to bypass generateCommandLine (e.g. VS Code on darwin, which must exec
+// the in-bundle `code` CLI directly rather than `open -a`) build their own
+// *exec.Cmd and call this helper.
+func (t *tool) runCmd(cmd *exec.Cmd) (int, error) {
 	// Normalize argv[0] so it matches cmd.Path on every platform. The darwin
 	// implementation builds Args starting at "-a" because it shells out via
 	// /usr/bin/open; without this fix the launched process sees "-a" as argv[0]

internal/tools/tool/vscode.go

@@ -60,7 +60,7 @@ func (t *VSCode) buildsToSearch() []string {
 
 func (t *VSCode) Run(args []string) (int, error) {
 	if !test.IsRunningInTestExecutor() {
-		return t.tool.Run(args)
+		return t.launch(args)
 	}
 	return 0, nil
 }

internal/tools/tool/vscode_darwin.go

@@ -4,14 +4,17 @@
 package tool
 
 import (
+	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 )
 
-// searchLocations returns the .app bundle paths to probe. tool_darwin.go's
-// generateCommandLine launches via "open -a <path> --args ...", which expects
-// either a registered app name or a .app bundle path; pointing it at the
-// in-bundle code binary would fail with "Unable to find application".
+// searchLocations returns the .app bundle paths to probe. We resolve at the
+// bundle level (not the in-bundle `code` CLI) so IsInstalled keeps working
+// when the bundle exists but the optional CLI shim is missing, and so
+// tests/users can point --build at the bundle they care about. launch()
+// derives the in-bundle CLI from the bundle path at execution time.
 func (t *VSCode) searchLocations() []string {
 	userProfile := os.Getenv("HOME")
 
@@ -35,6 +38,20 @@ func (t *VSCode) searchLocations() []string {
 	return locations
 }
 
+// launch executes VS Code with the given args. macOS's `open -a <App> --args`
+// only forwards args on a cold launch; when VS Code is already running the
+// args (including the vscode:// URL we use to drive the mssql extension) are
+// silently dropped. Bypass `open` entirely and exec the in-bundle `code` CLI,
+// which handles --open-url whether or not VS Code is already running.
+func (t *VSCode) launch(args []string) (int, error) {
+	cliPath := filepath.Join(t.exeName, "Contents", "Resources", "app", "bin", "code")
+	if _, err := os.Stat(cliPath); err != nil {
+		return 1, fmt.Errorf("VS Code CLI not found at %q: %w", cliPath, err)
+	}
+	cmd := exec.Command(cliPath, args...)
+	return t.runCmd(cmd)
+}
+
 func (t *VSCode) installText() string {
 	return `Install using Homebrew:
 

internal/tools/tool/vscode_linux.go

@@ -37,6 +37,13 @@ func (t *VSCode) searchLocations() []string {
 	return locations
 }
 
+// launch executes VS Code with the given args. On Linux exeName is already the
+// `code` CLI, which handles --open-url correctly whether or not VS Code is
+// already running, so we go through the standard tool.Run path.
+func (t *VSCode) launch(args []string) (int, error) {
+	return t.tool.Run(args)
+}
+
 func (t *VSCode) installText() string {
 	return `Install using a package manager:
 

internal/tools/tool/vscode_windows.go

@@ -131,6 +131,13 @@ func vscodeRegistryInstallLocation(build string) string {
 	return ""
 }
 
+// launch executes VS Code with the given args. On Windows exeName is Code.exe,
+// which handles --open-url correctly whether or not VS Code is already
+// running, so we go through the standard tool.Run path.
+func (t *VSCode) launch(args []string) (int, error) {
+	return t.tool.Run(args)
+}
+
 func (t *VSCode) installText() string {
 	return `Install using a package manager: