├── .babelrc
├── .editorconfig
├── .electron-vue
    ├── build.js
    ├── dev-client.js
    ├── dev-runner.js
    ├── webpack.main.config.js
    └── webpack.renderer.config.js
├── .eslintignore
├── .eslintrc.yml
├── .gitignore
├── .stylelintrc.yml
├── .travis.yml
├── README.md
├── appveyor.yml
├── build
    └── icons
    │   ├── 256x256.png
    │   ├── icon.icns
    │   └── icon.ico
├── dist
    ├── electron
    │   └── .gitkeep
    └── web
    │   └── .gitkeep
├── package-lock.json
├── package.json
├── resources
    └── suggestions.txt
├── screenshots
    ├── screenshot-1.jpg
    ├── screenshot-2.jpg
    ├── screenshot-3.JPG
    └── screenshot-merged.jpg
├── src
    ├── assistant.ejs
    ├── main
    │   └── index.js
    ├── renderer
    │   ├── assets
    │   │   └── .gitkeep
    │   ├── config.js
    │   ├── containers
    │   │   ├── assistant.vue
    │   │   └── response.vue
    │   ├── index.js
    │   └── providers
    │   │   ├── assistant
    │   │       ├── assistant.js
    │   │       ├── index.js
    │   │       ├── microphone.js
    │   │       └── player.js
    │   │   ├── authentication
    │   │       ├── authentication.js
    │   │       ├── google-electron-auth.js
    │   │       └── index.js
    │   │   ├── commands
    │   │       ├── assistant.js
    │   │       ├── audio-control.js
    │   │       ├── index.js
    │   │       ├── spotify.js
    │   │       └── youtube.js
    │   │   ├── router
    │   │       └── index.js
    │   │   ├── spotify
    │   │       ├── index.js
    │   │       └── spotify.js
    │   │   └── store
    │   │       ├── assistant.js
    │   │       ├── index.js
    │   │       └── store.js
    └── response.ejs
├── static
    ├── .gitkeep
    ├── bubbles.png
    ├── hotword_enrollment_confirm.png
    ├── ic_mic.png
    ├── icon.ico
    ├── icon.png
    ├── loading.gif
    ├── molecule.svg
    ├── opa_logo_big.png
    ├── ping.mp3
    ├── powered_by_google_dark.png
    ├── powered_by_google_light.png
    ├── quantum_ic_devices_other_grey600_24.png
    ├── recording.gif
    ├── splash.html
    ├── v.png
    └── waiting.svg
└── test
    ├── .eslintrc
    ├── e2e
        ├── index.js
        ├── specs
        │   └── Launch.spec.js
        └── utils.js
    └── unit
        ├── index.js
        └── karma.conf.js


/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"presets": [
 3 | 		[
 4 | 			"@babel/preset-env",
 5 | 			{
 6 | 				"targets": {
 7 | 					"chrome": "66",
 8 | 					"node": 8
 9 | 				}
10 | 			}
11 | 		]
12 | 	]
13 | }
14 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | indent_style = tab
 6 | end_of_line = lf
 7 | insert_final_newline = true
 8 | trim_trailing_whitespace = true
 9 | 
10 | [*.md]
11 | trim_trailing_whitespace = false
12 | 
13 | [*.yml]
14 | indent_size = 2
15 | indent_style = space
16 | 


--------------------------------------------------------------------------------
/.electron-vue/build.js:
--------------------------------------------------------------------------------
  1 | 'use strict'
  2 | 
  3 | process.env.NODE_ENV = 'production'
  4 | 
  5 | const { say } = require('cfonts')
  6 | const chalk = require('chalk')
  7 | const del = require('del')
  8 | const { spawn } = require('child_process')
  9 | const webpack = require('webpack')
 10 | const Multispinner = require('multispinner')
 11 | 
 12 | 
 13 | const mainConfig = require('./webpack.main.config')
 14 | const rendererConfig = require('./webpack.renderer.config')
 15 | 
 16 | const doneLog = chalk.bgGreen.white(' DONE ') + ' '
 17 | const errorLog = chalk.bgRed.white(' ERROR ') + ' '
 18 | const okayLog = chalk.bgBlue.white(' OKAY ') + ' '
 19 | const isCI = process.env.CI || false
 20 | 
 21 | if (process.env.BUILD_TARGET === 'clean') clean()
 22 | else build()
 23 | 
 24 | function clean () {
 25 |   del.sync(['build/*', '!build/icons', '!build/icons/icon.*'])
 26 |   console.log(`\n${doneLog}\n`)
 27 |   process.exit()
 28 | }
 29 | 
 30 | function build () {
 31 |   greeting()
 32 | 
 33 |   del.sync(['dist/electron/*', '!.gitkeep'])
 34 | 
 35 |   const tasks = ['main', 'renderer']
 36 |   const m = new Multispinner(tasks, {
 37 |     preText: 'building',
 38 |     postText: 'process'
 39 |   })
 40 | 
 41 |   let results = ''
 42 | 
 43 |   m.on('success', () => {
 44 |     process.stdout.write('\x1B[2J\x1B[0f')
 45 |     console.log(`\n\n${results}`)
 46 |     console.log(`${okayLog}take it away ${chalk.yellow('`electron-builder`')}\n`)
 47 |     process.exit()
 48 |   })
 49 | 
 50 |   pack(mainConfig).then(result => {
 51 |     results += result + '\n\n'
 52 |     m.success('main')
 53 |   }).catch(err => {
 54 |     m.error('main')
 55 |     console.log(`\n  ${errorLog}failed to build main process`)
 56 |     console.error(`\n${err}\n`)
 57 |     process.exit(1)
 58 |   })
 59 | 
 60 |   pack(rendererConfig).then(result => {
 61 |     results += result + '\n\n'
 62 |     m.success('renderer')
 63 |   }).catch(err => {
 64 |     m.error('renderer')
 65 |     console.log(`\n  ${errorLog}failed to build renderer process`)
 66 |     console.error(`\n${err}\n`)
 67 |     process.exit(1)
 68 |   })
 69 | }
 70 | 
 71 | function pack (config) {
 72 |   return new Promise((resolve, reject) => {
 73 |     webpack(config, (err, stats) => {
 74 |       if (err) reject(err.stack || err)
 75 |       else if (stats.hasErrors()) {
 76 |         let err = ''
 77 | 
 78 |         stats.toString({
 79 |           chunks: false,
 80 |           colors: true
 81 |         })
 82 |         .split(/\r?\n/)
 83 |         .forEach(line => {
 84 |           err += `    ${line}\n`
 85 |         })
 86 | 
 87 |         reject(err)
 88 |       } else {
 89 |         resolve(stats.toString({
 90 |           chunks: false,
 91 |           colors: true
 92 |         }))
 93 |       }
 94 |     })
 95 |   })
 96 | }
 97 | 
 98 | function greeting () {
 99 |   const cols = process.stdout.columns
100 |   let text = ''
101 | 
102 |   if (cols > 85) text = 'lets-build'
103 |   else if (cols > 60) text = 'lets-|build'
104 |   else text = false
105 | 
106 |   if (text && !isCI) {
107 |     say(text, {
108 |       colors: ['yellow'],
109 |       font: 'simple3d',
110 |       space: false
111 |     })
112 |   } else console.log(chalk.yellow.bold('\n  lets-build'))
113 |   console.log()
114 | }
115 | 


--------------------------------------------------------------------------------
/.electron-vue/dev-client.js:
--------------------------------------------------------------------------------
 1 | 
 2 | const hotClient = require('webpack-hot-middleware/client?noInfo=true&reload=true')
 3 | 
 4 | hotClient.subscribe((/* event */) => {
 5 |   /**
 6 |    * Reload browser when HTMLWebpackPlugin emits a new index.html
 7 |    *
 8 |    * Currently disabled until jantimon/html-webpack-plugin#680 is resolved.
 9 |    * https://github.com/SimulatedGREG/electron-vue/issues/437
10 |    * https://github.com/jantimon/html-webpack-plugin/issues/680
11 |    */
12 | 	// if (event.action === 'reload') {
13 | 	//   window.location.reload()
14 | 	// }
15 | })
16 | 


--------------------------------------------------------------------------------
/.electron-vue/dev-runner.js:
--------------------------------------------------------------------------------
  1 | 'use strict'
  2 | 
  3 | const chalk = require('chalk')
  4 | const electron = require('electron')
  5 | const path = require('path')
  6 | const { say } = require('cfonts')
  7 | const { spawn } = require('child_process')
  8 | const webpack = require('webpack')
  9 | const WebpackDevServer = require('webpack-dev-server')
 10 | const webpackHotMiddleware = require('webpack-hot-middleware')
 11 | 
 12 | const mainConfig = require('./webpack.main.config')
 13 | const rendererConfig = require('./webpack.renderer.config')
 14 | 
 15 | let electronProcess = null
 16 | let manualRestart = false
 17 | let hotMiddleware
 18 | 
 19 | function logStats(proc, data) {
 20 | 	let log = ''
 21 | 
 22 | 	log += chalk.yellow.bold(`┏ ${proc} Process ${new Array((19 - proc.length) + 1).join('-')}`)
 23 | 	log += '\n\n'
 24 | 
 25 | 	if (typeof data === 'object') {
 26 | 		data.toString({
 27 | 			colors: true,
 28 | 			chunks: false
 29 | 		}).split(/\r?\n/).forEach(line => {
 30 | 			log += '  ' + line + '\n'
 31 | 		})
 32 | 	} else {
 33 | 		log += `  ${data}\n`
 34 | 	}
 35 | 
 36 | 	log += '\n' + chalk.yellow.bold(`┗ ${new Array(28 + 1).join('-')}`) + '\n'
 37 | 
 38 | 	console.log(log)
 39 | }
 40 | 
 41 | function startRenderer() {
 42 | 	return new Promise((resolve, reject) => {
 43 | 		rendererConfig.entry.renderer = [path.join(__dirname, 'dev-client')].concat(rendererConfig.entry.renderer)
 44 | 
 45 | 		const compiler = webpack(rendererConfig)
 46 | 		hotMiddleware = webpackHotMiddleware(compiler, {
 47 | 			log: false,
 48 | 			heartbeat: 2500
 49 | 		})
 50 | 
 51 | 		compiler.plugin('compilation', compilation => {
 52 | 			compilation.plugin('html-webpack-plugin-after-emit', (data, cb) => {
 53 | 				hotMiddleware.publish({ action: 'reload' })
 54 | 				cb()
 55 | 			})
 56 | 		})
 57 | 
 58 | 		compiler.plugin('done', stats => {
 59 | 			logStats('Renderer', stats)
 60 | 		})
 61 | 
 62 | 		const server = new WebpackDevServer(
 63 | 			compiler,
 64 | 			{
 65 | 				contentBase: path.join(__dirname, '../'),
 66 | 				quiet: true,
 67 | 				before(app, ctx) {
 68 | 					app.use(hotMiddleware)
 69 | 					ctx.middleware.waitUntilValid(() => {
 70 | 						resolve()
 71 | 					})
 72 | 				}
 73 | 			}
 74 | 		)
 75 | 
 76 | 		server.listen(9080)
 77 | 	})
 78 | }
 79 | 
 80 | function startMain() {
 81 | 	return new Promise((resolve, reject) => {
 82 | 		// mainConfig.entry.main = [path.join(__dirname, '../src/main/index.js')].concat(mainConfig.entry.main)
 83 | 
 84 | 		const compiler = webpack(mainConfig)
 85 | 
 86 | 		compiler.plugin('watch-run', (compilation, done) => {
 87 | 			logStats('Main', chalk.white.bold('compiling...'))
 88 | 			hotMiddleware.publish({ action: 'compiling' })
 89 | 			done()
 90 | 		})
 91 | 
 92 | 		compiler.watch({}, (err, stats) => {
 93 | 			if (err) {
 94 | 				console.log(err)
 95 | 				return
 96 | 			}
 97 | 
 98 | 			logStats('Main', stats)
 99 | 
100 | 			if (electronProcess && electronProcess.kill) {
101 | 				manualRestart = true
102 | 				process.kill(electronProcess.pid)
103 | 				electronProcess = null
104 | 				startElectron()
105 | 
106 | 				setTimeout(() => {
107 | 					manualRestart = false
108 | 				}, 5000)
109 | 			}
110 | 
111 | 			resolve()
112 | 		})
113 | 	})
114 | }
115 | 
116 | function startElectron() {
117 | 	electronProcess = spawn(electron, ['--inspect=5858', path.join(__dirname, '../dist/electron/main.js')])
118 | 
119 | 	electronProcess.stdout.on('data', data => {
120 | 		electronLog(data, 'blue')
121 | 	})
122 | 	electronProcess.stderr.on('data', data => {
123 | 		electronLog(data, 'red')
124 | 	})
125 | 
126 | 	electronProcess.on('close', () => {
127 | 		if (!manualRestart) process.exit()
128 | 	})
129 | }
130 | 
131 | function electronLog(data, color) {
132 | 	let log = ''
133 | 	data = data.toString().split(/\r?\n/)
134 | 	data.forEach(line => {
135 | 		log += `  ${line}\n`
136 | 	})
137 | 	if (/[0-9A-z]+/.test(log)) {
138 | 		console.log(
139 | 			chalk[color].bold('┏ Electron -------------------') +
140 | 			'\n\n' +
141 | 			log +
142 | 			chalk[color].bold('┗ ----------------------------') +
143 | 			'\n'
144 | 		)
145 | 	}
146 | }
147 | 
148 | function greeting() {
149 | 	const cols = process.stdout.columns
150 | 	let text = ''
151 | 
152 | 	if (cols > 104) text = 'Assistant|Desktop';
153 | 	else if (cols > 76) text = 'Assistant-|Desktop'
154 | 	else text = false
155 | 
156 | 	if (text) {
157 | 		say(text, {
158 | 			colors: ['yellow'],
159 | 			font: 'simple',
160 | 			space: false
161 | 		})
162 | 	} else console.log(chalk.yellow.bold('\n  electron-vue'))
163 | 	console.log(chalk.blue('  getting ready...') + '\n')
164 | }
165 | 
166 | function init() {
167 | 	greeting()
168 | 
169 | 	Promise.all([startRenderer(), startMain()])
170 | 		.then(() => {
171 | 			startElectron()
172 | 		})
173 | 		.catch(err => {
174 | 			console.error(err)
175 | 		})
176 | }
177 | 
178 | init()
179 | 


--------------------------------------------------------------------------------
/.electron-vue/webpack.main.config.js:
--------------------------------------------------------------------------------
 1 | process.env.BABEL_ENV = 'main'
 2 | 
 3 | const path = require('path')
 4 | const { dependencies } = require('../package.json')
 5 | 
 6 | /* eslint-disable*/
 7 | const webpack = require('webpack')
 8 | /* eslint-enable */
 9 | 
10 | const mainConfig = {
11 | 	mode: process.env.NODE_ENV,
12 | 	entry: {
13 | 		main: path.join(__dirname, '../src/main/index.js'),
14 | 	},
15 | 	externals: [...Object.keys(dependencies || {})],
16 | 	module: {
17 | 		rules: [
18 | 			{
19 | 				test: /\.js$/,
20 | 				use: 'babel-loader',
21 | 				exclude: /node_modules/,
22 | 			},
23 | 			{
24 | 				test: /\.node$/,
25 | 				use: 'node-loader',
26 | 			},
27 | 		],
28 | 	},
29 | 	node: {
30 | 		__dirname: process.env.NODE_ENV !== 'production',
31 | 		__filename: process.env.NODE_ENV !== 'production',
32 | 	},
33 | 	output: {
34 | 		filename: '[name].js',
35 | 		libraryTarget: 'commonjs2',
36 | 		path: path.join(__dirname, '../dist/electron'),
37 | 	},
38 | 	// plugins: [new webpack.NoEmitOnErrorsPlugin()],
39 | 	resolve: {
40 | 		extensions: ['.js', '.json', '.node'],
41 | 	},
42 | 	target: 'electron-main',
43 | }
44 | 
45 | module.exports = mainConfig
46 | 


