@mongoui/skills 0.1.4 → 0.1.5

package/skills/glink-hotel-api/glink-openapi-integration/scripts/glink_signed_request.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Generate or send signed requests for the Glink open-platform gateway.
+
+Examples:
+  python scripts/glink_signed_request.py ^
+    --method POST ^
+    --path /openapi/v1/glink/queryBusinessList ^
+    --body-json "{\"language\":\"zh-CN\",\"cityCode\":\"1\"}" ^
+    --app-key open_app_xxx ^
+    --app-secret sk_xxx
+
+  python scripts/glink_signed_request.py ^
+    --method POST ^
+    --path /openapi/v1/glink/queryCreditBalance ^
+    --body-json "{}" ^
+    --app-key open_app_xxx ^
+    --app-secret sk_xxx ^
+    --send
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import hmac
+import json
+import os
+import sys
+import time
+import urllib.parse
+import urllib.request
+import uuid
+from pathlib import Path
+
+
+def sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def parse_query_items(items: list[str]) -> list[tuple[str, str]]:
+    pairs: list[tuple[str, str]] = []
+    for item in items:
+        if "=" not in item:
+            raise ValueError(f"invalid query item: {item!r}; expected key=value")
+        key, value = item.split("=", 1)
+        pairs.append((key, value))
+    return pairs
+
+
+def canonical_query(pairs: list[tuple[str, str]]) -> str:
+    ordered = sorted(pairs, key=lambda item: (item[0], item[1]))
+    return "&".join(
+        f"{urllib.parse.quote(key, safe='~-._')}={urllib.parse.quote(value, safe='~-._')}"
+        for key, value in ordered
+    )
+
+
+def build_sign_payload(
+    method: str,
+    path: str,
+    query_string: str,
+    body_bytes: bytes,
+    timestamp: str,
+    nonce: str,
+    app_key: str,
+) -> str:
+    return "\n".join(
+        [
+            method.upper(),
+            path,
+            query_string,
+            sha256_hex(body_bytes),
+            timestamp,
+            nonce,
+            app_key,
+        ]
+    )
+
+
+def sign(secret: str, payload: str) -> str:
+    return hmac.new(secret.encode("utf-8"), payload.encode("utf-8"), hashlib.sha256).hexdigest()
+
+
+def load_body(args: argparse.Namespace) -> bytes:
+    if args.body_file:
+        return Path(args.body_file).read_bytes()
+    if args.body_json is None:
+        return b""
+    parsed = json.loads(args.body_json)
+    return json.dumps(parsed, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+
+
+def build_url(base_url: str, path: str, query_string: str) -> str:
+    base = base_url.rstrip("/")
+    url = f"{base}{path}"
+    if query_string:
+        url = f"{url}?{query_string}"
+    return url
+
+
+def build_headers(app_key: str, timestamp: str, nonce: str, signature: str, has_body: bool) -> dict[str, str]:
+    headers = {
+        "Accept": "application/json",
+        "X-OP-App-Key": app_key,
+        "X-OP-Timestamp": timestamp,
+        "X-OP-Nonce": nonce,
+        "X-OP-Sign": signature,
+    }
+    if has_body:
+        headers["Content-Type"] = "application/json"
+    return headers
+
+
+def send_request(method: str, url: str, headers: dict[str, str], body_bytes: bytes, timeout: float) -> tuple[int, str]:
+    request = urllib.request.Request(url=url, data=body_bytes or None, headers=headers, method=method.upper())
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.status, response.read().decode("utf-8", errors="replace")
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read().decode("utf-8", errors="replace")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Generate or send a signed Glink open-platform request.")
+    parser.add_argument("--base-url", default=os.getenv("OPEN_PLATFORM_BASE_URL", "http://127.0.0.1:8671"))
+    parser.add_argument("--method", required=True)
+    parser.add_argument("--path", required=True)
+    parser.add_argument("--query", action="append", default=[], help="Repeatable key=value query parameter")
+    parser.add_argument("--body-json", help="JSON string request body")
+    parser.add_argument("--body-file", help="Path to a raw request body file")
+    parser.add_argument("--app-key", default=os.getenv("OPEN_PLATFORM_APP_KEY") or os.getenv("OPEN_PLATFORM_OPEN_APP_ID"))
+    parser.add_argument("--app-secret", default=os.getenv("OPEN_PLATFORM_APP_SECRET") or os.getenv("OPEN_PLATFORM_OPEN_SECRET"))
+    parser.add_argument("--timestamp", default=str(int(time.time())))
+    parser.add_argument("--nonce", default=uuid.uuid4().hex)
+    parser.add_argument("--send", action="store_true")
+    parser.add_argument("--timeout", type=float, default=15.0)
+    args = parser.parse_args()
+
+    if not args.app_key or not args.app_secret:
+        print("app key and app secret are required", file=sys.stderr)
+        return 2
+
+    try:
+        query_pairs = parse_query_items(args.query)
+        body_bytes = load_body(args)
+    except Exception as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+
+    query_string = canonical_query(query_pairs)
+    payload = build_sign_payload(
+        method=args.method,
+        path=args.path,
+        query_string=query_string,
+        body_bytes=body_bytes,
+        timestamp=args.timestamp,
+        nonce=args.nonce,
+        app_key=args.app_key,
+    )
+    signature = sign(args.app_secret, payload)
+    headers = build_headers(args.app_key, args.timestamp, args.nonce, signature, bool(body_bytes))
+    url = build_url(args.base_url, args.path, query_string)
+
+    print("URL:")
+    print(url)
+    print()
+    print("Canonical String:")
+    print(payload)
+    print()
+    print("Headers:")
+    print(json.dumps(headers, ensure_ascii=False, indent=2))
+    if body_bytes:
+        print()
+        print("Body:")
+        print(body_bytes.decode("utf-8", errors="replace"))
+
+    if not args.send:
+        return 0
+
+    status, response_text = send_request(args.method, url, headers, body_bytes, args.timeout)
+    print()
+    print(f"HTTP {status}")
+    print(response_text)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/flink-flight-api/SKILL.md

@@ -1,8 +0,0 @@
----
-name: flink-flight-api
-description: Placeholder skill for Flink Flight API.
----
-
-# Flink Flight API
-
-内容待补充。

package/skills/glink-hotel-api/SKILL.md

@@ -1,175 +0,0 @@
----
-name: glink-hotel-api
-description: Glink 酒店 API 接入规范。支持鉴权、酒店列表查询、参数封装、错误处理。触发词：Glink、酒店接口、酒店查询、鉴权函数、hotel list。
----
-
-# Glink Hotel API
-
-## 目标
-
-当用户提到 Glink 酒店相关需求时，优先帮助用户完成以下任务：
-
-- 实现 Glink API 的鉴权逻辑
-- 封装酒店列表查询函数
-- 生成 Node.js / TypeScript 调用示例
-- 根据接口文档补全请求头、请求体、错误处理
-- 在业务项目中封装可复用的 service / sdk 方法
-
-默认优先输出 TypeScript 示例，其次是 JavaScript。
-
-## 核心规则
-
-- 所有请求默认使用 HTTPS
-- 所有受保护接口必须携带 `Authorization: Bearer {access_token}`
-- 请求头必须包含 `Content-Type: application/json`
-- 日期字段使用 `YYYY-MM-DD`
-- 示例代码优先使用 `fetch`
-- 如果用户项目明显使用 `axios`，则跟随项目风格
-- 如果用户要求“实现函数”，默认补全类型定义、请求函数、错误处理
-- 如果用户没有说明运行环境，默认按 Node.js 18+ 处理
-- 如果用户没有说明框架，默认给出独立可复用函数，不强绑定 NestJS/Express
-
-## 鉴权要求
-
-当用户提到“鉴权”“token”“Bearer”“access_token”时：
-
-- 明确告诉用户需要在请求头中传递 Bearer Token
-- 不要把 token 写死在代码里
-- 优先从函数参数、环境变量或配置对象中读取 token
-- 生成代码时，默认将鉴权逻辑封装为独立函数或统一请求客户端
-
-推荐模式：
-
-1. 先定义配置项
-2. 再封装请求方法
-3. 再封装业务接口方法
-
-## 常见接口示例
-
-### 查询酒店列表
-
-```http
-POST /v1/hotel/list
-Authorization: Bearer {access_token}
-Content-Type: application/json
-
-{
-  "cityCode": "BJS",
-  "checkIn": "2026-05-01",
-  "checkOut": "2026-05-03",
-  "rooms": 1,
-  "adults": 2,
-  "starRating": [4, 5],
-  "sortBy": "price",
-  "page": 1,
-  "pageSize": 20
-}
-```
-
-## TypeScript 示例
-
-```ts
-type HotelListRequest = {
-  cityCode: string;
-  checkIn: string;
-  checkOut: string;
-  rooms: number;
-  adults: number;
-  starRating?: number[];
-  sortBy?: string;
-  page?: number;
-  pageSize?: number;
-};
-
-type GlinkClientOptions = {
-  baseUrl: string;
-  accessToken: string;
-};
-
-async function glinkRequest<T>(
-  path: string,
-  options: GlinkClientOptions,
-  body: unknown,
-): Promise<T> {
-  const response = await fetch(`${options.baseUrl}${path}`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${options.accessToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`Glink request failed: ${response.status} ${errorText}`);
-  }
-
-  return response.json() as Promise<T>;
-}
-
-export async function getHotelList<T>(
-  options: GlinkClientOptions,
-  payload: HotelListRequest,
-): Promise<T> {
-  return glinkRequest<T>("/v1/hotel/list", options, payload);
-}
-```
-
-## 当用户这样提问时
-
-### 用户说
-
-`帮我实现 Glink 鉴权函数`
-
-应该优先输出：
-
-- 一个可复用的鉴权请求封装
-- 如何传入 `access_token`
-- 如何设置 `Authorization: Bearer ...`
-- 一个最小可运行示例
-
-### 用户说
-
-`帮我调用 Glink 酒店列表接口`
-
-应该优先输出：
-
-- 请求函数
-- 请求参数类型
-- 调用示例
-- 错误处理
-- 必要请求头
-
-### 用户说
-
-`帮我封装成 service`
-
-应该优先输出：
-
-- 一个类或模块化 service
-- 构造函数接收 `baseUrl` 和 `accessToken`
-- 业务方法如 `getHotelList`
-
-## 输出要求
-
-- 优先输出完整可运行代码，而不是只解释思路
-- 如果用户没有要求框架，优先输出纯 TypeScript 函数
-- 如果接口字段不完整，明确标注“以下字段基于当前 Skills 示例推断”
-- 如果缺少响应结构，不要编造复杂返回值类型，可先使用泛型或基础类型
-- 如果用户要求接入现有项目，尽量贴近项目已有代码风格
-
-## 常见注意事项
-
-- 不要把 `Authorization` 写成普通自定义字段
-- 不要漏掉 `Content-Type: application/json`
-- 不要把日期写成时间戳，除非用户明确要求
-- 不要默认把所有字段都设成可选
-- 不要把分页参数写死
-- 如果用户要生产代码，提醒 token 不应硬编码
-
-## 回答风格
-
-- 直接给代码
-- 再简要说明关键点
-- 优先面向接入开发，不做空泛概念解释