Improve interceptor activation tracking & reporting

This now reports failed startups only for actual timeouts or
errors, and stops treating isActive as a strictly required
result for activate(). For existing terminals for example,
activate starts a server so they can be started, and isActive
returns true only once somebody has used that used.

Author: pimterry

src/httptoolkit-server.ts

@@ -74,23 +74,20 @@ const buildResolvers = (
                 const interceptor = interceptors[id];
                 if (!interceptor) throw new Error(`Unknown interceptor ${id}`);
 
-                let metadata: any = null;
-                await Promise.race([
-                    interceptor.activate(proxyPort, options)
-                        .then((result) => metadata = result)
-                        .catch(reportError),
-                    delay(30000) // After 30s, we don't stop activating, but we do report failure
+                const result = await Promise.race([
+                    // Activate, and either return metadata, or some error
+                    interceptor.activate(proxyPort, options).catch((e) => e),
+                    // After 30s, we don't stop activating, but we do return an error
+                    delay(30000).then(() => new Error(`Timeout activating ${id}`))
                 ]);
 
-                const isActive = interceptor.isActive(proxyPort);
-
-                if (isActive) {
-                    addBreadcrumb(`Successfully activated ${id}`, { category: 'interceptor' });
+                if (_.isError(result)) {
+                    reportError(result);
+                    return { success: false };
                 } else {
-                    reportError(new Error(`Failed to activate ${id}`));
+                    addBreadcrumb(`Successfully activated ${id}`, { category: 'interceptor' });
+                    return { success: true, metadata: result };
                 }
-
-                return { success: isActive, metadata };
             },
             deactivateInterceptor: async (__: void, args: _.Dictionary<any>) => {
                 const { id, proxyPort, options } = args;

src/interceptors/fresh-firefox.ts

@@ -10,6 +10,7 @@ import { getAvailableBrowsers, launchBrowser, BrowserInstance } from '../browser
 import { CertCheckServer } from '../cert-check-server';
 import { delay } from '../util';
 import { Interceptor } from '.';
+import { reportError } from '../error-tracking';
 
 const deleteFolder = promisify(rimraf);
 const readFile = promisify(fs.readFile);
@@ -132,6 +133,7 @@ export class FreshFirefox implements Interceptor {
             certCheckServer.stop();
             delete browsers[proxyPort];
             if (!success) {
+                reportError('Firefox certificate check failed');
                 deleteFolder(firefoxProfile).catch(console.warn);
             }
         });

src/interceptors/terminal/existing-terminal-interceptor.ts

@@ -6,9 +6,16 @@ import { HtkConfig } from '../../config';
 import { getTerminalEnvVars } from './terminal-env-overrides';
 import { getShellScript } from './terminal-scripts';
 
+interface ServerState {
+    server: Mockttp;
+    isActive: boolean;
+}
+
 export class ExistingTerminalInterceptor implements Interceptor {
 
-    private servers: { [proxyPort: number]: Mockttp } = {};
+    private servers: {
+        [proxyPort: number]: ServerState
+    } = {};
 
     id = 'existing-terminal';
     version = '1.0.0';
@@ -20,29 +27,40 @@ export class ExistingTerminalInterceptor implements Interceptor {
     }
 
     isActive(proxyPort: number): boolean {
-        return !!this.servers[proxyPort];
+        const serverState = this.servers[proxyPort];
+        return !!serverState && serverState.isActive;
     }
 
     async activate(proxyPort: number): Promise<{ port: number }> {
         if (this.servers[proxyPort]) {
-            return { port: this.servers[proxyPort].port };
+            return { port: this.servers[proxyPort].server.port };
         }
 
         const server = getLocal();
         await server.start({ startPort: proxyPort + 1, endPort: 65535 });
 
         const envVars = getTerminalEnvVars(proxyPort, this.config.https, 'runtime-inherit');
         const setupScript = getShellScript(envVars);
-        server.get('/setup').thenReply(200, setupScript, { "content-type": "text/x-shellscript" });
-
-        this.servers[proxyPort] = server;
 
+        const serverState = { server, isActive: false };
+        await server
+            .get('/setup')
+            .thenCallback(() => {
+                serverState.isActive = true;
+                return {
+                    status: 200,
+                    headers: { "content-type": "text/x-shellscript" },
+                    body: setupScript
+                };
+            });
+
+        this.servers[proxyPort] = serverState;
         return { port: server.port };
     }
 
     async deactivate(proxyPort: number): Promise<void> {
-        if (this.isActive(proxyPort)) {
-            await this.servers[proxyPort].stop();
+        if (this.servers[proxyPort]) {
+            await this.servers[proxyPort].server.stop();
             delete this.servers[proxyPort];
         }
     }