Initial commit of wails build

2026-08-05 13:53:43 -07:00 · 2019-01-08 07:58:46 +11:00
parent 96996431b4
commit 4742fd7ed2
36 changed files with 5261 additions and 2 deletions
@@ -0,0 +1,17 @@
+lib/project/templates/vue
+lib/project/templates/blank
+tools
+test
+.vscode/
+tmp
+examples/**/example*
+!examples/**/*.*
+node_modules
+cmd.old
+lib.old
+cmd/wails/wails
+.DS_Store
+rewrite
+.rewrite
+examples/WIP/*
+docs
@@ -10,3 +10,8 @@

 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+examples/**/example*
+!examples/**/*.*
+cmd/wails/wails
+.DS_Store
@@ -0,0 +1,142 @@
+package wails
+
+import (
+	"github.com/wailsapp/wails/cmd"
+	"github.com/wailsapp/wails/cmd/frameworks"
+)
+
+// -------------------------------- Compile time Flags ------------------------------
+
+// ReleaseMode indicates if we are in Release Mode
+var ReleaseMode = false
+
+// ----------------------------------------------------------------------------------
+
+// App defines the main application struct
+type App struct {
+	config         *AppConfig      // The Application configuration object
+	cli            *cmd.Cli        // In debug mode, we have a cli
+	renderer       Renderer        // The renderer is what we will render the app to
+	logLevel       string          // The log level of the app
+	headless       bool            // Indicates if the app should be started in headless mode
+	ipc            *ipcManager     // Handles the IPC calls
+	log            *CustomLogger   // Logger
+	bindingManager *bindingManager // Handles binding of Go code to renderer
+	eventManager   *eventManager   // Handles all the events
+	runtime        *Runtime        // The runtime object for registered structs
+
+	// This is a list of all the JS/CSS that needs injecting
+	// It will get injected in order
+	jsCache  []string
+	cssCache []string
+}
+
+// CreateApp creates the application window with the given configuration
+// If none given, the defaults are used
+func CreateApp(optionalConfig ...*AppConfig) *App {
+	var userConfig *AppConfig
+	if len(optionalConfig) > 0 {
+		userConfig = optionalConfig[0]
+	}
+
+	result := &App{
+		logLevel:       "debug",
+		renderer:       &webViewRenderer{},
+		ipc:            newIPCManager(),
+		bindingManager: newBindingManager(),
+		eventManager:   newEventManager(),
+		log:            newCustomLogger("App"),
+	}
+
+	appconfig, err := newAppConfig(userConfig)
+	if err != nil {
+		result.log.Fatalf("Cannot use custom HTML: %s", err.Error())
+	}
+	result.config = appconfig
+
+	// Set up the CLI if not in release mode
+	if !ReleaseMode {
+		result.cli = result.setupCli()
+	}
+
+	// Disable Inspector in release mode
+	if ReleaseMode {
+		result.config.DisableInspector = true
+	}
+
+	return result
+}
+
+// Run the app
+func (a *App) Run() {
+	a.cli.Run()
+}
+
+func (a *App) start() error {
+
+	// Set the log level
+	setLogLevel(a.logLevel)
+
+	// Log starup
+	a.log.Info("Starting")
+
+	// Check if we are to run in headless mode
+	if a.headless {
+		a.renderer = &Headless{}
+	}
+
+	// Initialise the renderer
+	err := a.renderer.Initialise(a.config, a.ipc, a.eventManager)
+	if err != nil {
+		return err
+	}
+
+	// Start event manager and give it our renderer
+	a.eventManager.start(a.renderer)
+
+	// Start the IPC Manager and give it the event manager and binding manager
+	a.ipc.start(a.eventManager, a.bindingManager)
+
+	// Create the runtime
+	a.runtime = newRuntime(a.eventManager, a.renderer)
+
+	// Start binding manager and give it our renderer
+	err = a.bindingManager.start(a.renderer, a.runtime)
+	if err != nil {
+		return err
+	}
+
+	// Inject framework, if specified
+	if frameworks.FrameworkToUse != nil {
+		a.renderer.InjectFramework(frameworks.FrameworkToUse.JS, frameworks.FrameworkToUse.CSS)
+	}
+
+	// Inject CSS
+	a.renderer.AddCSSList(a.cssCache)
+
+	// Inject JS
+	a.renderer.AddJSList(a.jsCache)
+
+	// Run the renderer
+	a.renderer.Run()
+
+	return nil
+}
+
+// Bind allows the user to bind the given object
+// with the application
+func (a *App) Bind(object interface{}) {
+	a.bindingManager.bind(object)
+}
+
+// AddJS adds a piece of Javascript to a cache that
+// gets injected at runtime
+func (a *App) AddJS(js string) {
+	a.jsCache = append(a.jsCache, js)
+}
+
+// AddCSS adds a CSS string to a cache that
+// gets injected at runtime
+func (a *App) AddCSS(js string) {
+	a.cssCache = append(a.cssCache, js)
+}
@@ -0,0 +1,38 @@
+package wails
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/cmd"
+)
+
+func (app *App) setupCli() *cmd.Cli {
+
+	// var apiFilename string
+
+	result := cmd.NewCli(app.config.Title, "Debug build")
+
+	// Gen API
+	// result.Command("genapi", "Generate JS stubs for the registered Go plugins").
+	// 	StringFlag("o", "Output filename", &apiFilename).
+	// 	Action(func() error {
+	// 		app.renderer = N
+	// 	})
+
+	result.
+		StringFlag("loglevel", "Sets the log level [info|debug|error|panic|fatal]. Default debug", &app.logLevel).
+		BoolFlag("headless", "Runs the app in headless mode", &app.headless).
+		Action(app.start)
+
+	// Banner
+	result.PreRun(func(cli *cmd.Cli) error {
+		log := cmd.NewLogger()
+		log.PrintBanner()
+		fmt.Println()
+		result.PrintHelp()
+		log.YellowUnderline(app.config.Title + " - Debug Build")
+		return nil
+	})
+
+	return result
+}
@@ -0,0 +1,99 @@
+package wails
+
+import (
+	"strings"
+
+	"github.com/dchest/htmlmin"
+	"github.com/gobuffalo/packr"
+)
+
+var assets = packr.NewBox("./assets/default")
+
+// AppConfig is the configuration structure used when creating a Wails App object
+type AppConfig struct {
+	Width, Height    int
+	Title            string
+	defaultHTML      string
+	HTML             string
+	JS               string
+	CSS              string
+	Colour           string
+	Resizable        bool
+	DisableInspector bool
+	isHTMLFragment   bool
+}
+
+func (a *AppConfig) merge(in *AppConfig) error {
+	if in.CSS != "" {
+		a.CSS = in.CSS
+	}
+	if in.Title != "" {
+		a.Title = in.Title
+	}
+	if in.HTML != "" {
+		minified, err := htmlmin.Minify([]byte(in.HTML), &htmlmin.Options{
+			MinifyScripts: true,
+		})
+		if err != nil {
+			return err
+		}
+		inlineHTML := string(minified)
+		inlineHTML = strings.Replace(inlineHTML, "'", "\\'", -1)
+		inlineHTML = strings.Replace(inlineHTML, "\n", " ", -1)
+		a.HTML = strings.TrimSpace(inlineHTML)
+
+		// Deduce whether this is a full html page or a fragment
+		// The document is determined to be a fragment if an HMTL
+		// tag exists and is located before the first div tag
+		HTMLTagIndex := strings.Index(a.HTML, "<html")
+		DivTagIndex := strings.Index(a.HTML, "<div")
+
+		if HTMLTagIndex == -1 {
+			a.isHTMLFragment = true
+		} else {
+			if DivTagIndex < HTMLTagIndex {
+				a.isHTMLFragment = true
+			}
+		}
+	}
+
+	if in.Colour != "" {
+		a.Colour = in.Colour
+	}
+
+	if in.JS != "" {
+		a.JS = in.JS
+	}
+
+	if in.Width != 0 {
+		a.Width = in.Width
+	}
+	if in.Height != 0 {
+		a.Height = in.Height
+	}
+	a.Resizable = in.Resizable
+	a.DisableInspector = in.DisableInspector
+
+	return nil
+}
+
+// Creates the default configuration
+func newAppConfig(userConfig *AppConfig) (*AppConfig, error) {
+	result := &AppConfig{
+		Width:     800,
+		Height:    600,
+		Resizable: true,
+		Title:     "My Wails App",
+		Colour:    "#FFF", // White by default
+		HTML:      defaultAssets.String("default.html"),
+	}
+
+	if userConfig != nil {
+		err := result.merge(userConfig)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return result, nil
+}
@@ -0,0 +1,160 @@
+package wails
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"runtime"
+)
+
+type boundFunction struct {
+	fullName           string
+	function           reflect.Value
+	functionType       reflect.Type
+	inputs             []reflect.Type
+	returnTypes        []reflect.Type
+	log                *CustomLogger
+	hasErrorReturnType bool
+}
+
+// Creates a new bound function based on the given method + type
+func newBoundFunction(object interface{}) (*boundFunction, error) {
+
+	objectValue := reflect.ValueOf(object)
+	objectType := reflect.TypeOf(object)
+
+	name := runtime.FuncForPC(objectValue.Pointer()).Name()
+
+	result := &boundFunction{
+		fullName:     name,
+		function:     objectValue,
+		functionType: objectType,
+		log:          newCustomLogger(name),
+	}
+
+	err := result.processParameters()
+
+	return result, err
+}
+
+func (b *boundFunction) processParameters() error {
+
+	// Param processing
+	functionType := b.functionType
+
+	// Input parameters
+	inputParamCount := functionType.NumIn()
+	if inputParamCount > 0 {
+		b.inputs = make([]reflect.Type, inputParamCount)
+		// We start at 1 as the first param is the struct
+		for index := 0; index < inputParamCount; index++ {
+			param := functionType.In(index)
+			name := param.Name()
+			kind := param.Kind()
+			b.inputs[index] = param
+			typ := param
+			index := index
+			b.log.DebugFields("Input param", Fields{
+				"index": index,
+				"name":  name,
+				"kind":  kind,
+				"typ":   typ,
+			})
+		}
+	}
+
+	// Process return/output declarations
+	returnParamsCount := functionType.NumOut()
+	// Guard against bad number of return types
+	switch returnParamsCount {
+	case 0:
+	case 1:
+		// Check if it's an error type
+		param := functionType.Out(0)
+		paramName := param.Name()
+		if paramName == "error" {
+			b.hasErrorReturnType = true
+		}
+		// Save return type
+		b.returnTypes = append(b.returnTypes, param)
+	case 2:
+		// Check the second return type is an error
+		secondParam := functionType.Out(1)
+		secondParamName := secondParam.Name()
+		if secondParamName != "error" {
+			return fmt.Errorf("last return type of method '%s' must be an error (got %s)", b.fullName, secondParamName)
+		}
+
+		// Check the second return type is an error
+		firstParam := functionType.Out(0)
+		firstParamName := firstParam.Name()
+		if firstParamName == "error" {
+			return fmt.Errorf("first return type of method '%s' must not be an error", b.fullName)
+		}
+		b.hasErrorReturnType = true
+
+		// Save return types
+		b.returnTypes = append(b.returnTypes, firstParam)
+		b.returnTypes = append(b.returnTypes, secondParam)
+
+	default:
+		return fmt.Errorf("cannot register method '%s' with %d return parameters. Please use up to 2", b.fullName, returnParamsCount)
+	}
+
+	return nil
+}
+
+// call the method with the given data
+func (b *boundFunction) call(data string) ([]reflect.Value, error) {
+
+	// The data will be an array of values so we will decode the
+	// input data into
+	var jsArgs []interface{}
+	d := json.NewDecoder(bytes.NewBufferString(data))
+	// d.UseNumber()
+	err := d.Decode(&jsArgs)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid data passed to method call: %s", err.Error())
+	}
+
+	// Check correct number of inputs
+	if len(jsArgs) != len(b.inputs) {
+		return nil, fmt.Errorf("Invalid number of parameters given to %s. Expected %d but got %d", b.fullName, len(b.inputs), len(jsArgs))
+	}
+
+	// Set up call
+	args := make([]reflect.Value, len(b.inputs))
+	for index := 0; index < len(b.inputs); index++ {
+
+		// Set the input values
+		value, err := b.setInputValue(index, b.inputs[index], jsArgs[index])
+		if err != nil {
+			return nil, err
+		}
+		args[index] = value
+	}
+	b.log.Infof("Unmarshalled Args: %+v\n", jsArgs)
+	b.log.Infof("Converted Args: %+v\n", args)
+	results := b.function.Call(args)
+
+	b.log.Debugf("results = %+v", results)
+	return results, nil
+}
+
+// Attempts to set the method input <typ> for parameter <index> with the given value <val>
+func (b *boundFunction) setInputValue(index int, typ reflect.Type, val interface{}) (result reflect.Value, err error) {
+
+	// Catch type conversion panics thrown by convert
+	defer func() {
+		if r := recover(); r != nil {
+			// Modify error
+			err = fmt.Errorf("%s for parameter %d of function %s", r.(string)[23:], index+1, b.fullName)
+		}
+	}()
+
+	// Do the conversion
+	result = reflect.ValueOf(val).Convert(typ)
+
+	return result, err
+}
@@ -0,0 +1,267 @@
+package wails
+
+import (
+	"fmt"
+	"reflect"
+	"unicode"
+)
+
+/**
+
+binding:
+ Name() // Full name (package+name)
+ Call(params)
+
+**/
+
+type bindingManager struct {
+	methods          map[string]*boundMethod
+	functions        map[string]*boundFunction
+	initMethods      []*boundMethod
+	log              *CustomLogger
+	renderer         Renderer
+	runtime          *Runtime // The runtime object to pass to bound structs
+	objectsToBind    []interface{}
+	bindPackageNames bool // Package name should be considered when binding
+}
+
+func newBindingManager() *bindingManager {
+	result := &bindingManager{
+		methods:   make(map[string]*boundMethod),
+		functions: make(map[string]*boundFunction),
+		log:       newCustomLogger("Bind"),
+	}
+	return result
+}
+
+// Sets flag to indicate package names should be considered when binding
+func (b *bindingManager) BindPackageNames() {
+	b.bindPackageNames = true
+}
+
+func (b *bindingManager) start(renderer Renderer, runtime *Runtime) error {
+	b.log.Info("Starting")
+	b.renderer = renderer
+	b.runtime = runtime
+	err := b.initialise()
+	if err != nil {
+		b.log.Errorf("Binding error: %s", err.Error())
+		return err
+	}
+	err = b.callWailsInitMethods()
+	return err
+}
+
+func (b *bindingManager) initialise() error {
+
+	var err error
+	// var binding *boundMethod
+
+	b.log.Info("Binding Go Functions/Methods")
+
+	// Create bindings for objects
+	for _, object := range b.objectsToBind {
+
+		// Safeguard against nils
+		if object == nil {
+			return fmt.Errorf("attempted to bind nil object")
+		}
+
+		// Determine kind of object
+		objectType := reflect.TypeOf(object)
+		objectKind := objectType.Kind()
+
+		switch objectKind {
+		case reflect.Ptr:
+			err = b.bindMethod(object)
+		case reflect.Func:
+			// spew.Dump(result.objectType.String())
+			err = b.bindFunction(object)
+		default:
+			err = fmt.Errorf("cannot bind object of type '%s'", objectKind.String())
+		}
+
+		// Return error if set
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// bind the given struct method
+func (b *bindingManager) bindMethod(object interface{}) error {
+
+	objectType := reflect.TypeOf(object)
+	baseName := objectType.String()
+
+	// Strip pointer if there
+	if baseName[0] == '*' {
+		baseName = baseName[1:]
+	}
+
+	b.log.Debugf("Processing struct: %s", baseName)
+
+	// Iterate over method definitions
+	for i := 0; i < objectType.NumMethod(); i++ {
+
+		// Get method definition
+		methodDef := objectType.Method(i)
+		methodName := methodDef.Name
+		fullMethodName := baseName + "." + methodName
+		method := reflect.ValueOf(object).MethodByName(methodName)
+
+		// Skip unexported methods
+		if !unicode.IsUpper([]rune(methodName)[0]) {
+			continue
+		}
+
+		// Create a new boundMethod
+		newMethod, err := newBoundMethod(methodName, fullMethodName, method, objectType)
+		if err != nil {
+			return err
+		}
+
+		// Check if it's a wails init function
+		if newMethod.isWailsInit {
+			b.log.Debugf("Detected WailsInit function: %s", fullMethodName)
+			b.initMethods = append(b.initMethods, newMethod)
+		} else {
+			// Save boundMethod
+			b.log.Infof("Bound Method: %s()", fullMethodName)
+			b.methods[fullMethodName] = newMethod
+
+			// Inform renderer of new binding
+			b.renderer.NewBinding(fullMethodName)
+		}
+	}
+
+	return nil
+}
+
+// bind the given function object
+func (b *bindingManager) bindFunction(object interface{}) error {
+
+	newFunction, err := newBoundFunction(object)
+	if err != nil {
+		return err
+	}
+
+	// Save method
+	b.log.Infof("Bound Function: %s()", newFunction.fullName)
+	b.functions[newFunction.fullName] = newFunction
+
+	// Register with Renderer
+	b.renderer.NewBinding(newFunction.fullName)
+
+	return nil
+}
+
+// Save the given object to be bound at start time
+func (b *bindingManager) bind(object interface{}) {
+	// Store binding
+	b.objectsToBind = append(b.objectsToBind, object)
+}
+
+// process an incoming call request
+func (b *bindingManager) processCall(callData *callData) (interface{}, error) {
+	b.log.Debugf("Wanting to call %s", callData.BindingName)
+
+	// Determine if this is function call or method call by the number of
+	// dots in the binding name
+	dotCount := 0
+	for _, character := range callData.BindingName {
+		if character == '.' {
+			dotCount++
+		}
+	}
+
+	// Return values
+	var result []reflect.Value
+	var err error
+
+	// We need to catch reflect related panics and return
+	// a decent error message
+	// TODO: DEBUG THIS!
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("%s", r.(string))
+		}
+	}()
+
+	switch dotCount {
+	case 1:
+		function := b.functions[callData.BindingName]
+		if function == nil {
+			return nil, fmt.Errorf("Invalid function name '%s'", callData.BindingName)
+		}
+		result, err = function.call(callData.Data)
+		if err != nil {
+			return nil, err
+		}
+
+		// Do we have an error return type?
+		if function.hasErrorReturnType {
+			// We do - last result is an error type
+			// Check if the last result was nil
+			b.log.Debugf("# of return types: %d", len(function.returnTypes))
+			b.log.Debugf("# of results: %d", len(result))
+			errorResult := result[len(function.returnTypes)-1]
+			if !errorResult.IsNil() {
+				// It wasn't - we have an error
+				return nil, errorResult.Interface().(error)
+			}
+		}
+		return result[0].Interface(), nil
+	case 2:
+		// do we have this method?
+		method := b.methods[callData.BindingName]
+		if method == nil {
+			return nil, fmt.Errorf("Invalid method name '%s'", callData.BindingName)
+		}
+		result, err = method.call(callData.Data)
+		if err != nil {
+			return nil, err
+		}
+
+		// Do we have an error return type?
+		if method.hasErrorReturnType {
+			// We do - last result is an error type
+			// Check if the last result was nil
+			b.log.Debugf("# of return types: %d", len(method.returnTypes))
+			b.log.Debugf("# of results: %d", len(result))
+			errorResult := result[len(method.returnTypes)-1]
+			if !errorResult.IsNil() {
+				// It wasn't - we have an error
+				return nil, errorResult.Interface().(error)
+			}
+		}
+		if result != nil {
+			return result[0].Interface(), nil
+		}
+		return nil, nil
+
+	default:
+		return nil, fmt.Errorf("Invalid binding name '%s'", callData.BindingName)
+	}
+}
+
+// callWailsInitMethods calls all of the WailsInit methods that were
+// registered with the runtime object
+func (b *bindingManager) callWailsInitMethods() error {
+	// Create reflect value for runtime object
+	runtimeValue := reflect.ValueOf(b.runtime)
+	params := []reflect.Value{runtimeValue}
+
+	// Iterate initMethods
+	for _, initMethod := range b.initMethods {
+		// Call
+		result := initMethod.method.Call(params)
+		// Check errors
+		err := result[0].Interface()
+		if err != nil {
+			return err.(error)
+		}
+	}
+	return nil
+}
@@ -0,0 +1,211 @@
+package wails
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+)
+
+type boundMethod struct {
+	Name               string
+	fullName           string
+	method             reflect.Value
+	inputs             []reflect.Type
+	returnTypes        []reflect.Type
+	log                *CustomLogger
+	hasErrorReturnType bool // Indicates if there is an error return type
+	isWailsInit        bool
+}
+
+// Creates a new bound method based on the given method + type
+func newBoundMethod(name string, fullName string, method reflect.Value, objectType reflect.Type) (*boundMethod, error) {
+	result := &boundMethod{
+		Name:     name,
+		method:   method,
+		fullName: fullName,
+	}
+
+	// Setup logger
+	result.log = newCustomLogger(result.fullName)
+
+	// Check if Parameters are valid
+	err := result.processParameters()
+
+	// Are we a WailsInit method?
+	if result.Name == "WailsInit" {
+		err = result.processWailsInit()
+	}
+
+	return result, err
+}
+
+func (b *boundMethod) processParameters() error {
+
+	// Param processing
+	methodType := b.method.Type()
+
+	// Input parameters
+	inputParamCount := methodType.NumIn()
+	if inputParamCount > 0 {
+		b.inputs = make([]reflect.Type, inputParamCount)
+		// We start at 1 as the first param is the struct
+		for index := 0; index < inputParamCount; index++ {
+			param := methodType.In(index)
+			name := param.Name()
+			kind := param.Kind()
+			b.inputs[index] = param
+			typ := param
+			index := index
+			b.log.DebugFields("Input param", Fields{
+				"index": index,
+				"name":  name,
+				"kind":  kind,
+				"typ":   typ,
+			})
+		}
+	}
+
+	// Process return/output declarations
+	returnParamsCount := methodType.NumOut()
+	// Guard against bad number of return types
+	switch returnParamsCount {
+	case 0:
+	case 1:
+		// Check if it's an error type
+		param := methodType.Out(0)
+		paramName := param.Name()
+		if paramName == "error" {
+			b.hasErrorReturnType = true
+		}
+		// Save return type
+		b.returnTypes = append(b.returnTypes, param)
+	case 2:
+		// Check the second return type is an error
+		secondParam := methodType.Out(1)
+		secondParamName := secondParam.Name()
+		if secondParamName != "error" {
+			return fmt.Errorf("last return type of method '%s' must be an error (got %s)", b.Name, secondParamName)
+		}
+
+		// Check the second return type is an error
+		firstParam := methodType.Out(0)
+		firstParamName := firstParam.Name()
+		if firstParamName == "error" {
+			return fmt.Errorf("first return type of method '%s' must not be an error", b.Name)
+		}
+		b.hasErrorReturnType = true
+
+		// Save return types
+		b.returnTypes = append(b.returnTypes, firstParam)
+		b.returnTypes = append(b.returnTypes, secondParam)
+
+	default:
+		return fmt.Errorf("cannot register method '%s' with %d return parameters. Please use up to 2", b.Name, returnParamsCount)
+	}
+
+	return nil
+}
+
+// call the method with the given data
+func (b *boundMethod) call(data string) ([]reflect.Value, error) {
+
+	// The data will be an array of values so we will decode the
+	// input data into
+	var jsArgs []interface{}
+	d := json.NewDecoder(bytes.NewBufferString(data))
+	// d.UseNumber()
+	err := d.Decode(&jsArgs)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid data passed to method call: %s", err.Error())
+	}
+
+	// Check correct number of inputs
+	if len(jsArgs) != len(b.inputs) {
+		return nil, fmt.Errorf("Invalid number of parameters given to %s. Expected %d but got %d", b.fullName, len(b.inputs), len(jsArgs))
+	}
+
+	// Set up call
+	args := make([]reflect.Value, len(b.inputs))
+	for index := 0; index < len(b.inputs); index++ {
+
+		// Set the input values
+		value, err := b.setInputValue(index, b.inputs[index], jsArgs[index])
+		if err != nil {
+			return nil, err
+		}
+		args[index] = value
+	}
+	b.log.Infof("Unmarshalled Args: %+v\n", jsArgs)
+	b.log.Infof("Converted Args: %+v\n", args)
+	results := b.method.Call(args)
+
+	b.log.Debugf("results = %+v", results)
+	return results, nil
+}
+
+// Attempts to set the method input <typ> for parameter <index> with the given value <val>
+func (b *boundMethod) setInputValue(index int, typ reflect.Type, val interface{}) (result reflect.Value, err error) {
+
+	// Catch type conversion panics thrown by convert
+	defer func() {
+		if r := recover(); r != nil {
+			// Modify error
+			fmt.Printf("Recovery message: %+v\n", r)
+			err = fmt.Errorf("%s for parameter %d of method %s", r.(string)[23:], index+1, b.fullName)
+		}
+	}()
+
+	// Do the conversion
+	// Handle nil values
+	if val == nil {
+		switch typ.Kind() {
+		case reflect.Chan,
+			reflect.Func,
+			reflect.Interface,
+			reflect.Map,
+			reflect.Ptr,
+			reflect.Slice:
+			logger.Debug("Converting nil to type")
+			result = reflect.ValueOf(val).Convert(typ)
+		default:
+			logger.Debug("Cannot convert nil to type, returning error")
+			return reflect.Zero(typ), fmt.Errorf("Unable to use null value for parameter %d of method %s", index+1, b.fullName)
+		}
+	} else {
+		result = reflect.ValueOf(val).Convert(typ)
+	}
+
+	return result, err
+}
+
+func (b *boundMethod) processWailsInit() error {
+	// We must have only 1 input, it must be *wails.Runtime
+	if len(b.inputs) != 1 {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected 1 input, but got %d", len(b.inputs))
+	}
+
+	// It must be *wails.Runtime
+	inputName := b.inputs[0].String()
+	b.log.Debugf("WailsInit input type: %s", inputName)
+	if inputName != "*wails.Runtime" {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected input to be wails.Runtime, but got %s", inputName)
+	}
+
+	// We must have only 1 output, it must be error
+	if len(b.returnTypes) != 1 {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected 1 return type, but got %d", len(b.returnTypes))
+	}
+
+	// It must be *wails.Runtime
+	outputName := b.returnTypes[0].String()
+	b.log.Debugf("WailsInit output type: %s", outputName)
+	if outputName != "error" {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected input to be error, but got %s", outputName)
+	}
+
+	// We are indeed a wails Init method
+	b.isWailsInit = true
+
+	return nil
+}
@@ -0,0 +1,193 @@
+package cmd
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/jackmordaunt/icns"
+)
+
+// BundleHelper helps with the 'wails bundle' command
+type BundleHelper struct {
+	fs     *FSHelper
+	log    *Logger
+	system *SystemHelper
+}
+
+// NewBundleHelper creates a new BundleHelper!
+func NewBundleHelper() *BundleHelper {
+	return &BundleHelper{
+		fs:     NewFSHelper(),
+		log:    NewLogger(),
+		system: NewSystemHelper(),
+	}
+}
+
+// var assetsBox packr.Box
+
+type plistData struct {
+	Title    string
+	Exe      string
+	BundleID string
+	Version  string
+	Author   string
+	Date     string
+}
+
+func newPlistData(title, exe, bundleID, version, author string) *plistData {
+	now := time.Now().Format(time.RFC822)
+	return &plistData{
+		Title:    title,
+		Exe:      exe,
+		Version:  version,
+		BundleID: bundleID,
+		Author:   author,
+		Date:     now,
+	}
+}
+
+func defaultString(val string, defaultVal string) string {
+	if val != "" {
+		return val
+	}
+	return defaultVal
+}
+
+func (b *BundleHelper) getBundleFileBaseDir() string {
+	return filepath.Join(b.system.homeDir, "go", "src", "github.com", "wailsapp", "wails", "cmd", "bundle", runtime.GOOS)
+}
+
+// Bundle the application into a platform specific package
+func (b *BundleHelper) Bundle(po *ProjectOptions) error {
+	// Check we have the exe
+	if !b.fs.FileExists(po.BinaryName) {
+		return fmt.Errorf("cannot bundle non-existant binary file '%s'. Please build with 'wails build' first", po.BinaryName)
+	}
+	switch runtime.GOOS {
+	case "darwin":
+		return b.bundleOSX(po)
+	default:
+		return fmt.Errorf("platform '%s' not supported for bundling yet", runtime.GOOS)
+	}
+}
+
+// Bundle the application
+func (b *BundleHelper) bundleOSX(po *ProjectOptions) error {
+
+	system := NewSystemHelper()
+	config, err := system.LoadConfig()
+	if err != nil {
+		return err
+	}
+
+	name := defaultString(po.Name, "WailsTest")
+	exe := defaultString(po.BinaryName, name)
+	version := defaultString(po.Version, "0.1.0")
+	author := defaultString(config.Name, "Anonymous")
+	bundleID := strings.Join([]string{"wails", name, version}, ".")
+	plistData := newPlistData(name, exe, bundleID, version, author)
+	appname := po.Name + ".app"
+
+	// Check binary exists
+	source := path.Join(b.fs.Cwd(), exe)
+	if !b.fs.FileExists(source) {
+		// We need to build!
+		return fmt.Errorf("Target '%s' not available. Has it been compiled yet?", exe)
+	}
+
+	// REmove the existing bundle
+	os.RemoveAll(appname)
+
+	exeDir := path.Join(b.fs.Cwd(), appname, "/Contents/MacOS")
+	b.fs.MkDirs(exeDir, 0755)
+	resourceDir := path.Join(b.fs.Cwd(), appname, "/Contents/Resources")
+	b.fs.MkDirs(resourceDir, 0755)
+	tmpl := template.New("infoPlist")
+	plistFile := filepath.Join(b.getBundleFileBaseDir(), "info.plist")
+	infoPlist, err := ioutil.ReadFile(plistFile)
+	if err != nil {
+		return err
+	}
+	tmpl.Parse(string(infoPlist))
+
+	// Write the template to a buffer
+	var tpl bytes.Buffer
+	err = tmpl.Execute(&tpl, plistData)
+	if err != nil {
+		return err
+	}
+	filename := path.Join(b.fs.Cwd(), appname, "Contents", "Info.plist")
+	err = ioutil.WriteFile(filename, tpl.Bytes(), 0644)
+	if err != nil {
+		return err
+	}
+
+	// Copy executable
+	target := path.Join(exeDir, exe)
+	err = b.fs.CopyFile(source, target)
+	if err != nil {
+		return err
+	}
+
+	err = os.Chmod(target, 0755)
+	if err != nil {
+		return err
+	}
+	err = b.bundleIcon(resourceDir)
+	return err
+}
+
+func (b *BundleHelper) bundleIcon(resourceDir string) error {
+
+	// TODO: Read this from project.json
+	const appIconFilename = "appicon.png"
+
+	srcIcon := path.Join(b.fs.Cwd(), appIconFilename)
+
+	// Check if appicon.png exists
+	if !b.fs.FileExists(srcIcon) {
+
+		// Install default icon
+		iconfile := filepath.Join(b.getBundleFileBaseDir(), "icon.png")
+		iconData, err := ioutil.ReadFile(iconfile)
+		if err != nil {
+			return err
+		}
+		err = ioutil.WriteFile(srcIcon, iconData, 0644)
+		if err != nil {
+			return err
+		}
+	}
+
+	tgtBundle := path.Join(resourceDir, "iconfile.icns")
+	imageFile, err := os.Open(srcIcon)
+	if err != nil {
+		return err
+	}
+	defer imageFile.Close()
+	srcImg, _, err := image.Decode(imageFile)
+	if err != nil {
+		return err
+
+	}
+	dest, err := os.Create(tgtBundle)
+	if err != nil {
+		return err
+
+	}
+	defer dest.Close()
+	if err := icns.Encode(dest, srcImg); err != nil {
+		return err
+
+	}
+	return nil
+}
@@ -2,17 +2,23 @@ package cmd

 import (
 	"bytes"
+	"fmt"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"syscall"
 )

 // ProgramHelper - Utility functions around installed applications
