FilesExpand file tree

develop

/

check-installed-app.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

166 lines (149 loc) · 6.04 KB

develop

/

check-installed-app.js

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

166 lines (149 loc) · 6.04 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

#!/usr/bin/env node

'use strict';

/*

* CAN THIS INSTALLED APP ACTUALLY MAKE A SOUND?

*

* Written the evening a shop's kitchen stayed silent with a correct build

* installed on the machine. Every part was present and one of them was older

* than the code that needed it, which is a state no test in the repository can

* see: the repository was green the whole time.

*

* The chain has five links and breaking any one of them is silence, with no

* error anywhere:

*

* 1. the main process can compose and synthesise (src/*.js in the asar)

* 2. the bridge exists to carry it to a page (src/preload.js)

* 3. a page is listening (the built dashboard bundle)

* 4. the browser is allowed to play a data: sound (the CSP the API sends)

* 5. somebody turned it on (kitchen-announce.json)

*

* The one that broke was 3, and it is the only one invisible from the source

* tree: frontend/public/ is gitignored build output, so an installer can carry

* a bundle built before the code it is supposed to contain.

*

* node scripts/check-installed-app.js

* node scripts/check-installed-app.js "C:/Users/x/AppData/Local/Programs/Posnic"

*

* Read-only. It opens files and asks the running app for one page.

*/

const fs = require('fs');

const path = require('path');

const http = require('http');

const WHERE = [

process.argv[2],

path.join(process.env.LOCALAPPDATA || '', 'Programs', 'Posnic'),

path.join(process.env.PROGRAMFILES || '', 'Posnic Desktop'),

].filter(Boolean);

const found = [];

const missing = [];

const say = (ok, what, detail) => {

(ok ? found : missing).push(what);

console.log(` ${ok ? 'OK ' : 'MISS'} ${what}${detail ? ' ' + detail : ''}`);

};

/** The asar index: an 8 byte pickle, then a JSON header of the stated length. */

function openAsar(file) {

const fd = fs.openSync(file, 'r');

const head = Buffer.alloc(16);

fs.readSync(fd, head, 0, 16, 0);

const size = head.readUInt32LE(12);

const json = Buffer.alloc(size);

fs.readSync(fd, json, 0, size, 16);

const index = JSON.parse(json.toString('utf8'));

const base = 16 + size;

return (entry) => {

let node = index;

for (const part of entry.split('/')) {

node = node && node.files ? node.files[part] : null;

if (!node) return null;

}

if (!node.size) return '';

const body = Buffer.alloc(Number(node.size));

fs.readSync(fd, body, 0, Number(node.size), base + Number(node.offset));

return body.toString('utf8');

};

}

function get(url) {

return new Promise((resolve) => {

const request = http.get(url, { timeout: 4000 }, (response) => {

let body = '';

response.setEncoding('utf8');

response.on('data', (chunk) => (body += chunk));

response.on('end', () => resolve({ headers: response.headers, body }));

});

request.on('error', () => resolve(null));

request.on('timeout', () => {

request.destroy();

resolve(null);

});

});

}

async function main() {

const root = WHERE.find((dir) => fs.existsSync(path.join(dir, 'resources', 'app.asar')));

if (!root) {

console.log('No installed app found. Pass its folder as an argument.');

process.exit(2);

}

console.log(`\nChecking ${root}\n`);

/* 1 and 2: the main process and the bridge. */

const read = openAsar(path.join(root, 'resources', 'app.asar'));

const call = read('src/kitchen-call.js');

const announce = read('src/kitchen-announce.js');

const alert = read('src/order-alert.js');

const preload = read('src/preload.js');

const main = read('src/main.js');

say(!!call, 'the announcement is composed', call ? '' : 'src/kitchen-call.js is not packaged');

say(!!announce, 'the switches are readable');

say(!!alert && /struck/.test(alert), 'the bells are struck notes, not a beep');

say(!!preload && /posnic:kitchen-call/.test(preload), 'the bridge carries it to a page');

say(

!!main && /autoplay-policy/.test(main),

'audio is allowed without a user gesture',

'a kitchen machine is one nobody has touched'

);

/*

* 3: A PAGE IS LISTENING. The link that broke, and the only one that cannot

* be seen from the source tree.

*/

const page = await get('http://localhost:5555/dashboard.html');

if (!page) {

console.log(' ---- the app is not running, so the page and the CSP were not checked');

} else {

const bundle = (page.body.match(/src="(script\/dashboard\.[0-9a-f]+\.js)"/) || [])[1];

const served = bundle ? await get(`http://localhost:5555/${bundle}`) : null;

const listening = !!served && /kitchenCall/.test(served.body);

say(

listening,

'a page is listening for the announcement',

listening ? bundle : `${bundle || 'no bundle'} was built before the player existed`

);

say(

!!served && /speechSynthesis/.test(served.body),

'that page can speak'

);

/* 4: the browser is allowed to play a generated sound. */

const csp = page.headers['content-security-policy'] || '';

say(

/media-src[^;]*data:/.test(csp),

'the browser may play a generated sound',

/media-src/.test(csp) ? '' : 'no media-src, so it falls back to default-src and is blocked'

);

}

/* 5: somebody turned it on. Not a fault, but the commonest reason for silence. */

const settings = path.join(process.env.APPDATA || '', 'posnic', 'kitchen-announce.json');

if (fs.existsSync(settings)) {

try {

const said = JSON.parse(fs.readFileSync(settings, 'utf8'));

say(said.ting === true || said.speak === true, 'this machine is set to make a sound',

`ting=${said.ting === true} speak=${said.speak === true}`);

} catch (e) {

say(false, 'this machine is set to make a sound', 'the settings file will not parse');

}

} else {

console.log(' ---- this machine has not been switched on yet (Core Settings, then Test)');

}

console.log(

`\n${missing.length ? 'NOT READY: ' + missing.length + ' of ' + (found.length + missing.length) + ' checks failed' : 'Ready: every link in the chain is present'}\n`

);

process.exit(missing.length ? 1 : 0);

}

main();