kayodebristol
diff --git a/‎web-app/src/errors/FailedToConnectToGitRepo.md renamed to ‎errors/FailedToConnectToGitRepo.md b/‎web-app/src/errors/FailedToConnectToGitRepo.md renamed to ‎errors/FailedToConnectToGitRepo.md
diff --git a/‎web-app/src/errors/GitNotFound.md renamed to ‎errors/GitNotFound.md b/‎web-app/src/errors/GitNotFound.md renamed to ‎errors/GitNotFound.md
diff --git a/‎web-app/src/errors/GitProjectAlreadyExists.md renamed to ‎errors/GitProjectAlreadyExists.md b/‎web-app/src/errors/GitProjectAlreadyExists.md renamed to ‎errors/GitProjectAlreadyExists.md
diff --git a/‎web-app/src/errors/UnknownError.md renamed to ‎errors/UnknownError.md b/‎web-app/src/errors/UnknownError.md renamed to ‎errors/UnknownError.md
diff --git a/‎src/actions/tutorialConfig.ts
Lines changed: 24 additions & 12 deletions b/‎src/actions/tutorialConfig.ts
Lines changed: 24 additions & 12 deletions
diff --git a/‎src/channel/index.ts
Lines changed: 32 additions & 10 deletions b/‎src/channel/index.ts
Lines changed: 32 additions & 10 deletions
diff --git a/‎src/services/git/index.ts
Lines changed: 13 additions & 18 deletions b/‎src/services/git/index.ts
Lines changed: 13 additions & 18 deletions
diff --git a/‎src/services/workspace/index.ts
Lines changed: 4 additions & 1 deletion b/‎src/services/workspace/index.ts
Lines changed: 4 additions & 1 deletion
diff --git a/‎typings/error.d.ts
Lines changed: 6 additions & 1 deletion b/‎typings/error.d.ts
Lines changed: 6 additions & 1 deletion
diff --git a/‎web-app/src/components/Error/index.tsx
Lines changed: 8 additions & 8 deletions b/‎web-app/src/components/Error/index.tsx
Lines changed: 8 additions & 8 deletions
@@ -13,28 +13,40 @@ interface TutorialConfigParams {
 const tutorialConfig = async ({ config, alreadyConfigured }: TutorialConfigParams): Promise<E.ErrorMessage | void> => {
   if (!alreadyConfigured) {
     // setup git, add remote
-    await git.initIfNotExists().catch((error: Error) => {
-      return {
+    const initError: E.ErrorMessage | void = await git.initIfNotExists().catch(
+      (error: Error): E.ErrorMessage => ({
         type: 'GitNotFound',
         message: error.message,
-      }
-    })
+      }),
+    )
+
+    if (initError) {
+      return initError
+    }
 
     // verify that internet is connected, remote exists and branch exists
-    await git.checkRemoteConnects(config.repo).catch((error: Error) => {
-      return {
+    const remoteConnectError: E.ErrorMessage | void = await git.checkRemoteConnects(config.repo).catch(
+      (error: Error): E.ErrorMessage => ({
         type: 'FailedToConnectToGitRepo',
         message: error.message,
-      }
-    })
+      }),
+    )
+
+    if (remoteConnectError) {
+      return remoteConnectError
+    }
 
     // TODO if remote not already set
-    await git.setupCodeRoadRemote(config.repo.uri).catch((error: Error) => {
-      return {
+    const coderoadRemoteError: E.ErrorMessage | void = await git.setupCodeRoadRemote(config.repo.uri).catch(
+      (error: Error): E.ErrorMessage => ({
         type: 'GitRemoteAlreadyExists',
         message: error.message,
-      }
-    })
+      }),
+    )
+
+    if (coderoadRemoteError) {
+      return coderoadRemoteError
+    }
   }
 
   await vscode.commands.executeCommand(COMMANDS.CONFIG_TEST_RUNNER, config.testRunner)
 
@@ -11,6 +11,11 @@ import logger from '../services/logger'
 import Context from './context'
 import { version as gitVersion } from '../services/git'
 import { openWorkspace, checkWorkspaceEmpty } from '../services/workspace'
+import { readFile } from 'fs'
+import { join } from 'path'
+import { promisify } from 'util'
+
+const readFileAsync = promisify(readFile)
 
 interface Channel {
   receive(action: T.Action): Promise<void>
@@ -40,7 +45,9 @@ class Channel implements Channel {
   public receive = async (action: T.Action) => {
     // action may be an object.type or plain string
     const actionType: string = typeof action === 'string' ? action : action.type
-    const onError = (error: T.ErrorMessage) => this.send({ type: 'ERROR', payload: { error } })
+    // const onError = (error: T.ErrorMessage) => this.send({ type: 'ERROR', payload: { error } })
+
+    // console.log(`ACTION: ${actionType}`)
 
     switch (actionType) {
       case 'EDITOR_ENV_GET':
@@ -107,13 +114,10 @@ class Channel implements Channel {
           throw new Error('Invalid tutorial to continue')
         }
         const continueConfig: TT.TutorialConfig = tutorialContinue.config
-        await tutorialConfig(
-          {
-            config: continueConfig,
-            alreadyConfigured: true,
-          },
-          onError,
-        )
+        await tutorialConfig({
+          config: continueConfig,
+          alreadyConfigured: true,
+        })
         // update the current stepId on startup
         vscode.commands.executeCommand(COMMANDS.SET_CURRENT_STEP, action.payload)
         return
@@ -156,6 +160,23 @@ class Channel implements Channel {
   }
   // send to webview
   public send = async (action: T.Action) => {
+    // Error middleware
+    if (action?.payload?.error?.type) {
+      // load error markdown message
+      const error = action.payload.error
+      const errorMarkdownFile = join(__dirname, '..', '..', 'errors', `${action.payload.error.type}.md`)
+      const errorMarkdown = await readFileAsync(errorMarkdownFile).catch(() => {
+        // onError(new Error(`Error Markdown file not found for ${action.type}`))
+      })
+
+      console.log(`ERROR:\n ${errorMarkdown}`)
+
+      if (errorMarkdown) {
+        // add a clearer error message for the user
+        error.message = `${errorMarkdown}\n${error.message}`
+      }
+    }
+
     // action may be an object.type or plain string
     const actionType: string = typeof action === 'string' ? action : action.type
     switch (actionType) {
@@ -170,8 +191,9 @@ class Channel implements Channel {
         saveCommit()
     }
 
-    const success = await this.postMessage(action)
-    if (!success) {
+    // send message
+    const sentToClient = await this.postMessage(action)
+    if (!sentToClient) {
       throw new Error(`Message post failure: ${JSON.stringify(action)}`)
     }
   }
 
@@ -1,11 +1,10 @@
 import * as TT from 'typings/tutorial'
 import node from '../node'
 import logger from '../logger'
-import onError from '../sentry/onError'
 
 const gitOrigin = 'coderoad'
 
-const stashAllFiles = async () => {
+const stashAllFiles = async (): Promise<never | void> => {
   // stash files including untracked (eg. newly created file)
   const { stdout, stderr } = await node.exec(`git stash --include-untracked`)
   if (stderr) {
@@ -14,7 +13,7 @@ const stashAllFiles = async () => {
   }
 }
 
-const cherryPickCommit = async (commit: string, count = 0): Promise<void> => {
+const cherryPickCommit = async (commit: string, count = 0): Promise<never | void> => {
   if (count > 1) {
     console.warn('cherry-pick failed')
     return
@@ -38,7 +37,7 @@ const cherryPickCommit = async (commit: string, count = 0): Promise<void> => {
     SINGLE git cherry-pick %COMMIT%
     if fails, will stash all and retry
 */
-export function loadCommit(commit: string): Promise<void> {
+export function loadCommit(commit: string): Promise<never | void> {
   return cherryPickCommit(commit)
 }
 
@@ -47,7 +46,7 @@ export function loadCommit(commit: string): Promise<void> {
     git commit -am '${level}/${step} complete'
 */
 
-export async function saveCommit(message: string): Promise<void> {
+export async function saveCommit(message: string): Promise<never | void> {
   const { stdout, stderr } = await node.exec(`git commit -am '${message}'`)
   if (stderr) {
     console.error(stderr)
@@ -56,7 +55,7 @@ export async function saveCommit(message: string): Promise<void> {
   logger(['save with commit & continue stdout', stdout])
 }
 
-export async function clear(): Promise<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')
@@ -83,23 +82,21 @@ export async function version(): Promise<string | null> {
   return null
 }
 
-async function init(): Promise<void> {
+async function init(): Promise<Error | void> {
   const { stderr } = await node.exec('git init')
   if (stderr) {
-    const error = new Error('Error initializing Git')
-    onError(error)
-    throw error
+    throw new Error('Error initializing Git')
   }
 }
 
-export async function initIfNotExists(): Promise<void> {
+export async function initIfNotExists(): Promise<never | void> {
   const hasGitInit = node.exists('.git')
   if (!hasGitInit) {
     await init()
   }
 }
 
-export async function checkRemoteConnects(repo: TT.TutorialRepo): Promise<boolean | Error> {
+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}`)
   if (externalRepoExists.stderr) {
@@ -114,10 +111,9 @@ export async function checkRemoteConnects(repo: TT.TutorialRepo): Promise<boolea
   if (!stdout || !stdout.length) {
     throw new Error('Tutorial branch does not exist')
   }
-  return true
 }
 
-export async function addRemote(repo: string): Promise<void> {
+export async function addRemote(repo: string): Promise<never | void> {
   const { stderr } = await node.exec(`git remote add ${gitOrigin} ${repo} && git fetch ${gitOrigin}`)
   if (stderr) {
     const alreadyExists = stderr.match(`${gitOrigin} already exists.`)
@@ -145,14 +141,13 @@ export async function checkRemoteExists(): Promise<boolean> {
   }
 }
 
-export async function setupCodeRoadRemote(repo: string): Promise<void> {
+export async function setupCodeRoadRemote(repo: string): Promise<never | void> {
   // check coderoad remote not taken
   const hasRemote = await checkRemoteExists()
   // git remote add coderoad tutorial
   // git fetch coderoad
-  if (!hasRemote) {
-    await add
F438
Remote(repo)
-  } else {
+  if (hasRemote) {
     throw new Error('A CodeRoad remote is already configured')
   }
+  await addRemote(repo)
 }
@@ -1,5 +1,8 @@
 import * as vscode from 'vscode'
 import * as fs from 'fs'
+import { promisify } from 'util'
+
+const readDir = promisify(fs.readdir)
 
 export const openWorkspace = () => {
   const openInNewWindow = false
@@ -9,7 +12,7 @@ export const openWorkspace = () => {
 export const checkWorkspaceEmpty = async (dirname: string) => {
   let files
   try {
-    files = await fs.promises.readdir(dirname)
+    files = await readDir(dirname)
   } catch (error) {
     throw new Error('Failed to check workspace')
   }
 
@@ -1,6 +1,11 @@
 export type ErrorMessageView = 'FULL_PAGE' | 'NOTIFY' | 'NONE'
 
-export type ErrorMessageType = 'UnknownError' | 'GitNotFound' | 'FailedToConnectToGitRepo' | 'GitProjectAlreadyExists'
+export type ErrorMessageType =
+  | 'UnknownError'
+  | 'GitNotFound'
+  | 'FailedToConnectToGitRepo'
+  | 'GitProjectAlreadyExists'
+  | 'GitRemoteAlreadyExists'
 
 export type ErrorMessage = {
   type: ErrorMessageType
 
@@ -1,6 +1,7 @@
 import * as React from 'react'
+import * as E from 'typings/error'
 import { css, jsx } from '@emotion/core'
-import onError from '../../services/sentry/onError'
+import Markdown from '../Markdown'
 
 const styles = {
   container: {
@@ -13,17 +14,16 @@ const styles = {
 }
 
 interface Props {
-  error?: Error
+  error?: E.ErrorMessage
 }
 
-const ErrorView = ({ error }: Props) => {
-  // log error
+const ErrorMarkdown = ({ error }: Props) => {
   React.useEffect(() => {
     if (error) {
+      // log error
       console.log(error)
-      onError(error)
     }
-  }, [])
+  }, [error])
 
   if (!error) {
     return null
@@ -32,9 +32,9 @@ const ErrorView = ({ error }: Props) => {
   return (
     <div css={styles.container}>
       <h1>Error</h1>
-      <div>{JSON.stringify(error)}</div>
+      <Markdown>{error.message}</Markdown>
     </div>
   )
 }
 
-export default ErrorView
+export default ErrorMarkdown