--------------------------------------------------------------------------------
/.electron-vue/webpack.renderer.config.js:
--------------------------------------------------------------------------------
  1 | 'use strict'
  2 | 
  3 | process.env.BABEL_ENV = 'renderer'
  4 | 
  5 | const path = require('path')
  6 | const { dependencies } = require('../package.json')
  7 | const webpack = require('webpack')
  8 | 
  9 | const CopyWebpackPlugin = require('copy-webpack-plugin')
 10 | const VueLoaderPlugin = require('vue-loader/lib/plugin')
 11 | // const MiniCssExtractPlugin = require('mini-css-extract-plugin')
 12 | const HtmlWebpackPlugin = require('html-webpack-plugin')
 13 | 
 14 | /**
 15 |  * List of node_modules to include in webpack bundle
 16 |  *
 17 |  * Required for specific packages like Vue UI libraries
 18 |  * that provide pure *.vue files that need compiling
 19 |  * https://simulatedgreg.gitbooks.io/electron-vue/content/en/webpack-configurations.html#white-listing-externals
 20 |  */
 21 | let whiteListedModules = ['vue', 'vuetify']
 22 | 
 23 | let rendererConfig = {
 24 | 	mode: 'none',
 25 | 	entry: {
 26 | 		renderer: path.join(__dirname, '../src/renderer/index.js')
 27 | 	},
 28 | 	externals: [
 29 | 		...Object.keys(dependencies || {}).filter(d => !whiteListedModules.includes(d))
 30 | 	],
 31 | 	module: {
 32 | 		rules: [
 33 | 			{
 34 | 				test: /\.scss$/,
 35 | 				use: ['vue-style-loader', 'css-loader', 'sass-loader'],
 36 | 			},
 37 | 			{
 38 | 				test: /\.sass$/,
 39 | 				use: ['vue-style-loader', 'css-loader', 'sass-loader?indentedSyntax'],
 40 | 			},
 41 | 			{
 42 | 				test: /\.less$/,
 43 | 				use: ['vue-style-loader', 'css-loader', 'less-loader'],
 44 | 			},
 45 | 			{
 46 | 				test: /\.css$/,
 47 | 				use: ['vue-style-loader', 'css-loader'],
 48 | 			},
 49 | 			{
 50 | 				test: /\.html$/,
 51 | 				use: 'vue-html-loader',
 52 | 			},
 53 | 			{
 54 | 				test: /\.js$/,
 55 | 				use: 'babel-loader',
 56 | 				exclude: /node_modules/,
 57 | 			},
 58 | 			{
 59 | 				test: /\.node$/,
 60 | 				use: 'node-loader',
 61 | 			},
 62 | 			{
 63 | 				test: /\.vue$/,
 64 | 				use: {
 65 | 					loader: 'vue-loader',
 66 | 					options: {
 67 | 						extractCSS: process.env.NODE_ENV === 'production',
 68 | 						loaders: {
 69 | 							sass: 'vue-style-loader!css-loader!sass-loader?indentedSyntax=1',
 70 | 							scss: 'vue-style-loader!css-loader!sass-loader',
 71 | 							less: 'vue-style-loader!css-loader!less-loader',
 72 | 						},
 73 | 					},
 74 | 				},
 75 | 			},
 76 | 			{
 77 | 				test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,
 78 | 				use: {
 79 | 					loader: 'url-loader',
 80 | 					query: {
 81 | 						limit: 10000,
 82 | 						name: 'imgs/[name]--[folder].[ext]',
 83 | 					},
 84 | 				},
 85 | 			},
 86 | 			{
 87 | 				test: /\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/,
 88 | 				loader: 'url-loader',
 89 | 				options: {
 90 | 					limit: 10000,
 91 | 					name: 'media/[name]--[folder].[ext]',
 92 | 				},
 93 | 			},
 94 | 			{
 95 | 				test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
 96 | 				use: {
 97 | 					loader: 'url-loader',
 98 | 					query: {
 99 | 						limit: 10000,
100 | 						name: 'fonts/[name]--[folder].[ext]',
101 | 					},
102 | 				},
103 | 			},
104 | 		],
105 | 	},
106 | 	node: {
107 | 		__dirname: process.env.NODE_ENV !== 'production',
108 | 		__filename: process.env.NODE_ENV !== 'production'
109 | 	},
110 | 	plugins: [
111 | 		new HtmlWebpackPlugin({
112 | 			filename: 'assistant.html',
113 | 			template: path.resolve(__dirname, '../src/assistant.ejs'),
114 | 			nodeModules: process.env.NODE_ENV !== 'production'
115 | 				? path.resolve(__dirname, '../node_modules')
116 | 				: false
117 | 		}),
118 | 		new HtmlWebpackPlugin({
119 | 			filename: 'response.html',
120 | 			template: path.resolve(__dirname, '../src/response.ejs'),
121 | 			nodeModules: process.env.NODE_ENV !== 'production'
122 | 				? path.resolve(__dirname, '../node_modules')
123 | 				: false
124 | 		}),
125 | 		new VueLoaderPlugin(),
126 | 		new webpack.HotModuleReplacementPlugin(),
127 | 		// new webpack.NoEmitOnErrorsPlugin(),
128 | 	],
129 | 	output: {
130 | 		filename: '[name].js',
131 | 		libraryTarget: 'commonjs2',
132 | 		path: path.join(__dirname, '../dist/electron')
133 | 	},
134 | 	resolve: {
135 | 		alias: {
136 | 			'@': path.join(__dirname, '../src/renderer'),
137 | 			vue$: path.resolve(__dirname, '../node_modules/vue/dist/vue.esm.js'),
138 | 		},
139 | 		extensions: ['.js', '.vue', '.json', '.css', '.node'],
140 | 		modules: [
141 | 			path.resolve(__dirname, '../node_modules'),
142 | 			path.resolve(__dirname, '../src/renderer'),
143 | 		],
144 | 	},
145 | 	target: 'electron-renderer'
146 | }
147 | 
148 | /**
149 |  * Adjust rendererConfig for production settings
150 | */
151 | if (process.env.NODE_ENV === 'production') {
152 | 	rendererConfig.devtool = ''
153 | 
154 | 	rendererConfig.plugins.push(
155 | 		new CopyWebpackPlugin([
156 | 			{
157 | 				from: path.join(__dirname, '../static'),
158 | 				to: path.join(__dirname, '../dist/electron/static'),
159 | 			}
160 | 		]),
161 | 	)
162 | }
163 | 
164 | module.exports = rendererConfig
165 | 


--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | test/unit/coverage/**
2 | test/unit/*.js
3 | test/e2e/*.js
4 | 


--------------------------------------------------------------------------------
/.eslintrc.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | parserOptions:
 3 |   parser: babel-eslint
 4 | 
 5 | extends:
 6 |   - airbnb-base
 7 |   - plugin:vue/recommended
 8 | 
 9 | settings:
10 |   import/resolver:
11 |     webpack:
12 |       config: ./.electron-vue/webpack.renderer.config.js
13 |   import/core-modules: [ electron ]
14 | 
15 | rules:
16 |   import/extensions:
17 |     - error
18 |     - on
19 |     - js: off
20 |       vue: off
21 | 
22 |   indent: off
23 |   indent-legacy:
24 |     - error
25 |     - tab
26 | 
27 |   no-tabs: off
28 |   max-len:
29 |     - warn
30 |     - 120
31 | 
32 |   no-console: off
33 | 
34 |   no-undef: error
35 |   no-unused-vars: error
36 | 
37 |   no-underscore-dangle:
38 |     - error
39 |     - allow: [ __static ]
40 | 
41 |   # Possible Errors
42 |   vue/no-dupe-keys: error
43 |   vue/no-reserved-keys: error
44 |   vue/no-shared-component-data: error
45 |   vue/no-unused-vars: error
46 | 
47 |   vue/require-valid-default-prop: error
48 |   vue/return-in-computed-property: error
49 | 
50 | 
51 |   # Best Practices
52 |   vue/no-duplicate-attributes: error
53 |   vue/no-side-effects-in-computed-properties: error
54 |   vue/order-in-components: error
55 | 
56 |   # Stylistic Issues
57 |   vue/attribute-hyphenation: error
58 |   vue/html-indent:
59 |     - error
60 |     - tab
61 |   vue/html-quotes: error
62 |   vue/html-self-closing:
63 |     - error
64 |     - html:
65 |         normal: always
66 |         void: always
67 |         component: always
68 |   vue/max-attributes-per-line: error
69 |   vue/mustache-interpolation-spacing: error
70 |   vue/name-property-casing:
71 |     - error
72 |     - PascalCase
73 |   vue/no-multi-spaces: error
74 |   vue/v-bind-style: error
75 |   vue/v-on-style: error
76 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | dist/electron/*
 3 | dist/web/*
 4 | build/*
 5 | !build/icons
 6 | coverage
 7 | node_modules/
 8 | npm-debug.log
 9 | npm-debug.log.*
10 | thumbs.db
11 | !.gitkeep
12 | .env
13 | client_secret*.json
14 | 


--------------------------------------------------------------------------------
/.stylelintrc.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | extends:
 3 |   - stylelint-config-standard
 4 |   - stylelint-config-concentric
 5 | 
 6 | plugins:
 7 |   - stylelint-scss
 8 | 
 9 | processors:
10 |   - '@mapbox/stylelint-processor-arbitrary-tags'
11 | 
12 | rules:
13 |   at-rule-no-unknown: null
14 |   declaration-empty-line-before: null
15 |   indentation: tab
16 |   no-empty-source: null
17 |   no-invalid-double-slash-comments: null
18 |   number-leading-zero: never
19 |   property-no-unknown:
20 |     - true
21 |     - ignoreProperties:
22 |         - '//'
23 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | # Commented sections below can be used to run tests on the CI server
 2 | # https://simulatedgreg.gitbooks.io/electron-vue/content/en/testing.html#on-the-subject-of-ci-testing
 3 | osx_image: xcode8.3
 4 | sudo: required
 5 | dist: trusty
 6 | language: c
 7 | matrix:
 8 |   include:
 9 |   - os: osx
10 |   - os: linux
11 |     env: CC=clang CXX=clang++ npm_config_clang=1
12 |     compiler: clang
13 | cache:
14 |   directories:
15 |   - node_modules
16 |   - "$HOME/.electron"
17 |   - "$HOME/.cache"
18 | addons:
19 |   apt:
20 |     packages:
21 |     - libgnome-keyring-dev
22 |     - icnsutils
23 |     #- xvfb
24 | before_install:
25 | - mkdir -p /tmp/git-lfs && curl -L https://github.com/github/git-lfs/releases/download/v1.2.1/git-lfs-$([
26 |   "$TRAVIS_OS_NAME" == "linux" ] && echo "linux" || echo "darwin")-amd64-1.2.1.tar.gz
27 |   | tar -xz -C /tmp/git-lfs --strip-components 1 && /tmp/git-lfs/git-lfs pull
28 | - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get install --no-install-recommends -y icnsutils graphicsmagick xz-utils; fi
29 | install:
30 | #- export DISPLAY=':99.0'
31 | #- Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &
32 | - nvm install 7
33 | - curl -o- -L https://yarnpkg.com/install.sh | bash
34 | - source ~/.bashrc
35 | - npm install -g xvfb-maybe
36 | - yarn
37 | script:
38 | #- xvfb-maybe node_modules/.bin/karma start test/unit/karma.conf.js
39 | #- yarn run pack && xvfb-maybe node_modules/.bin/mocha test/e2e
40 | - yarn run build
41 | branches:
42 |   only:
43 |   - master
44 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Google Assistant for Desktop
 2 | 
 3 | Google Assistant for Desktop is an cross-platform assistant powered by the Google Assistant SDK, it has support for the official HTML5 screen output.
 4 | 
 5 | ![Screenshot of Google Assistant Desktop Client](/screenshots/screenshot-3.JPG?raw=true "Full html5 window preview")
 6 | 
 7 | ## Features
 8 | 
 9 | * Google Assistant SDK v1alpha2
10 | * 'Transparent' HTML5 screen output overlay
11 | * Develop your own commands, trigger ```ask(question) // Promise``` or ```say(query)``` functions to let the assistant do whatever you want.
12 | * Build in basic Spotify Web API support as a demo.
13 | 
14 | ### Shortcut
15 | 
16 | Since hotword integration is not included yet, I've included a shortcut that triggers the assistant:
17 | 
18 | * Windows: Ctrl+Alt+A
19 | * Mac OS: Control+Option+A
20 | 
21 | You'll hear a sound when you can start speaking almost instantly.
22 | 
23 | #### NOTE
24 | 
25 | This assistant desktop app is made for developers and hackers alike who like to play around with the SDK's and software. It will probably never be released as a stand-alone app that you can download since Google will probably never give us production API keys for a desktop client.
26 | 
27 | ## TODO
28 | 
29 | * Update README configuration steps for key generation and creating basic commands yourself.
30 | 
31 | ## Configuration
32 | 
33 | There's a couple of things that need to be done in order to run this application properly.
34 | 
35 | First of all you need your own Google Cloud account, since the Google Assistant SDK is still in alpha, google allows only 500 api calls everyday, the trial version will suffice since the Google Assistant SDK is still in alpha.
36 | 
37 | Follow the steps on this page;
38 | https://developers.google.com/assistant/sdk/guides/library/python/embed/config-dev-project-and-account
39 | 
40 | After you've got your `client_secret_<client-id>.json` file rename it to `client_secret.json` and put it in the `src/renderer` folder.
41 | 
42 | ## Build Setup
43 | 
44 | ``` bash
45 | # install dependencies
46 | npm install # Install dev mode
47 | npm start #
48 | ```
49 | 
50 | ## Used Libraries / Boilerplates
51 | 
52 | * [Google Assistant (A node.js implementation of the Google Assistant SDK)](https://github.com/endoplasmic/google-assistant)
53 | ** Connection to the Google Assistant SDK Service
54 | * [A Node.js wrapper for Spotify's Web API](https://github.com/thelinmichael/spotify-web-api-node)
55 | ** Used for integrating custom commands for Spotify
56 | * [A voice control - voice commands - speech recognition and speech synthesis javascript library.](https://github.com/sdkcarlos/artyom.js)
57 | ** Used for text processing custom voice commands (The Google Assistant SDK does the actual transcription)
58 | 
59 | ---
60 | 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | # Commented sections below can be used to run tests on the CI server
 2 | # https://simulatedgreg.gitbooks.io/electron-vue/content/en/testing.html#on-the-subject-of-ci-testing
 3 | version: 0.1.{build}
 4 | 
 5 | branches:
 6 |   only:
 7 |     - master
 8 | 
 9 | image: Visual Studio 2017
10 | platform:
11 |   - x64
12 | 
13 | cache:
14 |   - node_modules
15 |   - '%APPDATA%\npm-cache'
16 |   - '%USERPROFILE%\.electron'
17 |   - '%USERPROFILE%\AppData\Local\Yarn\cache'
18 | 
19 | init:
20 |   - git config --global core.autocrlf input
21 | 
22 | install:
23 |   - ps: Install-Product node 8 x64
24 |   - choco install yarn --ignore-dependencies
25 |   - git reset --hard HEAD
26 |   - yarn
27 |   - node --version
28 | 
29 | build_script:
30 |   #- yarn test
31 |   - yarn build
32 | 
33 | test: off
34 | 


--------------------------------------------------------------------------------
/build/icons/256x256.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/build/icons/256x256.png


--------------------------------------------------------------------------------
/build/icons/icon.icns:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/build/icons/icon.icns


--------------------------------------------------------------------------------
/build/icons/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/build/icons/icon.ico


--------------------------------------------------------------------------------
/dist/electron/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/dist/electron/.gitkeep


--------------------------------------------------------------------------------
/dist/web/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/dist/web/.gitkeep


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"name": "ga-desktop",
  3 | 	"version": "0.4.2",
  4 | 	"author": "Wendell Misiedjan",
  5 | 	"description": "A Google Assistant desktop Client",
  6 | 	"license": "n/a",
  7 | 	"main": "./dist/electron/main.js",
  8 | 	"scripts": {
  9 | 		"build": "node .electron-vue/build.js && electron-builder",
 10 | 		"build:dir": "node .electron-vue/build.js && electron-builder --dir",
 11 | 		"build:noasar": "node .electron-vue/build.js && electron-builder --dir --asar=false",
 12 | 		"build:clean": "cross-env BUILD_TARGET=clean node .electron-vue/build.js",
 13 | 		"dev": "cross-env NODE_ENV=development node .electron-vue/dev-runner.js",
 14 | 		"e2e": "npm run pack && mocha test/e2e",
 15 | 		"lint": "eslint ./src/renderer/ --ext js,vue --max-warnings 0",
 16 | 		"lint:fix": "eslint ./src/renderer/ --ext js,vue --fix",
 17 | 		"pack": "npm run pack:main && npm run pack:renderer",
 18 | 		"pack:main": "cross-env NODE_ENV=production webpack --progress --colors --config .electron-vue/webpack.main.config.js",
 19 | 		"pack:renderer": "cross-env NODE_ENV=production webpack --progress --colors --config .electron-vue/webpack.renderer.config.js",
 20 | 		"test": "npm run unit && npm run e2e",
 21 | 		"unit": "karma start test/unit/karma.conf.js",
 22 | 		"postinstall": "npm rebuild --target=4.0.3 --runtime=electron",
 23 | 		"start": "npm run dev"
 24 | 	},
 25 | 	"build": {
 26 | 		"productName": "Google Assistant for Desktop",
 27 | 		"appId": "org.digispark.ga-desktop",
 28 | 		"directories": {
 29 | 			"output": "build"
 30 | 		},
 31 | 		"files": [
 32 | 			"dist/electron/**/*"
 33 | 		],
 34 | 		"dmg": {
 35 | 			"contents": [
 36 | 				{
 37 | 					"x": 410,
 38 | 					"y": 150,
 39 | 					"type": "link",
 40 | 					"path": "/Applications"
 41 | 				},
 42 | 				{
 43 | 					"x": 130,
 44 | 					"y": 150,
 45 | 					"type": "file"
 46 | 				}
 47 | 			]
 48 | 		},
 49 | 		"mac": {
 50 | 			"icon": "build/icons/icon.icns"
 51 | 		},
 52 | 		"win": {
 53 | 			"icon": "build/icons/icon.ico"
 54 | 		},
 55 | 		"linux": {
 56 | 			"icon": "build/icons/"
 57 | 		}
 58 | 	},
 59 | 	"dependencies": {
 60 | 		"@babel/runtime-corejs2": "^7.0.0",
 61 | 		"artyom.js": "^1.0.6",
 62 | 		"axios": "^0.18.0",
 63 | 		"co": "^4.6.0",
 64 | 		"dotenv": "^6.0.0",
 65 | 		"electron-rebuild": "^1.8.2",
 66 | 		"eslint-plugin-pug": "^1.1.1",
 67 | 		"fs": "0.0.1-security",
 68 | 		"google-assistant": "github:WMisiedjan/google-assistant#master",
 69 | 		"googleapis": "^34.0.0",
 70 | 		"grpc": "^1.18.0",
 71 | 		"jquery": "^3.3.1",
 72 | 		"metaget": "^1.0.6",
 73 | 		"mkdirp": "^0.5.1",
 74 | 		"msr": "^1.3.4",
 75 | 		"node-fetch": "^2.2.0",
 76 | 		"opn": "^5.4.0",
 77 | 		"path": "^0.12.7",
 78 | 		"pcm-convert": "^1.6.5",
 79 | 		"perfect-scrollbar": "^1.4.0",
 80 | 		"pump": "^3.0.0",
 81 | 		"pumpify": "^1.5.1",
 82 | 		"spotify-web-api-node": "^4.0.0",
 83 | 		"spotify-web-helper": "^1.14.0",
 84 | 		"v-bar": "^3.0.0",
 85 | 		"vue": "^2.5.17",
 86 | 		"vue-electron": "^1.0.6",
 87 | 		"vue-perfect-scrollbar": "^0.1.0",
 88 | 		"vue-router": "^3.0.1",
 89 | 		"vuetify": "^1.2.5",
 90 | 		"vuex": "^3.0.1"
 91 | 	},
 92 | 	"devDependencies": {
 93 | 		"@babel/core": "^7.2.2",
 94 | 		"@babel/polyfill": "^7.2.5",
 95 | 		"@babel/preset-env": "^7.3.1",
 96 | 		"@babel/register": "^7.0.0",
 97 | 		"@mapbox/stylelint-processor-arbitrary-tags": "^0.2.0",
 98 | 		"babel-eslint": "^10.0.0",
 99 | 		"babel-loader": "^8.0.5",
100 | 		"babel-minify-webpack-plugin": "^0.3.1",
101 | 		"babel-plugin-istanbul": "^5.0.1",
102 | 		"bootstrap-sass": "^3.4.0",
103 | 		"cfonts": "^2.4.2",
104 | 		"chai": "^4.2.0",
105 | 		"chalk": "^2.4.2",
106 | 		"copy-webpack-plugin": "^4.6.0",
107 | 		"cross-env": "^5.2.0",
108 | 		"css-loader": "^1.0.0",
109 | 		"del": "^3.0.0",
110 | 		"devtron": "^1.4.0",
111 | 		"electron": "4.0.3",
112 | 		"electron-builder": "^20.38.5",
113 | 		"electron-debug": "^2.1.0",
114 | 		"electron-devtools-installer": "^2.2.4",
115 | 		"electron-rebuild": "^1.8.4",
116 | 		"eslint": "^5.13.0",
117 | 		"eslint-config-airbnb-base": "^13.1.0",
118 | 		"eslint-import-resolver-webpack": "^0.10.1",
119 | 		"eslint-loader": "^2.1.2",
120 | 		"eslint-plugin-import": "^2.16.0",
121 | 		"eslint-plugin-vue": "^4.7.1",
122 | 		"file-loader": "^2.0.0",
123 | 		"html-webpack-plugin": "^3.2.0",
124 | 		"inject-loader": "^4.0.1",
125 | 		"karma": "^3.1.4",
126 | 		"karma-chai": "^0.1.0",
127 | 		"karma-coverage": "^1.1.2",
128 | 		"karma-electron": "^6.0.0",
129 | 		"karma-mocha": "^1.3.0",
130 | 		"karma-sourcemap-loader": "^0.3.7",
131 | 		"karma-spec-reporter": "^0.0.32",
132 | 		"karma-webpack": "^3.0.5",
133 | 		"mini-css-extract-plugin": "^0.4.5",
134 | 		"mocha": "^5.2.0",
135 | 		"multispinner": "^0.2.1",
136 | 		"node-loader": "^0.6.0",
137 | 		"require-dir": "^1.2.0",
138 | 		"spectron": "^5.0.0",
139 | 		"style-loader": "^0.23.0",
140 | 		"stylelint": "^9.10.1",
141 | 		"stylelint-config-concentric": "^2.0.2",
142 | 		"stylelint-config-standard": "^18.2.0",
143 | 		"stylelint-scss": "^3.5.3",
144 | 		"stylelint-webpack-plugin": "^0.10.5",
145 | 		"stylus": "^0.54.5",
146 | 		"stylus-loader": "^3.0.2",
147 | 		"url-loader": "^1.1.1",
148 | 		"vue-html-loader": "^1.2.4",
149 | 		"vue-loader": "^15.6.2",
150 | 		"vue-style-loader": "^4.1.2",
151 | 		"vue-template-compiler": "^2.6.5",
152 | 		"webpack": "^4.29.3",
153 | 		"webpack-dev-server": "^3.1.14",
154 | 		"webpack-hot-middleware": "^2.24.2",
155 | 		"webpack-merge": "^4.2.1"
156 | 	}
157 | }
158 | 


