DEV Community: Sergio Farfan Cardenete

NoSleep: Prevent your Mac to go sleep. Period.

Sergio Farfan Cardenete — Sun, 22 Mar 2026 05:09:02 +0000

Have you ever been mid-presentation, watching a long build compile, or waiting for a large file to download — only for your Mac to decide it's nap time? macOS ships a built-in tool for exactly this: caffeinate. But running it from the terminal every time is clunky.

So I built NoSleep — a tiny macOS menu bar utility that wraps caffeinate in a one-click toggle. No Dock icon. No main window. Just a cup icon in your menu bar.

Features

One-click toggle — start/stop caffeinate from the menu bar
Duration presets — 15 min, 30 min, 1 hr, 2 hr, 4 hr, 8 hr, 10 hr, or Indefinite
Live countdown — shows remaining time while active (e.g. 2h 34m)
Start at Login — optional LaunchAgent so it auto-starts on boot
Prevents display + idle sleep — uses caffeinate -d -i

The Stack

Swift 6.0 with strict concurrency
SwiftUI + MenuBarExtra (macOS 13+)
Swift Package Manager — no Xcode project file required
Minimum target: macOS 14 (Sonoma)

App Entry Point: MenuBarExtra

The entire app lives in the menu bar, which SwiftUI makes surprisingly clean with MenuBarExtra:

@main
struct NoSleepApp: App {
    @StateObject private var caffeinateManager = CaffeinateManager()
    @StateObject private var loginManager = LoginItemManager()

    var body: some Scene {
        MenuBarExtra {
            MenuBarView(manager: caffeinateManager, loginManager: loginManager)
        } label: {
            Image(systemName: caffeinateManager.isActive
                  ? "cup.and.saucer.fill"
                  : "cup.and.saucer")
        }
    }
}

That's the whole entry point. MenuBarExtra handles all the menu bar plumbing — no NSStatusItem, no AppKit boilerplate. The icon toggles between a filled and outlined cup based on whether caffeinate is running.

Setting LSUIElement: true in Info.plist hides the Dock icon and removes the main window entirely.

Core Logic: CaffeinateManager

The heart of the app is CaffeinateManager — an @MainActor ObservableObject that manages the caffeinate child process and a countdown timer.

Spawning the Process

func start() {
    stop()

    let proc = Process()
    proc.executableURL = URL(fileURLWithPath: "/usr/bin/caffeinate")

    var args = ["-d", "-i"]
    if selectedDuration != .indefinite {
        args += ["-t", "\(selectedDuration.rawValue)"]
        remainingSeconds = selectedDuration.rawValue
    }
    proc.arguments = args

    proc.terminationHandler = { [weak self] _ in
        Task { @MainActor [weak self] in
            self?.handleTermination()
        }
    }

    try? proc.run()
    process = proc
    isActive = true

    if selectedDuration != .indefinite {
        timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
            Task { @MainActor [weak self] in
                self?.tick()
            }
        }
    }
}

A few things worth noting:

-d -i flags — -d prevents the display from sleeping, -i prevents idle sleep. Together they cover the common use cases.

-t <seconds> — when a duration is selected, caffeinate self-terminates after that many seconds. The app also runs a Timer in parallel to track remaining time for the UI.

terminationHandler — if caffeinate exits on its own (duration expired, or the system killed it), this handler fires and cleans up app state. The Task { @MainActor in ... } pattern bridges from the background callback thread into the main actor, which Swift 6 strict concurrency requires.

Duration Options

Durations are a typed enum with raw values in seconds:

enum SleepDuration: Int, CaseIterable, Identifiable, Sendable {
    case fifteenMin = 900
    case thirtyMin  = 1800
    case oneHour    = 3600
    case twoHours   = 7200
    case fourHours  = 14400
    case eightHours = 28800
    case tenHours   = 36000
    case indefinite = 0
}

The selected duration is persisted in UserDefaults so the preference survives app restarts.

Login Item: LaunchAgent Plist

Rather than using SMAppService (which requires a sandboxed app), NoSleep writes a LaunchAgent plist directly to ~/Library/LaunchAgents/:

<?xml version="1.0" encoding="UTF-8"?>
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.nosleep.app</string>
    <key>ProgramArguments</key>
    <array>
        <string>/Users/you/Applications/NoSleep.app/Contents/MacOS/NoSleep</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
</dict>
</plist>

This approach works without sandboxing and gives full control over the plist.

Build & Install

The project uses Swift Package Manager — no .xcodeproj needed.

# Build (compiles, bundles, ad-hoc code signs)
./build.sh

# Run
open NoSleep.app

# Install to ~/Applications (optional)
./install.sh

Requirements: Swift 6.0+, Xcode Command Line Tools, macOS 14+.

Source Code

NoSleep is open source under the GPLv3.

GitHub: github.com/sergio-farfan/nosleep

Contributions, issues, and stars are all welcome. If you run into any macOS quirks with caffeinate or MenuBarExtra, feel free to open an issue.

Built with Swift 6 and SwiftUI on macOS Sonoma.

I Built a Windows-Style Alt+Tab Window Switcher for macOS in Pure Swift

Sergio Farfan Cardenete — Sun, 22 Mar 2026 04:16:11 +0000

One of my biggest frustrations after spending years on Windows was losing a proper window switcher when I moved to macOS. Cmd-Tab switches between applications, not windows. If you have four Terminal windows open, you cannot directly jump to a specific one — you have to Cmd-Tab to Terminal, then use Cmd-` to cycle through its windows. It is a two-step dance every single time.

So I built AltTab — a lightweight, zero-dependency macOS utility that brings back the Windows Alt-Tab experience using Option-Tab.

What It Does

Hold Option and tap Tab — a panel appears showing thumbnails of every open window across all your apps. Cycle through them with Tab / Shift-Tab or the arrow keys, then release Option to jump straight to the selected window. Click any thumbnail to switch instantly.

Shortcut	Action
`Option-Tab`	Open switcher / next window
`Tab`	Cycle forward
`Shift-Tab`	Cycle backward
`← / →`	Navigate left / right
`Escape`	Cancel
`Enter`	Confirm and switch
Click	Select and switch immediately

Minimized windows are included and will automatically unminimize when selected. No Dock icon, no clutter — just a clean menu bar icon.

Installation

Requirements: macOS 13 Ventura or later · Full Xcode installation

One-liner install

git clone https://github.com/sergio-farfan/alttab-macos.git && cd alttab-macos && ./build.sh install && open ~/Applications/AltTab.app

Then open System Settings → Privacy & Security → Accessibility and grant permission to AltTab. That is all — press Option-Tab and it just works.

Build options

./build.sh build          # Build Release binary only
./build.sh install        # Build and install to ~/Applications
./build.sh install --system  # Build and install to /Applications (requires sudo)
./build.sh run            # Build and launch immediately
./build.sh uninstall      # Remove the installed app

Permissions

Accessibility (required) — needed to intercept the Option-Tab hotkey and raise windows
Screen Recording (optional) — enables live window thumbnails; gracefully falls back to app icons if denied

How It Works

Global hotkey interception — A CGEvent tap installed at the session level intercepts Option-Tab system-wide before it reaches any app, without stealing keyboard focus.

Complete window discovery — On-screen windows come from CGWindowList. Minimized windows require a separate AXUIElement query per app — no single API covers both. Results are deduplicated and merged.

MRU ordering — Windows are sorted most-recently-used first. App-level focus is tracked via NSWorkspace notifications; intra-app window switches (like Cmd-`) are caught by per-app AXObserver callbacks.

Non-activating overlay — The switcher is an NSPanel with .nonactivatingPanel, so it appears on screen without stealing focus. Releasing Option activates the target window, not AltTab.

Live thumbnails — macOS 14+ uses ScreenCaptureKit for async, high-quality captures. macOS 13 falls back to CGWindowListCreateImage. If Screen Recording permission is denied, app icons are shown instead — no crash, no prompt.

Project Stats

