Open VS Code on Windows via protocol URI

- Launch `explorer.exe` with a `vscode://file/...` target for Windows editor opens - Improve Windows spawn handling with `windowsHide` and protocol URI coverage

julius committed 7 months ago

Commit 8d257e21 parent 1218eff4 files · +86 −25Browse files

Unified · Split

4 files

apps/server/spawned2.txt +2 −0
apps/server/src/process/Layers/DesktopLauncher.test.ts +14 −23
apps/server/src/process/Layers/DesktopLauncher.ts +67 −2
apps/server/tmp-test.cmd +3 −0

apps/server/spawned2.txt+2−0

@@ -0,0 +1,2 @@
	1	started
	2	started

apps/server/src/process/Layers/DesktopLauncher.test.ts+14−23

   readonly detached?: boolean | undefined;
   readonly shell?: boolean | string | undefined;
   readonly windowsVerbatimArguments?: boolean | undefined;
+  readonly windowsHide?: boolean | undefined;
   readonly stdin?: unknown;
   readonly stdout?: unknown;
   readonly stderr?: unknown;
         detached: input.detached,
         shell: input.shell,
         windowsVerbatimArguments: input.windowsVerbatimArguments,
+        windowsHide: input.windowsHide,
         stdin: input.stdin,
         stdout: input.stdout,
         stderr: input.stderr,
   }).pipe(Effect.provide(NodeFileSystem.layer)),
 );
-it.effect("openInEditor launches Windows batch shims through cmd.exe without shell mode", () =>
+it.effect("openInEditor uses explorer with a VS Code protocol target on Windows", () =>
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const dir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-open-vscode-win32-" });
-    yield* fs.writeFileString(`${dir}/code.cmd`, "@echo off\r\n");
+    yield* fs.writeFileString(`${dir}/explorer.exe`, "MZ");
     const calls: Array<SpawnCall> = [];
     const open = yield* runOpen(
       editor: "vscode",
     });
-    assert.equal(calls.length, 1);
+    assert.deepEqual(calls, [
-    assert.equal(calls[0]?.command.toLowerCase().includes("powershell"), true);
+      {
-    assert.deepEqual(calls[0]?.args.slice(0, 5), [
+        command: `${dir}/explorer.exe`,
-      "-NoProfile",
+        args: ["vscode://file/C:/work/100%25%20real/file.ts:12:4"],
-      "-NonInteractive",
+        detached: true,
-      "-ExecutionPolicy",
+        shell: false,
-      "Bypass",
+        stdin: "ignore",
-      "-EncodedCommand",
+        stdout: "ignore",
+        stderr: "ignore",
+      },
     ]);
-    const encoded = calls[0]?.args[5];
-    assert.isString(encoded);
-    const decoded = decodePowerShellCommand(encoded!);
-    assert.equal(decoded.includes("Start-Process"), true);
-    assert.equal(decoded.toLowerCase().includes(`${dir}/code.cmd`.toLowerCase()), true);
-    assert.equal(decoded.includes("--goto"), true);
-    assert.equal(decoded.includes("100% real"), true);
-    assert.equal(calls[0]?.detached, true);
-    assert.equal(calls[0]?.windowsVerbatimArguments, undefined);
-    assert.equal(calls[0]?.shell, false);
-    assert.equal(calls[0]?.stdin, "ignore");
-    assert.equal(calls[0]?.stdout, "ignore");
-    assert.equal(calls[0]?.stderr, "ignore");
   }).pipe(Effect.provide(NodeFileSystem.layer)),
 );

apps/server/src/process/Layers/DesktopLauncher.ts+67−2

  */
 import OS from "node:os";
 import { spawn as spawnNodeChildProcess } from "node:child_process";
+import { pathToFileURL } from "node:url";
 import { EDITORS, type EditorId } from "@t3tools/contracts";
 import { Array, Effect, FileSystem, Layer, Option, Path, Scope } from "effect";
   readonly detached?: boolean;
   readonly shell?: boolean;
   readonly windowsVerbatimArguments?: boolean;
+  readonly windowsHide?: boolean;
   readonly stdin?: "ignore";
   readonly stdout?: "ignore";
   readonly stderr?: "ignore";
   "powershell.exe",
   "pwsh.exe",
 ] as const;
+const WINDOWS_EDITOR_URI_SCHEMES: Partial<Record<EditorId, string>> = {
+  vscode: "vscode",
+  "vscode-insiders": "vscode-insiders",
+  vscodium: "vscodium",
+};
 function shouldUseGotoFlag(editor: (typeof EDITORS)[number], target: string): boolean {
   return editor.supportsGoto && LINE_COLUMN_SUFFIX_PATTERN.test(target);
   return value.replace(/^"+|"+$/g, "");
 }