--------------------------------------------------------------------------------
/resources/suggestions.txt:
--------------------------------------------------------------------------------
  1 |     <array name="suggestions">
  2 |         <item>Who is Roger Federer?</item>
  3 |         <item>How old is Adam Sandler?</item>
  4 |         <item>Where was Ashton Kutcher born?</item>
  5 |         <item>Who is Tiger Woods married to?</item>
  6 |         <item>Who is Uma Thurman&apos;s sister?</item>
  7 |         <item>Who wrote Gone with the Wind?</item>
  8 |         <item>Who invented the mobile phone?</item>
  9 |         <item>When is the sunrise in South Loy?</item>
 10 |         <item>What is the time zone in Rosaside?</item>
 11 |         <item>What time is it in Brandtview?</item>
 12 |         <item>What is the time at home?</item>
 13 |         <item>What&apos;s the weather like?</item>
 14 |         <item>Do I need a jacket for tomorrow?</item>
 15 |         <item>What&apos;s the weather going to be like in West Cedrick this afternoon?</item>
 16 |         <item>What&apos;s the temperature outside?</item>
 17 |         <item>Is there a chance of rain today?</item>
 18 |         <item>What&apos;s the Motorola stock price?</item>
 19 |         <item>What&apos;s Volkswagen trending at?</item>
 20 |         <item>What&apos;s 500 months in numbers?</item>
 21 |         <item>Convert 507 miles to yards?</item>
 22 |         <item>What&apos;s 569 rupees to dollars?</item>
 23 |         <item>What&apos;s the tip for 198 dollars?</item>
 24 |         <item>Square root of 7579?</item>
 25 |         <item>What&apos;s 9271 divided by 6518?</item>
 26 |         <item>What&apos;s 40 percent of 3293?</item>
 27 |         <item>What&apos;s 40 percent of 5617 divided by 3976?</item>
 28 |         <item>Open youtube.com</item>
 29 |         <item>Open Slack</item>
 30 |         <item>Increase brightness</item>
 31 |         <item>Take a picture</item>
 32 |         <item>Take a selfie</item>
 33 |         <item>Turn on WiFi</item>
 34 |         <item>Turn on flashlight</item>
 35 |         <item>Record a video</item>
 36 |         <item>Increase volume</item>
 37 |         <item>Set the volume to 6</item>
 38 |         <item>Set the volume to full</item>
 39 |         <item>Mute the volume</item>
 40 |         <item>Define nemo</item>
 41 |         <item>What&apos;s the definition of open-source?</item>
 42 |         <item>What&apos;s the meaning of pixel?</item>
 43 |         <item>Set an alarm in 29 minutes</item>
 44 |         <item>Set an alarm for 09:24 AM</item>
 45 |         <item>Set a repeating alarm for 03:06 AM</item>
 46 |         <item>Set an alarm for 09:21 PM labeled Pick kids from school</item>
 47 |         <item>Set a repeating alarm at 12:59 PM for Saturday</item>
 48 |         <item>Show me my alarms</item>
 49 |         <item>When is my next alarm?</item>
 50 |         <item>Wake me up at 03:22 AM everyday</item>
 51 |         <item>New meeting</item>
 52 |         <item>Schedule an event grandmas birthday tonight at 02:36 PM</item>
 53 |         <item>What&apos;s my next appointment?</item>
 54 |         <item>Show me the appointments for this afternoon</item>
 55 |         <item>What does my day look like on Sunday?</item>
 56 |         <item>Show me my bills</item>
 57 |         <item>Where is my package?</item>
 58 |         <item>Where&apos;s my hotel?</item>
 59 |         <item>Show me restaurants near my hotel</item>
 60 |         <item>Add eggs and oranges to my shopping list.</item>
 61 |         <item>Make a note: feed the dog</item>
 62 |         <item>Note to self: feed the dog</item>
 63 |         <item>Find Monte Anderson&apos;s number</item>
 64 |         <item>When is Calista Kunde&apos;s birthday?</item>
 65 |         <item>Call Concepcion Abernathy</item>
 66 |         <item>Call Bobbie Ondricka on speakerphone</item>
 67 |         <item>Call the nearest gas station</item>
 68 |         <item>Call McDonalds</item>
 69 |         <item>Show me my messages</item>
 70 |         <item>Text Delta Emard What are you doing</item>
 71 |         <item>Send an email to my brother Hey, you didn&apos;t give me feedback on the document</item>
 72 |         <item>Send a Whatsapp message to my father</item>
 73 |         <item>Post to Facebook</item>
 74 |         <item>Say I want to eat something in French?</item>
 75 |         <item>Translate Can I have water to Chinese?</item>
 76 |         <item>Add a reminder</item>
 77 |         <item>Remind me to download the new Foo Fighters album at 11:42 AM</item>
 78 |         <item>Remind me to drink more water next time i&apos;m at the gym</item>
 79 |         <item>Remind me to buy eggs at Wegmans</item>
 80 |         <item>Remind me to buy wet wipes at pharmacy</item>
 81 |         <item>Remind me to organize cables every Thursday</item>
 82 |         <item>Map of Greenland</item>
 83 |         <item>Show me nearest restaurants on map</item>
 84 |         <item>Navigate to Hansbury by car</item>
 85 |         <item>Navigate to my sister&apos;s place</item>
 86 |         <item>How far is North Emilia from Mariettaport?</item>
 87 |         <item>Walking directions to Tower Bridge</item>
 88 |         <item>What are some attractions around here?</item>
 89 |         <item>Show me popular museums in Africa</item>
 90 |         <item>Where is Eifell Tower?</item>
 91 |         <item>Is Big Ben open now?</item>
 92 |         <item>When does Van Gogh Museum close?</item>
 93 |         <item>Is Eifell Tower open on Thursday afternoon?</item>
 94 |         <item>Distance from here to Tower Bridge</item>
 95 |         <item>How far away is Cameroon?</item>
 96 |         <item>How is Manchester United doing?</item>
 97 |         <item>Results from Manchester City last game</item>
 98 |         <item>When is the next Manchester City game</item>
 99 |         <item>Did Tottenham Hotspur win the last game?</item>
100 |         <item>Flight AA 120</item>
101 |         <item>Flight status of AA 120</item>
102 |         <item>Has LH 210 landed?</item>
103 |         <item>When will AA 125 land?</item>
104 |         <item>Go to ABCNews</item>
105 |         <item>Browse androidauthority.com</item>
106 |         <item>When was Jupiter Ascending released?</item>
107 |         <item>Runtime of Inside Out?</item>
108 |         <item>Listen to TV</item>
109 |         <item>Who is the producer of Minions?</item>
110 |         <item>Who acted in Jurassic World?</item>
111 |         <item>Best movies of 2005</item>
112 |         <item>Best drama movies</item>
113 |         <item>Drama movies of 2002</item>
114 |         <item>Oscar winners of 2010</item>
115 |         <item>What are the best Anna Raadsveld movies</item>
116 |         <item>What movies are playing on Thursday?</item>
117 |         <item>Where is In the Heart of the Sea playing?</item>
118 |         <item>Do a barrel roll</item>
119 |         <item>What&apos;s the loneliest number?</item>
120 |         <item>Make me a sandwich</item>
121 |         <item>sudo Make me a sandwich</item>
122 |         <item>When am i?</item>
123 |         <item>Okay Jarvis</item>
124 |         <item>Who are you?</item>
125 |         <item>How much would could a woodchuck chuck if a woodchuck could chuck wood?</item>
126 |         <item>Beam me up Scotty</item>
127 |         <item>How can entropy be reversed?</item>
128 |         <item>What&apos;s Anna Raadsveld&apos;s bacon number</item>
129 |         <item>Tell me a joke</item>
130 |         <item>Up, up, down, down, left, right, left, right</item>
131 |         <item>Who&apos;s on first?</item>
132 |         <item>Go go gadget Dialer</item>
133 |         <item>Askew</item>
134 |         <item>Roll a dice</item>
135 |         <item>Flip a coin</item>
136 |         <item>Play some music</item>
137 |         <item>What&apos;s this song?</item>
138 |         <item>What song am i listening to?</item>
139 |         <item>Listen to my gym playlist</item>
140 |         <item>Next song</item>
141 |         <item>Pause song</item>
142 |         <item>Listen to pop</item>
143 |         <item>Play Lady Gaga</item>
144 |         <item>Play Love In Vain by Rolling Stones</item>
145 |         <item>Listen to the By the way album</item>
146 |         <item>Listen to AC/DC</item>
147 |         <item>Set timer for 20 minutes</item>
148 |         <item>Start countdown</item>
149 |     </array>


