
## The Problem

If you know the pain when you double-click a `.json` file and macOS opens it in TextEdit or Xcode. Every. Single. Time.

You can right-click → "Open With" → choose your editor, but that's tedious. You can change individual file associations in Finder's "Get Info" panel, but doing that for dozens of file types is painful.

## The Solution

Use `duti` - a command-line tool for managing file associations on macOS.

### 1. Install duti

```bash
brew install duti
```

### 2. Get Your Editor's Bundle ID

```bash
osascript -e 'id of app "Visual Studio Code"'
# com.microsoft.VSCode
```

For other editors:
- **Cursor**: `osascript -e 'id of app "Cursor"'`
- **Sublime Text**: `osascript -e 'id of app "Sublime Text"'`
- **Zed**: `osascript -e 'id of app "Zed"'`

### 3. Set Associations for All Code Files

Here's a script that covers most programming languages and config files:

```bash
editor_id=$(osascript -e 'id of app "Visual Studio Code"')

extensions=(
  c h cpp hpp
  py ipynb ini
  js ts jsx tsx
  rb erb gemfile gemspec rakefile rake rdoc spec
  ex eex ejs erl
  java go rs ru php
  tf tpl tmpl
  css scss sass svg
  json yaml yml xml toml csv
  md mdx txt log
  sh zsh bash profile zshrc
  sql
  env example sample
  gitconfig gitignore
)

for ext in "${extensions[@]}"; do
  duti -s "$editor_id" ".$ext" all
done
```

Add more extensions as needed - the pattern is simple.

### 4. Handle Executable Scripts

Some files don't have extensions but are identified by their UTI (Uniform Type Identifier). Set those too:

```bash
executables=(
  public.shell-script
  public.python-script
  public.ruby-script
  public.perl-script
  public.unix-executable
  public.script
  com.netscape.javascript-source
  com.apple.applescript.text
)

for exe in "${executables[@]}"; do
  duti -s "$editor_id" "$exe" all
done
```

### 5. Verify It Worked

```bash
duti -x .py
# Should show your editor
```

## Full Script

Save this as `set-editor.sh` and run it whenever you set up a new Mac:

```bash
#!/bin/bash

brew install duti

editor_id=$(osascript -e 'id of app "Visual Studio Code"')

extensions=(
  c h cpp hpp
  py ipynb ini
  js ts jsx tsx
  rb erb gemfile gemspec rakefile rake rdoc spec
  ex eex ejs erl
  java go rs ru php
  tf tpl tmpl
  css scss sass svg
  json yaml yml xml toml csv
  md mdx txt log
  sh zsh bash profile zshrc
  sql
  env example sample
  gitconfig gitignore
)

for ext in "${extensions[@]}"; do
  duti -s "$editor_id" ".$ext" all
done

executables=(
  public.shell-script
  public.python-script
  public.ruby-script
  public.perl-script
  public.unix-executable
  public.script
  com.netscape.javascript-source
  com.apple.applescript.text
)

for exe in "${executables[@]}"; do
  duti -s "$editor_id" "$exe" all
done

echo "Done. All source files now open in $editor_id"
```

## Summary

Save the script. After a macOS update or a reinstall of Xcode / xcode-select, the default application may change. When that happens, run this once to restore your preferred editor.


Set Your Default Code Editor for All Source Files on macOS


## The Problem

You have two servers:

- **Server A**: Sits behind a private network (NAT/firewall). It has internet access and can make outgoing SSH connections.
- **Server B**: A public server where you run Docker containers. You want these containers to access the internet through Server A's network.

Why would you want this? Maybe Server A has access to internal resources. Maybe you need traffic to appear from Server A's IP. Maybe Server A is in a specific geographic location you need.

The challenge: Server A is unreachable from the outside. You can't set up a traditional VPN because you can't initiate connections *to* Server A—only *from* it.

## The Solution

Use an SSH reverse tunnel with a SOCKS proxy. Server A initiates the connection to Server B, but traffic flows backward—from B through A to the internet.

```
[Docker on B] → [SSH Tunnel] → [Server A] → [Internet]
```

## Step-by-Step Setup

### 1. Create the Reverse Tunnel

From **Server A**, run:

```bash
ssh -R 1080 user@server-b -N
```

That's it. This command:
- Connects from A to B
- Opens port 1080 on Server B
- Creates a SOCKS5 proxy that routes traffic back through A
- `-N` means "don't run any commands, just keep the tunnel open"

### 2. Test the Proxy

On **Server B**, verify it works:

```bash
curl -x socks5://localhost:1080 https://ifconfig.me/ip
```

This should return Server A's public IP, not Server B's.

### 3. Route Docker Traffic Through the Proxy

The simplest approach—use host networking:

```bash
docker run --network=host curlimages/curl -x socks5://localhost:1080 https://ifconfig.me/ip
```

With `--network=host`, the container shares the host's network stack. It can reach `localhost:1080` directly.


### 4. Keep the Tunnel Running

The basic SSH command dies if the connection drops. Use `autossh` to auto-reconnect.

On **Server A**:

```bash
# Install autossh
sudo apt install autossh

# Run persistent tunnel
autossh -M 0 -f -N -R 1080 user@server-b \
  -o ServerAliveInterval=30 \
  -o ServerAliveCountMax=3
```

## Important Notes

**Not all apps respect ALL_PROXY.** Tools like `curl` and Python `requests` do. Many others don't. If your app ignores the proxy variable, you have an option to use `proxychains`.

## Summary

One SSH command gives you a working "reverse VPN" without installing any VPN software. Simple, encrypted, and effective.