-type ProgramHelper struct{}
+type ProgramHelper struct {
+	shell *ShellHelper
+}

 // NewProgramHelper - Creates a new ProgramHelper
 func NewProgramHelper() *ProgramHelper {
-	return &ProgramHelper{}
+	return &ProgramHelper{
+		shell: NewShellHelper(),
+	}
 }

 // IsInstalled tries to determine if the given binary name is installed
@@ -83,3 +89,31 @@ func (p *Program) Run(vars ...string) (stdout, stderr string, exitCode int, err
 	}
 	return
 }
+
+// InstallGoPackage installs the given Go package
+func (p *ProgramHelper) InstallGoPackage(packageName string) error {
+	args := strings.Split("get -u "+packageName, " ")
+	_, stderr, err := p.shell.Run("go", args...)
+	if err != nil {
+		fmt.Println(stderr)
+	}
+	return err
+}
+
+// RunCommand runs the given command
+func (p *ProgramHelper) RunCommand(command string) error {
+	args := strings.Split(command, " ")
+	program := args[0]
+	// TODO: Run FindProgram here and get the full path to the exe
+	program, err := exec.LookPath(program)
+	if err != nil {
+		fmt.Printf("ERROR: Looks like '%s' isn't installed. Please install and try again.", program)
+		return err
+	}
+	args = args[1:]
+	_, stderr, err := p.shell.Run(program, args...)
+	if err != nil {
+		fmt.Println(stderr)
+	}
+	return err
+}
@@ -0,0 +1,27 @@
+package cmd
+
+import (
+	"bytes"
+	"os/exec"
+)
+
+// ShellHelper helps with Shell commands
+type ShellHelper struct {
+}
+
+// NewShellHelper creates a new ShellHelper!
+func NewShellHelper() *ShellHelper {
+	return &ShellHelper{}
+}
+
+// Run the given command
+func (sh *ShellHelper) Run(command string, vars ...string) (stdout, stderr string, err error) {
+	cmd := exec.Command(command, vars...)
+	var stdo, stde bytes.Buffer
+	cmd.Stdout = &stdo
+	cmd.Stderr = &stde
+	err = cmd.Run()
+	stdout = string(stdo.Bytes())
+	stderr = string(stde.Bytes())
+	return
+}
@@ -16,6 +16,7 @@ import (

 const templateSuffix = ".template"

+// TemplateHelper helps with creating projects
 type TemplateHelper struct {
 	system      *SystemHelper
 	fs          *FSHelper
@@ -25,12 +26,14 @@ type TemplateHelper struct {
 	metadataFilename string
 }

+// Template defines a single template
 type Template struct {
 	Name     string
 	Dir      string
 	Metadata map[string]interface{}
 }

+// NewTemplateHelper creates a new template helper
 func NewTemplateHelper() *TemplateHelper {
 	result := TemplateHelper{
 		system:           NewSystemHelper(),
@@ -45,6 +48,7 @@ func NewTemplateHelper() *TemplateHelper {
 	return &result
 }

+// GetTemplateNames returns a map of all available templates
 func (t *TemplateHelper) GetTemplateNames() (map[string]string, error) {
 	templateDirs, err := t.fs.GetSubdirs(t.templateDir)
 	if err != nil {
@@ -53,6 +57,8 @@ func (t *TemplateHelper) GetTemplateNames() (map[string]string, error) {
 	return templateDirs, nil
 }

+// GetTemplateDetails returns a map of Template structs containing details
+// of the found templates
 func (t *TemplateHelper) GetTemplateDetails() (map[string]*Template, error) {
 	templateDirs, err := t.fs.GetSubdirs(t.templateDir)
 	if err != nil {
@@ -81,6 +87,7 @@ func (t *TemplateHelper) GetTemplateDetails() (map[string]*Template, error) {
 	return result, nil
 }

+// LoadMetadata loads the template's 'metadata.json' file
 func (t *TemplateHelper) LoadMetadata(dir string) (map[string]interface{}, error) {
 	templateFile := filepath.Join(dir, t.metadataFilename)
 	result := make(map[string]interface{})
@@ -95,6 +102,7 @@ func (t *TemplateHelper) LoadMetadata(dir string) (map[string]interface{}, error
 	return result, err
 }

+// TemplateExists returns true if the given template name exists
 func (t *TemplateHelper) TemplateExists(templateName string) (bool, error) {
 	templates, err := t.GetTemplateNames()
 	if err != nil {
@@ -104,6 +112,8 @@ func (t *TemplateHelper) TemplateExists(templateName string) (bool, error) {
 	return exists, nil
 }

+// InstallTemplate installs the template given in the project options to the
+// project path given
 func (t *TemplateHelper) InstallTemplate(projectPath string, projectOptions *ProjectOptions) error {

 	// Get template files
@@ -0,0 +1,225 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/leaanthony/spinner"
+	"github.com/wailsapp/wails/cmd"
+)
+
+func init() {
+
+	var bundle = false
+	var forceRebuild = false
+	buildSpinner := spinner.NewSpinner()
+	buildSpinner.SetSpinSpeed(50)
+
+	commandDescription := `This command will check to ensure all pre-requistes are installed prior to building. If not, it will attempt to install them. Building comprises of a number of steps: install frontend dependencies, build frontend, pack frontend, compile main application.`
+	initCmd := app.Command("build", "Builds your Wails project").
+		LongDescription(commandDescription).
+		BoolFlag("b", "Bundle application on successful build", &bundle).
+		BoolFlag("f", "Force rebuild of application components", &forceRebuild)
+
+	initCmd.Action(func() error {
+		log := cmd.NewLogger()
+		message := "Building Application"
+		if forceRebuild {
+			message += " (force rebuild)"
+		}
+		log.WhiteUnderline(message)
+
+		// Project options
+		projectOptions := &cmd.ProjectOptions{}
+
+		// Check we are in project directory
+		// Check project.json loads correctly
+		fs := cmd.NewFSHelper()
+		err := projectOptions.LoadConfig(fs.Cwd())
+		if err != nil {
+			return err
+		}
+
+		// Validate config
+		// Check if we have a frontend
+		if projectOptions.FrontEnd != nil {
+			if projectOptions.FrontEnd.Dir == "" {
+				return fmt.Errorf("Frontend directory not set in project.json")
+			}
+			if projectOptions.FrontEnd.Build == "" {
+				return fmt.Errorf("Frontend build command not set in project.json")
+			}
+			if projectOptions.FrontEnd.Install == "" {
+				return fmt.Errorf("Frontend install command not set in project.json")
+			}
+		}
+
+		// Check pre-requisites are installed
+
+		// Program checker
+		program := cmd.NewProgramHelper()
+
+		if projectOptions.FrontEnd != nil {
+			// npm
+			if !program.IsInstalled("npm") {
+				return fmt.Errorf("it appears npm is not installed. Please install and run again")
+			}
+		}
+
+		// packr
+		if !program.IsInstalled("packr") {
+			buildSpinner.Start("Installing packr...")
+			err := program.InstallGoPackage("github.com/gobuffalo/packr/...")
+			if err != nil {
+				buildSpinner.Error()
+				return err
+			}
+			buildSpinner.Success()
+		}
+
+		// Save project directory
+		projectDir := fs.Cwd()
+
+		// Install backend deps - needed?
+		if projectOptions.FrontEnd != nil {
+			// Install frontend deps
+			err = os.Chdir(projectOptions.FrontEnd.Dir)
+			if err != nil {
+				return err
+			}
+
+			// Check if frontend deps have been updated
+			buildSpinner.Start("Installing frontend dependencies...")
+
+			requiresNPMInstall := true
+
+			// Read in package.json MD5
+			packageJSONMD5, err := fs.FileMD5("package.json")
+			if err != nil {
+				return err
+			}
+
+			const md5sumFile = "package.json.md5"
+
+			// If we aren't forcing the install and the md5sum file exists
+			if !forceRebuild && fs.FileExists(md5sumFile) {
+				// Yes - read contents
+				savedMD5sum, err := fs.LoadAsString(md5sumFile)
+				// File exists
+				if err == nil {
+					// Compare md5
+					if savedMD5sum == packageJSONMD5 {
+						// Same - no need for reinstall
+						requiresNPMInstall = false
+						buildSpinner.Success("Skipped frontend dependencies (-f to force rebuild)")
+					}
+				}
+			}
+
+			// Md5 sum package.json
+			// Different? Build
+			if requiresNPMInstall || forceRebuild {
+				// Install dependencies
+				err = program.RunCommand(projectOptions.FrontEnd.Install)
+				if err != nil {
+					buildSpinner.Error()
+					return err
+				}
+				buildSpinner.Success()
+
+				// Update md5sum file
+				ioutil.WriteFile(md5sumFile, []byte(packageJSONMD5), 0644)
+			}
+
+			// Build frontend
+			buildSpinner.Start("Building frontend...")
+			err = program.RunCommand(projectOptions.FrontEnd.Build)
+			if err != nil {
+				buildSpinner.Error()
+				return err
+			}
+			buildSpinner.Success()
+		}
+
+		// Run packr in project directory
+		err = os.Chdir(projectDir)
+		if err != nil {
+			buildSpinner.Error()
+			return err
+		}
+
+		// Support build tags
+		buildTags := []string{}
+
+		// Do we have any frameworks specified?
+		if projectOptions.Framework != nil {
+			buildSpinner.Start()
+			buildSpinner.Success("Compiling support for " + projectOptions.Framework.Name)
+			buildTags = append(buildTags, projectOptions.Framework.BuildTag)
+		}
+
+		// // Initialise Go Module - if go.mod doesn't exist
+		// if !fs.FileExists("go.mod") {
+		// 	buildSpinner.Start("Initialising Go module...")
+		// 	err = program.RunCommand("go mod init " + projectOptions.BinaryName)
+		// 	if err != nil {
+		// 		buildSpinner.Error()
+		// 		return err
+		// 	}
+		// 	buildSpinner.Success()
+		// }
+
+		buildSpinner.Start("Installing Dependencies...")
+		installCommand := "go get"
+		err = program.RunCommand(installCommand)
+		if err != nil {
+			buildSpinner.Error()
+			return err
+		}
+		buildSpinner.Success()
+
+		buildSpinner.Start("Packing + Compiling project...")
+
+		buildCommand := "packr build"
+
+		// Add build tags
+		if len(buildTags) > 0 {
+			buildCommand += fmt.Sprintf(" --tags '%s'", strings.Join(buildTags, " "))
+		}
+
+		if projectOptions.BinaryName != "" {
+			buildCommand += " -o " + projectOptions.BinaryName
+		}
+
+		// If we are forcing a rebuild
+		if forceRebuild {
+			buildCommand += " -a"
+		}
+
+		err = program.RunCommand(buildCommand)
+		if err != nil {
+			buildSpinner.Error()
+			return err
+		}
+		buildSpinner.Success()
+
+		if bundle == false {
+			logger.Yellow("Awesome! Project '%s' built!", projectOptions.Name)
+			return nil
+		}
+
+		// Bundle app
+		buildSpinner.Start("Bundling Application")
+		bundler := cmd.NewBundleHelper()
+		err = bundler.Bundle(projectOptions)
+		if err != nil {
+			buildSpinner.Error()
+			return err
+		}
+		buildSpinner.Success()
+		logger.Yellow("Awesome! Project '%s' built!", projectOptions.Name)
+		return nil
+	})
+}
@@ -0,0 +1,148 @@
+package wails
+
+import (
+	"fmt"
+	"sync"
+)
+
+// eventManager handles and processes events
+type eventManager struct {
+	incomingEvents chan *eventData
+	listeners      map[string][]*eventListener
+	exit           bool
+	log            *CustomLogger
+	renderer       Renderer // Messages will be dispatched to the frontend
+}
+
+// newEventManager creates a new event manager with a 100 event buffer
+func newEventManager() *eventManager {
+	return &eventManager{
+		incomingEvents: make(chan *eventData, 100),
+		listeners:      make(map[string][]*eventListener),
+		exit:           false,
+		log:            newCustomLogger("Events"),
+	}
+}
+
+// PushEvent places the given event on to the event queue
+func (e *eventManager) PushEvent(eventData *eventData) {
+	e.incomingEvents <- eventData
+}
+
+// eventListener holds a callback function which is invoked when
+// the event listened for is emitted. It has a counter which indicates
+// how the total number of events it is interested in. A value of zero
+// means it does not expire (default).
+type eventListener struct {
+	callback func(...interface{}) // Function to call with emitted event data
+	counter  int                  // Expire after counter callbacks. 0 = infinite
+	expired  bool                 // Indicates if the listener has expired
+}
+
+// Creates a new event listener from the given callback function
+func (e *eventManager) addEventListener(eventName string, callback func(...interface{}), counter int) error {
+
+	// Sanity check inputs
+	if callback == nil {
+		return fmt.Errorf("nil callback bassed to addEventListener")
+	}
+
+	// Check event has been registered before
+	if e.listeners[eventName] == nil {
+		e.listeners[eventName] = []*eventListener{}
+	}
+
+	// Create the callback
+	listener := &eventListener{
+		callback: callback,
+		counter:  counter,
+	}
+
+	// Register listener
+	e.listeners[eventName] = append(e.listeners[eventName], listener)
+
+	// All good mate
+	return nil
+}
+
+func (e *eventManager) On(eventName string, callback func(...interface{})) {
+	// Add a persistent eventListener (counter = 0)
+	e.addEventListener(eventName, callback, 0)
+}
+
+// Emit broadcasts the given event to the subscribed listeners
+func (e *eventManager) Emit(eventName string, optionalData ...interface{}) {
+	e.incomingEvents <- &eventData{Name: eventName, Data: optionalData}
+}
+
+// Starts the event manager's queue processing
+func (e *eventManager) start(renderer Renderer) {
+
+	e.log.Info("Starting")
+
+	// Store renderer
+	e.renderer = renderer
+
+	// Set up waitgroup so we can wait for goroutine to start
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	// Run main loop in seperate goroutine
+	go func() {
+		wg.Done()
+		e.log.Info("Listening")
+		for e.exit == false {
+			// TODO: Listen for application exit
+			select {
+			case event := <-e.incomingEvents:
+				e.log.DebugFields("Got Event", Fields{
+					"data": event.Data,
+					"name": event.Name,
+				})
+
+				// Notify renderer
+				e.renderer.NotifyEvent(event)
+
+				// Notify Go listeners
+				var listenersToRemove []*eventListener
+
+				// Iterate listeners
+				for _, listener := range e.listeners[event.Name] {
+
+					// Call listener, perhaps with data
+					if event.Data == nil {
+						go listener.callback()
+					} else {
+						unpacked := event.Data.([]interface{})
+						go listener.callback(unpacked...)
+					}
+
+					// Update listen counter
+					if listener.counter > 0 {
+						listener.counter = listener.counter - 1
+						if listener.counter == 0 {
+							listener.expired = true
+						}
+					}
+				}
+
+				// Remove expired listners in place
+				if len(listenersToRemove) > 0 {
+					listeners := e.listeners[event.Name][:0]
+					for _, listener := range listeners {
+						if !listener.expired {
+							listeners = append(listeners, listener)
+						}
+					}
+				}
+			}
+		}
+	}()
+
+	// Wait for goroutine to start
+	wg.Wait()
+}
+
+func (e *eventManager) stop() {
+	e.exit = true
+}
@@ -3,8 +3,14 @@ module github.com/wailsapp/wails
 require (
 	github.com/AlecAivazis/survey v1.7.1
 	github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc
+	github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc // indirect
+	github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac
+	github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947 // indirect
 	github.com/fatih/color v1.7.0
+	github.com/go-playground/colors v1.2.0
 	github.com/gobuffalo/packr v1.21.9
+	github.com/gorilla/websocket v1.4.0
+	github.com/jackmordaunt/icns v1.0.0
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/leaanthony/spinner v0.4.0
 	github.com/leaanthony/synx v0.0.0-20180923230033-60efbd9984b0 // indirect
@@ -13,5 +19,8 @@ require (
 	github.com/mattn/go-isatty v0.0.4 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
 	github.com/mitchellh/go-homedir v1.0.0
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
+	github.com/sirupsen/logrus v1.2.0
+	golang.org/x/net v0.0.0-20190107155100-1a61f4433d85 // indirect
 	gopkg.in/AlecAivazis/survey.v1 v1.7.1 // indirect
 )
@@ -14,6 +14,12 @@ github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8Nz
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc h1:VBS1z48BFEe00G81z8MKOtwX7f/ISkuH38NscT8iVPw=
+github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc/go.mod h1:ABJPuor7YlcsHmvJ1QxX38e2NcufLY3hm0yXv+cy9sI=
+github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac h1:DpMwFluHWoZpV9ex5XjkWO4HyCz5HLVI8XbHw0FhHi4=
+github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac/go.mod h1:XsAE+b4rOZc8gvgsgF+wU75mNBvBcyED1wdd9PBLlJ0=
+github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947 h1:Fm10/KNuoAyBm2P5P5H91Xy21hGcZnBdjR+cMdytv1M=
+github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947/go.mod h1:Dv9D0NUlAsaQcGQZa5kc5mqR9ua72SmA8VXi4cd+cBw=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dustin/go-humanize v0.0.0-20180713052910-9f541cc9db5d/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -22,6 +28,8 @@ github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5Kwzbycv
 github.com/fatih/structs v1.0.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/go-playground/colors v1.2.0 h1:0EdjTXKrr2g1L/LQTYtIqabeHpZuGZz1U4osS1T8+5M=
+github.com/go-playground/colors v1.2.0/go.mod h1:miw1R2JIE19cclPxsXqNdzLZsk4DP4iF+m88bRc7kfM=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/gobuffalo/buffalo v0.12.8-0.20181004233540-fac9bb505aa8/go.mod h1:sLyT7/dceRXJUxSsE813JTQtA3Eb1vjxWfo/N//vXIY=
 github.com/gobuffalo/buffalo v0.13.0/go.mod h1:Mjn1Ba9wpIbpbrD+lIDMy99pQ0H0LiddMIIDGse7qT4=
@@ -185,11 +193,15 @@ github.com/gorilla/pat v0.0.0-20180118222023-199c85a7f6d1/go.mod h1:YeAe0gNeiNT5
 github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
 github.com/gorilla/sessions v1.1.2/go.mod h1:8KCfur6+4Mqcc6S0FEfKuN15Vl5MgXW92AE8ovaJD0w=
 github.com/gorilla/sessions v1.1.3/go.mod h1:8KCfur6+4Mqcc6S0FEfKuN15Vl5MgXW92AE8ovaJD0w=
+github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jackc/fake v0.0.0-20150926172116-812a484cc733/go.mod h1:WrMFNQdiFJ80sQsxDoMokWK1W5TQtxBFNpzWTD84ibQ=
 github.com/jackc/pgx v3.2.0+incompatible/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
+github.com/jackmordaunt/icns v1.0.0 h1:RYSxplerf/l/DUd09AHtITwckkv/mqjVv4DjYdPmAMQ=
+github.com/jackmordaunt/icns v1.0.0/go.mod h1:7TTQVEuGzVVfOPPlLNHJIkzA6CoV7aH1Dv9dW351oOo=
 github.com/jmoiron/sqlx v0.0.0-20180614180643-0dae4fefe7c0/go.mod h1:IiEW3SEiiErVyFdH8NTuWjSifiEQKUoyK3LNqr2kCHU=
 github.com/joho/godotenv v1.2.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
 github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
@@ -246,6 +258,8 @@ github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrk
 github.com/mitchellh/mapstructure v1.0.0/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/monoculum/formam v0.0.0-20180901015400-4e68be1d79ba/go.mod h1:RKgILGEJq24YyJ2ban8EO0RUVSJlF1pGsEvoLEACr/Q=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
 github.com/nicksnyder/go-i18n v1.10.0/go.mod h1:HrK7VCrbOvQoUAQ7Vpy7i87N7JZZZ7R2xBGjv0j365Q=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
@@ -271,6 +285,7 @@ github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.
 github.com/sirupsen/logrus v1.0.6/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
 github.com/sirupsen/logrus v1.1.0/go.mod h1:zrgwTnHtNr00buQ1vSptGe8m1f/BbgsPukg8qsT7A+A=
 github.com/sirupsen/logrus v1.1.1/go.mod h1:zrgwTnHtNr00buQ1vSptGe8m1f/BbgsPukg8qsT7A+A=
+github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
 github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
@@ -301,6 +316,7 @@ golang.org/x/crypto v0.0.0-20181025213731-e84da0312774/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20181106171534-e4dc69e5b2fd/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181112202954-3d3f9f413869/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 h1:mKdxBk7AujPs8kU4m80U72y/zjbZ3UcXC7dClwKbUI0=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180816102801-aaf60122140d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -314,7 +330,10 @@ golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181207154023-610586996380 h1:zPQexyRtNYBc7bcHmehl1dH6TB3qn8zytv8cBGLDNY0=
 golang.org/x/net v0.0.0-20181207154023-610586996380/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190107155100-1a61f4433d85 h1:3DfFuyqY+mca6oIDfim5rft3+Kl/CHLe7RdPrUMzwv0=
+golang.org/x/net v0.0.0-20190107155100-1a61f4433d85/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180816055513-1c9583448a9c/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -333,6 +352,7 @@ golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20181106135930-3a76605856fd/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181206074257-70b957f3b65e h1:njOxP/wVblhCLIUhjHXf6X+dzTt5OQ3vMQo9mkOIKIo=
 golang.org/x/sys v0.0.0-20181206074257-70b957f3b65e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -0,0 +1,38 @@
+package wails
+
+import (
+	"fmt"
+)
+
+type callData struct {
+	BindingName string `json:"bindingName"`
+	Data        string `json:"data,omitempty"`
+}
+
+func init() {
+	messageProcessors["call"] = processCallData
+}
+
+func processCallData(message *ipcMessage) (*ipcMessage, error) {
+
+	var payload callData
+
+	// Decode binding call data
+	payloadMap := message.Payload.(map[string]interface{})
+
+	// Check for binding name
+	if payloadMap["bindingName"] == nil {
+		return nil, fmt.Errorf("bindingName not given in call")
+	}
+	payload.BindingName = payloadMap["bindingName"].(string)
+
+	// Check for data
+	if payloadMap["data"] != nil {
+		payload.Data = payloadMap["data"].(string)
+	}
+
+	// Reassign payload to decoded data
+	message.Payload = &payload
+
+	return message, nil
+}
@@ -0,0 +1,40 @@
+package wails
+
+import (
+	"encoding/json"
+)
+
+type eventData struct {
+	Name string      `json:"name"`
+	Data interface{} `json:"data"`
+}
+
+// Register the message handler
+func init() {
+	messageProcessors["event"] = processEventData
+}
+
+// This processes the given event message
+func processEventData(message *ipcMessage) (*ipcMessage, error) {
+
+	// TODO: Is it worth double checking this is actually an event message,
+	// even though that's done by the caller?
+	var payload eventData
+
+	// Decode event data
+	payloadMap := message.Payload.(map[string]interface{})
+	payload.Name = payloadMap["name"].(string)
+
+	// decode the payload data
+	var data []interface{}
+	err := json.Unmarshal([]byte(payloadMap["data"].(string)), &data)
+	if err != nil {
+		return nil, err
+	}
+	payload.Data = data
+
+	// Reassign payload to decoded data
+	message.Payload = &payload
+
+	return message, nil
+}
@@ -0,0 +1,27 @@
+package wails
+
+type logData struct {
+	Level   string `json:"level"`
+	Message string `json:"string"`
+}
+
+// Register the message handler
+func init() {
+	messageProcessors["log"] = processLogData
+}
+
+// This processes the given log message
+func processLogData(message *ipcMessage) (*ipcMessage, error) {
+
+	var payload logData
+
+	// Decode event data
+	payloadMap := message.Payload.(map[string]interface{})
+	payload.Level = payloadMap["level"].(string)
+	payload.Message = payloadMap["message"].(string)
+
+	// Reassign payload to decoded data
+	message.Payload = &payload
+
+	return message, nil
+}
--- a/Show More
+++ b/Show More