Add deletion patch.

Author: sleexyz

patches/cleanup-socket.diff

@@ -0,0 +1,47 @@
+Delete session from session registry on extension host termination.
+
+Index: code-server/lib/vscode/src/vs/workbench/api/node/extensionHostProcess.ts
+===================================================================
+--- code-server.orig/lib/vscode/src/vs/workbench/api/node/extensionHostProcess.ts
++++ code-server/lib/vscode/src/vs/workbench/api/node/extensionHostProcess.ts
+@@ -3,6 +3,9 @@
+  *  Licensed under the MIT License. See License.txt in the project root for license information.
+  *--------------------------------------------------------------------------------------------*/
+ 
++import * as os from 'os';
++import * as _http from 'http';
++import * as path from 'vs/base/common/path';
+ import * as nativeWatchdog from 'native-watchdog';
+ import * as net from 'net';
+ import * as minimist from 'minimist';
+@@ -400,7 +403,29 @@ async function startExtensionHostProcess
+ 	);
+ 
+ 	// rewrite onTerminate-function to be a proper shutdown
+-	onTerminate = (reason: string) => extensionHostMain.terminate(reason);
++	onTerminate = (reason: string) => {
++		extensionHostMain.terminate(reason);
++		(() => {
++			const socketPath = process.env['VSCODE_IPC_HOOK_CLI'];
++			if (!socketPath) {
++				return;
++			}
++			const message = JSON.stringify({socketPath});
++			const codeServerSocketPath = path.join(os.tmpdir(), 'code-server-ipc.sock');
++			const opts: _http.RequestOptions = {
++				path: '/delete-session',
++				socketPath: codeServerSocketPath,
++				method: 'POST',
++				headers: {
++					'content-type': 'application/json',
++					'accept': 'application/json'
++				}
++			};
++			const req = _http.request(opts);
++			req.write(message);
++			req.end();
++		})();
++	};
+ }
+ 
+ startExtensionHostProcess().catch((err) => console.log(err));

patches/series

@@ -8,6 +8,7 @@ insecure-notification.diff
 update-check.diff
 logout.diff
 store-socket.diff
+cleanup-socket.diff
 proxy-uri.diff
 github-auth.diff
 unique-db.diff

patches/store-socket.diff

