Add support for intecepting existing Fish shells

Author: pimterry

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

@@ -4,13 +4,20 @@ import { Mockttp, getLocal } from 'mockttp';
 import { Interceptor } from '..';
 import { HtkConfig } from '../../config';
 import { getTerminalEnvVars } from './terminal-env-overrides';
-import { getShellScript } from './terminal-scripts';
+import { getBashShellScript, getFishShellScript } from './terminal-scripts';
 
 interface ServerState {
     server: Mockttp;
     isActive: boolean;
 }
 
+function getShellCommands(port: number) {
+    return {
+        'Bash': { command: `eval "$(curl -sS localhost:${port}/setup)"`, description: "Bash-compatible" },
+        'Fish': { command: `curl -sS localhost:${port}/fish-setup | source`, description: "Fish" }
+    }
+}
+
 export class ExistingTerminalInterceptor implements Interceptor {
 
     private servers: {
@@ -29,40 +36,46 @@ export class ExistingTerminalInterceptor implements Interceptor {
     }
 
     isActive(proxyPort: number): boolean {
-        const serverState = this.servers[proxyPort];
-        return !!serverState && serverState.isActive;
+        return this.servers[proxyPort]?.isActive ?? false;
     }
 
-    async activate(proxyPort: number): Promise<{ port: number }> {
+    async activate(proxyPort: number): Promise<{ port: number, commands: { [shellName: string]: { command: string, description: string } } }> {
         if (this.servers[proxyPort]) {
             // Reset isActive, so we wait again for a new request
             this.servers[proxyPort].isActive = false;
-            return { port: this.servers[proxyPort].server.port };
+            const serverPort = this.servers[proxyPort].server.port;
+            return {
+                port: serverPort,
+                commands: getShellCommands(serverPort)
+            };
         }
 
         const server = getLocal();
         await server.start({ startPort: proxyPort + 1, endPort: 65535 });
 
         const envVars = getTerminalEnvVars(proxyPort, this.config.https, 'runtime-inherit', {});
-        const setupScript = getShellScript(server.urlFor('/success'), envVars);
 
         const serverState = { server, isActive: false };
 
-        await server.get('/setup').thenCallback(() => {
-            return {
-                status: 200,
-                headers: { "content-type": "text/x-shellscript" },
-                body: setupScript
-            };
-        });
+        await server.forGet('/setup').thenReply(200,
+            getBashShellScript(server.urlFor('/success'), envVars),
+            { "content-type": "text/x-shellscript" }
+        );
+        await server.forGet('/fish-setup').thenReply(200,
+            getFishShellScript(server.urlFor('/success'), envVars),
+            { "content-type": "application/x-fish" }
+        );
 
-        await server.post('/success').thenCallback(() => {
+        await server.forPost('/success').thenCallback(() => {
             serverState.isActive = true;
             return { status: 200 };
         });
 
         this.servers[proxyPort] = serverState;
-        return { port: server.port };
+        return {
+            port: server.port,
+            commands: getShellCommands(server.port)
+        };
     }
 
     async deactivate(proxyPort: number): Promise<void> {

src/interceptors/terminal/terminal-scripts.ts

@@ -69,8 +69,8 @@ if [ -n "$HTTP_TOOLKIT_ACTIVE" ]
 end
 ${END_CONFIG_SECTION}`;
 
-// A source-able shell script. Should work for everything except fish, sadly.
-export const getShellScript = (callbackUrl: string, env: { [name: string]: string }) => `${
+// A source-able shell script. Should work for everything sh-compatible, e.g. Bash, Zsh, Ksh etc.
+export const getBashShellScript = (callbackUrl: string, env: { [name: string]: string }) => `${
         _.map(env, (value, key) => `    export ${key}="${value.replace(/"/g, '\\"')}"`).join('\n')
     }
 
@@ -88,6 +88,24 @@ export const getShellScript = (callbackUrl: string, env: { [name: string]: strin
     echo 'HTTP Toolkit interception enabled'
 `;
 
+export const getFishShellScript = (callbackUrl: string, env: { [name: string]: string }) => `${
+        _.map(env, (value, key) => `    set -x ${key} "${value.replace(/"/g, '\\"')}"`).join('\n')
+    }
+
+    if command -v winpty >/dev/null 2>&1
+        # Work around for winpty's hijacking of certain commands
+        alias php=php
+        alias node=node
+    end
+
+    if command -v curl >/dev/null 2>&1
+        # Let the HTTP Toolkit app know this ran succesfully
+        curl --noproxy '*' -X POST "${callbackUrl}" >/dev/null 2>&1 &
+    end
+
+    echo 'HTTP Toolkit interception enabled'
+`;
+
 // Find the relevant user shell config file, add the above line to it, so that
 // shells launched with HTTP_TOOLKIT_ACTIVE set use the interception PATH.
 export const editShellStartupScripts = async () => {

test/interceptors/existing-terminal.spec.ts

@@ -77,13 +77,13 @@ describe('Existing terminal interceptor', function () {
     it("should intercept all popular JS libraries", async function () {
         this.timeout(10000);
         const { interceptor, server } = await interceptorSetup;
-        const result = await interceptor.activate(server.port) as { port: number };
+        const result = await interceptor.activate(server.port) as { port: number, commands: { [shell: string]: { command: string } } };
 
-        const mainRule = await server.get(/https?:\/\/example.test\/js\/.*/).thenReply(200);
-        const stripeRule = await server.get('https://api.stripe.com/v1/customers').thenJson(200, {});
+        const mainRule = await server.forGet(/https?:\/\/example.test\/js\/.*/).thenReply(200);
+        const stripeRule = await server.forGet('https://api.stripe.com/v1/customers').thenJson(200, {});
 
         const scriptOutput = await execAsync(`
-            . <(curl -sS http://localhost:${result.port}/setup);
+            ${result.commands['Bash'].command}
             node "${require.resolve('../fixtures/terminal/js-test-script')}"
         `, {
             shell: '/bin/bash'