--------------------------------------------------------------------------------
/screenshots/screenshot-1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/screenshots/screenshot-1.jpg


--------------------------------------------------------------------------------
/screenshots/screenshot-2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/screenshots/screenshot-2.jpg


--------------------------------------------------------------------------------
/screenshots/screenshot-3.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/screenshots/screenshot-3.JPG


--------------------------------------------------------------------------------
/screenshots/screenshot-merged.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/screenshots/screenshot-merged.jpg


--------------------------------------------------------------------------------
/src/assistant.ejs:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html style="overflow: hidden;">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>ga-desktop</title>
 6 |     <% if (htmlWebpackPlugin.options.nodeModules) { %>
 7 |       <!-- Add `node_modules/` to global paths so `require` works properly in development -->
 8 |       <script>
 9 | 				Window.isAssistant = true;
10 | 				var module = require('module');
11 | 				var path = require('path');
12 |         module.globalPaths.push('<%= htmlWebpackPlugin.options.nodeModules.replace(/\\/g, '\\\\') %>')
13 | 				module.globalPaths.push(path.resolve('node_modules'));
14 | 				module.globalPaths.push(path.resolve('../node_modules'));
15 | 				module.globalPaths.push(path.resolve(__dirname, '..', '..', '..', '..',
16 | 					'resources', 'app', 'node_modules'));
17 | 				module.globalPaths.push(path.resolve(__dirname, '..', '..', '..', '..',
18 | 					'resources', 'app.asar', 'node_modules'))
19 | 			</script>
20 |     <% } %>
21 |   </head>
22 |   <body style="overflow: hidden;">
23 |     <div id="assistant">
24 | 		</div>
25 |     <!-- Set `__static` path to static files in production -->
26 |     <script>
27 |       if (process.env.NODE_ENV !== 'development') window.__static = require('path').join(__dirname, '/static').replace(/\\/g, '\\\\')
28 |     </script>
29 | 
30 |     <!-- webpack builds are automatically injected -->
31 |   </body>
32 | </html>
33 | 


--------------------------------------------------------------------------------
/src/main/index.js:
--------------------------------------------------------------------------------
  1 | import {
  2 | 	app,
  3 | 	BrowserWindow,
  4 | 	ipcMain,
  5 | 	globalShortcut,
  6 | 	screen,
  7 | 	Tray,
  8 | } from 'electron';
  9 | import path from 'path';
 10 | import os from 'os';
 11 | 
 12 | if (process.env.NODE_ENV === 'development') {
 13 | 	try {
 14 | 		// eslint-disable-next-line
 15 | 		require('electron-debug')({
 16 | 			showDevTools: 'undocked',
 17 | 		});
 18 | 	} catch (err) {
 19 | 		console.log('Failed to install `electron-debug`');
 20 | 	}
 21 | } else {
 22 | 	global.__static = path.join(__dirname, '/static').replace(/\\/g, '\\\\');
 23 | }
 24 | 
 25 | /** @type {BrowserWindow} */
 26 | let assistantWindow;
 27 | /** @type {BrowserWindow} */
 28 | let responseWindow;
 29 | /** @type {Tray} */
 30 | let mainTray;
 31 | 
 32 | const miniToolbarSize = {
 33 | 	width: 104,
 34 | 	height: 52,
 35 | };
 36 | 
 37 | const textToolbarSize = {
 38 | 	width: 326,
 39 | 	height: 52,
 40 | };
 41 | 
 42 | /**
 43 |  * Set the size of the toolbar / assistant window.
 44 |  *
 45 |  * @param {Object} size Information about the user.
 46 |  * @param {Number} size.width The name of the user.
 47 |  * @param {Number} size.height {Number} The email of the user.
 48 |  * @returns {undefined}
 49 |  */
 50 | function setToolbarSize({ width, height }) {
 51 | 	if (!assistantWindow) return;
 52 | 
 53 | 	assistantWindow.setSize(width, height, true);
 54 | 	assistantWindow.setPosition(
 55 | 		screen.getPrimaryDisplay().workAreaSize.width - width,
 56 | 		screen.getPrimaryDisplay().workAreaSize.height - height,
 57 | 	);
 58 | }
 59 | 
 60 | const assistantURL = process.env.NODE_ENV === 'development'
 61 | 	? 'http://localhost:9080/assistant.html'
 62 | 	: `file://${__dirname}/assistant.html`;
 63 | 
 64 | const responseURL = process.env.NODE_ENV === 'development'
 65 | 	? 'http://localhost:9080/response.html'
 66 | 	: `file://${__dirname}/response.html`;
 67 | 
 68 | /**
 69 |  * Registers the application shortcodes.
 70 |  */
 71 | function registerShortcuts() {
 72 | 	globalShortcut.register('CommandOrControl+Option+A', () => {
 73 | 		assistantWindow.show();
 74 | 		assistantWindow.webContents.send('start-assistant');
 75 | 		// [TODO]: Play activation sound
 76 | 	});
 77 | }
 78 | 
 79 | /**
 80 |  * Registers the application tray icon.
 81 |  *
 82 |  * @returns {Undefined}
 83 |  */
 84 | function registerTrayIcon() {
 85 | 	const platform = os.platform();
 86 | 	const imageFolder = global.__static ? global.__static : path.join('static');
 87 | 	let trayImage;
 88 | 
 89 | 	// Determine appropriate icon for platforms
 90 | 	if (platform === 'darwin' || platform === 'linux') {
 91 | 		trayImage = path.join(imageFolder, '/icon.png');
 92 | 	} else if (platform === 'win32') {
 93 | 		trayImage = path.join(imageFolder, '/icon.ico');
 94 | 	}
 95 | 
 96 | 	mainTray = new Tray(trayImage);
 97 | 	mainTray.setToolTip('Google Assistant For Desktop');
 98 | 	mainTray.on('click', () => {
 99 | 		assistantWindow.show();
100 | 	});
101 | }
102 | 
103 | function registerEvents() {
104 | 	ipcMain.on('message', (event, message) => {
105 | 		console.log('Incoming Message: ', message);
106 | 
107 | 		if (!assistantWindow) return;
108 | 
109 | 		assistantWindow.webContents.send('message', message);
110 | 		if (message.event && message.event.cardHide && responseWindow) {
111 | 			responseWindow.hide();
112 | 			assistantWindow.setAlwaysOnTop(false);
113 | 		}
114 | 	});
115 | 
116 | 	ipcMain.on('response', (event, html) => {
117 | 		if (!responseWindow) return;
118 | 		responseWindow.webContents.send('response', html);
119 | 		responseWindow.show();
120 | 		assistantWindow.setAlwaysOnTop(true);
121 | 	});
122 | 
123 | 	ipcMain.on('miniToolbar', () => {
124 | 		setToolbarSize(miniToolbarSize);
125 | 	});
126 | 
127 | 	ipcMain.on('textToolbar', () => {
128 | 		setToolbarSize(textToolbarSize);
129 | 	});
130 | }
131 | 
132 | /**
133 |  * Creates the main application window.
134 |  */
135 | function createWindows() {
136 | 	/** Assistant core and toolbar */
137 | 	assistantWindow = new BrowserWindow({
138 | 		height: 52,
139 | 		width: 104,
140 | 		show: true,
141 | 		frame: false,
142 | 		y: screen.getPrimaryDisplay().workAreaSize.height - 52, //  - (mainHeight + 32)
143 | 		x: screen.getPrimaryDisplay().workAreaSize.width - 104,
144 | 		transparent: true,
145 | 		resizable: true,
146 | 		useContentSize: true,
147 | 		fullscreenable: true,
148 | 	});
149 | 
150 | 	/** Response window will be hidden until needed */
151 | 	responseWindow = new BrowserWindow({
152 | 		height: screen.getPrimaryDisplay().workAreaSize.height,
153 | 		width: screen.getPrimaryDisplay().workAreaSize.width,
154 | 		show: false,
155 | 		frame: false,
156 | 		resizable: false,
157 | 		y: 0,
158 | 		x: 0,
159 | 		transparent: true,
160 | 		useContentSize: true,
161 | 	});
162 | 
163 | 	assistantWindow.on('closed', () => {
164 | 		assistantWindow = null;
165 | 	});
166 | 
167 | 	responseWindow.on('closed', () => {
168 | 		responseWindow = null;
169 | 	});
170 | 
171 | 	assistantWindow.on('ready-to-show', () => {
172 | 		assistantWindow.show();
173 | 	});
174 | 
175 | 	assistantWindow.loadURL(assistantURL);
176 | 	responseWindow.loadURL(responseURL);
177 | 	assistantWindow.webContents.openDevTools();
178 | }
179 | 
180 | 
181 | function initializeApp() {
182 | 	createWindows();
183 | 	registerEvents();
184 | 	registerTrayIcon();
185 | 	registerShortcuts();
186 | }
187 | 
188 | // NOTE: Setting a timeout here fixes the issues for linux transparency!
189 | app.on('ready', () => setTimeout(initializeApp, 1000));
190 | 
191 | app.on('window-all-closed', () => {
192 | 	if (process.platform !== 'darwin') {
193 | 		app.quit();
194 | 	}
195 | });
196 | 
197 | app.on('activate', () => {
198 | 	if (assistantWindow === null || responseWindow === null) {
199 | 		assistantWindow = null;
200 | 		responseWindow = null;
201 | 		initializeApp();
202 | 	}
203 | });
204 | 
205 | /**
206 |  * Auto Updater
207 |  *
208 |  * Uncomment the following code below and install `electron-updater` to
209 |  * support auto updating. Code Signing with a valid certificate is required.
210 |  * https://simulatedgreg.gitbooks.io/electron-vue/content/en/using-electron-builder.html#auto-updating
211 |  */
212 | 
213 | /*
214 | import { autoUpdater } from 'electron-updater'
215 | 
216 | autoUpdater.on('update-downloaded', () => {
217 |   autoUpdater.quitAndInstall()
218 | })
219 | 
220 | app.on('ready', () => {
221 |   if (process.env.NODE_ENV === 'production') autoUpdater.checkForUpdates()
222 | })
223 |  */
224 | 


--------------------------------------------------------------------------------
/src/renderer/assets/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/src/renderer/assets/.gitkeep


--------------------------------------------------------------------------------
/src/renderer/config.js:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line
 2 | import { remote } from 'electron';
 3 | import path from 'path';
 4 | import { installed as clientSecret } from './client_secret.json';
 5 | 
 6 | export default {
 7 | 	auth: {
 8 | 		/** [TODO]: Save tokens in local storage? */
 9 | 		/** [TODO]: Better secure client secret in main process maybe? */
10 | 		key: clientSecret,
11 | 		keyFilePath: path.resolve(__dirname, 'client_secret.json'),
12 | 		savedTokensPath: path.join(remote.app.getPath('userData'), '/google.json'),
13 | 	},
14 | 	assistant: {
15 | 		audio: {
16 | 			sampleRateOut: 24000,
17 | 			sampleRateIn: 16000,
18 | 			encodingIn: 'LINEAR16',
19 | 			encodingOut: 'MP3',
20 | 		},
21 | 		lang: 'en-US',
22 | 		deviceId: 'ga-desktop',
23 | 		deviceModelId: 'ga-desktop-electron',
24 | 		screen: {
25 | 			isOn: true,
26 | 		},
27 | 	},
28 | 	spotify: {
29 | 		clientId: '84286ed53eaf4370b812263004b40c10',
30 | 		clientSecret: 'a92ed06c4b0e413bb6ba39f0e21c1da6',
31 | 		redirectUri: 'https://ga-desktop.local/callback',
32 | 		scopes: [
33 | 			'user-read-private',
34 | 			'user-read-email',
35 | 			'user-top-read',
36 | 			'user-library-read',
37 | 			'user-read-currently-playing',
38 | 			'user-modify-playback-state',
39 | 			'user-read-playback-state',
40 | 			'streaming',
41 | 		],
42 | 		savedTokensPath: path.join(remote.app.getPath('userData'), '/spotify.json'),
43 | 	},
44 | };
45 | 


--------------------------------------------------------------------------------
/src/renderer/containers/assistant.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 | 	<v-app
  3 | 		id="action-bar"
  4 | 		class="action-bar"
  5 | 		dark>
  6 | 		<div id="toolbar">
  7 | 			<v-text-field
  8 | 				v-if="showActions && showTextField"
  9 | 				id="text-query"
 10 | 				ref="inputQuery"
 11 | 				v-model="inputQuery"
 12 | 				autofocus
 13 | 				single-line
 14 | 				full-width
 15 | 				solo
 16 | 				hide-details
 17 | 				placeholder="Type a message"
 18 | 				@keyup.enter="assist"
 19 | 			/>
 20 | 			<v-btn
 21 | 				v-if="showActions"
 22 | 				icon
 23 | 				@click="toggleTextField"
 24 | 			>
 25 | 				<v-icon>chat</v-icon>
 26 | 			</v-btn>
 27 | 			<v-btn
 28 | 				v-if="showActions"
 29 | 				icon
 30 | 				@click="assist"
 31 | 			>
 32 | 				<img
 33 | 					class="ic-mic"
 34 | 					v-if="status !== 'listening'"
 35 | 					src="static/ic_mic.png" />
 36 | 				<v-icon v-else>hearing</v-icon>
 37 | 			</v-btn>
 38 | 		</div>
 39 | 	</v-app>
 40 | </template>
 41 | 
 42 | <script>
 43 | import { ipcRenderer } from 'electron';
 44 | 
 45 | import Authentication from '@/providers/authentication';
 46 | import Assistant from '@/providers/assistant';
 47 | 
 48 | export default {
 49 | 	name: 'AssistantWindow',
 50 | 	components: {},
 51 | 	data: () => ({
 52 | 		inputQuery: '',
 53 | 		showTextField: false,
 54 | 		status: 'loading',
 55 | 	}),
 56 | 	computed: {
 57 | 		showActions() {
 58 | 			return this.status !== 'loading';
 59 | 		},
 60 | 	},
 61 | 	mounted() {
 62 |     // Listen for main process triggers to start the assistant.
 63 | 		ipcRenderer.on('start-assistant', () => {
 64 | 			Window.Assistant.player.playPing();
 65 | 			this.assist();
 66 | 		});
 67 | 		setTimeout(() => {
 68 |       // boot up the entire app!
 69 |       /** Registering global authenticator */
 70 | 			Window.Auth = new Authentication();
 71 | 			Window.Auth.once('authenticated', () => {
 72 | 				console.log('Authenticated, setup up Google Assistant...');
 73 | 				this.status = 'loading';
 74 | 				Window.Assistant = new Assistant();
 75 | 				Window.Assistant.on('ready', () => {
 76 | 					console.log('The assistant is ready.');
 77 | 					this.status = 'ready';
 78 | 				});
 79 | 				Window.Assistant.on('unauthorized', () => {
 80 | 					Window.Auth.authenticate();
 81 | 					this.status = 'waiting';
 82 | 				});
 83 | 				Window.Assistant.on('waiting', () => {
 84 | 					this.status = 'waiting';
 85 | 				});
 86 | 				Window.Assistant.on('listening', () => {
 87 | 					this.status = 'listening';
 88 | 				});
 89 | 				Window.Assistant.on('responseHtml', (html) => {
 90 | 					ipcRenderer.send('response', html);
 91 | 				});
 92 | 				Window.Assistant.authenticate();
 93 | 			});
 94 | 
 95 | 			Window.Auth.on('error', () => {
 96 | 				this.status = 'unauthenticated';
 97 | 			});
 98 | 
 99 | 			Window.Auth.authenticate();
100 | 		}, 0);
101 | 	},
102 | 	methods: {
103 | 		assist() {
104 | 			if (Window.Assistant) {
105 | 				if (this.inputQuery) {
106 | 					Window.Assistant.assist(this.inputQuery);
107 | 					this.clearInput();
108 | 				} else {
109 | 					Window.Assistant.assist();
110 | 				}
111 | 			}
112 | 		},
113 | 
114 | 		toggleTextField() {
115 | 			this.showTextField = !this.showTextField;
116 | 			if (this.showTextField) {
117 | 				ipcRenderer.send('textToolbar');
118 | 			} else {
119 | 				ipcRenderer.send('miniToolbar');
120 | 			}
121 | 		},
122 | 
123 | 		clearInput() {
124 | 			this.inputQuery = '';
125 | 			this.toggleTextField();
126 | 		},
127 | 
128 | 		authenticate() {
129 | 			Window.Auth.authenticate();
130 | 		},
131 | 	},
132 | };
133 | </script>
134 | 
135 | <style scoped>
136 | @import url("https://fonts.googleapis.com/css?family=Roboto:100,200,300,400,500,700|Material+Icons");
137 | 
138 | #toolbar .btn .btn__content img {
139 |   width: 2rem;
140 | }
141 | 
142 | #app,
143 | .application--wrap {
144 |   background-color: rgba(0, 0, 0, 0) !important;
145 |   background: rgba(0, 0, 0, 0) !important;
146 | }
147 | 
148 | html {
149 |   overflow-y: hidden;
150 |   -webkit-app-region: drag;
151 | }
152 | 
153 | #toolbar {
154 |   display: flex;
155 |   justify-content: center;
156 |   align-items: center;
157 |   align-content: center;
158 |   align-self: center;
159 |   flex: 1;
160 | }
161 | 
162 | #toolbar > .input-group {
163 |   padding: 0 !important;
164 |   background-color: transparent !important;
165 |   flex: 1;
166 | }
167 | 
168 | .ic-mic {
169 |   max-width: 100%;
170 |   height: auto;
171 | }
172 | </style>
173 | 