@@ -53,7 +53,7 @@ Index: code-server/lib/vscode/src/vs/workbench/api/node/extHostExtensionService.
 +			const codeServerSocketPath = path.join(os.tmpdir(), 'code-server-ipc.sock');
 +			await new Promise<void>((resolve, reject) => {
 +				const opts: _http.RequestOptions = {
-+					path: '/session',
++					path: '/add-session',
 +					socketPath: codeServerSocketPath,
 +					method: 'POST',
 +					headers: {

src/node/vscodeSocket.ts

@@ -24,11 +24,11 @@ export interface EditorSessionEntry {
   socketPath: string
 }
 
-// interface DeleteSessionRequest {
-//   socketPath: string
-// }
+interface DeleteSessionRequest {
+  socketPath: string
+}
 
-interface RegisterSessionRequest {
+interface AddSessionRequest {
   entry: EditorSessionEntry
 }
 
@@ -37,52 +37,15 @@ interface GetSessionResponse {
   socketPath?: string
 }
 
-export class EditorSessionManagerClient {
-  constructor(private codeServerSocketPath: string) {}
-
-  async canConnect() {
-    return canConnect(this.codeServerSocketPath)
-  }
-
-  async getConnectedSocketPath(filePath: string): Promise<string | undefined> {
-    const response = await new Promise<GetSessionResponse>((resolve, reject) => {
-      const opts = {
-        path: "/session?filePath=" + encodeURIComponent(filePath),
-        socketPath: this.codeServerSocketPath,
-      }
-      const req = http.get(opts, (res) => {
-        let rawData = ""
-        res.setEncoding("utf8")
-        res.on("data", (chunk) => {
-          rawData += chunk
-        })
-        res.on("end", () => {
-          try {
-            const obj = JSON.parse(rawData)
-            if (res.statusCode === 200) {
-              resolve(obj)
-            } else {
-              reject(new Error("Unexpected status code: " + res.statusCode))
-            }
-          } catch (e: unknown) {
-            reject(e)
-          }
-        })
-      })
-      req.on("error", reject)
-      req.end()
-    })
-    return response.socketPath
-  }
-}
-
 export async function makeEditorSessionManagerServer(
   codeServerSocketPath: string,
   editorSessionManager: EditorSessionManager,
 ): Promise<http.Server> {
   const router = express()
+
   // eslint-disable-next-line import/no-named-as-default-member
   router.use(express.json())
+
   router.get("/session", async (req, res) => {
     const filePath = req.query.filePath as string
     if (!filePath) {
@@ -97,17 +60,25 @@ export async function makeEditorSessionManagerServer(
       res.status(500).send(error)
     }
   })
-  router.post("/session", async (req, res) => {
-    const request = req.body as RegisterSessionRequest
+
+  router.post("/add-session", async (req, res) => {
+    const request = req.body as AddSessionRequest
     if (!request.entry) {
       res.status(400).send("entry is required")
     }
-    editorSessionManager.registerSession(request.entry)
+    editorSessionManager.addSession(request.entry)
     res.status(200).send()
   })
-  router.delete("/session", async (req, res) => {
-    throw new Error("Not implemented")
+
+  router.post("/delete-session", async (req, res) => {
+    const request = req.body as DeleteSessionRequest
+    if (!request.socketPath) {
+      res.status(400).send("socketPath is required")
+    }
+    editorSessionManager.deleteSession(request.socketPath)
+    res.status(200).send()
   })
+
   const server = http.createServer(router)
   try {
     await fs.unlink(codeServerSocketPath)
@@ -133,18 +104,19 @@ export class EditorSessionManager {
   // Map from socket path to EditorSessionEntry.
   private entries = new Map<string, EditorSessionEntry>()
 
-  registerSession(entry: EditorSessionEntry): void {
+  addSession(entry: EditorSessionEntry): void {
+    logger.debug(`Adding session to session registry: ${entry.socketPath}`)
     this.entries.set(entry.socketPath, entry)
   }
 
-  getCandidatesForFile(path: string): EditorSessionEntry[] {
+  getCandidatesForFile(filePath: string): EditorSessionEntry[] {
     const matchCheckResults = new Map<string, boolean>()
 
     const checkMatch = (entry: EditorSessionEntry): boolean => {
       if (matchCheckResults.has(entry.socketPath)) {
         return matchCheckResults.get(entry.socketPath)!
       }
-      const result = this.containsPath(entry, path)
+      const result = entry.workspace.folders.some((folder) => filePath.startsWith(folder.uri.path + path.sep))
       matchCheckResults.set(entry.socketPath, result)
       return result
     }
@@ -165,17 +137,17 @@ export class EditorSessionManager {
       })
   }
 
-  private containsPath(entry: EditorSessionEntry, path: string): boolean {
-    return entry.workspace.folders.some((folder) => path.startsWith(folder.uri.path))
+  async deleteSession(socketPath: string): Promise<void> {
+    logger.debug(`Deleting session from session registry: ${socketPath}`)
+    this.entries.delete(socketPath)
   }
 
   /**
    * Returns the best socket path that we can connect to.
-   * See getSocketPaths for the order of preference.
    * We also delete any sockets that we can't connect to.
    */
-  async getConnectedSocketPath(path: string): Promise<string | undefined> {
-    const candidates = this.getCandidatesForFile(path)
+  async getConnectedSocketPath(filePath: string): Promise<string | undefined> {
+    const candidates = this.getCandidatesForFile(filePath)
     let match: EditorSessionEntry | undefined = undefined
 
     const toDelete = new Set<EditorSessionEntry>()
@@ -189,11 +161,49 @@ export class EditorSessionManager {
 
     if (toDelete.size > 0) {
       for (const candidate of toDelete) {
-        logger.debug(`Deleting stale socket from socket registry: ${candidate.socketPath}`)
-        this.entries.delete(candidate.socketPath)
+        this.deleteSession(candidate.socketPath)
       }
     }
 
     return match?.socketPath
   }
 }
+
+export class EditorSessionManagerClient {
+  constructor(private codeServerSocketPath: string) {}
+
+  async canConnect() {
+    return canConnect(this.codeServerSocketPath)
+  }
+
+  async getConnectedSocketPath(filePath: string): Promise<string | undefined> {
+    const response = await new Promise<GetSessionResponse>((resolve, reject) => {
+      const opts = {
+        path: "/session?filePath=" + encodeURIComponent(filePath),
+        socketPath: this.codeServerSocketPath,
+      }
+      const req = http.get(opts, (res) => {
+        let rawData = ""
+        res.setEncoding("utf8")
+        res.on("data", (chunk) => {
+          rawData += chunk
+        })
+        res.on("end", () => {
+          try {
+            const obj = JSON.parse(rawData)
+            if (res.statusCode === 200) {
+              resolve(obj)
+            } else {
+              reject(new Error("Unexpected status code: " + res.statusCode))
+            }
+          } catch (e: unknown) {
+            reject(e)
+          }
+        })
+      })
+      req.on("error", reject)
+      req.end()
+    })
+    return response.socketPath
+  }
+}