DEV Community

Cover image for I kept missing Claude Code's permission prompts, so I built a desktop around it
Fred 🍓
Fred 🍓

Posted on

I kept missing Claude Code's permission prompts, so I built a desktop around it

I usually have two or three Claude Code sessions open: a frontend, an API, sometimes a side project. And the most annoying thing wasn't the model or the cost. It was this:

One session finishes. Another one is working. And the third one has been sitting there for fifteen minutes, asking "Do you want to run npm test?" in a window I wasn't looking at.

So I built VibeDesk, a full-screen Windows desktop around the real Claude Code CLI.

The idea: one dot per session

Every session gets a short name in a dock and a colored dot:

  • green: Claude is working
  • yellow (pulsing): Claude is waiting for you
  • blue: done

That alone fixed most of my problem. I glance down, see a yellow dot, click it.

Permission prompts as cards

When Claude wants to run a command, VibeDesk shows a card with the command and four buttons: In terminal, Deny, Always, Allow. One click, and the session keeps going. No hunting for the right terminal.

The same card shows up on your phone if you pair it (6-digit code, local network by default). Your phone buzzes, you tap Allow from the kitchen.

A memory for each project

Claude Code forgets your project between sessions. VibeDesk gives every project a small "brain": Markdown notes with links between them (Obsidian-compatible) that Claude reads and writes through MCP. Decisions, pitfalls, conventions. New sessions start from there instead of exploring the whole repo again.

Claude can drive the desktop

VibeDesk also ships an MCP server for the desktop itself. In any session you can say "sort my windows", "zen mode on" or "tokyo scene with more rain", and Claude does it. It can even open your local dev server in the preview window after starting it.

How it's built

Electron, React, xterm.js with WebGL, node-pty. It doesn't replace or proxy anything: each terminal runs the normal claude command with your own Pro/Max plan or API key. MIT licensed, Windows 10/11, no telemetry.

And yes, most of the code was written by Claude Code itself, with me steering, testing and saying no a lot.

Try it

Windows SmartScreen will warn because the installer isn't signed yet ("More info" → "Run anyway").

VibeDesk 2.0 ships on November 1, and the most-upvoted wish on GitHub goes in. I'd love feedback from people who run several sessions in parallel: what would you want to see at a glance?

Top comments (17)

Collapse
 
autenai profile image
Auten •

Putting the permission card on the phone too is a nice touch. Most of my lost time is exactly that yellow-dot case.

To your question, from the Auten team (we build a computer-use MCP server, so our sessions click and type on the real screen): what I'd want at a glance is which session is currently driving the mouse and keyboard. Two sessions running a screen-control tool at once fight over focus, and a dot that says "this one holds the screen", plus a way to make the others wait, would save a lot of confusion.

A smaller one: how long each yellow dot has been waiting. Fifteen minutes vs fifteen seconds changes which one I click first.

Can the desktop MCP server see the other sessions' states, or only the windows and scenes?

Collapse
 
fxdgif profile image
Fred 🍓 •

Thanks, this is really useful.

Waiting time: you're right, the dot only shows the state right now, not how long it's been yellow. 15 s vs 15 min is exactly the difference that matters when three are waiting. I opened an issue for it: github.com/fxd-gif/vibedesk/issues/5 (a 👍 there moves it up the list).

Screen holder: VibeDesk sees every PreToolUse hook, so it knows when a session is calling a tool from a computer-use server. Marking "this one has the screen" and holding the others back until it's done sounds doable. I hadn't thought about two sessions fighting over the mouse, but it makes total sense for your setup.

MCP: in the current release (1.9) the desktop MCP only sees windows, layout and scenes. 2.0 comes out on Nov 1 and adds desk_sessions (every session with its state: working, waiting for you, done) and desk_session_send, so one session can hand a task to another one, e.g. "frontend is done, write the matching API in the backend".

Collapse
 
autenai profile image
Auten •

Thanks for opening the issue, and for the clear answer on the MCP side.

desk_session_send sounds like the interesting part. When frontend hands off to backend, does the receiving session get only the message text, or also something like the sender's last diff or a short state summary? That decides whether the backend session starts from context or from a cold prompt.

Thread Thread
 
fxdgif profile image
Fred 🍓 •

Right now it's only the message text. It lands in the other session exactly as if you had typed it, nothing else is attached.

To make that work, the tool description tells the sending Claude that the other session doesn't know its context and that it should write the task so it stands on its own (what changed, which files, what the API should look like). In practice Claude does that pretty well. The receiving session then reads the files itself, so it doesn't start completely cold, but it also doesn't get the sender's reasoning.

Attaching something like the sender's last diff or a short state summary is a good idea though. 2.0 also adds a wrap-up when a session finishes (summary + changed files), so handing that over together with the task would be the natural next step. I'll write it down.

Thread Thread
 
fxdgif profile image
Fred 🍓 •

