kite-strings 0.1.0__tar.gz

kite_strings-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fuqingxu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kite_strings-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: kite-strings
+Version: 0.1.0
+Summary: Expose web services on internal servers through a cloud relay with a dashboard and reverse proxy over WebSocket tunnels.
+Author: fuqingxu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/binary-husky/kite-string
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Dynamic: license-file
+
+# Kite - 反向隧道服务注册系统
+
+将内网服务器上的 Web 服务通过云服务器暴露给外部访问。
+
+## 适用场景
+
+```
+┌─────────┐   WebSocket    ┌─────────────┐   HTTP    ┌─────────┐
+│ 内网服务器├──────────────►│  云服务器 X   │◄─────────│  浏览器  │
+│ A/B/C   │               │  kite-server │           └─────────┘
+│(kite-client)             │  Dashboard   │
+└─────────┘               │  + 反向代理   │
+                          └─────────────┘
+```
+
+- 内网服务器 A/B/C 无法从外部直接访问
+- A/B/C 可以主动连接云服务器 X，反之不行
+- 需要通过 X 访问 A/B/C 上的 Web 服务
+
+## 安装
+
+Python 3.8+，唯一依赖 `aiohttp`：
+
+```bash
+pip install aiohttp
+```
+
+## 使用
+
+### 1. 在云服务器 X 上启动 Server
+
+```bash
+python kite_server.py --port 8080
+```
+
+可选参数：
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| `--host` | `0.0.0.0` | 监听地址 |
+| `--port` | `8080` | 监听端口 |
+
+### 2. 在内网服务器上启动 Client
+
+假设 A 上有一个运行在 3000 端口的 Web 服务：
+
+```bash
+python kite_client.py --server ws://X:8080/ws --port 3000 --name "my-api"
+```
+
+可选参数：
+
+| 参数 | 必填 | 默认值 | 说明 |
+|------|------|--------|------|
+| `--server` | 是 | - | Server 的 WebSocket 地址 |
+| `--port` | 是 | - | 本地 Web 服务端口 |
+| `--name` | 否 | `主机名:端口` | 服务显示名称 |
+
+### 3. 访问
+
+- **Dashboard**：浏览器打开 `http://X:8080`，查看所有已注册服务
+- **代理访问**：点击服务名称，或直接访问 `http://X:8080/proxy/{service_id}/`
+
+## 工作原理
+
+1. Client 通过 WebSocket 连接 Server，注册本地服务信息
+2. Server 记录服务并在 Dashboard 展示
+3. 浏览器访问代理路径时，Server 将 HTTP 请求通过 WebSocket 转发给 Client
+4. Client 向本地服务发起请求，将响应原路返回
+5. Client 断线后自动重连（指数退避，1s → 30s）
+
+## 示例
+
+在同一台机器上快速体验：
+
+```bash
+# 终端 1：启动 Server
+python kite_server.py --port 8080
+
+# 终端 2：启动一个测试 Web 服务
+python -m http.server 9000
+
+# 终端 3：启动 Client，将 9000 端口暴露到 Server
+python kite_client.py --server ws://localhost:8080/ws --port 9000 --name "file-server"
+
+# 浏览器打开 http://localhost:8080 查看 Dashboard，点击服务即可访问
+```
+
+## 多服务注册
+
+每个 Web 服务启动一个 Client 实例即可：
+
+```bash
+# Server A
+python kite_client.py --server ws://X:8080/ws --port 3000 --name "api-server"
+python kite_client.py --server ws://X:8080/ws --port 8888 --name "jupyter"
+
+# Server B
+python kite_client.py --server ws://X:8080/ws --port 5000 --name "flask-app"
+```

kite_strings-0.1.0/README.md

