Skip to content
Back to search

hongkong-restaurant-skill

Hong Kong restaurant lookup across the official FEHD licensed-restaurant list, OpenRice search and Foodpanda delivery listings. Use for restaurant licences, addresses, districts, cuisine search, ratings, opening status, delivery fees or nearby Foodpanda vendors. Keeta is not covered because it has no public consumer API.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/hongkong-ai-labs--hongkong-restaurant-skill/badge.svg)](/listings/hongkong-ai-labs--hongkong-restaurant-skill)

HTML

<a href="/listings/hongkong-ai-labs--hongkong-restaurant-skill"><img src="/api/listings/hongkong-ai-labs--hongkong-restaurant-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

**Agent skill** — installs `SKILL.md` and the binary bootstrap script:

npx skills add hongkong-ai-labs/hongkong-restaurant-skill
npx skills update        # refresh the installed skill later

**Prebuilt binary** — macOS (Intel or Apple silicon) and Linux (x86_64 or aarch64, static musl), checksum-verified, into `~/.local/bin`:

curl -fsSL https://raw.githubusercontent.com/hongkong-ai-labs/hongkong-restaurant-skill/main/scripts/install.sh | sh

**From source** — Rust 1.89 or newer:

git clone https://github.com/hongkong-ai-labs/hongkong-restaurant-skill
cd hongkong-restaurant-skill
cargo install --path . --locked
# or directly from GitHub:
cargo install --git https://github.com/hongkong-ai-labs/hongkong-restaurant-skill --locked
# or: cargo build --release --locked   # target/release/hkrestaurant

Verify:

$ hkrestaurant --version

`hkrestaurant update` detects whether the binary came from cargo, the release installer, a source checkout or Homebrew, and updates with that same method. `hkrestaurant update --check` only reports.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 170 lines · 1 finding marked
  1. ---
  2. name: hongkong-restaurant-skill
  3. description: Hong Kong restaurant lookup across the official FEHD licensed-restaurant list, OpenRice search and Foodpanda delivery listings. Use for restaurant licences, addresses, districts, cuisine search, ratings, opening status, delivery fees or nearby Foodpanda vendors. Keeta is not covered because it has no public consumer API.
  4. license: MIT
  5. ---
  6. # Hong Kong restaurants
  7. `hkrestaurant` is a Rust CLI and MCP server that combines three restaurant
  8. sources. It needs no API key. It is an independent, unofficial project.
  9. | Source | What it is | Status |
  10. | --- | --- | --- |
  11. | **FEHD** | Official list of every licensed General, Light Refreshment and Marine restaurant | stable open data |
  12. | **OpenRice** | Editorial search results from the OpenRice Hong Kong website | undocumented public endpoint |
  13. | **Foodpanda** | Vendors delivering near a coordinate | undocumented public endpoint |
  14. **Keeta is deliberately not supported.** Keeta has no public consumer search
  15. API. Its documented OpenAPI is merchant-only and needs credentials. This skill
  16. does not scrape the app or bypass that boundary. Say so if the user asks for
  17. Keeta data, and use the Keeta app instead.
  18. ## Before first use
  19. ```console
  20. $ bash scripts/ensure-binary.sh
  21. /Users/you/.local/bin/hkrestaurant
  22. ```
  23. ```bash
  24. BIN="$(bash scripts/ensure-binary.sh)"
  25. ```
  26. It checks `$HKRESTAURANT_BIN`, `hkrestaurant` on `PATH`,
  27. `scripts/install.sh`, then `cargo build --release --locked` in the repo root.
  28. ### Install the binary directly
  29. `npx skills add` installs the skill files. If the binary is missing, install it
  30. with the release installer or cargo:
  31. ```bash
  32. curl -fsSL https://raw.githubusercontent.com/hongkong-ai-labs/hongkong-restaurant-skill/main/scripts/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 43 on GitHub
  33. # or
  34. cargo install --git https://github.com/hongkong-ai-labs/hongkong-restaurant-skill --locked
  35. ```
  36. Register it with any MCP client:
  37. ```bash
  38. npx add-mcp "$(command -v hkrestaurant) mcp" --name hongkong-restaurant -a claude-code -a codex -a cursor -y
  39. claude mcp add hongkong-restaurant -- hkrestaurant mcp
  40. codex mcp add hongkong-restaurant -- hkrestaurant mcp
  41. ```
  42. `add-mcp` detects the client configuration files in the current project; add
  43. `-g` for a global install. `$(command -v hkrestaurant)` keeps the entry correct
  44. when the binary is on `PATH`; substitute an absolute path if your client does
  45. not inherit the shell `PATH`.
  46. ## CLI
  47. ```bash
  48. # Official licences (best for "is this restaurant licensed?" and addresses)
  49. $BIN licences --query "jade" --limit 5
  50. $BIN licences --district "Yau Tsim" --kind "General"
  51. $BIN licences --query "Causeway Bay" --json
  52. # OpenRice editorial search (best for cuisine / dish discovery)
  53. $BIN openrice sushi --limit 5
  54. $BIN openrice "dim sum" --json
  55. # Foodpanda nearby delivery (best for "what can deliver here?")
  56. $BIN foodpanda --lat 22.2793 --lng 114.1628
  57. $BIN foodpanda --lat 22.2793 --lng 114.1628 --query sushi
  58. $BIN foodpanda --lat 22.2793 --lng 114.1628 --limit 48 --json
  59. # What each source covers
  60. $BIN sources
  61. $BIN mcp
  62. $BIN update --check
  63. ```
  64. ### Trade-offs
  65. - **Licences** are authoritative for existence, name, address, district,
  66. licence type and expiry. They do not carry ratings, menus, opening hours or
  67. delivery.
  68. - **OpenRice** gives scores, review counts, price bands, categories and a
  69. current open/closed flag. It returns 15 results per page; `--limit` fetches
  70. more pages up to 150.
  71. - **Foodpanda** gives rating, minimum order, delivery fee, ETA and distance for
  72. vendors delivering to a coordinate. The public listing has no reliable
  73. keyword parameter, so `--query` filters the nearby list client-side. A query
  74. can therefore miss a restaurant that is further away.
  75. - A restaurant can appear in one source and not another. Absence from OpenRice
  76. or Foodpanda is not evidence that it is closed.
  77. ## JSON fields
  78. `licences` returns
  79. `{generation_date, count, restaurants:[{licence_no,name,address,district,licence_type,licence_type_code,expiry_date,info}]}`.
  80. `generation_date` is the day FEHD generated the list, not the time of your call.
  81. `openrice` returns an array of
  82. `{name,name_other_lang,address,address_other_lang,district,categories,score,review_count,price,open_now,url}`.
  83. `score` is OpenRice's 0-5 overall score, not a hygiene rating. `open_now` is
  84. the website's current flag.
  85. `foodpanda` returns an array of
  86. `{code,name,address,cuisines,rating,review_count,budget,minimum_order,delivery_fee,delivery_minutes,distance_km,url}`.
  87. Fees and minimum orders are in HKD and can change at checkout.
  88. ## MCP
  89. ```json
  90. {
  91. "mcpServers": {
  92. "hongkong-restaurant": {
  93. "command": "/absolute/path/to/hkrestaurant",
  94. "args": ["mcp"]
  95. }
  96. }
  97. }
  98. ```
  99. Tools:
  100. | Tool | Arguments |
  101. | --- | --- |
  102. | `search_restaurant_licences` | `{ query?, district?, type?, limit? }` |
  103. | `search_openrice` | `{ query, limit? }` |
  104. | `list_foodpanda_vendors` | `{ lat, lng, query?, limit? }` |
  105. | `list_restaurant_sources` | `{}` |
  106. ## Answering patterns
  107. - "Is X licensed?" → `licences --query X`; quote the licence number, type and
  108. expiry, and say if there is no match.
  109. - "Where is X?" → `licences --query X` for the official address, not a delivery
  110. platform's pin.
  111. - "Good sushi in Causeway Bay?" → `openrice sushi`, then filter the district in
  112. the results. Mention scores and review counts, and that they are OpenRice's.
  113. - "What can deliver to me?" → `foodpanda --lat ... --lng ...`; quote minimum
  114. order, fee and ETA together, since a cheap fee with a high minimum is not
  115. cheap.
  116. - "What about Keeta?" → explain that Keeta has no public consumer API and this
  117. skill does not scrape it.
  118. ## Cautions
  119. - OpenRice and Foodpanda endpoints are undocumented consumer endpoints. They
  120. can change, rate-limit, or require a browser session without notice. The
  121. skill sends a normal browser User-Agent and does not log in.
  122. - Do not bulk-harvest either platform. Use small `--limit` values and keep the
  123. cache on (5 minutes for OpenRice, 2 minutes for Foodpanda, 6 hours for FEHD).
  124. - Ratings are platform-specific and not comparable across OpenRice and
  125. Foodpanda.
  126. - Prices, fees, availability and opening status are a snapshot, not a quote.
  127. - FEHD licence data lists licensed premises, not a food-safety grade. A valid
  128. licence is not a hygiene rating.
  129. - Do not present this as an official FEHD, OpenRice, Foodpanda or Keeta
  130. channel. Follow each platform's terms when redistributing its data.
  131. ## Sources
  132. - FEHD: `https://www.fehd.gov.hk/english/licensing/license/text/LP_Restaurants_EN.XML`
  133. - OpenRice: `https://www.openrice.com/api/pois?...`
  134. - Foodpanda: `https://disco.deliveryhero.io/listing/api/v1/pandora/vendors?...`
  135. with `x-disco-client-id: web`
README.md · README · 196 lines · 1 finding marked
  1. # hkrestaurant
  2. Hong Kong restaurant lookup as a Rust CLI and MCP server.
  3. Three sources:
  4. - **FEHD** — official licensed-restaurant list (name, address, district,
  5. licence type and expiry)
  6. - **OpenRice** — editorial search with scores, reviews, price bands and open
  7. status
  8. - **Foodpanda** — nearby delivery vendors with minimum order, fee and ETA
  9. Keeta is **not** supported: it has no public consumer API, only a credentialed
  10. merchant API. This project does not scrape the app.
  11. ## Install
  12. **Agent skill** — installs `SKILL.md` and the binary bootstrap script:
  13. ```bash
  14. npx skills add hongkong-ai-labs/hongkong-restaurant-skill
  15. npx skills update # refresh the installed skill later
  16. ```
  17. **Prebuilt binary** — macOS (Intel or Apple silicon) and Linux (x86_64 or
  18. aarch64, static musl), checksum-verified, into `~/.local/bin`:
  19. ```bash
  20. curl -fsSL https://raw.githubusercontent.com/hongkong-ai-labs/hongkong-restaurant-skill/main/scripts/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 29 on GitHub
  21. ```
  22. **From source** — Rust 1.89 or newer:
  23. ```bash
  24. git clone https://github.com/hongkong-ai-labs/hongkong-restaurant-skill
  25. cd hongkong-restaurant-skill
  26. cargo install --path . --locked
  27. # or directly from GitHub:
  28. cargo install --git https://github.com/hongkong-ai-labs/hongkong-restaurant-skill --locked
  29. # or: cargo build --release --locked # target/release/hkrestaurant
  30. ```
  31. Verify:
  32. ```console
  33. $ hkrestaurant --version
  34. ```
  35. `hkrestaurant update` detects whether the binary came from cargo, the release
  36. installer, a source checkout or Homebrew, and updates with that same
  37. method. `hkrestaurant update --check` only reports.
  38. ## CLI
  39. ```bash
  40. hkrestaurant licences --query "jade" --limit 5
  41. hkrestaurant licences --district "Yau Tsim" --kind General
  42. hkrestaurant openrice sushi --limit 5
  43. hkrestaurant foodpanda --lat 22.2793 --lng 114.1628
  44. hkrestaurant foodpanda --lat 22.2793 --lng 114.1628 --query sushi
  45. hkrestaurant sources
  46. hkrestaurant mcp
  47. hkrestaurant update --check
  48. ```
  49. ## MCP
  50. ```json
  51. {
  52. "mcpServers": {
  53. "hongkong-restaurant": { "command": "hkrestaurant", "args": ["mcp"] }
  54. }
  55. }
  56. ```
  57. Register it with any MCP client:
  58. ```bash
  59. npx add-mcp "$(command -v hkrestaurant) mcp" --name hongkong-restaurant -a claude-code -a codex -a cursor -y
  60. claude mcp add hongkong-restaurant -- hkrestaurant mcp
  61. codex mcp add hongkong-restaurant -- hkrestaurant mcp
  62. ```
  63. `add-mcp` detects the client configuration files in the current project; add
  64. `-g` for a global install. `$(command -v hkrestaurant)` keeps the entry correct
  65. when the binary is on `PATH`; substitute an absolute path if your client does
  66. not inherit the shell `PATH`.
  67. Tools: `search_restaurant_licences`, `search_openrice`,
  68. `list_foodpanda_vendors`, `list_restaurant_sources`.
  69. ## Limits
  70. OpenRice and Foodpanda are undocumented public endpoints, not partner APIs.
  71. They can change or rate-limit without notice and remain subject to their terms.
  72. Foodpanda keyword filtering is client-side over the nearby list. FEHD licences
  73. do not include hygiene grades, menus or opening hours.
  74. ## Run modes and deployment
  75. | Mode | Start with | Use for |
  76. | --- | --- | --- |
  77. | CLI | `hkrestaurant <command>` | Interactive use and shell scripts |
  78. | JSON | `<command>` with `--json` | `jq`, automation, other programs |
  79. | MCP stdio | `hkrestaurant mcp` | Desktop and CLI MCP clients |
  80. | Container | `docker run --rm -i hkrestaurant mcp` | No local Rust toolchain |
  81. ### MCP and authentication
  82. This server is **stdio-only**: the client launches the process and speaks MCP
  83. over stdin/stdout. There is no listening port, so there is no network
  84. authentication layer and no API-key setting. Optional API keys in this project
  85. family apply only to servers that expose an HTTP transport. Keep the process
  86. local and let the MCP client manage it.
  87. Typical client entry:
  88. ```json
  89. {
  90. "mcpServers": {
  91. "hongkong-restaurant-skill": {
  92. "command": "hkrestaurant",
  93. "args": ["mcp"]
  94. }
  95. }
  96. }
  97. ```
  98. If the client does not inherit `PATH`, use the absolute installed path.
  99. ### Docker and Apple container
  100. ```bash
  101. docker build -t hkrestaurant .
  102. docker run --rm hkrestaurant --help
  103. docker run --rm -i hkrestaurant mcp # stdio MCP
  104. docker compose run --rm stdio # same, through Compose
  105. ```
  106. Apple's `container` runtime uses the same OCI image:
  107. ```bash
  108. container build -t hkrestaurant .
  109. container run --rm hkrestaurant --help
  110. container run --rm -i hkrestaurant mcp
  111. ```
  112. The runtime image contains the release binary and CA certificates, runs as a
  113. non-root user, and defaults to `--help` so a bare `docker run` is harmless.
  114. ### Cloudflare and WASM
  115. There is no Worker or WASM deployment. The binary talks directly to upstream
  116. HTTP APIs over TLS and uses a Tokio runtime; packaging it as a stdio server is
  117. the supported integration. A Worker would need a separate HTTP/JavaScript
  118. adapter and is out of scope for this repo.
  119. ### Releases
  120. Pushing a `v*` tag runs the release workflow, which checks the tag against
  121. `Cargo.toml` and `CHANGELOG.md`, builds four targets, smoke-tests native
  122. binaries and publishes:
  123. - `hkrestaurant-<tag>-<target>.tar.gz` for macOS and static Linux
  124. - `SHA256SUMS` covering every tarball
  125. `scripts/install.sh` downloads the latest release, verifies its checksum and
  126. falls back to `cargo build --release --locked` when no release is available.
  127. `just tag X.Y.Z` creates the annotated tag locally; `just release X.Y.Z` tags
  128. and pushes to trigger the workflow.
  129. ## Development
  130. ```bash
  131. just # fmt check, clippy with -D warnings, tests
  132. just skill-check # validate SKILL.md and shell syntax
  133. just container # build the image and print CLI help
  134. cargo test --all --locked
  135. cargo clippy --all-targets --locked -- -D warnings
  136. cargo fmt --all -- --check
  137. ```
  138. `rust-toolchain.toml` pins the stable toolchain with `rustfmt` and
  139. `clippy`, so `rustup` sets contributors up automatically. `just doc`
  140. builds the API documentation. See `CONTRIBUTING.md` for the full check
  141. list and the signed-commit requirement.
  142. CI runs the same checks. Dependabot proposes weekly Cargo and GitHub Actions
  143. updates, and the audit workflow checks the lockfile against the RustSec
  144. advisory database.
  145. ## Licence
  146. MIT. Data remains subject to FEHD, OpenRice and Foodpanda terms.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.