Written down here, if you want to follow it: github.com/fxd-gif/vibedesk/issues/6

Thread Thread
 
autenai profile image
Auten •

Thanks, that makes sense: a self-contained task plus the receiving session reading the files itself already covers most of it. Pairing the 2.0 wrap-up (summary + changed files) with the handoff sounds like the right next step. Following issue 6.

Thread Thread
 
fxdgif profile image
Fred 🍓 •

Small update: issue 6 shipped today in 2.0. When one session hands another a task, the wrap-up from the sending session comes along now: Claude's short summary plus the changed files with line counts, so the receiving session knows what moved without re-reading everything. #5 (how long Claude has been waiting) made it in too. Details: dev.to/fxdgif/vibedesk-20-is-out-e... – thanks for pushing on this one.

Thread Thread
 
autenai profile image
Auten •

Nice, thanks for the update and the credit. The changed-files-with-line-counts part is the bit I'd have missed: it tells the receiving session where to look without dumping the diff into its context.

One question: when the sending session still has uncommitted edits at handoff, does the wrap-up flag them, or does the receiver just see them as normal working-tree changes?

Thread Thread
 
fxdgif profile image
Fred 🍓 •

Good question. Right now they aren't flagged as "uncommitted" explicitly. The file list is whatever the sender touched in its current turn, and the line counts come from git diff against HEAD, so a file that shows counts is in practice still uncommitted. If you commit through the wrap-up first, the turn is closed and only the summary goes along.

If both sessions work in the same folder, the receiver just sees those edits as normal working-tree changes. If the sender is in its own worktree, the handoff names that folder so the receiver can read the files there. An explicit "uncommitted" marker would be clearer though, so I've noted it for the next round.

Collapse
 
altair_alter profile image
Altair •

That "Do you want to run npm test?" sitting unseen for 15 minutes is exactly what pushed me to build something too: a Stream Deck where each key turns red when a session needs permission. Approving right from the card goes one step further than just pointing me at the window. Since you own the terminal, do you detect "waiting" from hooks or from the CLI output?

Collapse
 
fxdgif profile image
Fred 🍓 • • Edited

Hooks, not the output. I tried parsing the terminal first and it broke every time Claude Code changed its UI a little.

Every session VibeDesk starts gets its own settings file that sends all hook events (PermissionRequest, Notification, Stop, PreToolUse, ...) to a tiny forwarder. PermissionRequest is the useful one: the hook just stays open until you click Allow or Deny on the card (or on the phone), and the answer goes back as the hook result. Nothing has to "type y" into the terminal. Claude Code still shows its own prompt in the terminal while the hook waits, so you can answer in either place, and the card closes itself when the matching PostToolUse comes in.

A Stream Deck with red keys sounds great btw. Is it public somewhere? I'd love to see it.

Collapse
 
altair_alter profile image
Altair •

That's a clever use of PermissionRequest: holding the hook open and returning the decision means nothing has to type into the terminal. I hadn't thought of answering from the device itself. On a Stream Deck that could be a long-press to allow. It isn't public yet, since the code is still tangled with my own setup, but there's a write-up here: dev.to/altair_alter/which-session-... and a short video of it running (Japanese, but the keys speak for themselves): youtube.com/watch?v=m7cUQ3Owqv0

Thread Thread
 
fxdgif profile image
Fred 🍓 •

Sorry for the slow reply – and thanks for the video, the red keys are great even without the Japanese. A long-press to allow feels exactly right for a physical button: hard to hit by accident, no window needed.

In case it helps with your Stream Deck: the phone page in VibeDesk talks to a small local HTTP API on the PC with a paired device key, and the PermissionRequest hook just waits for whichever client answers first. A Stream Deck plugin could pair the same way. If you ever want to try that, open an issue and I'll write down the endpoints properly.

And if your setup gets public one day, I'd love to link it.

Thread Thread
 
altair_alter profile image
Altair •

No need to apologize — thanks for writing it out.

"Whichever client answers first" is the part I like most. The terminal, the phone and a physical key all become equal ways to answer the same question, instead of the key being a remote control for the terminal.

Mine stays simple for now: hooks color the keys, and I still answer in the terminal. That's enough for my setup, but your design is a good reference if I ever want more. Thanks again.

Thread Thread
 
fxdgif profile image
Fred 🍓 •

Keeping it simple makes sense: colored keys already solve the part where you don't notice a session is waiting, and that's most of the lost time. If you ever publish the Stream Deck setup, I'd like to see it. Thanks for the good back and forth!

Collapse
 
pang_claw profile image
pang •

A permission prompt in a window you aren't watching is a silent fifteen-minute stall.

Collapse
 
fxdgif profile image
Fred 🍓 •

Exactly, and the worst part is you don't even notice it. You come back, see it's still on step 2 and think the model is slow.

That's the one thing I wanted fixed first: a yellow dot on the card the moment a session waits, a small sound, and the same card on the phone so you can approve from the couch.