Skip to content
Skills Library
Programming · Building & coding

localhost-dashboard-serving

/localhost-dashboard-serving

Use when serving agent data as a phone-accessible page.

Licence
MIT
Last repository change
01.11.2026

Assessment and security

96/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability21 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
30
Scripts
11
HTML comments
0
URLs in SKILL.md
5
Deprecation

No signals detected. Repository changed on 01.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 11 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/dashboard_card_shot_probe.py, scripts/dashboard_content_probe.py, scripts/dashboard_visual_audit.py, scripts/gen_pwa_icons.py, scripts/mobile_probe.py, scripts/mobile_probe_row.py, scripts/nav_tap_probe.py, scripts/sw_navigation_probe.py, templates/localhost_dashboard_server.py, templates/pwa_service_worker.js, templates/service_keeper.sh

What it does and when to use it

Use when serving agent data as a phone-accessible page.

Original author description

Use when serving agent data as a phone-accessible page.

How it works

  1. When to Use
  2. Architecture (4 parts, all cheap)
  3. Keeper + cron: the no-notification-spam pattern
  4. Verify before reporting (all three layers)
  5. Making it actually look good on a phone (and proving it)
  6. Pitfalls
  7. References
Original SKILL.md headings · 294 lines, 3,446 words
SKILL.md preview
---
name: localhost-dashboard-serving
description: Use when serving agent data as a phone-accessible page.
version: 1.0.0
author: Hermes Agent
license: MIT
metadata:
  hermes:
    tags: [dashboard, localhost, cloudflared, tunnel, watchdog, web-ui, mobile]
    related_skills: [third-party-monitor-cloning, hermes-cron-automation, webhook-receivers, cron-output-style]
---

# Serving agent data as a localhost dashboard (and getting it onto the user's phone)

## When to Use

Load when the user asks to *see* something the agent already computes, instead of only getting
Telegram messages: "bikin webnya", "atau localhost yg bisa gw akses kyk gitu", "bikin dashboard
dong", "gw mau liat sendiri", "bisa dibuka dari HP ga", or names a product ("zemiztracker") for
such a page.

Typical trigger chain: a CLI tool/monitor was just built (see `third-party-monitor-cloning`) and the
next ask is always "bisa gw akses sendiri nggak?". Answer: **stdlib HTTP server on 127.0.0.1 +
cloudflared quick tunnel + a keeper cron**. No dependencies, no account, no inbound port.

Deliver it BRANDED (title, `/<name>` route, favicon, mobile-app meta) — the user treats this as a
product of theirs, not a debug view. Terse one-word messages like "zemiztracker" mean *name it that*.

## Architecture (4 parts, all cheap)

1. **Server** — Python stdlib `ThreadingHTTPServer`, bound to `127.0.0.1` only (never `0.0.0.0`;
   the tunnel is the only public path). Routes: `/` plus `/<name>` (same page), `/api/<data>` (JSON),
   `/api/refresh` (force), `/healthz`. See `templates/localhost_dashboard_server.py`.
2. **Cache + history** — a daemon thread refreshes the upstream data every `TTL` (60 s) into memory;
   requests never hit the upstream API. Append one JSONL row per refresh (`~/.hermes/data/<tool>_history.jsonl`,
   trimmed to a few hundred lines) so the page can draw a real trend chart instead of a single number.
   Reuse the CLI tool's own functions by loading it with `importlib.util.spec_from_file_location`.
3. **Page** — one self-contained HTML file next to the server (no CDN, no build step, inline CSS/JS),
   rendered client-side from the JSON API with a `fetch` refresh loop. Dark theme, tabular numbers,
   `@media(max-width:620px)` for phone. Put a brand in `<title>` + `<h1>`, an inline data-URI SVG
   favicon, and `theme-color` + `apple-mobile-web-app-*` so "Add to Home Screen" looks like an app.
4. **Exposure + keeper** — `cloudflared tunnel --url http://localhost:<port>` (quick tunnel, no
   account) and `templates/service_keeper.sh` running from a `no_agent` cron every 5–10 min that
   restarts the server/tunnel if dead and **prints the URL only when it changed**.

## Keeper + cron: the no-notification-spam pattern

Quick-tunnel URLs rotate on every restart, so never hand the user a bare URL without a way to learn
the new one. The keeper script is idempotent and does three things:

```bash
curl -sf -m 5 "http://127.0.0.1:$PORT/healthz" >/dev/null || restart_server   # pkill + setsid nohup
pgrep -f "cloudflared tunnel --url http://localhost:$PORT" >/dev/null || restart_tunnel
URL=$(grep -ho 'https://[a-z0-9-]*\.trycloudflare\.com' "$TUN_LOG" | tail -1)
# write URL to data/<tool>_url.txt; print the message ONLY if it differs from the *_seen.txt copy
```

The `pgrep` line proves a process exists, not that the tunnel works. cloudflared can sit in a
reconnect loop (`ERR failed to serve tunnel connection … Retrying connection in up to 1m4s`) with the
URL already dead, and a pgrep-only keeper stays silent for hours. Gate on the public URL too:
`curl -s -o /dev/null -w '%{http_code}' -m 15 "$URL<route>"`; on a non-200 kill the tunnel and
restart it, accepting the URL rotation rather than keeping a link that 404s.

Register it as `no_agent=true`, `deliver=origin`, `script=<keeper>.sh`: empty stdout = no message, so
the cron is silent on the happy path and only pings the user when the link actually changes. That is
the same delta-only rule as the alert lanes (`cron-output-style`, `hermes-cron-automation`). A second
`no_agent` job runs the data scanner itself on its own cadence.

Restart durability: the detached child must be started **inside the script file** with
`setsid nohup ... >>log 2>&1 </dev/null &`. Do that from the script, not from an agent terminal call.
On hosts where `systemctl --user` fails with "Failed to connect to bus: No medium found" (Hermes
gateway as a system service), script + cron keeper IS the supervisor — don't fight systemd.

**After a host reboot/upgrade, bring lanes back one script per call.** Each keeper script starts a
server *and* a tunnel and waits ~20 s for health, so a loop over four of them blows past the 420 s
tool timeout and you lose which lane failed. Run `timeout 70 bash <script>.sh` per call, then verify
the layer that matters: every port 200 locally **and** every saved tunnel URL 200 publicly. Cron jobs
that logged an error during the boot window (`exit -15`) are not broken jobs — the gateway was still
starting; they reschedule themselves, and the only follow-up needed is re-running a data job whose
slot was missed. Quick tunnels rotate on reboot, so any external webhook pointed at the old hostname is
silently dead: hand the new URL over in the same reply.

## Verify before reporting (all three layers)

1. **Local**: `curl -s -o /dev/null -w '%{http_code}'` on `/`, `/<name>`, `/api/<data>`, `/healthz`.
2. **Public**: repeat the same curls against the tunnel URL and assert the real payload — a 200 with
   `size_download` near the file size, and `grep -o '<title>[^<]*</title>'` matching the brand.
3. **Layout in a REAL browser** (best signal — do this whenever the ask is about looks/mobile).
   A Playwright chromium build already exists on this host: binary
   `$HOME/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome` (no `chromium`/`google-chrome`
   on PATH, but this works). Install the driver once into a throwaway venv:
   `~/.hermes/bin/uv venv /tmp/pwenv && ~/.hermes/bin/uv pip install --python /tmp/pwenv/bin/python playwright`
   then `p.chromium.launch(executable_path=<that path>, args=["--no-sandbox","--disable-dev-shm-usage"])`.
   Screenshot at the phone viewport (`viewport={"width":390,"height":844}, device_scale_factor=2,
   is_mobile=True, has_touch=True`, `full_page=True`) and then READ THE IMAGE with `vision_analyze`
   — your model can't see pixels directly, but the vision tool can.
   Measure numerically too, in the same pass: `document.documentElement.scrollWidth` vs `clientWidth`
   (equal = no sideways scroll) and every element whose `getBoundingClientRect().right > vw` (the
   overflow offenders), plus per-row heights of `tr.row`. Copy `scripts/mobile_probe.py` and
   `scripts/mobile_probe_row.py` from this skill.
   Fallback when no browser: run the inline JS under `node` with a DOM stub and print the rendered
   fields (`references/localhost-dashboard-serving.md` has the harness).
   `node --check` on the extracted inline `<script>` is the cheap syntax gate — always run it first.