~2,000 lines of Swift across 9 source files
Zero external dependencies — pure Swift + AppKit
MIT licensed — fork it, modify it, ship it
macOS 13+ (Ventura, Sonoma, Sequoia)

Try It Out

The code is on GitHub: github.com/sergio-farfan/alttab-macos

If you have been frustrated by macOS window switching, give it a try. And if you are curious about the low-level macOS APIs — CGEvent taps, AXUIElement, ScreenCaptureKit — the codebase is small enough to read in an afternoon.

Feedback, issues, and PRs are welcome!

Generate OCI Architecture Diagrams from Terraform with One Claude Code Command

Sergio Farfan Cardenete — Tue, 17 Mar 2026 01:16:57 +0000

The problem

Manually drawing OCI diagrams in draw.io is tedious...
If you have ever had to document an OCI architecture, the process is familiar. You open draw.io, locate the correct Oracle icon set, drag shapes onto the canvas, manually wire up VCNs and subnets, nudge elements into alignment — then spend another 30 minutes reconciling colors against Oracle's official template, only to discover that the Terraform configuration changed the previous week and the diagram is already out of date.

For cloud architects working with OCI, this is a recurring overhead on every project:

Diagrams drift from reality

Terraform is the source of truth, but draw.io has no awareness of it. Every infrastructure change requires a manual diagram update — one that typically does not occur until someone requests it during a review.

The OCI icon set is not native to draw.io

It must be located, imported, and mapped to the correct services across 15 categories and 220+ icons — a non-trivial exercise before any actual diagramming begins.

Layout is time-consuming

Correctly representing the Region → VCN → Subnet → Service hierarchy, with proper spacing, non-overlapping containers, and Oracle's color scheme, requires significant effort even for experienced practitioners.

Hub-and-spoke topologies are especially difficult

Arranging 10–15 spoke VCNs connected through a DRG in a clean, readable layout is an hour-long exercise in manual positioning.

Diagrams are created once and abandoned

Because updates are costly, teams stop maintaining them. By the time a new team member onboards or an audit is conducted, the diagram reflects an architecture from two sprints prior.

The root cause is that architecture diagrams are treated as design artifacts — something produced manually — rather than something derived directly from the infrastructure definition.

What I built

https://github.com/sergio-farfan/OCI-draw.io-Architect

A Claude Code plugin — type /drawio-architect in any project...

How it works

The plugin accepts three input types: a Terraform directory path — parsed to extract VCNs, subnets, gateways, and DRG attachments — a VCN name resolved against existing .tfvars files, or a plain-text description of the target architecture.

From any of these inputs, it computes a pixel-precise grid layout, calculating container bounding boxes to eliminate element overlap, and generates a Python script leveraging a custom DrawioBuilder class backed by 220 bundled OCI SVG icons. Executing the script produces a .drawio file fully styled with Oracle's official color palette.

The entire workflow is invoked within Claude Code via a single /drawio-architect command.

Step by Step Installation

Prerequisites

Claude Code (CLI) installed and working
Python 3.8+
draw.io desktop for viewing generated .drawio files

The plugin bundles 220 OCI SVG icons and auto-installs Pillow (Python imaging library) if missing.

Installation

Step 1 - Download, Extract and Install

One command:

curl -fsSL https://github.com/sergio-farfan/OCI-draw.io-Architect/releases/download/v1.0.0/oci-drawio-architect-v1.0.0.tar.gz | tar -xz && ./oci-drawio-architect/install.sh

This will:

Download, extract and execute the Installer script
Check prerequisites (Python 3, Pillow)
Install Pillow automatically if missing
Create a local marketplace at ~/.claude/plugins/marketplaces/local/
Copy the plugin files into the marketplace
Verify all components (5 checks)

Step 2 - Register in Claude Code

Open Claude Code and run these two commands:

/plugin marketplace add ~/.claude/plugins/marketplaces/local
/plugin install oci-drawio-architect@local

Exit Claude Code and reopen it for the plugin to load.

Step 3 - Verify

Run inside Claude Code:

/drawio-architect

The command should prompt you for what to diagram.

Example Snippet: