Is That Mac App Spying on You?A 5-Minute Audit Anyone Can Run

How I verified my clipboard manager like Maccy never phones home, using only built-in macOS commands and the exact AI prompt that automates the whole audit.

Maccy (Clipboard Manager)

Every week brings a new breach headline. And while we obsess over which cloud services got popped, most of us never ask a more personal question: what is the software on my own laptop doing with my data?

Clipboard managers are the perfect example. They see everything you copy be it passwords, API keys or that salary figure from your offer letter. If one of them silently synced to a server, then you’ll be famous.

Let’s take Maccy for example, a free, open-source (20k+ GitHub stars) clipboard manager that remembers hundreds of things you’ve copied, including text, images, and files, and lets you find any of them with fuzzy search and paste them in a couple of keystrokes (Shift+Cmd+C). It can pin your most-used snippets to the top and paste without formatting, all in a tiny menu-bar app that outclasses most paid alternatives.

But now the question comes, how to verify if Maccy (or any other open source mac app) is safe?

The good news: macOS gives you everything you need to answer this question yourself. No security background required. In this article I’ll audit Maccy, the popular open-source clipboard manager, and show you the exact commands so you can repeat the process on any app. At the end, there’s a copy-paste prompt that makes an AI agent like Claude Code do the entire audit for you.

The framework: five layers of trust

Marketing pages say “we respect your privacy.” Don’t argue with claims — verify layers:

1. Claims — what does the developer say? (Open source? No telemetry?)
2. Possible — what is the app allowed to do? (Entitlements, sandbox)
3. Happening — what is it actually doing right now? (Live network connections)
4. Stored — where does your data physically live? (Local file vs. nowhere visible)
5. Readable — who can read that data? (File permissions, disk encryption)

When all five layers agree, you can genuinely trust the conclusion. Let’s walk through them.

Layer 1: Check the claims

Before touching the terminal, spend two minutes on research:

• Is the app open source? Maccy is — MIT license, full code on GitHub with thousands of stars and years of public scrutiny.
• Is it on the Mac App Store? App Store distribution forces Apple’s sandbox and review.
• What does the site claim? Maccy’s says: everything stored locally, no telemetry, no accounts.

Claims noted. Now we verify them.

Layer 2: What is the app allowed to do?

This is the most powerful check most people have never heard of. First, confirm the app is what it says it is:

codesign -dv --verbose=2 /Applications/Maccy.app

This prints the code signature. You’re looking for:

• Authority=Developer ID Application: Alexey Rodionov — signed by the actual developer, not a random repackager
• Notarization Ticket=stapled — Apple scanned this exact binary for malware

If the signature is missing, ad-hoc, or from a developer name that doesn’t match the project, stop right there.

Now the star of the show, entitlements:

codesign -d --entitlements - /Applications/Maccy.app

Entitlements are capabilities enforced by the operating system, not promises made by the developer. Maccy’s output:

com.apple.security.app-sandbox = true
com.apple.security.files.user-selected.read-only = true

Two things jump out:

• The app is sandboxed — it lives in a container and can’t roam your disk.
• There is no com.apple.security.network.client entitlement.

That second point is huge. A sandboxed app without the network-client entitlement cannot make outgoing network connections. Not “promises not to” — cannot. macOS blocks the connection at the kernel level. Even if Maccy’s developer turned malicious tomorrow, this binary could not upload your clipboard anywhere.

This single command settles the “does it phone home?” question for any sandboxed app.

Layer 3: What is it actually doing right now?

Entitlements show what’s possible. Live inspection shows what’s happening:

# Is it running? Grab the process
pgrep -fl -i maccy

# Does it have any open network sockets?
lsof -i -n -P | grep -i maccy

