myhololens
diff --git a/‎src/actions/setupActions.ts
Lines changed: 1 addition & 3 deletions b/‎src/actions/setupActions.ts
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/actions/solutionActions.ts
Lines changed: 2 additions & 7 deletions b/‎src/actions/solutionActions.ts
Lines changed: 2 additions & 7 deletions
diff --git a/‎src/actions/utils/loadWatchers.ts
Lines changed: 3 additions & 7 deletions b/‎src/actions/utils/loadWatchers.ts
Lines changed: 3 additions & 7 deletions
diff --git a/‎src/actions/utils/runCommands.ts
Lines changed: 2 additions & 2 deletions b/‎src/actions/utils/runCommands.ts
Lines changed: 2 additions & 2 deletions
diff --git a/‎src/channel/index.ts
Lines changed: 4 additions & 8 deletions b/‎src/channel/index.ts
Lines changed: 4 additions & 8 deletions
diff --git a/‎src/editor/commands.ts
Lines changed: 1 addition & 3 deletions b/‎src/editor/commands.ts
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/editor/index.ts
Lines changed: 1 addition & 8 deletions b/‎src/editor/index.ts
Lines changed: 1 addition & 8 deletions
diff --git a/‎src/environment.ts
Lines changed: 5 additions & 0 deletions b/‎src/environment.ts
Lines changed: 5 additions & 0 deletions
diff --git a/‎src/services/dependencies/index.ts
Lines changed: 2 additions & 2 deletions b/‎src/services/dependencies/index.ts
Lines changed: 2 additions & 2 deletions
diff --git a/‎src/services/git/index.ts
Lines changed: 11 additions & 11 deletions b/‎src/services/git/index.ts
Lines changed: 11 additions & 11 deletions
@@ -1,14 +1,12 @@
 import * as T from 'typings'
 import * as TT from 'typings/tutorial'
-import * as vscode from 'vscode'
 import * as git from '../services/git'
 import loadWatchers from './utils/loadWatchers'
 import openFiles from './utils/openFiles'
 import runCommands from './utils/runCommands'
 import onError from '../services/sentry/onError'
 
 const setupActions = async (
-  workspaceRoot: vscode.WorkspaceFolder,
   actions: TT.StepActions,
   send: (action: T.Action) => void, // send messages to client
 ): Promise<void> => {
@@ -26,7 +24,7 @@ const setupActions = async (
   openFiles(files || [])
 
   // 3. start file watchers
-  loadWatchers(watchers || [], workspaceRoot.uri)
+  loadWatchers(watchers || [])
 
   // 4. run command
   await runCommands(commands || [], send).catch(onError)
 
@@ -1,17 +1,12 @@
 import * as T from 'typings'
 import * as TT from 'typings/tutorial'
-import * as vscode from 'vscode'
 import * as git from '../services/git'
 import setupActions from './setupActions'
 import onError from '../services/sentry/onError'
 
-const solutionActions = async (
-  workspaceRoot: vscode.WorkspaceFolder,
-  stepActions: TT.StepActions,
-  send: (action: T.Action) => void,
-): Promise<void> => {
+const solutionActions = async (stepActions: TT.StepActions, send: (action: T.Action) => void): Promise<void> => {
   await git.clear()
-  return setupActions(workspaceRoot, stepActions, send).catch(onError)
+  return setupActions(stepActions, send).catch(onError)
 }
 
 export default solutionActions
@@ -1,6 +1,7 @@
 import * as chokidar from 'chokidar'
 import * as vscode from 'vscode'
 import { COMMANDS } from '../../editor/commands'
+import environment from '../../environment'
 
 // NOTE: vscode createFileWatcher doesn't seem to detect changes outside of vscode
 // such as `npm install` of a package. Went with chokidar instead
@@ -13,7 +14,7 @@ const disposeWatcher = (watcher: string) => {
   delete watcherObject[watcher]
 }
 
-const loadWatchers = (watchers: string[], workspaceUri: vscode.Uri) => {
+const loadWatchers = (watchers: string[]) => {
   if (!watchers.length) {
     // remove all watchers
     for (const watcher of Object.keys(watcherObject)) {
@@ -24,13 +25,8 @@ const loadWatchers = (watchers: string[], workspaceUri: vscode.Uri) => {
     if (!watcherObject[watcher]) {
       // see how glob patterns are used in VSCode (not like a regex)
       // https://code.visualstudio.com/api/references/vscode-api#GlobPattern
-      const rootUri = vscode.workspace.getWorkspaceFolder(workspaceUri)
-      if (!rootUri) {
-        return
-      }
-
       const fsWatcher: chokidar.FSWatcher = chokidar.watch(watcher, {
-        cwd: rootUri.uri.path,
+        cwd: environment.WORKSPACE_ROOT,
         interval: 1000,
       })
 
 
@@ -1,5 +1,5 @@
 import * as T from 'typings'
-import node from '../../services/node'
+import { exec } from '../../services/node'
 
 const runCommands = async (commands: string[], send: (action: T.Action) => void) => {
   if (!commands.length) {
@@ -13,7 +13,7 @@ const runCommands = async (commands: string[], send: (action: T.Action) => void)
     send({ type: 'COMMAND_START', payload: { process: { ...process, status: 'RUNNING' } } })
     let result: { stdout: string; stderr: string }
     try {
-      result = await node.exec(command)
+      result = await exec(command)
     } catch (error) {
       console.log(error)
       send({ type: 'COMMAND_FAIL', payload: { process: { ...process, status: 'FAIL' } } })
 
@@ -14,7 +14,6 @@ import { openWorkspace, checkWorkspaceEmpty } from '../services/workspace'
 import { readFile } from 'fs'
 import { join } from 'path'
 import { promisify } from 'util'
-import { compare } from 'semver'
 
 const readFileAsync = promisify(readFile)
 
@@ -26,18 +25,15 @@ interface Channel {
 interface ChannelProps {
   postMessage: (action: T.Action) => Thenable<boolean>
   workspaceState: vscode.Memento
-  workspaceRoot: vscode.WorkspaceFolder
 }
 
 class Channel implements Channel {
   private postMessage: (action: T.Action) => Thenable<boolean>
   private workspaceState: vscode.Memento
-  private workspaceRoot: vscode.WorkspaceFolder
   private context: Context
-  constructor({ postMessage, workspaceState, workspaceRoot }: ChannelProps) {
+  constructor({ postMessage, workspaceState }: ChannelProps) {
     // workspaceState used for local storage
     this.workspaceState = workspaceState
-    this.workspaceRoot = workspaceRoot
     this.postMessage = postMessage
     this.context = new Context(workspaceState)
   }
@@ -181,7 +177,7 @@ class Channel implements Channel {
         return
       case 'EDITOR_VALIDATE_SETUP':
         // 1. check workspace is selected
-        const isEmptyWorkspace = await checkWorkspaceEmpty(this.workspaceRoot.uri.path)
+        const isEmptyWorkspace = await checkWorkspaceEmpty()
         if (!isEmptyWorkspace) {
           const error: E.ErrorMessage = {
             type: 'WorkspaceNotEmpty',
@@ -225,11 +221,11 @@ class Channel implements Channel {
       // load step actions (git commits, commands, open files)
       case 'SETUP_ACTIONS':
         await vscode.commands.executeCommand(COMMANDS.SET_CURRENT_STEP, action.payload)
-        setupActions(this.workspaceRoot, action.payload, this.send)
+        setupActions(action.payload, this.send)
         return
       // load solution step actions (git commits, commands, open files)
       case 'SOLUTION_ACTIONS':
-        await solutionActions(this.workspaceRoot, action.payload, this.send)
+        await solutionActions(action.payload, this.send)
         // run test following solution to update position
         vscode.commands.executeCommand(COMMANDS.RUN_TEST, action.payload)
         return
 
@@ -14,10 +14,9 @@ export const COMMANDS = {
 interface CreateCommandProps {
   extensionPath: string
   workspaceState: vscode.Memento
-  workspaceRoot: vscode.WorkspaceFolder
 }
 
-export const createCommands = ({ extensionPath, workspaceState, workspaceRoot }: CreateCommandProps) => {
+ 10000export const createCommands = ({ extensionPath, workspaceState }: CreateCommandProps) => {
   // React panel webview
   let webview: any
   let currentStepId = ''
@@ -41,7 +40,6 @@ export const createCommands = ({ extensionPath, workspaceState, workspaceRoot }:
       webview = createWebView({
         extensionPath,
         workspaceState,
-        workspaceRoot,
       })
     },
     // open React webview
 
@@ -1,4 +1,5 @@
 import * as vscode from 'vscode'
+import notify from '../services/notify'
 import { createCommands } from './commands'
 
 class Editor {
@@ -28,18 +29,10 @@ class Editor {
   }
 
   private activateCommands = (): void => {
-    // set workspace root for node executions
-    const workspaceRoots: vscode.WorkspaceFolder[] | undefined = vscode.workspace.workspaceFolders
-    if (!workspaceRoots || !workspaceRoots.length) {
-      throw new Error('No workspace root path')
-    }
-    const workspaceRoot: vscode.WorkspaceFolder = workspaceRoots[0]
-
     const commands = createCommands({
       extensionPath: this.vscodeExt.extensionPath,
       // NOTE: local storage must be bound to the vscodeExt.workspaceState
       workspaceState: this.vscodeExt.workspaceState,
-      workspaceRoot,
     })
 
     // register commands
 
@@ -2,12 +2,16 @@ require('dotenv').config({
   path: './web-app/.env',
 })
 
+import * as vscode from 'vscode'
+import { getWorkspaceRoot } from './services/workspace'
+
 interface Environment {
   VERSION: string
   NODE_ENV: string
   LOG: boolean
   API_URL: string
   SENTRY_DSN: string | null
+  WORKSPACE_ROOT: string
 }
 
 const environment: Environment = {
@@ -16,6 +20,7 @@ const environment: Environment = {
   LOG: (process.env.LOG || '').toLowerCase() === 'true',
   API_URL: process.env.REACT_APP_GQL_URI || '',
   SENTRY_DSN: process.env.SENTRY_DSN || null,
+  WORKSPACE_ROOT: getWorkspaceRoot(),
 }
 
 export default environment
@@ -1,11 +1,11 @@
 import { satisfies } from 'semver'
-import node from '../node'
+import { exec } from '../node'
 
 const semverRegex = /(?<=^v?|\sv?)(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[\da-z-]*[a-z-][\da-z-]*)(?:\.(?:0|[1-9]\d*|[\da-z-]*[a-z-][\da-z-]*))*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?(?=$|\s)/gi
 
 export const version = async (name: string): Promise<string | null> => {
   try {
-    const { stdout, stderr } = await node.exec(`${name} --version`)
+    const { stdout, stderr } = await exec(`${name} --version`)
     if (!stderr) {
       const match = stdout.match(semverRegex)
       if (match) {
 
@@ -1,12 +1,12 @@
 import * as TT from 'typings/tutorial'
-import node from '../node'
+import { exec, exists } from '../node'
 import logger from '../logger'
 
 const gitOrigin = 'coderoad'
 
 const stashAllFiles = async (): Promise<never | void> => {
   // stash files including untracked (eg. newly created file)
-  const { stdout, stderr } = await node.exec(`git stash --include-untracked`)
+  const { stdout, stderr } = await exec(`git stash --include-untracked`)
   if (stderr) {
     console.error(stderr)
     throw new Error('Error stashing files')
@@ -21,7 +21,7 @@ const cherryPickCommit = async (commit: string, count = 0): Promise<never | void
   try {
     // cherry-pick pulls commits from another branch
     // -X theirs merges and accepts incoming changes over existing changes
-    const { stdout } = await node.exec(`git cherry-pick -X theirs ${commit}`)
+    const { stdout } = await exec(`git cherry-pick -X theirs ${commit}`)
     if (!stdout) {
       throw new Error('No cherry-pick output')
     }
@@ -47,7 +47,7 @@ export function loadCommit(commit: string): Promise<never | void> {
 */
 
 export async function saveCommit(message: string): Promise<never | void> {
-  const { stdout, stderr } = await node.exec(`git commit -am '${message}'`)
+  const { stdout, stderr } = await exec(`git commit -am '${message}'`)
   if (stderr) {
     console.error(stderr)
     throw new Error('Error saving progress to Git')
@@ -58,7 +58,7 @@ export async function saveCommit(message: string): Promise<never | void> {
 export async function clear(): Promise<Error | void> {
   try {
     // commit progress to git
-    const { stderr } = await node.exec('git reset HEAD --hard && git clean -fd')
+    const { stderr } = await exec('git reset HEAD --hard && git clean -fd')
     if (!stderr) {
       return
     }
@@ -70,28 +70,28 @@ export async function clear(): Promise<Error | void> {
 }
 
 async function init(): Promise<Error | void> {
-  const { stderr } = await node.exec('git init')
+  const { stderr } = await exec('git init')
   if (stderr) {
     throw new Error('Error initializing Git')
   }
 }
 
 export async function initIfNotExists(): Promise<never | void> {
-  const hasGitInit = node.exists('.git')
+  const hasGitInit = exists('.git')
   if (!hasGitInit) {
     await init()
   }
 }
 
 export async function checkRemoteConnects(repo: TT.TutorialRepo): Promise<never | void> {
   // check for git repo
-  const externalRepoExists = await node.exec(`git ls-remote --exit-code --heads ${repo.uri}`)
+  const externalRepoExists = await exec(`git ls-remote --exit-code --heads ${repo.uri}`)
   if (externalRepoExists.stderr) {
     // no repo found or no internet connection
     throw new Error(externalRepoExists.stderr)
   }
   // check for git repo branch
-  const { stderr, stdout } = await node.exec(`git ls-remote --exit-code --heads ${repo.uri} ${repo.branch}`)
+  const { stderr, stdout } = await exec(`git ls-remote --exit-code --heads ${repo.uri} ${repo.branch}`)
   if (stderr) {
     throw new Error(stderr)
   }
@@ -101,7 +101,7 @@ export async function checkRemoteConnects(repo: TT.TutorialRepo): Promise<never
 }
 
 export async function addRemote(repo: string): Promise<never | void> {
-  const { stderr } = await node.exec(`git remote add ${gitOrigin} ${repo} && git fetch ${gitOrigin}`)
+  const { stderr } = await exec(`git remote add ${gitOrigin} ${repo} && git fetch ${gitOrigin}`)
   if (stderr) {
     const alreadyExists = stderr.match(`${gitOrigin} already exists.`)
     const successfulNewBranch = stderr.match('new branch')
@@ -116,7 +116,7 @@ export async function addRemote(repo: string): Promise<never | void> {
 
 export async function checkRemoteExists(): Promise<boolean> {
   try {
-    const { stdout, stderr } = await node.exec('git remote -v')
+    const { stdout, stderr } = await exec('git remote -v')
     if (stderr) {
       return false
     }