Terminull

Tutorials

Terminull lets a coding agent run on your Mac or a VPS while you drive it from your phone — code, see the result, read the logs, and schedule the boring parts. Pick your role for a flow built around it.

Build, see, and ship your iOS app from your pocket. The agent runs on your Mac next to Xcode; Terminull streams the diffs, the running UI, and the logs into a chat on your phone — and can watch the App Store for you.

  1. Pair your Mac

    Install the menu-bar bridge and scan the pairing QR once. Your agents (Claude Code, Codex, Gemini, Cursor, and more) are detected automatically.

  2. Code with any agent

    Start a session, pick an agent, and describe the feature — type it or dictate it by voice, or attach a screenshot or design and ask the agent to match it. File changes and diffs stream into the chat as cards; switch agents or models mid-conversation without losing context.

  3. See the result, not just the code

    Ask the agent to run the app in the simulator — it drops screenshots and screen recordings straight into the chat bubble. Tap to zoom, scrub the video, confirm the UI is right before you ever open the laptop.

  4. Tail logs in chat

    Pipe xcrun simctl / device logs or your own bLog output into the session and reason over a crash inline — grep, ask "why", and have the agent patch it, all in the same thread.

  5. Schedule error alerting & stats

    Set a scheduled run that scans your crash dashboard each morning and pushes only when something regressed, plus a weekly digest of installs and active users. Quiet runs leave no trace.

  6. Schedule App Store events

    A script schedule polls App Store Connect on a cadence and stays silent until the review state moves — then pushes exactly what to do next: "In review → Approved 🎉 release it" or "Rejected — open Resolution Center."

Recipe · script schedule

App Store review watcher

A Script schedule (Type → Script in the editor), hourly, with Run visibility: Only notable runs. It notifies on a real status change and is silent the rest of the time — no LLM cost, no drawer clutter.

# exit 0 = notify (line 1 = push title) · exit 75 = nothing changed · other = error
state=$(cat $TERMINULL_STATE_DIR/last 2>/dev/null)
now=$(asc_review_state)                 # your ASC API call
if [ "$state" = "$now" ]; then exit 75; fi   # unchanged → silent
echo "$now" > $TERMINULL_STATE_DIR/last
echo "App review: $now"                 # → push title
echo "Next: release it, or open Resolution Center if rejected"
exit 0

Same loop, on the green robot. The agent drives Gradle and adb on your machine; you get the emulator screen and logcat on your phone.

  1. Pair & pick an agent

    Install the bridge, scan the QR, start a session with your agent of choice.

  2. Build with the agent

    Describe the change; watch Gradle output and file diffs stream into chat.

  3. See the emulator

    The agent captures adb screenshots and screen recordings of the running app and posts them inline — verify layout and flows without a screen share.

  4. Tail logcat in chat

    Stream adb logcat into the session, filter by tag, and have the agent trace a crash to the offending commit.

  5. Schedule crash & release alerts

    A quiet daily check on your crash reporting and a Play Console review/rollout watcher — pushed only when they change.

Ship the page and actually look at it. The agent runs your dev server and a headless browser on the host; the rendered page comes back to your phone.

  1. Pair & start coding

    Pair the bridge, then have the agent scaffold or edit components — diffs stream into chat.

  2. Preview the running site

    The agent boots the dev server and screenshots the page (or a Playwright flow) into the chat — responsive breakpoints included.

  3. Tail build & console logs

    Vite/webpack output and browser console errors flow into the session so you can debug a broken build from the couch.

  4. Schedule quality checks

    Nightly Lighthouse or uptime/synthetic checks that push only on a regression or an outage.

Drive the API from your thumb. The agent edits code, hits your endpoints, and shows you the responses and the server logs.

  1. Code with the agent

    Add an endpoint or fix a bug; review the diff as a card.

  2. Exercise it live

    The agent curls the endpoint (or runs your test suite) and posts the response + status inline — confirm the contract before merging.

  3. Tail server logs

    Stream app logs into chat and have the agent correlate a 500 with the request that caused it.

  4. Webhooks & scheduled checks

    Wire CI/deploy webhooks to a chat notification, and schedule synthetic health checks + DB backups that stay silent until something needs you.

Turn a $4 VPS into an agent you can text. Terminull runs headless on Linux, keeps your secrets encrypted, receives webhooks, and runs schedules — and you approve or redirect any of it from your phone.

  1. Rent a tiny VPS

    1 vCPU / 1 GB is plenty. One-line install, then pair with the QR the installer prints to the terminal — no GUI, no cable.

  2. Keep secrets encrypted

    Env keys live in ~/.config/terminull/.env and are used only in-process during a run. Every session is end-to-end encrypted between your phone and the box, so nothing sensitive rides the relay or lands in a plaintext log.

  3. Receive & control webhooks

    Ask the agent to create_webhook — you get a secret URL. Point GitHub, CI, or your monitoring at it: an inbound POST reaches your phone as an alert, or kicks off an agent run on the box. Revoke it any time.

  4. Run schedules on your box

    Cron-style script or agent schedules: nightly backups, cert renewals, log rotation, health checks. Only notable runs keeps them silent until one actually needs your attention.

  5. Automate from your pocket

    The agent runs commands on the VPS and streams output as cards; approve, redirect, or interrupt mid-run, and get a push when it finishes or hits a decision point.

Recipe · webhook → agent

Deploy on merge, reply on your phone

A GitHub push webhook triggers a run that pulls, builds, restarts the service, and pushes the result to you — with a script schedule as a safety-net health check afterward.

# GitHub webhook → your Terminull hook URL:
POST https://relay.terminull.dev/hook/<beacon>/<secret>
     { "title": "main pushed", "text": "deploy prod" }

# the agent, on the box:
git pull && docker compose up -d --build && curl -fsS localhost/health
# → push: "Deploy OK · health 200"  (or the error, if not)

Every flow runs on these

Whatever your role, the same capabilities are underneath.

🧩

Any agent, your pick

Claude Code, Codex, Gemini, Cursor, Goose, Copilot & more — choose per session, switch model or agent mid-chat.

🎙️

Talk to it

On-device voice dictation with live correction. Say “send it” to fire the message — hands-free while you're away from the desk.

🖼️

See, don't imagine

Screenshots, screen recordings and file previews land in the chat — and you can send a photo or design back with a question.

📜

Logs in the thread

Tail simulator, device, or server logs into the session and reason over a crash inline with the agent.

⏰

Schedules & digests

Recurring agent or script runs. Only notable runs stays silent until something matters, then pushes.

🪝

Webhooks

Hand CI, GitHub, or monitoring a secret URL that pings your phone — or kicks off an agent run.

🔒

Private by design

End-to-end encrypted. Titles and summaries run on-device, and a LAN-only mode talks to no cloud at all.

📶

Home Wi-Fi or anywhere

Direct LAN when you're on the same network, encrypted relay when you're out — it switches automatically.

📲

Live Activities

Watch multiple sessions' progress on the Lock Screen and get a push the moment a turn finishes.

💻

Works on a closed lid

The Mac stays awake to finish background and scheduled runs after you walk away, then goes back to sleep.

Ready to try it?

Install the bridge on your Mac or VPS, grab the app, and pair in under a minute.

Install the bridge Get the iOS app Read the docs