--------------------------------------------------------------------------------
/src/renderer/containers/response.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 | 	<div id="response">
 3 | 		<iframe
 4 | 			id="frame"
 5 | 			class="raw-response"
 6 | 		/>
 7 | 	</div>
 8 | </template>
 9 | 
10 | <script>
11 | import { ipcRenderer } from 'electron';
12 | import jQuery from 'jquery';
13 | 
14 | export default {
15 | 	name: 'ResponseWindow',
16 | 	mounted() {
17 | 		// Transfer window messages to the main process
18 | 		window.addEventListener('message', (event) => {
19 | 			ipcRenderer.send('message', event.data);
20 | 		});
21 | 
22 | 		// Incoming html response from the assistent window / process.
23 | 		ipcRenderer.on('response', (event, html) => {
24 | 			// Set the html content into the srcdoc of the iframe
25 | 			jQuery('#frame').get(0).srcdoc = html;
26 | 			// Wait half a second (so the iframe can load) before adding events
27 | 			// TODO: Find an event trigger?
28 | 			setTimeout(() => {
29 | 				// If being clicked outside of the assistant main cards, send an hide event to main process.
30 | 				jQuery('#assistant-main-cards', jQuery('#frame').get(0).contentDocument).click((e) => {
31 | 					e.stopPropagation();
32 | 				});
33 | 
34 | 				jQuery('html', jQuery('#frame').get(0).contentDocument).click(() => {
35 | 					const eventOut = { event: { cardHide: true } };
36 | 					ipcRenderer.send('message', eventOut);
37 | 				});
38 | 			}, 500);
39 | 		});
40 | 	},
41 | };
42 | </script>
43 | 
44 | <style scoped>
45 | #frame {
46 | 	width: 100%;
47 |     height: 100vh;
48 | 	border: 0;
49 | }
50 | </style>
51 | 


--------------------------------------------------------------------------------
/src/renderer/index.js:
--------------------------------------------------------------------------------
 1 | /* eslint-disable */
 2 | import '@babel/polyfill';
 3 | 
 4 | import Vue from 'vue';
 5 | import VueElectron from 'vue-electron';
 6 | import Vuetify from 'vuetify';
 7 | import axios from 'axios';
 8 | 
 9 | 
10 | import 'vuetify/dist/vuetify.css';
11 | 
12 | import AssistantWindow from './containers/assistant';
13 | import ResponseWindow from './containers/response';
14 | 
15 | import Vuex from 'vuex';
16 | 
17 | import store from './providers/store';
18 | import SpotifyClient from './providers/spotify';
19 | 
20 | Vue.use(VueElectron);
21 | Vue.use(Vuetify);
22 | Vue.use(Vuex);
23 | 
24 | Vue.http = Vue.prototype.$http = axios;
25 | Vue.config.productionTip = false;
26 | 
27 | Window.Store = store;
28 | 
29 | if (Window.isAssistant) {
30 | 	Window.Spotify = new SpotifyClient();
31 | 
32 | 	Window.AssistantWindow = new Vue({
33 | 		components: { AssistantWindow },
34 | 		store,
35 | 		el: '#assistant',
36 | 		template: '<AssistantWindow />',
37 | 	});
38 | }
39 | 
40 | if (Window.isResponse) {
41 | 	Window.ResponseWindow = new Vue({
42 | 		components: { ResponseWindow },
43 | 		store,
44 | 		el: '#response',
45 | 		template: '<ResponseWindow />',
46 | 	});
47 | }
48 | 


--------------------------------------------------------------------------------
/src/renderer/providers/assistant/assistant.js:
--------------------------------------------------------------------------------
  1 | import { ipcRenderer } from 'electron';
  2 | import { EventEmitter } from 'events';
  3 | import opn from 'opn';
  4 | 
  5 | import GoogleAssistant from 'google-assistant';
  6 | 
  7 | import Configuration from '@/config';
  8 | import Commands from '@/providers/commands';
  9 | 
 10 | import Player from './player';
 11 | import Microphone from './microphone';
 12 | 
 13 | export default class Assistant extends EventEmitter {
 14 | 	constructor() {
 15 | 		super();
 16 | 
 17 | 		/** Audio player for Google Assistant responses */
 18 | 		this.player = new Player();
 19 | 
 20 | 		/** Microphone class build to transform the browser microphone to an output that's ready for google. */
 21 | 		this.microphone = new Microphone(Configuration.assistant.audio.sampleRateIn);
 22 | 
 23 | 		/** Processor for commands */
 24 | 		this.commands = new Commands();
 25 | 
 26 | 		/** The assistant library we use to process everything and connect to Google */
 27 | 		this.assistant = undefined;
 28 | 
 29 | 		/** Expecting an response window */
 30 | 		this.textAskResponse = undefined;
 31 | 
 32 | 		/** Check if last input was a textQuery */
 33 | 		this.lastAssistTextQuery = undefined;
 34 | 
 35 | 		this.conversation = undefined;
 36 | 
 37 | 		ipcRenderer.on('message', (event, message) => {
 38 | 			console.log('Message from childeren:', message, event);
 39 | 			if (message.query) {
 40 | 				this.assist(message.query.queryText);
 41 | 			} else if (message.url && message.url.href) {
 42 | 				opn(message.url.href);
 43 | 			}
 44 | 		});
 45 | 
 46 | 		this.startConversation = (conversation) => {
 47 | 			this.conversation = conversation;
 48 | 			console.log('[Assistant SDK]', 'Starting conversation...');
 49 | 
 50 | 			console.log(
 51 | 				'Starting conversation, type: ',
 52 | 				Configuration.assistant.textQuery ? 'textQuery' : 'voice input',
 53 | 				Configuration.assistant.textQuery,
 54 | 			);
 55 | 
 56 | 			if (Configuration.assistant.textQuery === undefined) {
 57 | 				this.emit('listening');
 58 | 				this.microphone.enabled = true;
 59 | 			}
 60 | 
 61 | 			conversation.on('audio-data', (data) => {
 62 | 				if (this.disableOutput) return;
 63 | 
 64 | 				console.log('incoming audio buffer...');
 65 | 				this.player.appendBuffer(Buffer.from(data));
 66 | 			});
 67 | 
 68 | 			conversation.on('end-of-utterance', () => {
 69 | 				this.microphone.enabled = false;
 70 | 				this.emit('waiting');
 71 | 			});
 72 | 
 73 | 			conversation.on('device-action', (data) => {
 74 | 				console.log('Device action: ', data);
 75 | 			});
 76 | 
 77 | 			conversation.on('transcription', ({ transcription, done }) => {
 78 | 				console.log('Transcription: ', transcription, done);
 79 | 				if (done) {
 80 | 					this.emit('waiting');
 81 | 					this.microphone.enabled = false;
 82 | 					this.runCommand(transcription);
 83 | 				}
 84 | 			});
 85 | 
 86 | 			conversation.on('response', (text) => {
 87 | 				if (this.disableOutput) return;
 88 | 				console.log('Response: ', text);
 89 | 			});
 90 | 
 91 | 			conversation.on('screen-data', ({ format, data }) => {
 92 | 				if (this.disableOutput) return;
 93 | 
 94 | 				switch (format) {
 95 | 				case 'HTML': {
 96 | 					let html = data.toString();
 97 | 					html = html.replace('You said:', ''); // NOTE: Fix for saying output html.
 98 | 					this.updateResponseWindow(html);
 99 | 					break;
100 | 				}
101 | 				default:
102 | 					console.log('Error: unknown data format.');
103 | 				}
104 | 			});
105 | 
106 | 			conversation.on('ended', (error = undefined, followOn = false) => {
107 | 				console.debug('[Assistant SDK]', 'Conversation ended...');
108 | 				this.player.play();
109 | 				this.followOn = !Configuration.assistant.textQuery ? followOn : false;
110 | 
111 | 				if (error) {
112 | 					console.log('Conversation error', error);
113 | 				}
114 | 
115 | 				this.emit('ready');
116 | 				this.conversation = undefined;
117 | 			});
118 | 		};
119 | 
120 | 		/** Registers if we need to follow on the input we've given */
121 | 		this.followOn = false;
122 | 
123 | 		/** Store if current action is a command */
124 | 		this.disableOutput = false;
125 | 
126 | 		this.player.on('ready', () => console.log('Audio player ready...'));
127 | 
128 | 		this.microphone.on('data', (data) => {
129 | 			const buffer = Buffer.from(data);
130 | 			if (this.conversation) {
131 | 				this.conversation.write(buffer);
132 | 			}
133 | 		});
134 | 
135 | 		this.microphone.on('ready', () => console.log('Microphone ready...'));
136 | 
137 | 		// Event for when the assistant stopped talking
138 | 		this.player.on('waiting', () => this.onAssistantFinishedTalking());
139 | 		this.player.audioPlayer.addEventListener('ended', () => console.log('[Audio Player] Ended playing...'));
140 | 
141 | 		/** Registering events for registered services */
142 | 	}
143 | 
144 | 	/** Triggers when the audio player has stopped playing audio. */
145 | 	onAssistantFinishedTalking() {
146 | 		console.log('[Assistant Client] Player is done talking?');
147 | 		if (this.followOn) {
148 | 			console.log('Follow on required.');
149 | 			this.followOn = false;
150 | 			this.stopConversation();
151 | 			this.assist();
152 | 		}
153 | 	}
154 | 
155 | 	updateResponseWindow(html) {
156 | 		this.emit('responseHtml', html);
157 | 	}
158 | 
159 | 	ask(question) {
160 | 		return new Promise((resolve) => {
161 | 			console.log('[Assistant Client]', 'Starting ask:', question);
162 | 			if (question) {
163 | 				this.assistant.once('started', () => {
164 | 					this.conversation.once('ended', () => {
165 | 						if (Configuration.assistant.textQuery) {
166 | 							console.log('[Assistant Client] Question asked, waiting for textQuery...');
167 | 							this.textAskResponse = true;
168 | 							this.once('ask-response', (response) => {
169 | 								Configuration.assistant.textQuery = undefined;
170 | 								console.debug('[Assistant Client] Ask Text Response Received:', response);
171 | 								this.textAskResponse = false;
172 | 								resolve(response);
173 | 							});
174 | 						} else {
175 | 							this.player.once('waiting', () => {
176 | 								console.log('[Assistant Client]', 'Audio output finished, waiting for answer...');
177 | 								this.microphone.enabled = true;
178 | 								this.assist();
179 | 								this.conversation.removeAllListeners('transcription')
180 | 									.on('transcription', ({ transcription, done }) => {
181 | 										this.disableOutput = true;
182 | 										console.info('[Assistant Client] Answer - Speech Results:', transcription);
183 | 										if (done) {
184 | 											console.info('[Assistant Client] Final Answer:', transcription);
185 | 											this.disableOutput = false;
186 | 											this.stopConversation(true).then(() => {
187 | 												resolve(transcription);
188 | 											});
189 | 										}
190 | 									});
191 | 							});
192 | 						}
193 | 					});
194 | 				});
195 | 				this.disableOutput = false;
196 | 				this.microphone.enabled = false;
197 | 				this.say(question);
198 | 			}
199 | 		});
200 | 	}
201 | 
202 | 	/**
203 | 	 * Let's the Google Assistant say a given sentence.
204 | 	 *
205 | 	 * @param string sentence
206 | 	 * @param int Delay in seconds
207 | 	 */
208 | 	say(sentence, delay = 0) {
209 | 		console.log('[Assistant Client]', `Manually saying: ${sentence}...`);
210 | 		setTimeout(() => {
211 | 			this.stopConversation(true).then(() => {
212 | 				console.log(
213 | 					'[Assistant Client]',
214 | 					`Sending manual sentence (${sentence}) to Google Assistant for voice...`,
215 | 				);
216 | 				this.disableOutput = false;
217 | 				this.microphone.enabled = false;
218 | 				this.assist(`repeat after me ${sentence}`, false);
219 | 			});
220 | 		}, 1000 * delay);
221 | 	}
222 | 
223 | 	playPing() {
224 | 		this.player.playPing();
225 | 	}
226 | 
227 | 	/**
228 | 	 * Sends a request to Google Assistant to start audio streaming
229 | 	 * or for the text input given in the arguemnt
230 | 	 *
231 | 	 * @param {*} inputQuery
232 | 	 */
233 | 	assist(inputQuery = null, checkCommands = true) {
234 | 		this.player.stop();
235 | 		if (inputQuery) {
236 | 			this.emit('waiting');
237 | 			if (this.textAskResponse) {
238 | 				this.emit('ask-response', inputQuery);
239 | 				return;
240 | 			}
241 | 			if (checkCommands) {
242 | 				if (this.runCommand(inputQuery)) {
243 | 					return;
244 | 				}
245 | 			}
246 | 			Configuration.assistant.textQuery = inputQuery;
247 | 			this.assistant.start(Configuration.assistant);
248 | 		} else {
249 | 			this.emit('loading');
250 | 			Configuration.assistant.textQuery = undefined;
251 | 			this.assistant.start(Configuration.assistant);
252 | 		}
253 | 	}
254 | 
255 | 	/**
256 | 	 * Run's a command based on the input text query
257 | 	 * @param {*} textQuery
258 | 	 * @param {*} queueCommand Queue the command when the assistant has ended current converstion.
259 | 	 */
260 | 	runCommand(textQuery, queueCommand = false) {
261 | 		console.log('Checking if"', textQuery, '"is a command.');
262 | 		const command = this.commands.findCommand(textQuery);
263 | 		if (command) {
264 | 			this.disableOutput = true;
265 | 			console.log('Command found.', command);
266 | 			if (!queueCommand) {
267 | 				console.log('[Commands] Executing command...');
268 | 				if (Commands.run(command)) {
269 | 					console.log('executing command done.');
270 | 					this.emit('ready');
271 | 				}
272 | 			} else {
273 | 				console.log('executing command after session.');
274 | 				this.conversation.once('ended', () => {
275 | 					console.log('ready for command...');
276 | 					if (Commands.run(command)) {
277 | 						console.log('command finished!');
278 | 						this.emit('ready');
279 | 					}
280 | 				});
281 | 				this.stopConversation(true);
282 | 			}
283 | 			return true;
284 | 		}
285 | 		console.log('no command found.');
286 | 		return false;
287 | 	}
288 | 
289 | 	/** Stops the microphone output and plays what's left in the buffer (if any) */
290 | 	stopConversation(forceStop = false) {
291 | 		return new Promise((resolve) => {
292 | 			console.log('[Assistant Client]', 'Stopping conversation...');
293 | 
294 | 			this.microphone.enabled = false;
295 | 			this.disableOutput = forceStop ? true : this.disableOutput;
296 | 
297 | 			if (forceStop) {
298 | 				this.player.stop();
299 | 			} else {
300 | 				this.player.play();
301 | 			}
302 | 
303 | 			if (!this.conversation) resolve();
304 | 
305 | 			this.conversation.once('ended', () => {
306 | 				console.log('[Assistant Client]', 'Conversation stopped...');
307 | 				this.conversation = undefined;
308 | 				resolve();
309 | 			});
310 | 
311 | 			this.conversation.end();
312 | 		});
313 | 	}
314 | 
315 | 	/**
316 | 	 * Sets up the Google Assistant for Electron.
317 | 	 * @param {*} OAuth2Client
318 | 	 */
319 | 	authenticate() {
320 | 		this.assistant = new GoogleAssistant(Configuration.auth);
321 | 		this.assistant.on('ready', () => {
322 | 			console.log('[Assistant SDK]', 'Ready...');
323 | 			this.emit('ready');
324 | 		});
325 | 
326 | 		this.assistant.on('error', (error) => {
327 | 			console.log('[Assistant SDK]', error);
328 | 		});
329 | 
330 | 		this.assistant.on('started', this.startConversation);
331 | 	}
332 | }
333 | 