Then compare the numbers shown against the source dataset one last time — the page is a view, so a
data-parity check is still required.

## Making it actually look good on a phone (and proving it)

Tables are the #1 mobile breakage: a 6-column table with `white-space:nowrap` chips forces its
min-content width past the card, so the WHOLE page scrolls sideways and columns squash/wrap. The fix
that worked (ZemizTracker, 390px): keep the `<table>` markup on desktop and turn each row into a
**grid card** under `@media(max-width:620px)` — never a horizontal scroller.

```css
@media(max-width:620px){
  html,body{overflow-x:hidden;-webkit-text-size-adjust:100%}
  *{-webkit-tap-highlight-color:transparent}
  .hidesm{display:none!important}          /* columns dropped on phone */
  .onlysm{display:inline!important}        /* bits that exist ONLY on phone */
  table,thead,tbody,tr,td{display:block}   /* kill the table box */
  thead{display:none}
  tr.row{display:grid;grid-template-columns:auto 1fr auto auto;
    grid-template-areas:"coin coin coin coin" "px chg net del";gap:5px 10px;padding:10px 12px}
  tr.row td{display:block;border:0;padding:0;text-align:left!important}
  .tw tr.row td:nth-child(1){grid-area:coin}  /* …map each td to an area by nth-child */
  }
```

Rules of thumb that came out of it:
- Map cells to grid areas by `nth-child`; the headers are hidden, so re-add micro-labels with a
  phone-only `<span class="onlysm nl">net </span>` inside the cell.
- Duplicate info you want in two places (e.g. the long/short chips) rather than trying to overlay
  cells — one copy gets `class="onlysm"`, the other stays inside a `class="hidesm"` cell.
- Chips/`white-space:nowrap` are what blow up min-content width. Give them the full row width by
  spanning their cell across all columns; if they must fit a narrow cell, count the pixels first
  (measure `getBoundingClientRect().width` of every chip) instead of guessing.
- Aim for ≤3 lines and ~85px per row (from 138px when it was wrapping), ≤60px on desktop.
- Sticky tab bar (`position:sticky;top:0`) so switching tabs doesn't need a scroll back up; equal
  `flex:1 1 0` on the tabs so they fill the width; `#input{font-size:16px}` so iOS doesn't auto-zoom.
- Header: one line only — shorten badge text with `<span class="hidesm">` (e.g. `54 wallet<span
  class="hidesm"> Hyperliquid</span>`), icon-only refresh button whose label span also carries
  `hidesm`. Watch out: click handlers that rewrite `textContent` must restore the `hidesm` span
  (`b.innerHTML='↻<span class="hidesm"> Refresh</span>'`) and use `event.target.closest('button')`.
- Flat trend charts: if `max-min < 0.2`, draw a **dashed line at mid-height** and label it "stabil"
  instead of a scaled polygon — otherwise the 0-range case renders a fake curve.
- Always screenshot BEFORE and AFTER, stitch them side by side with PIL, and send the image to the
  user (Telegram `MEDIA:` path) — the visual diff is the proof, not prose.

## Pitfalls

