chore: cleanup

Author: cmoog

.prettierrc

@@ -5,9 +5,7 @@
   "overrides": [
     {
       "files": [
-        "./README.md",
-        "./reports/**/*.md",
-        "./rfcs/**/*.md"
+        "./README.md"
       ],
       "options": {
         "printWidth": 80,

src/extension.ts

@@ -10,26 +10,28 @@ import {
   rebuildWorkspace,
   openWorkspace,
   shutdownWorkspace,
+  CoderWorkspaceListItem,
 } from "./workspaces"
 import { coderWorkspaceLogsDocumentProvider, handleShowLogsCommand } from "./logs"
 
 export function activate(context: vscode.ExtensionContext) {
   preflightCheckCoderInstalled()
+
   const workspaceProvider = new CoderWorkspacesProvider()
 
   vscode.commands.registerCommand("coderWorkspaces.showWorkspaceLogs", handleShowLogsCommand)
   vscode.window.registerTreeDataProvider("coderWorkspaces", workspaceProvider)
   vscode.window.registerTreeDataProvider("coderHelpFeedback", new CoderHelpProvider())
-  vscode.commands.registerCommand("coderWorkspaces.openWorkspace", (ws: CoderWorkspace) => {
-    const { name } = ws.workspace
+  vscode.commands.registerCommand("coderWorkspaces.openWorkspace", (item: CoderWorkspaceListItem) => {
+    const { name } = item.workspace
     openWorkspace(name)
   })
-  vscode.commands.registerCommand("coderWorkspaces.rebuildWorkspace", (ws: CoderWorkspace) => {
-    const { name } = ws.workspace
+  vscode.commands.registerCommand("coderWorkspaces.rebuildWorkspace", (item: CoderWorkspaceListItem) => {
+    const { name } = item.workspace
     rebuildWorkspace(name).then(() => workspaceProvider.refresh())
   })
-  vscode.commands.registerCommand("coderWorkspaces.shutdownWorkspace", (ws: CoderWorkspace) => {
-    const { name } = ws.workspace
+  vscode.commands.registerCommand("coderWorkspaces.shutdownWorkspace", (item: CoderWorkspaceListItem) => {
+    const { name } = item.workspace
     shutdownWorkspace(name).then(() => workspaceProvider.refresh())
   })
 

src/utils.ts

@@ -1,3 +1,24 @@
 import * as path from "path"
+import * as cp from "child_process"
+import * as vscode from "vscode"
 
 export const mediaDir = path.join(__filename, "..", "..", "media")
+
+export const exec = async (command: string): Promise<string> => {
+  return new Promise((res, rej) => {
+    cp.exec(command, (err, stdout) => (err ? rej(err) : res(stdout)))
+  })
+}
+
+export const execJSON = async <T>(command: string): Promise<T> => {
+  const output = await exec(command)
+  return JSON.parse(output)
+}
+
+export const bubbleError = (f: () => void) => {
+  try {
+    f()
+  } catch (e) {
+    vscode.window.showErrorMessage(JSON.stringify(e))
+  }
+}

src/workspaces.ts

@@ -1,13 +1,14 @@
 import * as vscode from "vscode"
 import * as cp from "child_process"
 import * as path from "path"
-import { mediaDir } from "./utils"
+import { exec, mediaDir, execJSON } from "./utils"
 
-export class CoderWorkspacesProvider implements vscode.TreeDataProvider<CoderWorkspace> {
-  private _onDidChangeTreeData: vscode.EventEmitter<CoderWorkspace | undefined | void> = new vscode.EventEmitter<
-    CoderWorkspace | undefined | void
-  >()
-  readonly onDidChangeTreeData: vscode.Event<CoderWorkspace | undefined | void> = this._onDidChangeTreeData.event
+export class CoderWorkspacesProvider implements vscode.TreeDataProvider<CoderWorkspaceListItem> {
+  private _onDidChangeTreeData: vscode.EventEmitter<
+    CoderWorkspaceListItem | undefined | void
+  > = new vscode.EventEmitter<CoderWorkspaceListItem | undefined | void>()
+  readonly onDidChangeTreeData: vscode.Event<CoderWorkspaceListItem | undefined | void> = this._onDidChangeTreeData
+    .event
 
   constructor() {
     this.refresh()
@@ -17,87 +18,53 @@ export class CoderWorkspacesProvider implements vscode.TreeDataProvider<CoderWor
     this._onDidChangeTreeData.fire()
   }
 
-  getTreeItem(element: CoderWorkspace): vscode.TreeItem {
+  getTreeItem(element: CoderWorkspaceListItem): vscode.TreeItem {
     return element
   }
 
-  getChildren(element?: CoderWorkspace): Thenable<CoderWorkspace[]> {
-    return getWorkspaces()
+  getChildren(element?: CoderWorkspaceListItem): Thenable<CoderWorkspaceListItem[]> {
+    return getWorkspaceItems()
   }
 }
 
 export const rebuildWorkspace = async (name: string): Promise<void> => {
-  return new Promise((res, rej) => {
-    cp.exec(`coder envs rebuild ${name} --force`, (err, stdout, stderr) => {
-      if (err) {
-        vscode.window.showErrorMessage(`Failed to rebuild Coder Workspaces: ${err}`)
-        rej(err)
-        return
-      }
-      res()
-      vscode.window.showInformationMessage(`Rebuilding Coder Workspace "${name}"`)
-    })
-  })
+  try {
+    await exec(`coder envs rebuild ${name} --force`)
+    vscode.window.showInformationMessage(`Rebuilding Coder Workspace "${name}"`)
+  } catch (e) {
+    vscode.window.showErrorMessage(`Failed to rebuild Coder Workspaces: ${e}`)
+  }
 }
 
 export const shutdownWorkspace = async (name: string): Promise<void> => {
-  return new Promise((res, rej) => {
-    cp.exec(`coder envs stop ${name}`, (err, stdout, stderr) => {
-      if (err) {
-        vscode.window.showErrorMessage(`Failed to shutdown Coder Workspaces: ${err}`)
-        rej(err)
-        return
-      }
-      res()
-      vscode.window.showInformationMessage(`Shutting down Coder Workspace "${name}"`)
-    })
-  })
+  try {
+    await exec(`coder envs stop ${name}`)
+    vscode.window.showInformationMessage(`Shutting down Coder Workspace "${name}"`)
+  } catch (e) {
+    vscode.window.showErrorMessage(`Failed to shutdown Coder Workspaces: ${e}`)
+  }
 }
 
 export const openWorkspace = async (name: string): Promise<void> => {
-  return new Promise((res, rej) => {
-    cp.exec(
-      `coder config-ssh && code --remote "ssh-remote+coder.${name}" $(coder sh ${name} pwd | head -n 1)`,
-      (err, stdout, stderr) => {
-        if (err) {
-          vscode.window.showErrorMessage(`Failed to open Coder Workspaces: ${err}`)
-          rej(err)
-          return
-        }
-        res()
-        vscode.window.showInformationMessage(`Opening Coder Workspace "${name}"`)
-      },
-    )
-  })
+  try {
+    await exec(`coder config-ssh && code --remote "ssh-remote+coder.${name}" $(coder sh ${name} pwd | head -n 1)`)
+    vscode.window.showInformationMessage(`Opening Coder Workspace ${name}`)
+  } catch (e) {
+    vscode.window.showErrorMessage(`Failed to open Coder Workspace ${name}: ${e}`)
+  }
+  return
 }
 
-const getWorkspaces = async (): Promise<CoderWorkspace[]> => {
+const getWorkspaceItems = async (): Promise<CoderWorkspaceListItem[]> => {
   const images = await getImages()
-  return new Promise((res, rej) => {
-    cp.exec("coder envs ls --output json", (err, stdout, stderr) => {
-      if (err) {
-        vscode.window.showErrorMessage("Failed to fetch Coder Workspaces")
-        res([])
-        return
-      }
-      const workspaces: CoderWorkspace[] = JSON.parse(stdout)
-      res(workspaces.map((w) => new CoderWorkspace(w, images, vscode.TreeItemCollapsibleState.None)))
-    })
-  })
+  const envs = await getWorkspaces()
+  return envs.map((w) => new CoderWorkspaceListItem(w, images, vscode.TreeItemCollapsibleState.None))
 }
 
-const getImages = (): Promise<CoderImage[]> => {
-  return new Promise((res, rej) => {
-    cp.exec("coder images ls --output json", (err, stdout, stderr) => {
-      if (err) {
-        vscode.window.showErrorMessage("Failed to fetch Coder Images")
-        res([])
-        return
-      }
-      res(JSON.parse(stdout))
-    })
-  })
-}
+const getWorkspaces = async (): Promise<CoderWorkspace[]> =>
+  await execJSON<CoderWorkspace[]>("coder envs ls --output json")
+
+const getImages = (): Promise<CoderImage[]> => execJSON<CoderImage[]>(`coder images ls --output json`)
 
 export interface CoderWorkspace {
   id: string
@@ -108,6 +75,7 @@ export interface CoderWorkspace {
   image_tag: string
   image_id: string
   gpus: number
+  updating: boolean
   latest_stat: {
     container_status: string
   }
@@ -118,7 +86,7 @@ export interface CoderImage {
   repository: string
 }
 
-export class CoderWorkspace extends vscode.TreeItem {
+export class CoderWorkspaceListItem extends vscode.TreeItem {
   constructor(
     public readonly workspace: CoderWorkspace,
     public readonly images: CoderImage[],