--------------------------------------------------------------------------------
/src/renderer/providers/assistant/index.js:
--------------------------------------------------------------------------------
1 | export { default } from './assistant';
2 | 


--------------------------------------------------------------------------------
/src/renderer/providers/assistant/microphone.js:
--------------------------------------------------------------------------------
 1 | import { EventEmitter } from 'events';
 2 | // import PCMConvert from 'pcm-convert';
 3 | 
 4 | export default class Microphone extends EventEmitter {
 5 | 	constructor(sampleRate = 16000) {
 6 | 		super();
 7 | 
 8 | 		this.rawStream = null;
 9 | 		this.stream = null;
10 | 		this.audioProcessor = null;
11 | 
12 | 		this.audioContext = new AudioContext();
13 | 		this.bufferSize = 4096;
14 | 
15 | 		this.sampleRate = sampleRate;
16 | 
17 | 		this.open();
18 | 	}
19 | 
20 | 	/**
21 | 	 * Opens & initializes the Microphone stream from the browser
22 | 	 */
23 | 	open() {
24 | 		navigator.mediaDevices.getUserMedia({
25 | 			audio: true,
26 | 			video: false,
27 | 		}).then((rawStream) => {
28 | 			this.rawStream = rawStream;
29 | 			this.stream = this.audioContext.createMediaStreamSource(this.rawStream);
30 | 
31 | 			this.audioProcessor = this.audioContext.createScriptProcessor(this.bufferSize, 1, 1);
32 | 			this.audioProcessor.onaudioprocess = event => this.onAudioProcess(event);
33 | 
34 | 			this.stream.connect(this.audioProcessor);
35 | 			this.audioProcessor.connect(this.audioContext.destination);
36 | 			this.emit('ready');
37 | 		});
38 | 	}
39 | 
40 | 	/**
41 | 	 * Processes the audio to be ready for Google.
42 | 	 *
43 | 	 * @param event event
44 | 	 */
45 | 	onAudioProcess(event) {
46 | 		if (!this.enabled) return;
47 | 
48 | 		let data = event.inputBuffer.getChannelData(0);
49 | 		data = this.downsampleBuffer(data);
50 | 		// [TODO]: Implement piping?
51 | 		this.emit('data', data);
52 | 	}
53 | 
54 | 	/**
55 | 	 * Downsamles the buffer if needed to right sampleRate & converts the data into an int16 buffer
56 | 	 *
57 | 	 * @param buffer buffer
58 | 	 */
59 | 	downsampleBuffer(buffer) {
60 | 		if (this.audioContext.sampleRate === this.sampleRate) {
61 | 			return buffer;
62 | 		}
63 | 		const sampleRateRatio = this.audioContext.sampleRate / this.sampleRate;
64 | 		const newLength = Math.round(buffer.length / sampleRateRatio);
65 | 		const result = new Int16Array(newLength);
66 | 		let offsetResult = 0;
67 | 		let offsetBuffer = 0;
68 | 		while (offsetResult < result.length) {
69 | 			const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
70 | 			let accum = 0;
71 | 			let count = 0;
72 | 			for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i += 1) {
73 | 				accum += buffer[i];
74 | 				count += 1;
75 | 			}
76 | 			result[offsetResult] = Math.min(1, accum / count) * 0x7FFF;
77 | 			offsetResult += 1;
78 | 			offsetBuffer = nextOffsetBuffer;
79 | 		}
80 | 		return result.buffer;
81 | 	}
82 | }
83 | 


--------------------------------------------------------------------------------
/src/renderer/providers/assistant/player.js:
--------------------------------------------------------------------------------
  1 | import { EventEmitter } from 'events';
  2 | 
  3 | /**
  4 |  * Audio Player for Google Assistant
  5 |  */
  6 | export default class Player extends EventEmitter {
  7 | 	constructor() {
  8 | 		super();
  9 | 		this.initialize();
 10 | 	}
 11 | 
 12 | 	initialize() {
 13 | 		/** Variables for the Audio Player */
 14 | 		this.mediaSource = new MediaSource();
 15 | 
 16 | 		this.audioPlayer = new Audio();
 17 | 
 18 | 		this.audioBuffer = null;
 19 | 
 20 | 		this.audioQueue = [];
 21 | 
 22 | 		this.setup();
 23 | 		this.setupAudioProcessor();
 24 | 	}
 25 | 
 26 | 	/**
 27 | 	 * Reconstructs the current player.
 28 | 	 */
 29 | 	reset() {
 30 | 		this.initialize();
 31 | 	}
 32 | 
 33 | 	/**
 34 | 	 * Setups the player with the given buffer as source.
 35 | 	 */
 36 | 	setup() {
 37 | 		this.audioPlayer.addEventListener('waiting', () => {
 38 | 			console.log('[Audio Player] Player is waiting on data...');
 39 | 			this.emit('waiting');
 40 | 		});
 41 | 
 42 | 		this.audioPlayer.preload = 'none';
 43 | 		this.audioPlayer.autoplay = true;
 44 | 		this.audioPlayer.src = URL.createObjectURL(this.mediaSource);
 45 | 	}
 46 | 
 47 | 	/**
 48 | 	 * Appends or queue's audio data into the buffer.
 49 | 	 * @param {*} buffer
 50 | 	 */
 51 | 	appendBuffer(buffer) {
 52 | 		if (this.audioBuffer.updating || this.audioQueue.length > 0) {
 53 | 			this.audioQueue.push(buffer);
 54 | 		} else {
 55 | 			this.audioBuffer.appendBuffer(buffer);
 56 | 		}
 57 | 	}
 58 | 
 59 | 	/**
 60 | 	 * Set's up the audio processor required to process the mpeg receiving by Google.
 61 | 	 */
 62 | 	setupAudioProcessor() {
 63 | 		this.mediaSource.addEventListener('sourceopen', () => {
 64 | 			this.audioBuffer = this.mediaSource.addSourceBuffer('audio/mpeg');
 65 | 			this.audioBuffer.mode = 'sequence';
 66 | 			this.audioBuffer.addEventListener('update', () => {
 67 | 				if (this.audioQueue.length > 0 && this.audioBuffer && !this.audioBuffer.updating) {
 68 | 					this.audioBuffer.appendBuffer(this.audioQueue.shift());
 69 | 					this.play();
 70 | 				}
 71 | 			});
 72 | 
 73 | 			this.audioBuffer.addEventListener('error', (e) => {
 74 | 				console.log('AudioBuffer Error: ', e);
 75 | 			});
 76 | 
 77 | 			this.emit('ready');
 78 | 		});
 79 | 	}
 80 | 
 81 | 	/**
 82 | 	 * Play's the Audio Player if nessesary.
 83 | 	 */
 84 | 	play() {
 85 | 		if (this.audioPlayer.paused) {
 86 | 			this.audioPlayer.play().then(() => {
 87 | 				console.log('Assistant Audio is playing...');
 88 | 			}).catch(e => console.log('something went wrong starting the player...', e));
 89 | 		}
 90 | 	}
 91 | 
 92 | 	/**
 93 | 	 * Empties the audioQueue and resets the current player.
 94 | 	 */
 95 | 	stop() {
 96 | 		this.audioQueue = [];
 97 | 		this.audioPlayer.src = '';
 98 | 		this.reset();
 99 | 	}
100 | 
101 | 	playPing() {
102 | 		const pingPlayer = new Audio('static/ping.mp3');
103 | 		pingPlayer.play();
104 | 		this.emit('ping');
105 | 	}
106 | }
107 | 


--------------------------------------------------------------------------------
/src/renderer/providers/authentication/authentication.js:
--------------------------------------------------------------------------------
  1 | import { EventEmitter } from 'events';
  2 | import config from '@/config';
  3 | import fs from 'fs';
  4 | import mkdirp from 'mkdirp';
  5 | import path from 'path';
  6 | import { google } from 'googleapis';
  7 | import ElectronGoogleOAuth from './google-electron-auth';
  8 | 
  9 | const { OAuth2 } = google.auth;
 10 | /**
 11 |  * OAuth2 Authenticator for Electron.
 12 |  *
 13 |  * This Authenticator saves the tokens locally and refreshes them if nessesay,
 14 |  * it's specially made for Electron use.
 15 |  */
 16 | export default class Authenticator extends EventEmitter {
 17 | 	constructor() {
 18 | 		super();
 19 | 
 20 | 		this.OAuth2Client = new OAuth2(
 21 | 			config.auth.key.client_id,
 22 | 			config.auth.key.client_secret,
 23 | 			config.auth.key.redirect_uris[0],
 24 | 		);
 25 | 		this.inProcess = false;
 26 | 	}
 27 | 
 28 | 	// [TODO]: Save authentication information in LocalStorage.
 29 | 	authenticate() {
 30 | 		/** Check if we have existing credentials saved */
 31 | 		let fileContents;
 32 | 		let credentials;
 33 | 		(async () => {
 34 | 			console.debug('Authenticating...');
 35 | 			try {
 36 | 				console.debug('Checking for existing tokens...');
 37 | 				fileContents = fs.readFileSync(config.auth.savedTokensPath, 'utf8');
 38 | 				if (fileContents) {
 39 | 					credentials = JSON.parse(fileContents);
 40 | 					if (credentials.refresh_token) {
 41 | 						console.log('Existing tokens found');
 42 | 						this.OAuth2Client.credentials = credentials;
 43 | 						// [TODO]: Check timestamp on file and check validity of token?
 44 | 						this.OAuth2Client.refreshAccessToken((err, tokens) => {
 45 | 							this.refreshAccessToken(err, tokens);
 46 | 						});
 47 | 					} else {
 48 | 						this.googleAuthenticate();
 49 | 					}
 50 | 				} else {
 51 | 					console.debug('No tokens found!');
 52 | 					this.googleAuthenticate();
 53 | 				}
 54 | 			} catch (err) {
 55 | 				console.log('Error reading file', err);
 56 | 				this.googleAuthenticate();
 57 | 			}
 58 | 		})();
 59 | 	}
 60 | 
 61 | 	refreshAccessToken(err, tokens) {
 62 | 		console.log('Refreshing access token...');
 63 | 		if (err || !tokens) {
 64 | 			console.log('Error refreshing tokens...', err, tokens);
 65 | 			this.googleAuthenticate();
 66 | 		} else {
 67 | 			this.saveTokens(tokens);
 68 | 		}
 69 | 	}
 70 | 
 71 | 	/**
 72 | 	 * Opens a Google popup to authenticate.
 73 | 	 */
 74 | 	googleAuthenticate() {
 75 | 		const googleOauth = new ElectronGoogleOAuth();
 76 | 
 77 | 		(async () => {
 78 | 			try {
 79 | 				console.log('Opening Google Window...');
 80 | 				this.inProcess = false;
 81 | 				// retrieve access token and refresh token
 82 | 				const result = await googleOauth.getAccessToken(
 83 | 					['https://www.googleapis.com/auth/assistant-sdk-prototype'],
 84 | 					config.auth.key.client_id,
 85 | 					config.auth.key.client_secret,
 86 | 					config.auth.key.redirect_uris[0],
 87 | 				);
 88 | 				this.inProcess = true;
 89 | 				this.saveTokens(result);
 90 | 			} catch (err) {
 91 | 				console.log('Something went wrong with authenticating, try again.', err);
 92 | 				this.inProcess = false;
 93 | 				this.emit('error', err);
 94 | 			}
 95 | 		})();
 96 | 	}
 97 | 
 98 | 	/**
 99 | 	 * Saves the given tokens.
100 | 	 *
101 | 	 * [TODO]: Save tokens in localStorage instead of a local file.
102 | 	 * @param {*} tokens
103 | 	 */
104 | 	saveTokens(tokens) {
105 | 		this.OAuth2Client.credentials = tokens;
106 | 		console.log('Saving tokens...', tokens);
107 | 		mkdirp(path.dirname(config.auth.savedTokensPath), () => {
108 | 			fs.writeFile(config.auth.savedTokensPath, JSON.stringify(tokens), (err) => {
109 | 				if (!err) {
110 | 					console.debug('Tokens saved.');
111 | 					this.emit('authenticated', this.OAuth2Client);
112 | 				} else {
113 | 					console.debug('error saving tokens');
114 | 				}
115 | 			});
116 | 		});
117 | 	}
118 | 
119 | 	/**
120 | 	 * Removes the locally saved tokens.
121 | 	 */
122 | 	static resetTokens() {
123 | 		fs.writeFile(config.auth.savedTokensPath, '', () => console.log('tokens reset'));
124 | 	}
125 | }
126 | 


--------------------------------------------------------------------------------
/src/renderer/providers/authentication/google-electron-auth.js:
--------------------------------------------------------------------------------
 1 | /* eslint-disable */
 2 | /**
 3 |  * Source / fork: https://github.com/parro-it/electron-google-oauth
 4 |  */
 5 | 
 6 | const { stringify } = require('querystring');
 7 | const { google } = require('googleapis');
 8 | const co = require('co');
 9 | const fetch = require('node-fetch');
10 | // eslint-disable-next-line import/no-extraneous-dependencies
11 | const { BrowserWindow } = require('electron').remote;
12 | 
13 | const OAuth2 = google.auth.OAuth2;
14 | 
15 | /* eslint-disable camelcase */
16 | 
17 | function getAuthenticationUrl(scopes, clientId, clientSecret, redirectUri = 'urn:ietf:wg:oauth:2.0:oob') {
18 | 	const oauth2Client = new OAuth2(
19 | 		clientId,
20 | 		clientSecret,
21 | 		redirectUri
22 | 	);
23 | 	const url = oauth2Client.generateAuthUrl({
24 | 		access_type: 'offline', // 'online' (default) or 'offline' (gets refresh_token)
25 | 		scope: scopes // If you only need one scope you can pass it as string
26 | 	});
27 | 	return url;
28 | }
29 | 
30 | function authorizeApp(url, browserWindowParams) {
31 | 	return new Promise((resolve, reject) => {
32 | 		const win = new BrowserWindow(browserWindowParams || { 'use-content-size': true });
33 | 
34 | 		win.on('closed', () => {
35 | 			reject(new Error('User closed the window'));
36 | 		});
37 | 
38 | 		win.on('page-title-updated', () => {
39 | 			const title = win.getTitle();
40 | 			if (title.startsWith('Denied')) {
41 | 				win.removeAllListeners('closed');
42 | 				setImmediate(() => win.close());
43 | 				reject(new Error(title.split(/[ =]/)[2]));
44 | 			} else if (title.startsWith('Success')) {
45 | 				const titleProcessed = title.split(/[ =]/)[2];
46 | 				win.removeAllListeners('closed');
47 | 				setImmediate(() => win.close());
48 | 
49 | 				resolve(titleProcessed);
50 | 			}
51 | 		});
52 | 
53 | 		win.loadURL(url);
54 | 	});
55 | }
56 | 
57 | export default function electronGoogleOauth(browserWindowParams, httpAgent) {
58 | 	function getAuthorizationCode(scopes, clientId, clientSecret, redirectUri = 'urn:ietf:wg:oauth:2.0:oob') {
59 | 		const url = getAuthenticationUrl(scopes, clientId, clientSecret, redirectUri);
60 | 		return authorizeApp(url, browserWindowParams);
61 | 	}
62 | 
63 | 	const getAccessToken = co.wrap(function* (scopes, clientId, clientSecret, redirectUri = 'urn:ietf:wg:oauth:2.0:oob') {
64 | 		const authorizationCode = yield getAuthorizationCode(scopes, clientId, clientSecret, redirectUri);
65 | 
66 | 		const data = stringify({
67 | 			code: authorizationCode,
68 | 			client_id: clientId,
69 | 			client_secret: clientSecret,
70 | 			grant_type: 'authorization_code',
71 | 			redirect_uri: redirectUri
72 | 		});
73 | 
74 | 		const res = yield fetch('https://accounts.google.com/o/oauth2/token', {
75 | 			method: 'post',
76 | 			headers: {
77 | 				'Accept': 'application/json',
78 | 				'Content-Type': 'application/x-www-form-urlencoded'
79 | 			},
80 | 			body: data,
81 | 			agent: httpAgent
82 | 		});
83 | 		return yield res.json();
84 | 	});
85 | 
86 | 	return { getAuthorizationCode, getAccessToken };
87 | };
88 | 


