Ensure PHP interception works on OSX

On OSX, we can't prepend to PATH, because a script called path_helpers
prepends all standard paths to the PATH in every new shell, effectively
overwriting us. To fix this, we edit each of the common shell startup
config files, which gives us a hook into shells _after_ this happens.
The hooks are behind an env var flag (HTTP_TOOLKIT_ACTIVE), so have
no effect the rest of the time, and are cleared up when the terminal
closes (n.b. on OSX we get proper process exit events that make this work)

Author: pimterry

src/interceptors/fresh-terminal.ts

@@ -1,5 +1,6 @@
 import * as _ from 'lodash';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import * as util from 'util';
 import { spawn, ChildProcess, SpawnOptions } from 'child_process';
@@ -20,6 +21,8 @@ const commandExists = (path: string): Promise<boolean> => ensureCommandExists(pa
 
 const DEFAULT_GIT_BASH_PATH = 'C:/Program Files/git/git-bash.exe';
 const PATH_VAR_SEPARATOR = process.platform === 'win32' ? ';' : ':';
+const SHELL = (process.env.SHELL || '').split('/').slice(-1)[0];
+const OVERRIDE_BIN_PATH = path.join(__dirname, 'terminal-wrappers');
 
 interface SpawnArgs {
     command: string;
@@ -72,6 +75,110 @@ const getTerminalCommand = _.memoize(async (): Promise<SpawnArgs | null> => {
     return null;
 });
 
+// Works in bash, zsh, dash, ksh, sh (not fish)
+const SH_SHELL_PATH_CONFIG = `
+# Do not edit (all lines including $HTTP_TOOLKIT_ACTIVE will be removed automatically)
+if [ -n "$HTTP_TOOLKIT_ACTIVE" ]; then export PATH="${OVERRIDE_BIN_PATH}:$PATH"; fi`;
+const FISH_SHELL_PATH_CONFIG = `
+# Do not edit (all lines including $HTTP_TOOLKIT_ACTIVE will be removed automatically)
+[ -n "$HTTP_TOOLKIT_ACTIVE" ]; and set -x PATH "${OVERRIDE_BIN_PATH}" $PATH;`;
+// Used to remove these lines from the config later
+const SHELL_PATH_CONFIG_MATCHER = /.*\$HTTP_TOOLKIT_ACTIVE.*/;
+
+const appendOrCreateFile = util.promisify(fs.appendFile);
+const appendToFirstExisting = async (paths: string[], forceWrite: boolean, contents: string) => {
+    for (let path of paths) {
+        // Small race here, but end result is ok either way
+        if (await canAccess(path)) {
+            return appendOrCreateFile(path, contents);
+        }
+    }
+
+    if (forceWrite) {
+        // If force write is set, write the last file anyway
+        return appendOrCreateFile(paths.slice(-1)[0], contents);
+    }
+};
+
+// 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.
+const editShellStartupScripts = async () => {
+    await resetShellStartupScripts();
+
+    // .profile is used by Dash, Bash sometimes, and by Sh:
+    appendOrCreateFile(path.join(os.homedir(), '.profile'), SH_SHELL_PATH_CONFIG)
+        .catch(reportError);
+
+    // Bash uses some other files by preference, if they exist:
+    appendToFirstExisting(
+        [
+            path.join(os.homedir(), '.bash_profile'),
+            path.join(os.homedir(), '.bash_login')
+        ],
+        false, // Do nothing if they don't exist - it falls back to .profile
+        SH_SHELL_PATH_CONFIG
+    ).catch(reportError);
+
+    // Zsh has its own files (both are actually used)
+    appendToFirstExisting(
+        [
+            path.join(os.homedir(), '.zshenv'),
+            path.join(os.homedir(), '.zshrc')
+        ],
+        SHELL === 'zsh', // If you use zsh, we _always_ write a config file
+        SH_SHELL_PATH_CONFIG
+    ).catch(reportError);
+
+    // Fish always uses the same config file
+    appendToFirstExisting(
+        [
+            path.join(os.homedir(), '.config', 'fish', 'config.fish'),
+        ],
+        SHELL === 'fish' || await canAccess(path.join(os.homedir(), '.config', 'fish')),
+        FISH_SHELL_PATH_CONFIG
+    ).catch(reportError);
+};
+
+const readFile = util.promisify(fs.readFile);
+const writeFile = util.promisify(fs.writeFile);
+const renameFile = util.promisify(fs.rename);
+const removeMatchingInFile = async (path: string, matcher: RegExp) => {
+    let fileLines: string[];
+
+    try {
+        fileLines = (await readFile(path, 'utf8')).split('\n');
+    } catch (e) {
+        // Silently skip any files we can't read
+        return;
+    }
+
+    // Drop all matching lines from the config file
+    fileLines = fileLines.filter(line => !matcher.test(line));
+    // Write & rename to ensure this is atomic, and avoid races here
+    // as much as we reasonably can.
+    const tempFile = path + Date.now() + '.temp';
+    await writeFile(tempFile, fileLines.join('\n'));
+    return renameFile(tempFile, path);
+};
+
+// Cleanup: strip our extra config line from all config files
+// Good to do for tidiness, not strictly necessary (the config does nothing
+// unless HTTP_TOOLKIT_ACTIVE is set anyway).
+const resetShellStartupScripts = () => {
+    // For each possible config file, remove our magic line, if present
+    return Promise.all([
+        path.join(os.homedir(), '.profile'),
+        path.join(os.homedir(), '.bash_profile'),
+        path.join(os.homedir(), '.bash_login'),
+        path.join(os.homedir(), '.zshenv'),
+        path.join(os.homedir(), '.zshrc'),
+        path.join(os.homedir(), '.config', 'fish', 'config.fish'),
+    ].map((configFile) =>
+        removeMatchingInFile(configFile, SHELL_PATH_CONFIG_MATCHER)
+        .catch(reportError)
+    ));
+};
+
 const terminals: _.Dictionary<ChildProcess[] | undefined> = {}
 
 export class TerminalInterceptor implements Interceptor {
@@ -95,7 +202,16 @@ export class TerminalInterceptor implements Interceptor {
 
         const { command, args, options } = terminalSpawnArgs;
 
-        const childProc = spawn(command, args || [], _.assign(options || {}, {
+        // On OSX, our PATH override below doesn't work, because path_helper always runs and prepends
+        // the real paths over the top. To fix this, we (very carefully!) rewrite shell startup
+        // scripts, to reset PATH there.
+        // This gets reset on exit, and is behind a flag so it won't affect other shells anyway.
+        if (process.platform === 'darwin') await editShellStartupScripts();
+
+        const childProc = spawn(
+            command,
+            (args || []),
+            _.assign(options || {}, {
             env: _.assign({}, process.env, {
                 'http_proxy': `http://localhost:${proxyPort}`,
                 'HTTP_PROXY': `http://localhost:${proxyPort}`,
@@ -115,16 +231,18 @@ export class TerminalInterceptor implements Interceptor {
                 // Trust cert for HTTPS requests from Git
                 'GIT_SSL_CAINFO': this.config.https.certPath,
 
+                'HTTP_TOOLKIT_ACTIVE': 'true',
+
                 // Prepend our bin overrides into $PATH
-                'PATH': `${path.join(__dirname, 'terminal-wrappers')}${PATH_VAR_SEPARATOR}${process.env.PATH}`
+                'PATH': `${OVERRIDE_BIN_PATH}${PATH_VAR_SEPARATOR}${process.env.PATH}`
             }),
             cwd: process.env.HOME || process.env.USERPROFILE
         }));
 
         terminals[proxyPort] = (terminals[proxyPort] || []).concat(childProc);
 
-
         const onTerminalClosed = () => {
+            if (process.platform === 'darwin') resetShellStartupScripts();
             terminals[proxyPort] = _.reject(terminals[proxyPort], childProc);
         };
         childProc.once('exit', onTerminalClosed);