- **Wallet/flow graphs: aggregate edges or you ship spaghetti.** 1,000+ raw transfers between ~80
  nodes render as an unreadable bundle (vision-check confirms "spageti"). Three cheap fixes, in order:
  (1) aggregate every `src→dst` pair into one line — sum USD, count `n`, label `$1,2jt ×7`;
  (2) cap what you draw (`sort by usd` → top ~55 pairs; keep the funding-chain `hop-src` links
  unconditionally, dashed) instead of drawing everything above a floor;
  (3) put the floor in the COLLECTOR, not the view, so the JSONL stays clean
  (USDC < ~$1K and HL transfers < ~$10K are dust — token spam like a $500M memecoin to `0x0` also
  has to be filtered by token allow-list).
  Draw edges before nodes (nodes then mask lines crossing them) and give same-lane edges a routed
  bezier so they don't loop through the node boxes.
- **Layered graphs: wrap each depth into lanes.** One column per hop-depth explodes vertically when a
  depth holds 29 nodes (~2,200 px tall inside a horizontal scroller = nested-scroll misery on a phone).
  Chunk each depth into lanes of ~12 (`for(i=0;i<col.length;i+=12) lanes.push(col.slice(i,i+12))`) and
  lay lanes left→right — height caps at ~800 px and the wide scroller stays usable.
- **Trackers adopt `0x000…0` as a "wallet".** A bridge/withdraw destination of the zero address gets
  added like any fresh wallet, and its on-chain "spot" balances are junk (billions of dust tokens).
  Keep an `IGNORE_ADDRS` set in the collector, delete it from state, and remap the zero address to a
  named `jembatan`/bridge node in the view so inflow/outflow still shows.
- **`/healthz` must never build the payload, and must not take the build lock.** In the Zemiz Chain
  board the probe called `payload()`, which rebuilt an 8.7 MB / 7 s payload on a cold cache while
  holding `_lock`; the keeper's `curl -m 5` timed out, killed a healthy server, the restart reset the
  cache, and the loop ran 3,500+ times (visible as a log full of "server jalan di :PORT"). Liveness =
  read two globals and answer in microseconds; data builds belong on `/api/*` or a refresh thread.
- **A TTL cache that rebuilds on the request path stalls every first hit.** A 60 s cache means the
  first request after idle pays the whole build (5 s through a quick tunnel vs 0,3 s warm), which the
  user reports as "lambat/rusak", not as "cold cache". Serve the stale payload and rebuild behind it;
  take the lock only to read the cache and set a `_building` flag, never while `build()` runs:

```python
with _lock:
    d = _cache
    fresh = d is not None and time.time() - _cache_at < 60
    kick = (not fresh) and (not _building)
    if kick:
        _building = True
if fresh:
    return d
if d is not None:
    if kick:
        threading.Thread(target=_rebuild, daemon=True).start()
    return d          # stale now, refreshed seconds later
_rebuild()            # cold start only, when no payload exists yet
return _cache
```

  `_rebuild()` assigns `_cache` / `_cache_at` and clears `_building` in a `finally`, so a failed build
  cannot wedge the flag and leave every request waiting on a cache that never arrives.
- **Unbounded edge logs turn a graph page into a timeout.** 1.05M raw transfer rows made `/api/chain`
  never answer (>2 min) and the JSON 226 MB, because (a) `any(a == e["dst"] for e in edges)` inside a
  per-node comprehension is O(nodes x edges) — precompute `dst_seen = {e["dst"] for e in edges}` — and
  (b) the page aggregates by `src>dst` anyway. Aggregate server-side into one row per pair (`usd` sum,
  `n` count), keep the raw total for the headline stat: 226 MB → 5 MB, 869 KB gzipped, 145 ms.
- **A dedupe function that is never called is not a dedupe.** `insider_chain_build.py` had `prune()`
  and `--prune`, but the refresh path only appended, so 54% of the JSONL was duplicate rows and the
  file grew every 6 h. Call `prune()` at the end of the refresh run (it rewrites the file, ~17 s for
  420 MB → 191 MB) and verify with `wc -l` plus a unique-key count.
- **A silent refresh job hides its own failures.** `no_agent` + empty stdout = no message, so a
  crashed data-builder looks identical to a quiet tick. Capture the child's exit code in the `.sh`
  wrapper and print one line on non-zero — with `deliver=local` for data jobs, so the error lands in
  the local cron output instead of spamming the chat.
- **A service worker registered by ONE page can hijack EVERY page on the origin.** A risk dashboard's
  SW matched `req.mode === 'navigate'` (all navigations) and cached every fetched HTML under the key
  `/risk`; opening the tracker at `/` then showed the cached RISK page, and `/risk`'s cache got
  overwritten with the tracker's HTML. The symptom the user reports is "error / blank" that you CANNOT
  reproduce with curl (server returns 200 every time) because it only happens in the browser holding
  the SW. FIX: scope the fetch handler to the SW's own paths (`if (!RISK_PATHS.includes(pathname)) return;`),
  cache under the requested path, bump the cache name so the old cache is dropped on activate, and serve
  the SW with a short `Cache-Control` (max-age=300) so phones pick the fix up fast. Prove it with the
  offline trick: `ctx.set_offline(True)` then navigate to the OTHER page — with the bug it serves the
  wrong cached page, with the fix it fails normally.
- **Cross-link every page of a multi-page app.** The tracker had no visible link to `/risk` and the risk
  page none back — on a phone that reads as "the link doesn't exist". Add the counterpart link in both
  headers and click-test the round trip.
- **Dict-valued API fields print as `[object Object]`.** If the payload returns `age`/`ttl` as a
  per-section dict, format it (`Object.entries(age).map(([k,v])=>k+' '+Math.round(v)+'s').join(' · ')`)
  instead of concatenating it into a string.
- **Layout: phone cards, desktop 2 columns.** A horizontal table scroller is the #1 mobile breakage —
  render each row as a card (date + total on line 1, per-item chips below). Wrap cards in a `.cards`
  container and switch to `grid-template-columns:1fr 1fr` at `min-width:900px` with the hero card
  `grid-column:1/-1`; a 760px-max single column on a 1280px screen reads as unpolished. Cap chip lists
  (top 6 by absolute value + a `lainnya` residual) so a busy day doesn't wrap to three lines.
- **Label/value pairs must not split across lines on mobile** — wrap each pair in a `white-space:nowrap`
  span, or the label ends one line and its number starts the next.
- **Read the page from disk per request.** Serve the HTML with `open(path).read()` inside `do_GET` (not
  a module-level constant) so you can iterate on the UI without restarting the server each time.
- **The keeper silently stops working after its first restart — flock fd inheritance.** If step 0 does
  `exec 9>lock; flock -n 9` and then launches the server/tunnel with `setsid nohup … &`, the children
  **inherit fd 9** and hold the lock for their whole lifetime. Every later run exits at
  `flock -n 9 || exit 0`, so the keeper can never restart anything again — and never announces a URL
  change (the run that would print it exits first). Symptom: the URL file is stale, the user's saved
  link 404s, and the cron output files all say "silent (empty output)". Diagnose with
  `fuser -v <lockfile>` — if the *server*/*tunnel* PIDs show up, this is it. Fix: close the fd for the
  children — `… >>"$LOG" 2>&1 </dev/null 9>&- &` on both launches (clearing it needs one restart of
  those children, which rotates a quick-tunnel URL). Verify after: `fuser -v <lockfile>` empty, then
  run the keeper twice → second run must be silent.
- **Two keepers sharing one seen-file = the user never gets the new URL.** If a `@reboot`/system
  crontab entry runs the same script with stdout appended to a *log*, it consumes the URL-change and
  writes the seen-file; the Hermes cron run (the one with `deliver=origin`) then sees nothing new and
  stays silent. Give the log-only caller its own watermark via an env override
  (`WHALE_BOARD_SEEN_FILE=…seen.sys.txt`, i.e. make `SEEN_FILE="${VAR:-default}"` in the script) so
  the Telegram-facing keeper stays the one that announces.
- **`pkill -f <script>.py` from an agent terminal call kills your own shell** — the pattern matches
  the shell's own command line (exit `-15`, no output). The bracket trick (`pkill -f "[w]hale_.."`)
  only protects you when that literal text appears NOWHERE else in the command you send: inside a
  heredoc or `python -c` payload that mentions the path (`trade/server.py`), the regex matches your own
  shell and kills the very server you were restarting. The same trap applies to daemons matched by full
  command line (`pkill -f "cloudflared tunnel --url http://localhost:8787"` kills the shell that runs
  it). Safest: keep the pkill inside the keeper script
  file and run it as a script, or resolve the PID from the port and kill that:
  `PID=$(ss -ltnpH "sport = :8790" | grep -oP 'pid=\K[0-9]+' | head -1); kill "$PID"` — the command
  line then never contains the daemon's name at all. Confirm with `pgrep -af "[w]..."`.
- **A live tunnel process can serve a dead URL.** Process-existence keepers report healthy while the
  quick tunnel is stuck reconnecting: `pgrep` matches, the URL file is stale, and every `curl` to the
  old host fails. Diagnose from the tunnel log's tail (`ERR failed to serve tunnel connection`,
  `Retrying connection in up to 1m4s`) and from a real request to the public URL — not from `ps`.
  Kill by PID (`pgrep -af cloudflared` → `kill <pid>`) and rerun the keeper; the URL changes, so hand
  the new one over in the same reply.
- **Long inline shell payloads get hardline-blocked** (parser limit, saved to
  `~/.hermes/cache/blocked-scripts/`). Split into small calls or write a `.sh` file and run that.
- **`patch` in V4A mode can append a duplicated line instead of replacing it** when the context guess
  is loose, and the file then fails with `IndentationError`. Always read back (`read_file` around the
  region) or rely on the tool's own lint result, then fix with `mode=replace` on a unique anchor.
- **Dense snapshots eat the chart window.** A monitor that appends a history row every 15 min fills a
  240-point sparkline with ~2,5 days and pushes the rest off the left edge. Downsample ON READ, don't
  thin the writer: one point per hour, latest per hour —
  `SELECT ts,v FROM t WHERE ts IN (SELECT MAX(ts) FROM t GROUP BY substr(ts,1,13)) ORDER BY ts DESC LIMIT 240`,
  then reverse in Python. Raw rows stay intact.
- **Don't re-verify by grepping the served HTML alone** — the header may render only after JS runs.
  Check the JSON API, then the render harness. Cheap first pass: drive the browser CLI at the tunnel URL
  and read the rendered fields (`document.getElementById('eq').textContent`, the body `innerText`), plus
  a screenshot to send the user — a 200 on `/` proves nothing about JS-rendered content.
- Cache the upstream in memory (TTL) and report in the footer which thresholds/staleness are in
  effect, plus a visible "update berikutnya dalam Ns" countdown, so the user trusts the numbers.
- Optional light gate: token in `?k=` or an `X-Board-Token` header, enabled by env var; leave OFF by
  default for convenience, and say plainly that anyone with the link can view it (public on-chain data
  only — never put the user's own positions/secrets behind a bare quick-tunnel URL).
- Stable URL options to offer when the user wants a permanent name: Cloudflare **named tunnel + own
  domain** (free, needs their CF login), or a `<name>.vercel.app` static page (needs a Vercel token —
  check `~/.vercel` and `.env` first and report what's missing rather than assuming).

## References

- Multi-agent chat UI ("kantor") for several persona bots: see the `agent-chat-office` skill — it reuses
  this skill's server/tunnel/keeper pattern and adds per-persona dispatch plus a token gate.
- `references/localhost-dashboard-serving.md` — worked example (ZemizTracker: paths, ports, cron IDs,
  the node render harness, verification transcript, branding diff) and the failure transcript of the
  pitfalls above.
- `scripts/mobile_probe.py` — real-browser (playwright/chromium) mobile + desktop layout probe:
  overflow offenders, row heights, tabs/header height, phone screenshots for `vision_analyze`.
- `scripts/mobile_probe_row.py` — per-`td` / per-chip measurement of one row; catches the wrapped-chip
  case that makes mobile cards too tall.
- `templates/localhost_dashboard_server.py` — stdlib ThreadingHTTPServer + TTL cache + history +
  optional token, ready to copy and re-point at any data source.
- `templates/service_keeper.sh` — idempotent keeper: healthz, pgrep, tunnel URL parse, print-on-change.
Files in this package (30)
  • SKILL.md 22 KB
  • references/collapse-toggle-reuse.md 2 KB
  • references/collapsible-news-cards.md 5 KB
  • references/conclusion-block-and-install-bar.md 6 KB
  • references/file-based-page-patching.md 3 KB
  • references/keeper-invocation-self-kill.md 2 KB
  • references/large-payload-and-gzip.md 5 KB
  • references/localhost-dashboard-serving.md 7 KB
  • references/mobile-legibility-and-privacy.md 7 KB
  • references/nav-tap-wiring.md 8 KB
  • references/per-entity-reasoning-blocks.md 5 KB
  • references/pwa-installability.md 8 KB
  • references/service-worker-route-hijack.md 5 KB
  • references/shell-200-but-backend-down.md 4 KB
  • references/slow-collector-dashboards.md 6 KB
  • references/stale-data-column-diagnosis.md 4 KB
  • references/theming-to-reference-ui.md 5 KB
  • references/web3-glass-theme.md 7 KB
  • scripts/dashboard_card_shot_probe.py 6 KB
  • scripts/dashboard_content_probe.py 5 KB
  • scripts/dashboard_visual_audit.py 7 KB
  • scripts/gen_pwa_icons.py 4 KB
  • scripts/mobile_probe.py 5 KB
  • scripts/mobile_probe_row.py 2 KB
  • scripts/nav_tap_probe.py 4 KB
  • scripts/sw_navigation_probe.py 5 KB
  • templates/localhost_dashboard_server.py 6 KB
  • templates/pwa_manifest.json 1 KB
  • templates/pwa_service_worker.js 2 KB
  • templates/service_keeper.sh 3 KB

Versions

The database has no other skills named localhost-dashboard-serving.

Database snapshot: 13.11.2026 · package version 35b5c8c098de (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100page-serve
    Serves a static HTML page at a stable https://NAME.localhost/ URL via portless, never a port, and stops it on request. Use when an agent made a page a person should open. Not for app dev servers (use dev).
  • 100pr-review-canvas
    Use when asked to render a PR review as a Cursor Canvas artifact or a standalone HTML page served on localhost (mode: html), with risky hunks foregrounded.
  • 90tt-vllm-serving-review
    Reviews the vLLM and tt-inference-server serving path — generator_vllm.py contracts, plugin registration, the tt_data_parallel ambiguity, and TT-fork branch and config conventions. Use when reviewing changes to generator_vllm.py, vLLM plugin registration, or serving configuration.
  • 90html
    The html skill owns creating and revising durable, standalone HTML artifacts: a complete self-contained index.html saved in a requested or generated artifact directory, with inline dependencies, accessible structure, loopback serving, and exact-file verification. It triggers…
  • 100pr-review-canvas
    Use when asked to render a PR review as a Cursor Canvas artifact or a standalone HTML page served on localhost (mode: html), with risky hunks foregrounded.
  • 100tensorflow-serving-setup
    Configure tensorflow serving setup operations. Auto-activating skill for ML Deployment. Triggers on: tensorflow serving setup, tensorflow serving setup Part of the ML Deployment skill category. Use when working with tensorflow serving setup functionality. Trigger with phrases…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.