--------------------------------------------------------------------------------
/src/renderer/providers/authentication/index.js:
--------------------------------------------------------------------------------
1 | export { default } from './authentication';
2 | 


--------------------------------------------------------------------------------
/src/renderer/providers/commands/assistant.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 | 	{
 3 | 		smart: false,
 4 | 		indexes: [
 5 | 			'custom commands',
 6 | 		],
 7 | 		action: () => {
 8 | 			Window.Assistant.say('Seems like custom commands work!');
 9 | 		},
10 | 	},
11 | 	{
12 | 		smart: false,
13 | 		indexes: [
14 | 			'talk',
15 | 			'let\'s talk',
16 | 			'I\'m bored',
17 | 			'say something',
18 | 		],
19 | 		action: () => {
20 | 			Window.Assistant.ask('What do you wanna talk about?').then((answer) => {
21 | 				console.log('Resolved the answer: ', answer);
22 | 				Window.Assistant.say(`Alright, let's talk about ${answer}`);
23 | 			});
24 | 		},
25 | 
26 | 	},
27 | 	{
28 | 		smart: false,
29 | 		indexes: [
30 | 			'Who created you',
31 | 			'Who is your creator',
32 | 			'Who programmed you',
33 | 			'testing',
34 | 		],
35 | 		action: () => {
36 | 			Window.Assistant.say('I was made by a team at Google.');
37 | 			Window.Assistant.say('But this Desktop client you are using is made by the open source community.', 1);
38 | 			Window.Assistant.say('Pretty awesome right?', 1);
39 | 		},
40 | 	},
41 | 	{
42 | 		smart: false,
43 | 		indexes: [
44 | 			'clear screen',
45 | 			'clear window',
46 | 			'clear conversation',
47 | 		],
48 | 		action: () => {
49 | 			Window.Store.state.assistant.messages = [];
50 | 		},
51 | 	},
52 | 	{
53 | 		smart: false,
54 | 		indexes: [
55 | 			'make smaller',
56 | 			'mini mode',
57 | 		],
58 | 		action: () => {
59 | 			Window.Assistant.setMiniMode(true);
60 | 		},
61 | 	},
62 | 	{
63 | 		smart: false,
64 | 		indexes: [
65 | 			'make bigger',
66 | 			'disable mini mode',
67 | 			'make screen bigger',
68 | 		],
69 | 		action: () => {
70 | 			Window.Assistant.setMiniMode(false);
71 | 		},
72 | 	},
73 | 	{
74 | 		smart: false,
75 | 		indexes: [
76 | 			'exit',
77 | 			'turn off',
78 | 		],
79 | 		action: () => {
80 | 			// [TODO]: Exiting app
81 | 		},
82 | 	},
83 | 	{
84 | 		smart: false,
85 | 		indexes: [
86 | 			'ping',
87 | 		],
88 | 		action: () => {
89 | 			Window.Assistant.playPing();
90 | 		},
91 | 	},
92 | ];
93 | 


--------------------------------------------------------------------------------
/src/renderer/providers/commands/audio-control.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 | 	{
 3 | 		smart: false,
 4 | 		indexes: [
 5 | 			'play media',
 6 | 			'continue playing music',
 7 | 			'continue playing video',
 8 | 			'play music',
 9 | 			'pause music',
10 | 			'toggle music',
11 | 			'turn on the music',
12 | 			'stop music',
13 | 			'stop playing music',
14 | 			'stop the music',
15 | 			'stop * music',
16 | 		],
17 | 		action: () => {
18 | 			Window.Assistant.say('This is functionality is temporary disabled.');
19 | 		},
20 | 	},
21 | ];
22 | 