@@ -0,0 +1,100 @@
+# Kite - 反向隧道服务注册系统
+
+将内网服务器上的 Web 服务通过云服务器暴露给外部访问。
+
+## 适用场景
+
+```
+┌─────────┐   WebSocket    ┌─────────────┐   HTTP    ┌─────────┐
+│ 内网服务器├──────────────►│  云服务器 X   │◄─────────│  浏览器  │
+│ A/B/C   │               │  kite-server │           └─────────┘
+│(kite-client)             │  Dashboard   │
+└─────────┘               │  + 反向代理   │
+                          └─────────────┘
+```
+
+- 内网服务器 A/B/C 无法从外部直接访问
+- A/B/C 可以主动连接云服务器 X，反之不行
+- 需要通过 X 访问 A/B/C 上的 Web 服务
+
+## 安装
+
+Python 3.8+，唯一依赖 `aiohttp`：
+
+```bash
+pip install aiohttp
+```
+
+## 使用
+
+### 1. 在云服务器 X 上启动 Server
+
+```bash
+python kite_server.py --port 8080
+```
+
+可选参数：
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| `--host` | `0.0.0.0` | 监听地址 |
+| `--port` | `8080` | 监听端口 |
+
+### 2. 在内网服务器上启动 Client
+
+假设 A 上有一个运行在 3000 端口的 Web 服务：
+
+```bash
+python kite_client.py --server ws://X:8080/ws --port 3000 --name "my-api"
+```
+
+可选参数：
+
+| 参数 | 必填 | 默认值 | 说明 |
+|------|------|--------|------|
+| `--server` | 是 | - | Server 的 WebSocket 地址 |
+| `--port` | 是 | - | 本地 Web 服务端口 |
+| `--name` | 否 | `主机名:端口` | 服务显示名称 |
+
+### 3. 访问
+
+- **Dashboard**：浏览器打开 `http://X:8080`，查看所有已注册服务
+- **代理访问**：点击服务名称，或直接访问 `http://X:8080/proxy/{service_id}/`
+
+## 工作原理
+
+1. Client 通过 WebSocket 连接 Server，注册本地服务信息
+2. Server 记录服务并在 Dashboard 展示
+3. 浏览器访问代理路径时，Server 将 HTTP 请求通过 WebSocket 转发给 Client
+4. Client 向本地服务发起请求，将响应原路返回
+5. Client 断线后自动重连（指数退避，1s → 30s）
+
+## 示例
+
+在同一台机器上快速体验：
+
+```bash
+# 终端 1：启动 Server
+python kite_server.py --port 8080
+
+# 终端 2：启动一个测试 Web 服务
+python -m http.server 9000
+
+# 终端 3：启动 Client，将 9000 端口暴露到 Server
+python kite_client.py --server ws://localhost:8080/ws --port 9000 --name "file-server"
+
+# 浏览器打开 http://localhost:8080 查看 Dashboard，点击服务即可访问
+```
+
+## 多服务注册
+
+每个 Web 服务启动一个 Client 实例即可：
+
+```bash
+# Server A
+python kite_client.py --server ws://X:8080/ws --port 3000 --name "api-server"
+python kite_client.py --server ws://X:8080/ws --port 8888 --name "jupyter"
+
+# Server B
+python kite_client.py --server ws://X:8080/ws --port 5000 --name "flask-app"
+```

kite_strings-0.1.0/kite_string/__init__.py

@@ -0,0 +1,3 @@
+"""Kite String - Reverse tunnel service registry and proxy."""
+
+__version__ = "0.1.0"