For Maccy: the process is running, and lsof returns nothing. Zero connections. For non-sandboxed apps (where entitlements can't reassure you), this check matters even more — and if you want continuous monitoring, tools like LuLu (free, open source) will alert you on every new outbound connection.

Layer 4: Where does your data live?

If an app stores your data locally, you should be able to point at the file:

# Sandboxed apps keep data in a container
ls -la ~/Library/Containers/ | grep -i maccy

# List what's inside and how big it is
find ~/Library/Containers/org.p0deje.Maccy -type f
du -sh ~/Library/Containers/org.p0deje.Maccy

Maccy’s entire universe turns out to be one SQLite database:

~/Library/Containers/org.p0deje.Maccy/Data/Library/Application Support/Maccy/Storage.sqlite   (~28 MB)

Your whole clipboard history, in one local file you can inspect, back up, or delete. That’s exactly what “local-only” should look like. An app that claims local storage but has no visible data files deserves suspicion.

Layer 5: Who can read it?

# File permissions on the container
stat -f "%Sp %Su" ~/Library/Containers/org.p0deje.Maccy

# Is your disk encrypted at rest?
fdesetup status

Result: drwx------ abs — only my user account can read the folder — and FileVault is On, so the file is encrypted whenever the disk is at rest.

One honest caveat: the database itself is plain text while you’re logged in. Anything running as your user (or a Time Machine backup) includes your clipboard history. The fix is a habit, not a tool: clear history after copying anything sensitive, and keep the app’s “ignore confidential data” option on — well-behaved password managers mark copied passwords as concealed, and Maccy skips them automatically.

Bonus layer: audit the helpers

Even when a main app has no network access, bundled components can:

# What frameworks ship inside the bundle?
ls /Applications/Maccy.app/Contents/Frameworks/

# Sparkle (the common macOS auto-updater) bundles XPC services - check their entitlements too
codesign -d --entitlements - \
"/Applications/Maccy.app/Contents/Frameworks/Sparkle.framework/Versions/B/XPCServices/Downloader.xpc"

# Where do updates come from, and are auto-checks even on?
defaults read /Applications/Maccy.app/Contents/Info.plist SUFeedURL
defaults read org.p0deje.Maccy | grep -iE "SU|update|crash|analytic"

In Maccy’s case the only network-capable component is the standard Sparkle updater, its feed points at the developer’s GitHub repository, and on my machine automatic checks were disabled. The one “outbound connection” the app could ever make is fetching its own changelog.

The verdict on Maccy

All five layers agree. Maccy is exactly what it claims to be.

Let AI do this for you

If you use any AI agent in your terminal like Claude Code, or Claude Cowork on the desktop, you don’t have to remember any of this. Open it in any folder and paste the prompt below, swapping in the app you want to audit.

How to use: install Claude Code (npm install -g @anthropic-ai/claude-code), run claude in your terminal, paste the prompt. The agent will run the commands itself (asking your permission for each one — read-only commands are safe to approve), pull in web research about the app, and give you a verdict with evidence. In Claude Cowork, paste the same prompt into a new session.

I want a privacy and safety audit of the macOS app "<APP NAME>" installed on
this machine. I'm worried about my data leaving my laptop. Please verify with
evidence, not the developer's claims. Use only read-only commands — do not
modify, delete, or reconfigure anything.

1. RESEARCH: Search the web for what this app is, whether it's open source,
   who develops it, its privacy claims, and any known security incidents or
   CVEs.
2. IDENTITY: Find the app in /Applications and verify its code signature and
   notarization with codesign. Confirm the signing developer matches the real
   project author.
3. CAPABILITIES: Dump its entitlements with codesign. Tell me explicitly:
   is it sandboxed? Does it have the network-client entitlement? What file
   access does it have? Explain what each entitlement allows in plain English.
4. LIVE BEHAVIOR: Check if it's running (pgrep) and whether it has any open
   network connections (lsof -i). 
5. DATA STORAGE: Locate where it stores my data (~/Library/Containers or
   ~/Library/Application Support). List the files, their sizes, and their
   permissions. Confirm the data is in a local file I can see.
6. HELPERS: List bundled frameworks and XPC services and check their
   entitlements too (especially auto-updaters like Sparkle). Report the
   update feed URL and whether auto-update/telemetry/crash reporting is
   enabled in my actual configuration (defaults read).
7. ENCRYPTION: Check whether FileVault is on (fdesetup status).
Finish with:
- A verdict: is my data staying on this laptop? Cite the specific evidence
  for each layer (claims → possible → happening → stored → readable).
- Any caveats or residual risks, honestly stated.
- 2-3 concrete recommendations (settings to change, habits to adopt).

The five-layer framework is the part worth internalizing; the agent handles the syntax.

Closing thought

You can’t audit ServiceNow. You can’t audit your bank’s backend. But the software running on your own Mac, holding your most sensitive day-to-day data? That you can audit in five minutes, with tools Apple already gave you.

The next time an app asks for your trust, don’t read its privacy policy. Read its entitlements.

Commands tested on macOS Sequoia and later. Maccy findings are from a December 2024 build (v0.x, Developer ID: Alexey Rodionov); always re-verify on your own installation — that’s the whole point.