From 10a2dd6010ff21d4ffa3cff6a1cb83c020ded722 Mon Sep 17 00:00:00 2001
From: Asher <ash@coder.com>
Date: Wed, 31 Jan 2024 11:00:58 -0900
Subject: [PATCH 1/2] Refresh workspaces list

---
 src/extension.ts          | 11 +++++++--
 src/workspacesProvider.ts | 50 ++++++++++++++++++++++++++++++++++++---
 2 files changed, 56 insertions(+), 5 deletions(-)

diff --git a/src/extension.ts b/src/extension.ts
index 8167c7ff..66754b50 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -90,12 +90,19 @@ export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
     return config
   })
 
-  const myWorkspacesProvider = new WorkspaceProvider(WorkspaceQuery.Mine, storage)
+  const myWorkspacesProvider = new WorkspaceProvider(WorkspaceQuery.Mine, storage, 5)
   const allWorkspacesProvider = new WorkspaceProvider(WorkspaceQuery.All, storage)
 
-  vscode.window.registerTreeDataProvider("myWorkspaces", myWorkspacesProvider)
+  // createTreeView, unlike registerTreeDataProvider, gives us the tree view API
+  // (so we can see when it is visible) but otherwise they have the same effect.
+  const wsTree = vscode.window.createTreeView("myWorkspaces", { treeDataProvider: myWorkspacesProvider })
   vscode.window.registerTreeDataProvider("allWorkspaces", allWorkspacesProvider)
 
+  myWorkspacesProvider.setVisibility(wsTree.visible)
+  wsTree.onDidChangeVisibility((event) => {
+    myWorkspacesProvider.setVisibility(event.visible)
+  })
+
   const url = storage.getURL()
   if (url) {
     getAuthenticatedUser()
diff --git a/src/workspacesProvider.ts b/src/workspacesProvider.ts
index fba0f65a..2928e66d 100644
--- a/src/workspacesProvider.ts
+++ b/src/workspacesProvider.ts
@@ -14,17 +14,22 @@ export enum WorkspaceQuery {
 export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
   private workspaces: WorkspaceTreeItem[] = []
   private agentWatchers: Record<WorkspaceAgent["id"], { dispose: () => void; metadata?: AgentMetadataEvent[] }> = {}
+  private timeout: NodeJS.Timeout | undefined
+  private visible = false
   private fetching = false
 
   constructor(
     private readonly getWorkspacesQuery: WorkspaceQuery,
     private readonly storage: Storage,
+    private readonly timerSeconds?: number,
   ) {
     this.fetchAndRefresh()
   }
 
-  // fetchAndRefresh fetches new workspaces then re-renders the entire tree.
-  // Trying to call this while already refreshing is a no-op and will return
+  // fetchAndRefresh fetches new workspaces, re-renders the entire tree, then
+  // keeps refreshing (if a timer length was provided) as long as the user is
+  // still logged in and no errors were encountered fetching workspaces.
+  // Calling this while already refreshing is a no-op and will return
   // immediately.
   async fetchAndRefresh() {
     if (this.fetching) {
@@ -32,16 +37,24 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
     }
     this.fetching = true
 
+    // TODO: It would be better to reuse these.
     Object.values(this.agentWatchers).forEach((watcher) => watcher.dispose())
 
+    // It is possible we called fetchAndRefresh() manually (through the button
+    // for example), in which case we might still have a pending refresh that
+    // needs to be cleared.
+    this.cancelPendingRefresh()
+
     try {
       this.workspaces = await this.fetch()
+      this.fetching = false
+      this.maybeScheduleRefresh()
     } catch (error) {
       this.workspaces = []
+      this.fetching = false
     }
 
     this.refresh()
-    this.fetching = false
   }
 
   /**
@@ -82,6 +95,37 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
     })
   }
 
+  /**
+   * Either start or stop the refresh timer based on visibility.
+   */
+  setVisibility(visible: boolean) {
+    this.visible = visible
+    if (!visible) {
+      this.cancelPendingRefresh()
+    } else {
+      this.maybeScheduleRefresh()
+    }
+  }
+
+  private cancelPendingRefresh() {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+      this.timeout = undefined
+    }
+  }
+
+  /**
+   * Schedule a refresh if one is not already scheduled or underway and a
+   * timeout length was provided.
+   */
+  private maybeScheduleRefresh() {
+    if (this.timerSeconds && !this.timeout && !this.fetching) {
+      this.timeout = setTimeout(() => {
+        this.fetchAndRefresh()
+      }, this.timerSeconds * 1000)
+    }
+  }
+
   private _onDidChangeTreeData: vscode.EventEmitter<vscode.TreeItem | undefined | null | void> =
     new vscode.EventEmitter<vscode.TreeItem | undefined | null | void>()
   readonly onDidChangeTreeData: vscode.Event<vscode.TreeItem | undefined | null | void> =

From 62e514320d2baa9894923e9f6aac62deffb6ecf5 Mon Sep 17 00:00:00 2001
From: Asher <ash@coder.com>
Date: Thu, 1 Feb 2024 13:32:44 -0900
Subject: [PATCH 2/2] Set fetching once

---
 src/workspacesProvider.ts | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/workspacesProvider.ts b/src/workspacesProvider.ts
index 2928e66d..830409a3 100644
--- a/src/workspacesProvider.ts
+++ b/src/workspacesProvider.ts
@@ -45,16 +45,22 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
     // needs to be cleared.
     this.cancelPendingRefresh()
 
+    let hadError = false
     try {
       this.workspaces = await this.fetch()
-      this.fetching = false
-      this.maybeScheduleRefresh()
     } catch (error) {
+      hadError = true
       this.workspaces = []
-      this.fetching = false
     }
 
+    this.fetching = false
+
     this.refresh()
+
+    // As long as there was no error we can schedule the next refresh.
+    if (hadError) {
+      this.maybeScheduleRefresh()
+    }
   }
 
   /**