kite_strings-0.1.0/kite_string/client.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""Kite Client - Register a local web service through a Kite server tunnel."""
+
+import argparse
+import asyncio
+import base64
+import json
+import platform
+import signal
+import sys
+
+import aiohttp
+
+# ---------------------------------------------------------------------------
+# Tunnel client
+# ---------------------------------------------------------------------------
+
+async def run_tunnel(server_url: str, local_port: int, name: str):
+    """Connect to Kite server and serve proxy requests."""
+    backoff = 1
+    max_backoff = 30
+    host = platform.node()
+
+    while True:
+        try:
+            async with aiohttp.ClientSession() as session:
+                print(f"Connecting to {server_url} ...")
+                async with session.ws_connect(server_url, heartbeat=20) as ws:
+                    # Register
+                    await ws.send_json({
+                        "type": "register",
+                        "name": name,
+                        "port": local_port,
+                        "host": host,
+                    })
+
+                    reg = await ws.receive_json()
+                    service_id = reg.get("id", "?")
+                    print(f"Registered as '{name}' (id={service_id}), tunneling localhost:{local_port}")
+                    backoff = 1  # reset on successful connect
+
+                    async for msg in ws:
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            data = json.loads(msg.data)
+                            if data.get("type") == "request":
+                                asyncio.create_task(
+                                    handle_request(ws, data, local_port)
+                                )
+                        elif msg.type in (aiohttp.WSMsgType.ERROR, aiohttp.WSMsgType.CLOSE):
+                            break
+
+        except (aiohttp.ClientError, OSError, asyncio.TimeoutError) as e:
+            print(f"Connection lost: {e}")
+
+        print(f"Reconnecting in {backoff}s ...")
+        await asyncio.sleep(backoff)
+        backoff = min(backoff * 2, max_backoff)
+
+
+async def handle_request(ws, data: dict, local_port: int):
+    """Forward a proxied request to the local service and return the response."""
+    req_id = data["id"]
+    method = data.get("method", "GET")
+    path = data.get("path", "/")
+    query = data.get("query", "")
+    headers = data.get("headers", {})
+    body_b64 = data.get("body", "")
+
+    url = f"http://127.0.0.1:{local_port}{path}"
+    if query:
+        url += f"?{query}"
+
+    body = base64.b64decode(body_b64) if body_b64 else None
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.request(
+                method, url, headers=headers, data=body, timeout=aiohttp.ClientTimeout(total=25)
+            ) as resp:
+                resp_body = await resp.read()
+                resp_headers = {k: v for k, v in resp.headers.items()
+                                if k.lower() not in ("transfer-encoding", "connection", "keep-alive")}
+
+                await ws.send_json({
+                    "type": "response",
+                    "id": req_id,
+                    "status": resp.status,
+                    "headers": resp_headers,
+                    "body": base64.b64encode(resp_body).decode(),
+                })
+    except Exception as e:
+        print(f"Error proxying request {req_id}: {e}")
+        try:
+            await ws.send_json({
+                "type": "response",
+                "id": req_id,
+                "status": 502,
+                "headers": {"content-type": "text/plain"},
+                "body": base64.b64encode(f"Proxy error: {e}".encode()).decode(),
+            })
+        except Exception:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="Kite Client")
+    parser.add_argument("--server", required=True, help="Kite server WebSocket URL (e.g. ws://X:8080/ws)")
+    parser.add_argument("--port", type=int, required=True, help="Local port to expose")
+    parser.add_argument("--name", default="", help="Service name (default: hostname:port)")
+    args = parser.parse_args()
+
+    name = args.name or f"{platform.node()}:{args.port}"
+
+    loop = asyncio.new_event_loop()
+
+    def shutdown():
+        print("\nShutting down...")
+        for task in asyncio.all_tasks(loop):
+            task.cancel()
+
+    if sys.platform != "win32":
+        loop.add_signal_handler(signal.SIGINT, shutdown)
+        loop.add_signal_handler(signal.SIGTERM, shutdown)
+
+    try:
+        loop.run_until_complete(run_tunnel(args.server, args.port, name))
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    finally:
+        loop.close()
+        print("Bye.")
+
+
+if __name__ == "__main__":
+    main()

kite_strings-0.1.0/kite_string/server.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""Kite Server - Reverse tunnel service registry and proxy."""
+
+import argparse
+import asyncio
+import base64
+import json
+import time
+import uuid
+
+from aiohttp import web, WSMsgType
+
+# ---------------------------------------------------------------------------
+# State
+# ---------------------------------------------------------------------------
+
+services: dict[str, dict] = {}          # service_id -> service info
+pending: dict[str, asyncio.Future] = {} # request_id -> Future[response_msg]
+
+# ---------------------------------------------------------------------------
+# Dashboard HTML (embedded)
+# ---------------------------------------------------------------------------
+
+DASHBOARD_HTML = """\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Kite Dashboard</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+         background: #f5f7fa; color: #333; padding: 2rem; }
+  h1 { margin-bottom: 1.5rem; font-size: 1.6rem; }
+  .empty { color: #999; font-style: italic; }
+  table { width: 100%; border-collapse: collapse; background: #fff;
+          border-radius: 8px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,.1); }
+  th, td { text-align: left; padding: .75rem 1rem; }
+  th { background: #4a90d9; color: #fff; font-weight: 600; }
+  tr:nth-child(even) { background: #f9fafb; }
+  tr:hover { background: #eef3fb; }
+  a { color: #4a90d9; text-decoration: none; font-weight: 500; }
+  a:hover { text-decoration: underline; }
+  .status { display: inline-block; width: 10px; height: 10px; border-radius: 50%;
+            background: #4caf50; margin-right: .4rem; vertical-align: middle; }
+  .status.offline { background: #ccc; }
+  .refresh-note { margin-top: 1rem; font-size: .85rem; color: #999; }
+</style>
+</head>
+<body>
+<h1>Kite Dashboard</h1>
+<div id="content"><p class="empty">Loading...</p></div>
+<p class="refresh-note">Auto-refreshes every 5 seconds</p>
+<script>
+async function load() {
+  try {
+    const res = await fetch('/api/services');
+    const data = await res.json();
+    if (data.length === 0) {
+      document.getElementById('content').innerHTML = '<p class="empty">No services registered.</p>';
+      return;
+    }
+    let html = '<table><tr><th></th><th>Name</th><th>Host</th><th>Port</th><th>Registered</th></tr>';
+    for (const s of data) {
+      const t = new Date(s.registered_at * 1000).toLocaleString();
+      html += `<tr>
+        <td><span class="status ${s.online ? '' : 'offline'}"></span></td>
+        <td><a href="/proxy/${s.id}/" target="_blank">${esc(s.name)}</a></td>
+        <td>${esc(s.host)}</td>
+        <td>${s.port}</td>
+        <td>${t}</td>
+      </tr>`;
+    }
+    html += '</table>';
+    document.getElementById('content').innerHTML = html;
+  } catch(e) { console.error(e); }
+}
+function esc(s) { const d = document.createElement('div'); d.textContent = s; return d.innerHTML; }
+load();
+setInterval(load, 5000);
+</script>
+</body>
+</html>
+"""
+
+# ---------------------------------------------------------------------------
+# Handlers
+# ---------------------------------------------------------------------------
+
+async def handle_dashboard(request: web.Request) -> web.Response:
+    return web.Response(text=DASHBOARD_HTML, content_type="text/html")
+
+
+async def handle_api_services(request: web.Request) -> web.Response:
+    items = sorted(services.values(), key=lambda s: s["registered_at"], reverse=True)
+    out = [
+        {
+            "id": s["id"],
+            "name": s["name"],
+            "host": s["host"],
+            "port": s["port"],
+            "registered_at": s["registered_at"],
+            "online": s.get("online", False),
+        }
+        for s in items
+    ]
+    return web.json_response(out)
+
+
+async def handle_ws(request: web.Request) -> web.WebSocketResponse:
+    ws = web.WebSocketResponse(heartbeat=20)
+    await ws.prepare(request)
+
+    service_id = None
+
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                data = json.loads(msg.data)
+
+                if data.get("type") == "register":
+                    service_id = str(uuid.uuid4())[:8]
+                    services[service_id] = {
+                        "id": service_id,
+                        "name": data.get("name", "unnamed"),
+                        "host": data.get("host", "unknown"),
+                        "port": data.get("port", 0),
+                        "registered_at": time.time(),
+                        "online": True,
+                        "ws": ws,
+                    }
+                    await ws.send_json({"type": "registered", "id": service_id})
+                    print(f"[+] Service registered: {services[service_id]['name']} "
+                          f"({services[service_id]['host']}:{data.get('port')}) -> {service_id}")
+
+                elif data.get("type") == "response":
+                    req_id = data.get("id")
+                    fut = pending.pop(req_id, None)
+                    if fut and not fut.done():
+                        fut.set_result(data)
+
+            elif msg.type in (WSMsgType.ERROR, WSMsgType.CLOSE):
+                break
+    finally:
+        if service_id and service_id in services:
+            services[service_id]["online"] = False
+            services[service_id].pop("ws", None)
+            print(f"[-] Service disconnected: {services[service_id]['name']} ({service_id})")
+
+    return ws
+
+
+async def handle_proxy(request: web.Request) -> web.Response:
+    service_id = request.match_info["service_id"]
+    subpath = request.match_info.get("path", "")
+
+    svc = services.get(service_id)
+    if not svc or not svc.get("online") or not svc.get("ws"):
+        return web.Response(status=502, text="Service not available")
+
+    # Read request body
+    body_bytes = await request.read()
+    body_b64 = base64.b64encode(body_bytes).decode() if body_bytes else ""
+
+    # Build headers dict (single value per key for simplicity)
+    headers = {k: v for k, v in request.headers.items()
+               if k.lower() not in ("host", "connection", "upgrade")}
+
+    req_id = str(uuid.uuid4())
+    msg = {
+        "type": "request",
+        "id": req_id,
+        "method": request.method,
+        "path": "/" + subpath,
+        "query": request.query_string,
+        "headers": headers,
+        "body": body_b64,
+    }
+
+    fut: asyncio.Future = asyncio.get_event_loop().create_future()
+    pending[req_id] = fut
+
+    try:
+        ws = svc["ws"]
+        await ws.send_json(msg)
+        resp_data = await asyncio.wait_for(fut, timeout=30)
+    except (asyncio.TimeoutError, Exception) as e:
+        pending.pop(req_id, None)
+        return web.Response(status=504, text=f"Gateway timeout: {e}")
+
+    # Build response
+    status = resp_data.get("status", 502)
+    resp_headers = resp_data.get("headers", {})
+    resp_body = base64.b64decode(resp_data.get("body", "")) if resp_data.get("body") else b""
+
+    # Filter hop-by-hop headers
+    skip = {"transfer-encoding", "connection", "keep-alive"}
+    filtered = {k: v for k, v in resp_headers.items() if k.lower() not in skip}
+
+    return web.Response(status=status, headers=filtered, body=resp_body)
+
+
+# ---------------------------------------------------------------------------
+# App setup
+# ---------------------------------------------------------------------------
+
+def create_app() -> web.Application:
+    app = web.Application()
+    app.router.add_get("/", handle_dashboard)
+    app.router.add_get("/api/services", handle_api_services)
+    app.router.add_get("/ws", handle_ws)
+    app.router.add_route("*", "/proxy/{service_id}/{path:.*}", handle_proxy)
+    return app
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Kite Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Listen address (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8080, help="Listen port (default: 8080)")
+    args = parser.parse_args()
+
+    print(f"Kite server starting on {args.host}:{args.port}")
+    web.run_app(create_app(), host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

kite_strings-0.1.0/kite_strings.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: kite-strings
+Version: 0.1.0
+Summary: Expose web services on internal servers through a cloud relay with a dashboard and reverse proxy over WebSocket tunnels.
+Author: fuqingxu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/binary-husky/kite-string
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Dynamic: license-file
+
+# Kite - 反向隧道服务注册系统
+
+将内网服务器上的 Web 服务通过云服务器暴露给外部访问。
+
+## 适用场景
+
+```
+┌─────────┐   WebSocket    ┌─────────────┐   HTTP    ┌─────────┐
+│ 内网服务器├──────────────►│  云服务器 X   │◄─────────│  浏览器  │
+│ A/B/C   │               │  kite-server │           └─────────┘
+│(kite-client)             │  Dashboard   │
+└─────────┘               │  + 反向代理   │
+                          └─────────────┘
+```
+
+- 内网服务器 A/B/C 无法从外部直接访问
+- A/B/C 可以主动连接云服务器 X，反之不行
+- 需要通过 X 访问 A/B/C 上的 Web 服务
+
+## 安装
+
+Python 3.8+，唯一依赖 `aiohttp`：
+
+```bash
+pip install aiohttp
+```
+
+## 使用
+
+### 1. 在云服务器 X 上启动 Server
+
+```bash
+python kite_server.py --port 8080
+```
+
+可选参数：
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| `--host` | `0.0.0.0` | 监听地址 |
+| `--port` | `8080` | 监听端口 |
+
+### 2. 在内网服务器上启动 Client
+
+假设 A 上有一个运行在 3000 端口的 Web 服务：
+
+```bash
+python kite_client.py --server ws://X:8080/ws --port 3000 --name "my-api"
+```
+
+可选参数：
+
+| 参数 | 必填 | 默认值 | 说明 |
+|------|------|--------|------|
+| `--server` | 是 | - | Server 的 WebSocket 地址 |
+| `--port` | 是 | - | 本地 Web 服务端口 |
+| `--name` | 否 | `主机名:端口` | 服务显示名称 |
+
+### 3. 访问
+
+- **Dashboard**：浏览器打开 `http://X:8080`，查看所有已注册服务
+- **代理访问**：点击服务名称，或直接访问 `http://X:8080/proxy/{service_id}/`
+
+## 工作原理
+
+1. Client 通过 WebSocket 连接 Server，注册本地服务信息
+2. Server 记录服务并在 Dashboard 展示
+3. 浏览器访问代理路径时，Server 将 HTTP 请求通过 WebSocket 转发给 Client
+4. Client 向本地服务发起请求，将响应原路返回
+5. Client 断线后自动重连（指数退避，1s → 30s）
+
+## 示例
+
+在同一台机器上快速体验：
+
+```bash
+# 终端 1：启动 Server
+python kite_server.py --port 8080
+
+# 终端 2：启动一个测试 Web 服务
+python -m http.server 9000
+
+# 终端 3：启动 Client，将 9000 端口暴露到 Server
+python kite_client.py --server ws://localhost:8080/ws --port 9000 --name "file-server"
+
+# 浏览器打开 http://localhost:8080 查看 Dashboard，点击服务即可访问
+```
+
+## 多服务注册
+
+每个 Web 服务启动一个 Client 实例即可：
+
+```bash
+# Server A
+python kite_client.py --server ws://X:8080/ws --port 3000 --name "api-server"
+python kite_client.py --server ws://X:8080/ws --port 8888 --name "jupyter"
+
+# Server B
+python kite_client.py --server ws://X:8080/ws --port 5000 --name "flask-app"
+```

kite_strings-0.1.0/kite_strings.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+kite_string/__init__.py
+kite_string/client.py
+kite_string/server.py
+kite_strings.egg-info/PKG-INFO
+kite_strings.egg-info/SOURCES.txt
+kite_strings.egg-info/dependency_links.txt
+kite_strings.egg-info/entry_points.txt
+kite_strings.egg-info/requires.txt
+kite_strings.egg-info/top_level.txt

kite_strings-0.1.0/kite_strings.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kite_strings-0.1.0/kite_strings.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+kite-client = kite_string.client:main
+kite-server = kite_string.server:main

kite_strings-0.1.0/kite_strings.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.9

kite_strings-0.1.0/kite_strings.egg-info/top_level.txt

@@ -0,0 +1 @@
+kite_string

kite_strings-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kite-strings"
+version = "0.1.0"
+description = "Expose web services on internal servers through a cloud relay with a dashboard and reverse proxy over WebSocket tunnels."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    {name = "fuqingxu"},
+]
+dependencies = [
+    "aiohttp>=3.9",
+]
+
+[project.scripts]
+kite-server = "kite_string.server:main"
+kite-client = "kite_string.client:main"
+
+[project.urls]
+Homepage = "https://github.com/binary-husky/kite-string"

kite_strings-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+