--------------------------------------------------------------------------------
/src/renderer/providers/commands/index.js:
--------------------------------------------------------------------------------
 1 | import Artyom from 'artyom.js';
 2 | import { EventEmitter } from 'events';
 3 | 
 4 | /**
 5 |  * Handles & loads text commands, commands are loaded from files within this folder,
 6 |  * given as an array.
 7 |  */
 8 | export default class Commands extends EventEmitter {
 9 | 	constructor() {
10 | 		super();
11 | 		this.artyom = new Artyom();
12 | 		this.commands = [];
13 | 		this.setup();
14 | 	}
15 | 
16 | 	/** Loads commands from files within this folder. */
17 | 	setup() {
18 | 		const files = require.context('./', false, /\.js$/);
19 | 		let commandBuffer = [];
20 | 		files.keys().forEach((key) => {
21 | 			if (key === './index.js') return;
22 | 			// console.log('Commands from', key, ' file: ', files(key).default);
23 | 			commandBuffer = commandBuffer.concat(files(key).default);
24 | 		});
25 | 		this.commands = commandBuffer;
26 | 		this.artyom.addCommands(this.commands);
27 | 		this.emit('ready');
28 | 	}
29 | 
30 | 	/**
31 | 	 * Run's a given command, function is a replicate of an Artyom function.
32 | 	 *
33 | 	 * @param {*} command
34 | 	 */
35 | 	static run(command) {
36 | 		if (typeof (command) === 'object') {
37 | 			if (command.instruction) {
38 | 				if (command.instruction.smart) {
39 | 					command.instruction.action(command.index, command.wildcard.item, command.wildcard.full);
40 | 				} else {
41 | 					command.instruction.action(command.index);
42 | 				}
43 | 				return true;
44 | 			}
45 | 			return false;
46 | 		}
47 | 		return false;
48 | 	}
49 | 
50 | 	/**
51 | 	 * Finds a command given by a text sentence.
52 | 	 * @param string sentence
53 | 	 */
54 | 	findCommand(sentence) {
55 | 		return this.artyom.execute(sentence);
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/src/renderer/providers/commands/spotify.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 | 	{
 3 | 		smart: false,
 4 | 		indexes: [
 5 | 			'spotify login',
 6 | 			'login to spotify',
 7 | 		],
 8 | 		action: () => {
 9 | 			Window.Assistant.say('Login to spotify on your screen.');
10 | 			Window.Spotify.authenticate();
11 | 			Window.Spotify.once('authenticated', () => {
12 | 				Window.Assistant.say('You succesfully logged into spotify!');
13 | 			});
14 | 		},
15 | 	},
16 | 	{
17 | 		smart: false,
18 | 		indexes: [
19 | 			'spotify song',
20 | 			'what is playing right now',
21 | 			'what\'s playing right now',
22 | 			'what music is playing',
23 | 			'what song is this',
24 | 			'what\'s playing',
25 | 			'what song is playing',
26 | 			'what artist is playing',
27 | 			'what artist is playing right now',
28 | 			'who is playing right now',
29 | 			'who\'s playing right now',
30 | 			'what is playing',
31 | 		],
32 | 		action: () => {
33 | 			Window.Spotify.getMyCurrentPlayingTrack().then((track) => {
34 | 				console.log('Current track', track);
35 | 				if (track.item) {
36 | 					Window.Assistant.say(`You're listening to ${track.item.name} by ${track.item.artists[0].name}`);
37 | 				} else {
38 | 					Window.Assistant.say('Nothing is playing right now.');
39 | 				}
40 | 			}).catch((err) => {
41 | 				if (err.message && err.statusCode === 401) {
42 | 					Window.Assistant
43 | 						.say('You\'re not logged in to Spotify, say or type \'login to spotify\' to login.');
44 | 				} else {
45 | 					console.log(err);
46 | 					Window.Assistant
47 | 						.say('Something went wrong, try \'login to spotify\' to try again');
48 | 				}
49 | 			});
50 | 		},
51 | 	},
52 | 	{
53 | 		smart: false,
54 | 		indexes: [
55 | 			'spotify next',
56 | 			'play the next song',
57 | 			'next',
58 | 			'play next',
59 | 		],
60 | 		action: () => {
61 | 			Window.Spotify.skipToNext().then(() => {
62 | 				Window.Assistant.say('Alright!', 0, true);
63 | 			}).catch((err) => {
64 | 				console.log(err);
65 | 				Window.Assistant
66 | 					.say('Something went wrong, try \'login to spotify\' to try again');
67 | 			});
68 | 		},
69 | 	},
70 | 	{
71 | 		smart: false,
72 | 		indexes: [
73 | 			'shuffle music',
74 | 		],
75 | 		action: () => {
76 | 			Window.Spotify.shuffle().then(() => {
77 | 				Window.Assistant.say('Enjoy!');
78 | 			}).catch((err) => {
79 | 				console.log(err);
80 | 				Window.Assistant.say('Something went wrong, try \'spotify login\' to try again');
81 | 			});
82 | 		},
83 | 	},
84 | ];
85 | 


--------------------------------------------------------------------------------
/src/renderer/providers/commands/youtube.js:
--------------------------------------------------------------------------------
 1 | import opn from 'opn';
 2 | 
 3 | export default [
 4 | 	{
 5 | 		smart: true,
 6 | 		indexes: [
 7 | 			'play * on youtube',
 8 | 			'open * on youtube',
 9 | 			'search * on youtube',
10 | 			'find * on youtube'],
11 | 		action: (i, wildcard) => {
12 | 			Window.Assistant.say(`Playing ${wildcard} on YouTube`);
13 | 			opn('https://www.youtube.com/results?search_query='.concat(encodeURIComponent(wildcard)));
14 | 		},
15 | 	},
16 | ];
17 | 


--------------------------------------------------------------------------------
/src/renderer/providers/router/index.js:
--------------------------------------------------------------------------------
 1 | import VueRouter from 'vue-router';
 2 | 
 3 | /**
 4 |  * Load a container lazy or async.
 5 |  *
 6 |  * @param  {string} name
 7 |  * @return {function}
 8 |  */
 9 | export function lazyLoadContainer(name) {
10 | 	return resolve => require([`@/containers/${name}`], resolve).default; // eslint-disable-line
11 | }
12 | 
13 | export default new VueRouter({
14 | 	mode: 'history',
15 | 	base: __dirname,
16 | 	routes: [
17 | 		{
18 | 			path: '/',
19 | 			name: 'home',
20 | 			component: lazyLoadContainer('Home'),
21 | 		},
22 | 		{
23 | 			path: '/inspire',
24 | 			name: 'inspire',
25 | 			component: lazyLoadContainer('InspireView'),
26 | 		},
27 | 		{
28 | 			path: '/mini',
29 | 			name: 'mini',
30 | 			component: lazyLoadContainer('MiniView'),
31 | 		},
32 | 		{
33 | 			path: '*',
34 | 			redirect: '/',
35 | 		},
36 | 	],
37 | });
38 | 


--------------------------------------------------------------------------------
/src/renderer/providers/spotify/index.js:
--------------------------------------------------------------------------------
1 | export { default } from './spotify';
2 | 


--------------------------------------------------------------------------------
/src/renderer/providers/spotify/spotify.js:
--------------------------------------------------------------------------------
  1 | // eslint-disable-next-line
  2 | import { ipcRenderer, remote } from 'electron';
  3 | // eslint-disable-next-line import/no-extraneous-dependencies
  4 | import { EventEmitter } from 'events';
  5 | import SpotifyAPIClient from 'spotify-web-api-node';
  6 | import fs from 'fs';
  7 | import mkdirp from 'mkdirp';
  8 | import path from 'path';
  9 | import config from '@/config';
 10 | 
 11 | export default class SpotifyClient extends EventEmitter {
 12 | 	constructor() {
 13 | 		super();
 14 | 		this.spotifyClient = new SpotifyAPIClient({
 15 | 			clientId: config.spotify.clientId,
 16 | 			clientSecret: config.spotify.clientSecret,
 17 | 			redirectUri: config.spotify.redirectUri,
 18 | 		});
 19 | 		this.scopes = config.spotify.scopes;
 20 | 	}
 21 | 
 22 | 	/**
 23 | 	 * Fetches the tokens and saves them.
 24 | 	 *
 25 | 	 * @param {String} code
 26 | 	 */
 27 | 	handleAuthorization(code) {
 28 | 		this.spotifyClient.authorizationCodeGrant(code)
 29 | 			.then(({ body: tokens }) => {
 30 | 				this.spotifyClient.setAccessToken(tokens.access_token);
 31 | 				this.spotifyClient.setRefreshToken(tokens.refresh_token);
 32 | 				console.debug('The token expires in', tokens.expires_in);
 33 | 				console.debug('The access token is', tokens.access_token);
 34 | 				console.debug('The refresh token is', tokens.refresh_token);
 35 | 				this.saveTokens(tokens);
 36 | 				this.emit('authenticated', tokens);
 37 | 			}, (err) => {
 38 | 				this.emit('error', err);
 39 | 			});
 40 | 	}
 41 | 
 42 | 	/**
 43 | 	 * Saves the tokens from the included spotify web api client.
 44 | 	 */
 45 | 	saveTokens() {
 46 | 		const tokens = {
 47 | 			access_token: this.spotifyClient.getAccessToken(),
 48 | 			refresh_token: this.spotifyClient.getRefreshToken(),
 49 | 		};
 50 | 		mkdirp(path.dirname(config.spotify.savedTokensPath), () => {
 51 | 			fs.writeFile(config.spotify.savedTokensPath, JSON.stringify(tokens), (err) => {
 52 | 				if (!err) {
 53 | 					console.debug('Tokens saved.');
 54 | 				} else {
 55 | 					console.debug('error saving tokens');
 56 | 				}
 57 | 			});
 58 | 		});
 59 | 	}
 60 | 
 61 | 	requestAuthorizationCode() {
 62 | 		const { BrowserWindow } = remote;
 63 | 		const authenticationUrl = this.spotifyClient.createAuthorizeURL(this.scopes);
 64 | 
 65 | 		console.debug('[Spotify Client] Requesting Authorization code...', authenticationUrl);
 66 | 
 67 | 		return new Promise((resolve, reject) => {
 68 | 			const win = new BrowserWindow({
 69 | 				webPreferences: {
 70 | 					nodeIntegration: false,
 71 | 					webSecurity: false,
 72 | 				},
 73 | 			});
 74 | 
 75 | 			win.webContents.on('closed', () => {
 76 | 				reject(new Error('User closed the window'));
 77 | 			});
 78 | 
 79 | 			/** Detect redirects to find the code parameter for RedirectUri */
 80 | 			win.webContents.on('did-get-redirect-request', (event, oldURL, newURL) => {
 81 | 				console.log('[Spotify Client] Found redirection in BrowserWindow.');
 82 | 				console.log('[Spotify Client] From:', oldURL, '| To:', newURL);
 83 | 
 84 | 				/** Only process the url when we find the url that starts with our redirectUri */
 85 | 				if (!newURL.startsWith(config.spotify.redirectUri)) {
 86 | 					return;
 87 | 				}
 88 | 
 89 | 				const url = new URL(newURL);
 90 | 
 91 | 				const code = url.searchParams.get('code');
 92 | 
 93 | 
 94 | 				if (code) {
 95 | 					setImmediate(() => win.close());
 96 | 					win.webContents.removeAllListeners('closed');
 97 | 					console.log('[Spotify Client] Code found', code);
 98 | 					resolve(code);
 99 | 				} else {
100 | 					reject(new Error(`No token found at redirectUri ${newURL}`));
101 | 				}
102 | 			});
103 | 			win.loadURL(authenticationUrl);
104 | 		});
105 | 	}
106 | 
107 | 	authenticate() {
108 | 		// [TODO]: Load saved tokens and use refresh token to get new tokens?
109 | 		console.debug('[Spotify Client] Authenticating current user...');
110 | 		this.requestAuthorizationCode().then((code) => {
111 | 			this.handleAuthorization(code).then(() => {
112 | 				this.handleAuthorization(code);
113 | 			}).catch((err) => {
114 | 				this.emit('unauthenticated', err);
115 | 			});
116 | 		}).catch((err) => {
117 | 			this.emit('unauthenticated', err);
118 | 		});
119 | 	}
120 | 
121 | 	getMyCurrentPlayingTrack() {
122 | 		return new Promise((resolve, reject) => {
123 | 			this.spotifyClient.getMyCurrentPlayingTrack().then((response) => {
124 | 				resolve(response.body);
125 | 			}, (err) => {
126 | 				reject(err);
127 | 			});
128 | 		});
129 | 	}
130 | 
131 | 	searchTrack(searchTerm) {
132 | 		this.spotifyClient.searchTracks(searchTerm)
133 | 			.then((data) => {
134 | 				console.log('Results for search term; ', data.body);
135 | 			}, (err) => {
136 | 				console.error(err);
137 | 			});
138 | 	}
139 | 
140 | 	skipToNext() {
141 | 		return new Promise((resolve, reject) => {
142 | 			this.spotifyClient.skipToNext().then((response) => {
143 | 				console.log('skipped song to next...', response);
144 | 				resolve(response);
145 | 			}, (err) => {
146 | 				console.log('error??');
147 | 				reject(err);
148 | 			});
149 | 		});
150 | 	}
151 | 
152 | 	shuffle(playTracks = true) {
153 | 		return new Promise((resolve, reject) => {
154 | 			this.spotifyClient.setShuffle({ state: true }).then((response) => {
155 | 				if (playTracks) {
156 | 					this.skipToNext();
157 | 				}
158 | 				resolve(response);
159 | 			}, (err) => {
160 | 				console.log('error??');
161 | 				reject(err);
162 | 			});
163 | 		});
164 | 	}
165 | 
166 | 	play() {
167 | 		return new Promise((resolve, reject) => {
168 | 			this.spotifyClient.play().then((response) => {
169 | 				console.log('playing music', response);
170 | 				resolve(response);
171 | 			}, (err) => {
172 | 				console.log('error??');
173 | 				reject(err);
174 | 			});
175 | 		});
176 | 	}
177 | }
178 | 


--------------------------------------------------------------------------------
/src/renderer/providers/store/assistant.js:
--------------------------------------------------------------------------------
 1 | export default {
 2 | 	state: {
 3 | 		messages: [],
 4 | 		commandResponse: '',
 5 | 		speechTextBuffer: '',
 6 | 		statusMessage: '',
 7 | 		status: 'loading',
 8 | 		isMini: false,
 9 | 	},
10 | 
11 | 	mutations: {
12 | 		addMessage(state, message) {
13 | 			state.messages.push(message);
14 | 		},
15 | 		removeMessage(state, message) {
16 | 			state.messages.splice(state.todos.indexOf(message), 1);
17 | 		},
18 | 		updateLatestMessage(state, message) {
19 | 			let buffer = state.messages.pop();
20 | 			buffer = Object.assign(buffer, message);
21 | 			state.messages.push(buffer);
22 | 		},
23 | 	},
24 | 
25 | 	getters: {
26 | 		messages: state => state.messages,
27 | 	},
28 | };
29 | 


--------------------------------------------------------------------------------
/src/renderer/providers/store/index.js:
--------------------------------------------------------------------------------
1 | export { default } from './store';
2 | 


--------------------------------------------------------------------------------
/src/renderer/providers/store/store.js:
--------------------------------------------------------------------------------
 1 | import Vue from 'vue';
 2 | import Vuex from 'vuex';
 3 | 
 4 | import assistantStore from './assistant';
 5 | 
 6 | Vue.use(Vuex);
 7 | 
 8 | export default new Vuex.Store({
 9 | 	modules: {
10 | 		assistant: assistantStore,
11 | 	},
12 | });
13 | 


--------------------------------------------------------------------------------
/src/response.ejs:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html style="overflow: hidden;">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>ga-desktop</title>
 6 | 		<% if (htmlWebpackPlugin.options.nodeModules) { %>
 7 | 			<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
 8 |       <!-- Add `node_modules/` to global paths so `require` works properly in development -->
 9 |       <script>
10 | 				Window.isResponse = true;
11 | 				var module = require('module');
12 | 				var path = require('path');
13 |         module.globalPaths.push('<%= htmlWebpackPlugin.options.nodeModules.replace(/\\/g, '\\\\') %>')
14 | 				module.globalPaths.push(path.resolve('node_modules'));
15 | 				module.globalPaths.push(path.resolve('../node_modules'));
16 | 				module.globalPaths.push(path.resolve(__dirname, '..', '..', '..', '..',
17 | 					'resources', 'app', 'node_modules'));
18 | 				module.globalPaths.push(path.resolve(__dirname, '..', '..', '..', '..',
19 | 					'resources', 'app.asar', 'node_modules'))
20 | 			</script>
21 |     <% } %>
22 |   </head>
23 |   <body style="overflow: hidden;">
24 |     <div id="response">
25 | 		</div>
26 |     <!-- Set `__static` path to static files in production -->
27 |     <script>
28 |       if (process.env.NODE_ENV !== 'development') window.__static = require('path').join(__dirname, '/static').replace(/\\/g, '\\\\')
29 |     </script>
30 | 
31 |     <!-- webpack builds are automatically injected -->
32 |   </body>
33 | </html>
34 | 


--------------------------------------------------------------------------------
/static/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/.gitkeep


--------------------------------------------------------------------------------
/static/bubbles.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/bubbles.png


--------------------------------------------------------------------------------
/static/hotword_enrollment_confirm.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/hotword_enrollment_confirm.png


--------------------------------------------------------------------------------
/static/ic_mic.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/ic_mic.png


--------------------------------------------------------------------------------
/static/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/icon.ico


--------------------------------------------------------------------------------
/static/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/icon.png


--------------------------------------------------------------------------------
/static/loading.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/loading.gif


--------------------------------------------------------------------------------
/static/molecule.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 373 373"><style>.st0{display:none}.st1{fill:#34a853}.st2{fill:#ea4335}.st3{fill:#4285f4}.st4{fill:#fbbc05}</style><image width="375" height="375" xlink:href="Molecule-Formation-stop.png" transform="translate(4 4) scale(.9733)" overflow="visible" id="Layer_1" class="st0"/><g id="Layer_2"><circle class="st1" cx="260.6" cy="153.1" r="11.2"/><circle class="st2" cx="226.3" cy="180.9" r="22.6"/><circle class="st3" cx="147.9" cy="158.6" r="46.5"/><circle class="st4" cx="226.3" cy="239.9" r="26.5"/></g></svg>


--------------------------------------------------------------------------------
/static/opa_logo_big.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/opa_logo_big.png


--------------------------------------------------------------------------------
/static/ping.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/ping.mp3


--------------------------------------------------------------------------------
/static/powered_by_google_dark.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/powered_by_google_dark.png


--------------------------------------------------------------------------------
/static/powered_by_google_light.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/powered_by_google_light.png


--------------------------------------------------------------------------------
/static/quantum_ic_devices_other_grey600_24.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/quantum_ic_devices_other_grey600_24.png


--------------------------------------------------------------------------------
/static/recording.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/recording.gif


--------------------------------------------------------------------------------
/static/splash.html:
--------------------------------------------------------------------------------
1 | <style>
2 | 	body {
3 |     -ms-overflow-style: scrollbar;
4 |     -webkit-app-region:drag;
5 | }
6 | </style>
7 | <img src="./splash.gif" width="100%" height="100%" />
8 | 


--------------------------------------------------------------------------------
/static/v.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ItsWendell/google-assistant-desktop-client/9b775bc3e4d8da8c99fb33cb9452ec3019f413a5/static/v.png


--------------------------------------------------------------------------------
/static/waiting.svg:
--------------------------------------------------------------------------------
 1 | <svg width="200px" height="200px" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="xMidYMid" class="lds-ellipsis" style="animation-play-state: running; animation-delay: 0s; background: none;">
 2 |     <!--circle(cx="16",cy="50",r="10")-->
 3 |     <circle cx="84" cy="50" r="0" fill="#1875e5" style="animation-play-state: running; animation-delay: 0s;">
 4 |       <animate attributeName="r" values="10;0;0;0;0" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="0s" style="animation-play-state: running; animation-delay: 0s;"></animate>
 5 |       <animate attributeName="cx" values="84;84;84;84;84" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="0s" style="animation-play-state: running; animation-delay: 0s;"></animate>
 6 |     </circle>
 7 |     <circle cx="16" cy="50" r="5.26629" fill="#499255" style="animation-play-state: running; animation-delay: 0s;">
 8 |       <animate attributeName="r" values="0;10;10;10;0" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="-1s" style="animation-play-state: running; animation-delay: 0s;"></animate>
 9 |       <animate attributeName="cx" values="16;16;50;84;84" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="-1s" style="animation-play-state: running; animation-delay: 0s;"></animate>
10 |     </circle>
11 |     <circle cx="84" cy="50" r="4.73371" fill="#f2b736" style="animation-play-state: running; animation-delay: 0s;">
12 |       <animate attributeName="r" values="0;10;10;10;0" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="-0.5s" style="animation-play-state: running; animation-delay: 0s;"></animate>
13 |       <animate attributeName="cx" values="16;16;50;84;84" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="-0.5s" style="animation-play-state: running; animation-delay: 0s;"></animate>
14 |     </circle>
15 |     <circle cx="67.9054" cy="50" r="10" fill="#c5523f" style="animation-play-state: running; animation-delay: 0s;">
16 |       <animate attributeName="r" values="0;10;10;10;0" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="0s" style="animation-play-state: running; animation-delay: 0s;"></animate>
17 |       <animate attributeName="cx" values="16;16;50;84;84" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="0s" style="animation-play-state: running; animation-delay: 0s;"></animate>
18 |     </circle>
19 |     <circle cx="33.9054" cy="50" r="10" fill="#1875e5" style="animation-play-state: running; animation-delay: 0s;">
20 |       <animate attributeName="r" values="0;0;10;10;10" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="0s" style="animation-play-state: running; animation-delay: 0s;"></animate>
21 |       <animate attributeName="cx" values="16;16;16;50;84" keyTimes="0;0.25;0.5;0.75;1" keySplines="0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1;0 0.5 0.5 1" calcMode="spline" dur="2s" repeatCount="indefinite" begin="0s" style="animation-play-state: running; animation-delay: 0s;"></animate>
22 |     </circle>
23 |   </svg>


--------------------------------------------------------------------------------
/test/.eslintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "env": {
 3 |     "mocha": true
 4 |   },
 5 |   "globals": {
 6 |     "assert": true,
 7 |     "expect": true,
 8 |     "should": true,
 9 |     "__static": true
10 |   },
11 |   "rules": {
12 |     "func-names": 0,
13 |     "prefer-arrow-callback": 0
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/test/e2e/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | // Set BABEL_ENV to use proper env config
 4 | process.env.BABEL_ENV = 'test'
 5 | 
 6 | // Enable use of ES6+ on required files
 7 | require('babel-register')({
 8 |   ignore: /node_modules/
 9 | })
10 | 
11 | // Attach Chai APIs to global scope
12 | const { expect, should, assert } = require('chai')
13 | global.expect = expect
14 | global.should = should
15 | global.assert = assert
16 | 
17 | // Require all JS files in `./specs` for Mocha to consume
18 | require('require-dir')('./specs')
19 | 


--------------------------------------------------------------------------------
/test/e2e/specs/Launch.spec.js:
--------------------------------------------------------------------------------
 1 | import utils from '../utils';
 2 | 
 3 | describe('Launch', function () {
 4 | 	beforeEach(utils.beforeEach);
 5 | 	afterEach(utils.afterEach);
 6 | 
 7 | 	it('shows the proper application title', function () {
 8 | 		return this.app.client.getTitle()
 9 |       .then((title) => {
10 | 	expect(title).to.equal('ga-desktop');
11 | });
12 | 	});
13 | });
14 | 


--------------------------------------------------------------------------------
/test/e2e/utils.js:
--------------------------------------------------------------------------------
 1 | import electron from 'electron'
 2 | import { Application } from 'spectron'
 3 | 
 4 | export default {
 5 |   afterEach () {
 6 |     this.timeout(10000)
 7 | 
 8 |     if (this.app && this.app.isRunning()) {
 9 |       return this.app.stop()
10 |     }
11 |   },
12 |   beforeEach () {
13 |     this.timeout(10000)
14 |     this.app = new Application({
15 |       path: electron,
16 |       args: ['dist/electron/main.js'],
17 |       startTimeout: 10000,
18 |       waitTimeout: 10000
19 |     })
20 | 
21 |     return this.app.start()
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/test/unit/index.js:
--------------------------------------------------------------------------------
 1 | import Vue from 'vue'
 2 | Vue.config.devtools = false
 3 | Vue.config.productionTip = false
 4 | 
 5 | // require all test files (files that ends with .spec.js)
 6 | const testsContext = require.context('./specs', true, /\.spec$/)
 7 | testsContext.keys().forEach(testsContext)
 8 | 
 9 | // require all src files except main.js for coverage.
10 | // you can also change this to match only the subset of files that
11 | // you want coverage for.
12 | const srcContext = require.context('../../src/renderer', true, /^\.\/(?!main(\.js)?$)/)
13 | srcContext.keys().forEach(srcContext)
14 | 


--------------------------------------------------------------------------------
/test/unit/karma.conf.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | const path = require('path')
 4 | const merge = require('webpack-merge')
 5 | const webpack = require('webpack')
 6 | 
 7 | const baseConfig = require('../../.electron-vue/webpack.renderer.config')
 8 | const projectRoot = path.resolve(__dirname, '../../src/renderer')
 9 | 
10 | // Set BABEL_ENV to use proper preset config
11 | process.env.BABEL_ENV = 'test'
12 | 
13 | let webpackConfig = merge(baseConfig, {
14 |   devtool: '#inline-source-map',
15 |   plugins: [
16 |     new webpack.DefinePlugin({
17 |       'process.env.NODE_ENV': '"testing"'
18 |     })
19 |   ]
20 | })
21 | 
22 | // don't treat dependencies as externals
23 | delete webpackConfig.entry
24 | delete webpackConfig.externals
25 | delete webpackConfig.output.libraryTarget
26 | 
27 | // apply vue option to apply isparta-loader on js
28 | webpackConfig.module.rules
29 |   .find(rule => rule.use.loader === 'vue-loader').use.options.loaders.js = 'babel-loader'
30 | 
31 | module.exports = config => {
32 |   config.set({
33 |     browsers: ['visibleElectron'],
34 |     client: {
35 |       useIframe: false
36 |     },
37 |     coverageReporter: {
38 |       dir: './coverage',
39 |       reporters: [
40 |         { type: 'lcov', subdir: '.' },
41 |         { type: 'text-summary' }
42 |       ]
43 |     },
44 |     customLaunchers: {
45 |       'visibleElectron': {
46 |         base: 'Electron',
47 |         flags: ['--show']
48 |       }
49 |     },
50 |     frameworks: ['mocha', 'chai'],
51 |     files: ['./index.js'],
52 |     preprocessors: {
53 |       './index.js': ['webpack', 'sourcemap']
54 |     },
55 |     reporters: ['spec', 'coverage'],
56 |     singleRun: true,
57 |     webpack: webpackConfig,
58 |     webpackMiddleware: {
59 |       noInfo: true
60 |     }
61 |   })
62 | }
63 | 


--------------------------------------------------------------------------------