+function splitLineColumnSuffix(target: string): {
+  readonly filePath: string;
+  readonly suffix: string;
+} {
+  const match = target.match(LINE_COLUMN_SUFFIX_PATTERN);
+  if (!match) {
+    return {
+      filePath: target,
+      suffix: "",
+    };
+  }
+  return {
+    filePath: target.slice(0, -match[0].length),
+    suffix: match[0],
+  };
+}
 function resolvePathEnvironmentVariable(env: NodeJS.ProcessEnv): string {
   return env.PATH ?? env.Path ?? env.path ?? "";
 }
   return `'${value.replaceAll("'", "''")}'`;
 }
+function quotePowerShellArgument(value: string): string {
+  return `"\`"${value.replaceAll("`", "``").replaceAll('"', '`"')}\`""`;
+}
 function encodePowerShellCommand(command: string): string {
   return Buffer.from(command, "utf16le").toString("base64");
 }
   return runtime.isWsl && !runtime.isInsideContainer && isUriLikeTarget(input.target);
 }
+function makeWindowsEditorProtocolTarget(editor: EditorId, target: string): string | undefined {
+  const scheme = WINDOWS_EDITOR_URI_SCHEMES[editor];
+  if (!scheme) return undefined;
+  const { filePath, suffix } = splitLineColumnSuffix(target);
+  const fileUrl = pathToFileURL(filePath).href;
+  const fileTarget = fileUrl.startsWith("file:///")
+    ? fileUrl.slice("file:///".length)
+    : fileUrl.replace(/^file:\/\//, "");
+  return `${scheme}://file/${fileTarget}${suffix}`;
+}
 function makeLaunchPlan(
   command: string,
   args: ReadonlyArray<string>,
   args: ReadonlyArray<string>,
 ): ReadonlyArray<string> {
   const argumentList =
-    args.length > 0 ? ` -ArgumentList ${args.map(quotePowerShellValue).join(", ")}` : "";
+    args.length > 0 ? ` -ArgumentList ${args.map(quotePowerShellArgument).join(",")}` : "";
-  const command = `Start-Process -FilePath ${quotePowerShellValue(commandPath)}${argumentList} -WindowStyle Hidden`;
+  const command = `Start ${quotePowerShellArgument(commandPath)}${argumentList} -WindowStyle Hidden`;
   return [
     "-NoProfile",
     "-NonInteractive",
   return makeLaunchPlan("explorer", [input.target], {
     wait: false,
     allowNonzeroExitCode: false,
+    detached: true,
+    stdio: "ignore",
     shell: false,
   });
 }
       args: makePowerShellStartProcessArgs(resolvedCommand.path, plan.args),
       ...(plan.detached !== undefined ? { detached: plan.detached } : {}),
       ...(plan.shell !== undefined ? { shell: plan.shell } : {}),
+      ...(runtime.platform === "win32"
+        ? { windowsVerbatimArguments: true, windowsHide: true }
+        : {}),
       ...(plan.stdio === "ignore"
         ? {
             stdin: "ignore" as const,
         : {}),
     };
   }
+  const windowsHide = runtime.platform === "win32" && plan.detached ? true : undefined;
   return {
     command: resolvedCommand.usesCmdWrapper
       ? resolveWindowsCommandShell(runtime.env)
       : [...plan.args],
     ...(plan.detached !== undefined ? { detached: plan.detached } : {}),
     ...(plan.shell !== undefined ? { shell: plan.shell } : {}),
+    ...(windowsHide ? { windowsHide } : {}),
     ...(resolvedCommand.usesCmdWrapper ? { windowsVerbatimArguments: true } : {}),
     ...(plan.stdio === "ignore"
       ? {
       spawnNodeChildProcess(input.command, [...input.args], {
         ...(input.detached !== undefined ? { detached: input.detached } : {}),
         ...(input.shell !== undefined ? { shell: input.shell } : {}),
+        ...(input.windowsHide !== undefined ? { windowsHide: input.windowsHide } : {}),
         ...(input.windowsVerbatimArguments !== undefined
           ? { windowsVerbatimArguments: input.windowsVerbatimArguments }
           : {}),
         return yield* new DesktopLauncherUnknownEditorError({ editor: input.editor });
       }
+      const windowsEditorProtocolTarget =
+        runtime.platform === "win32"
+          ? makeWindowsEditorProtocolTarget(input.editor, input.cwd)
+          : undefined;
+      if (windowsEditorProtocolTarget) {
+        return yield* runFirstAvailablePlan(
+          [makeWindowsExplorerPlan({ target: windowsEditorProtocolTarget })],
+          {
+            operation: "openInEditor",
+            target: input.cwd,
+            editor: input.editor,
+          },
+        );
+      }
       if (editor.command) {
         return yield* runFirstAvailablePlan(
           [

apps/server/tmp-test.cmd+3−0

@@ -0,0 +1,3 @@
	1	@echo off
	2	echo started >> spawned2.txt
	3