ccoding 0.2.2__tar.gz → 0.2.4__tar.gz

{ccoding-0.2.2 → ccoding-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccoding
-Version: 0.2.2
+Version: 0.2.4
 Summary: Curses-based Claude Code launcher
 Project-URL: Homepage, https://github.com/8DE4732A/ccode
 Project-URL: Repository, https://github.com/8DE4732A/ccode
@@ -173,8 +173,8 @@ uv sync --extra remote          # 同时安装 client/server 依赖
 
 - `↑ / ↓`：移动字段焦点
 - `Enter / Space`：切换开关项
-- 文本输入：编辑 BASE_URL / API_KEY、remote local/server URL/token/device/prefix 等字段
-- `g`：在 Remote local token 或 server client token 字段重新生成访问 token
+- 文本输入：编辑 BASE_URL / API_KEY、remote local/server URL/appId/appKey/device/prefix 等字段
+- `g`：在 Remote appId 或 appKey 字段重新生成对应值
 - `ESC`：自动保存并返回主界面
 
 ## 配置文件
@@ -209,11 +209,13 @@ uv sync --extra remote          # 同时安装 client/server 依赖
     "local": {
       "host": "127.0.0.1",
       "port": 8765,
-      "token": ""
+      "appId": "",
+      "appKey": ""
     },
     "server": {
       "url": "",
-      "token": "",
+      "appId": "",
+      "appKey": "",
       "device_name": "",
       "device_id": "",
       "auto_connect": true,
@@ -232,6 +234,8 @@ Remote/Web 让 Claude Code 运行在 tmux session 中，浏览器通过 WebSocke
 | `local` | 直接访问本机 local hub | 当前这台机器 | 单机使用，或把这一台机器通过 tunnel 暴露出去 |
 | `server` | 访问公网中心 `ccode-remote-server` | 各客户端设备本机 | 多设备、NAT 后设备、统一入口管理多个 sessions |
 
+Remote/Web 使用 appId/appKey HMAC 认证。网络请求只携带 `appId`、`timestamp` 和 `sign`，其中 `sign` 由 appKey 计算，appKey 不会被发送。浏览器端只保存 24 小时有效的签名票据，过期后需要重新输入 appKey；客户端 connector 会从本地配置读取 appKey 并在重连时自动重新签名。旧版配置中的 `token` 会在读取时迁移为 `appKey`，并自动生成 `appId`。
+
 ### local 模式
 
 local 模式会在本机启动一个共享 FastAPI hub。浏览器直接访问这个 hub，hub 再 attach 到本机 tmux session。
@@ -262,23 +266,23 @@ claude
    - `MODE`：`local`
    - `LOCAL HOST`：默认 `127.0.0.1`
    - `LOCAL PORT`：默认 `8765`
-   - `LOCAL TOKEN`：手动输入，或在该字段按 `g` 生成
+   - `LOCAL APP ID` / `LOCAL APP KEY`：手动输入，或在对应字段按 `g` 生成
 
 3. 回到主界面，按 `r` 开启 Remote/Web，再按 `Enter` 启动 remote session。
 
-4. 浏览器打开终端输出的本地地址，输入 `LOCAL TOKEN`，选择 session 后进入 terminal。
+4. 浏览器打开终端输出的本地地址，输入 `LOCAL APP ID` / `LOCAL APP KEY`，选择 session 后进入 terminal。
 
-local 模式默认只监听 `127.0.0.1`。终端只输出不带 token 的本地访问地址。浏览器打开页面后需要手动输入 token，前端会用 `sessionStorage` 做浏览器会话级缓存；关闭该浏览器会话后需要重新输入。所有 session list、session API 和 WebSocket 连接仍然需要 token。
+local 模式默认只监听 `127.0.0.1`。终端只输出不带认证信息的本地访问地址。浏览器打开页面后需要手动输入 appId/appKey，前端只保存由 appKey 生成的 24 小时 HMAC 签名票据，不保存 appKey；票据过期或关闭浏览器会话后需要重新输入。所有 session list、session API 和 WebSocket 连接仍然需要签名认证。
 
-每个启用 Remote/Web 的 `ccode` 进程都会创建一个唯一 tmux session，session 名由配置里的 `session_name` 前缀、时间戳和进程号组成，例如 `ccode-claude-20260509-153022-12345`。本机只启动一个共享 remote hub，多个本地 `ccode` 进程会复用同一个 host/port/token。浏览器认证后会先显示 session 列表，选择某个 session 后进入 terminal，也可以返回列表重新选择。
+每个启用 Remote/Web 的 `ccode` 进程都会创建一个唯一 tmux session，session 名由配置里的 `session_name` 前缀、时间戳和进程号组成，例如 `ccode-claude-20260509-153022-12345`。本机只启动一个共享 remote hub，多个本地 `ccode` 进程会复用同一个 host/port/appId/appKey。浏览器认证后会先显示 session 列表，选择某个 session 后进入 terminal，也可以返回列表重新选择。
 
-如果通过 Cloudflare Tunnel、Nginx、Caddy 等反向代理暴露 local hub，建议额外叠加 Cloudflare Access、Basic Auth 或 OAuth2 proxy。监听 `0.0.0.0` 会把所有 remote sessions 暴露给网络内可达主机，请保护好访问入口和 token。
+如果通过 Cloudflare Tunnel、Nginx、Caddy 等反向代理暴露 local hub，建议额外叠加 Cloudflare Access、Basic Auth 或 OAuth2 proxy。监听 `0.0.0.0` 会把所有 remote sessions 暴露给网络内可达主机，请保护好访问入口和 app credentials。
 
 ```bash
 cloudflared tunnel --url http://127.0.0.1:8765
 ```
 
-local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、session 注册、session API 和 WebSocket 连接状态，不记录 token。启动 hub 前如果日志超过 5 MiB 会自动轮转，默认保留 3 个历史文件（`.1`、`.2`、`.3`）。
+local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、session 注册、session API 和 WebSocket 连接状态，不记录 appKey。启动 hub 前如果日志超过 5 MiB 会自动轮转，默认保留 3 个历史文件（`.1`、`.2`、`.3`）。
 
 ### server 模式和 `ccode-remote-server`
 
@@ -289,7 +293,7 @@ local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、sessio
 ```text
                   Browser
                      │
-                     │ HTTPS/WSS + admin token
+                     │ HTTPS/WSS + admin HMAC
                      ▼
           ┌───────────────────────┐
           │ ccode-remote-server   │
@@ -314,31 +318,35 @@ local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、sessio
 
 server 不反连客户端，所以客户端可以在 NAT、家庭网络或公司内网后面。只要客户端能主动访问 server，就可以注册设备和暴露自己的 remote sessions。
 
-#### server token
+#### server app credentials
 
-server token 不会自动生成，必须通过环境变量显式设置：
+server app credentials 不会自动生成，必须通过环境变量显式设置。认证时网络上传输 appId、timestamp 和 HMAC sign，不传输 appKey：
 
-- `CCODE_REMOTE_SERVER_ADMIN_TOKEN`：浏览器 Web UI / `/api/*` / browser WebSocket 使用的管理 token。
-- `CCODE_REMOTE_SERVER_CLIENT_TOKEN`：各设备客户端 connector 注册和心跳使用的 token。
+- `CCODE_REMOTE_SERVER_ADMIN_APP_ID` / `CCODE_REMOTE_SERVER_ADMIN_APP_KEY`：浏览器 Web UI / `/api/*` / browser WebSocket 使用的管理凭据。
+- `CCODE_REMOTE_SERVER_CLIENT_APP_ID` / `CCODE_REMOTE_SERVER_CLIENT_APP_KEY`：各设备客户端 connector 注册和心跳使用的客户端凭据。
 - `CCODE_REMOTE_SERVER_HOST` / `CCODE_REMOTE_SERVER_PORT`：可选，默认监听 `127.0.0.1:8765`。
 
 启动中心 server：
 
 ```bash
-CCODE_REMOTE_SERVER_ADMIN_TOKEN="admin-secret" \
-CCODE_REMOTE_SERVER_CLIENT_TOKEN="client-secret" \
+CCODE_REMOTE_SERVER_ADMIN_APP_ID="admin-app" \
+CCODE_REMOTE_SERVER_ADMIN_APP_KEY="admin-secret" \
+CCODE_REMOTE_SERVER_CLIENT_APP_ID="client-app" \
+CCODE_REMOTE_SERVER_CLIENT_APP_KEY="client-secret" \
 ccode-remote-server --host 127.0.0.1 --port 8765
 ```
 
 如果使用源码开发环境运行：
 
 ```bash
-CCODE_REMOTE_SERVER_ADMIN_TOKEN="admin-secret" \
-CCODE_REMOTE_SERVER_CLIENT_TOKEN="client-secret" \
+CCODE_REMOTE_SERVER_ADMIN_APP_ID="admin-app" \
+CCODE_REMOTE_SERVER_ADMIN_APP_KEY="admin-secret" \
+CCODE_REMOTE_SERVER_CLIENT_APP_ID="client-app" \
+CCODE_REMOTE_SERVER_CLIENT_APP_KEY="client-secret" \
 uv run --extra remote-server ccode-remote-server --host 127.0.0.1 --port 8765
 ```
 
-浏览器访问 server 页面时输入 `admin-secret`。如果未设置 `CCODE_REMOTE_SERVER_ADMIN_TOKEN`，管理 API 会返回 401，页面上任何 token 都无法通过认证。
+浏览器访问 server 页面时输入 admin appId/appKey。前端只保存 24 小时有效的 HMAC 签名票据，不保存 appKey。如果未设置 `CCODE_REMOTE_SERVER_ADMIN_APP_ID` / `CCODE_REMOTE_SERVER_ADMIN_APP_KEY`，管理 API 会返回 401。
 
 #### 客户端设备配置
 
@@ -352,7 +360,7 @@ uv tool install 'ccoding[remote-client]'
 
 - `MODE`：`server`
 - `SERVER URL`：中心 server 地址，例如 `http://127.0.0.1:8765`；如果只填 `127.0.0.1:8765`，会自动按 `http://127.0.0.1:8765` 处理
-- `CLIENT TOKEN`：与 server 的 `CCODE_REMOTE_SERVER_CLIENT_TOKEN` 一致
+- `CLIENT APP ID` / `CLIENT APP KEY`：与 server 的 `CCODE_REMOTE_SERVER_CLIENT_APP_ID` / `CCODE_REMOTE_SERVER_CLIENT_APP_KEY` 一致
 - `DEVICE NAME`：设备显示名，可留空后由配置迁移填充 hostname
 - `DEVICE ID`：稳定设备 ID，可留空后自动生成
 - `AUTO CONNECT`：是否默认自动连接中心 server
@@ -384,7 +392,7 @@ server 只做 registry/router/relay，不保存 terminal frame data，不保存
 
 #### Cloudflare Tunnel / 反向代理
 
-如果用 Cloudflare Tunnel 暴露中心 server，只需要 tunnel server 这一处入口，多台客户端设备都配置同一个 `SERVER URL` 和 `CLIENT TOKEN`：
+如果用 Cloudflare Tunnel 暴露中心 server，只需要 tunnel server 这一处入口，多台客户端设备都配置同一个 `SERVER URL` 和 `CLIENT APP ID` / `CLIENT APP KEY`：
 
 ```bash
 cloudflared tunnel --url http://127.0.0.1:8765

{ccoding-0.2.2 → ccoding-0.2.4}/README.md

@@ -122,8 +122,8 @@ uv sync --extra remote          # 同时安装 client/server 依赖
 
 - `↑ / ↓`：移动字段焦点
 - `Enter / Space`：切换开关项
-- 文本输入：编辑 BASE_URL / API_KEY、remote local/server URL/token/device/prefix 等字段
-- `g`：在 Remote local token 或 server client token 字段重新生成访问 token
+- 文本输入：编辑 BASE_URL / API_KEY、remote local/server URL/appId/appKey/device/prefix 等字段
+- `g`：在 Remote appId 或 appKey 字段重新生成对应值
 - `ESC`：自动保存并返回主界面
 
 ## 配置文件
@@ -158,11 +158,13 @@ uv sync --extra remote          # 同时安装 client/server 依赖
     "local": {
       "host": "127.0.0.1",
       "port": 8765,
-      "token": ""
+      "appId": "",
+      "appKey": ""
     },
     "server": {
       "url": "",
-      "token": "",
+      "appId": "",
+      "appKey": "",
       "device_name": "",
       "device_id": "",
       "auto_connect": true,
@@ -181,6 +183,8 @@ Remote/Web 让 Claude Code 运行在 tmux session 中，浏览器通过 WebSocke
 | `local` | 直接访问本机 local hub | 当前这台机器 | 单机使用，或把这一台机器通过 tunnel 暴露出去 |
 | `server` | 访问公网中心 `ccode-remote-server` | 各客户端设备本机 | 多设备、NAT 后设备、统一入口管理多个 sessions |
 
+Remote/Web 使用 appId/appKey HMAC 认证。网络请求只携带 `appId`、`timestamp` 和 `sign`，其中 `sign` 由 appKey 计算，appKey 不会被发送。浏览器端只保存 24 小时有效的签名票据，过期后需要重新输入 appKey；客户端 connector 会从本地配置读取 appKey 并在重连时自动重新签名。旧版配置中的 `token` 会在读取时迁移为 `appKey`，并自动生成 `appId`。
+
 ### local 模式
 
 local 模式会在本机启动一个共享 FastAPI hub。浏览器直接访问这个 hub，hub 再 attach 到本机 tmux session。
@@ -211,23 +215,23 @@ claude
    - `MODE`：`local`
    - `LOCAL HOST`：默认 `127.0.0.1`
    - `LOCAL PORT`：默认 `8765`
-   - `LOCAL TOKEN`：手动输入，或在该字段按 `g` 生成
+   - `LOCAL APP ID` / `LOCAL APP KEY`：手动输入，或在对应字段按 `g` 生成
 
 3. 回到主界面，按 `r` 开启 Remote/Web，再按 `Enter` 启动 remote session。
 
-4. 浏览器打开终端输出的本地地址，输入 `LOCAL TOKEN`，选择 session 后进入 terminal。
+4. 浏览器打开终端输出的本地地址，输入 `LOCAL APP ID` / `LOCAL APP KEY`，选择 session 后进入 terminal。
 
-local 模式默认只监听 `127.0.0.1`。终端只输出不带 token 的本地访问地址。浏览器打开页面后需要手动输入 token，前端会用 `sessionStorage` 做浏览器会话级缓存；关闭该浏览器会话后需要重新输入。所有 session list、session API 和 WebSocket 连接仍然需要 token。
+local 模式默认只监听 `127.0.0.1`。终端只输出不带认证信息的本地访问地址。浏览器打开页面后需要手动输入 appId/appKey，前端只保存由 appKey 生成的 24 小时 HMAC 签名票据，不保存 appKey；票据过期或关闭浏览器会话后需要重新输入。所有 session list、session API 和 WebSocket 连接仍然需要签名认证。
 
-每个启用 Remote/Web 的 `ccode` 进程都会创建一个唯一 tmux session，session 名由配置里的 `session_name` 前缀、时间戳和进程号组成，例如 `ccode-claude-20260509-153022-12345`。本机只启动一个共享 remote hub，多个本地 `ccode` 进程会复用同一个 host/port/token。浏览器认证后会先显示 session 列表，选择某个 session 后进入 terminal，也可以返回列表重新选择。
+每个启用 Remote/Web 的 `ccode` 进程都会创建一个唯一 tmux session，session 名由配置里的 `session_name` 前缀、时间戳和进程号组成，例如 `ccode-claude-20260509-153022-12345`。本机只启动一个共享 remote hub，多个本地 `ccode` 进程会复用同一个 host/port/appId/appKey。浏览器认证后会先显示 session 列表，选择某个 session 后进入 terminal，也可以返回列表重新选择。
 
-如果通过 Cloudflare Tunnel、Nginx、Caddy 等反向代理暴露 local hub，建议额外叠加 Cloudflare Access、Basic Auth 或 OAuth2 proxy。监听 `0.0.0.0` 会把所有 remote sessions 暴露给网络内可达主机，请保护好访问入口和 token。
+如果通过 Cloudflare Tunnel、Nginx、Caddy 等反向代理暴露 local hub，建议额外叠加 Cloudflare Access、Basic Auth 或 OAuth2 proxy。监听 `0.0.0.0` 会把所有 remote sessions 暴露给网络内可达主机，请保护好访问入口和 app credentials。
 
 ```bash
 cloudflared tunnel --url http://127.0.0.1:8765
 ```
 
-local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、session 注册、session API 和 WebSocket 连接状态，不记录 token。启动 hub 前如果日志超过 5 MiB 会自动轮转，默认保留 3 个历史文件（`.1`、`.2`、`.3`）。
+local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、session 注册、session API 和 WebSocket 连接状态，不记录 appKey。启动 hub 前如果日志超过 5 MiB 会自动轮转，默认保留 3 个历史文件（`.1`、`.2`、`.3`）。
 
 ### server 模式和 `ccode-remote-server`
 
@@ -238,7 +242,7 @@ local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、sessio
 ```text
                   Browser
                      │
-                     │ HTTPS/WSS + admin token
+                     │ HTTPS/WSS + admin HMAC
                      ▼
           ┌───────────────────────┐
           │ ccode-remote-server   │
@@ -263,31 +267,35 @@ local hub 日志写入 `~/.ccode/remote_server.log`，记录 hub 启停、sessio
 
 server 不反连客户端，所以客户端可以在 NAT、家庭网络或公司内网后面。只要客户端能主动访问 server，就可以注册设备和暴露自己的 remote sessions。
 
-#### server token
+#### server app credentials
 
-server token 不会自动生成，必须通过环境变量显式设置：
+server app credentials 不会自动生成，必须通过环境变量显式设置。认证时网络上传输 appId、timestamp 和 HMAC sign，不传输 appKey：
 
-- `CCODE_REMOTE_SERVER_ADMIN_TOKEN`：浏览器 Web UI / `/api/*` / browser WebSocket 使用的管理 token。
-- `CCODE_REMOTE_SERVER_CLIENT_TOKEN`：各设备客户端 connector 注册和心跳使用的 token。
+- `CCODE_REMOTE_SERVER_ADMIN_APP_ID` / `CCODE_REMOTE_SERVER_ADMIN_APP_KEY`：浏览器 Web UI / `/api/*` / browser WebSocket 使用的管理凭据。
+- `CCODE_REMOTE_SERVER_CLIENT_APP_ID` / `CCODE_REMOTE_SERVER_CLIENT_APP_KEY`：各设备客户端 connector 注册和心跳使用的客户端凭据。
 - `CCODE_REMOTE_SERVER_HOST` / `CCODE_REMOTE_SERVER_PORT`：可选，默认监听 `127.0.0.1:8765`。
 
 启动中心 server：
 
 ```bash
-CCODE_REMOTE_SERVER_ADMIN_TOKEN="admin-secret" \
-CCODE_REMOTE_SERVER_CLIENT_TOKEN="client-secret" \
+CCODE_REMOTE_SERVER_ADMIN_APP_ID="admin-app" \
+CCODE_REMOTE_SERVER_ADMIN_APP_KEY="admin-secret" \
+CCODE_REMOTE_SERVER_CLIENT_APP_ID="client-app" \
+CCODE_REMOTE_SERVER_CLIENT_APP_KEY="client-secret" \
 ccode-remote-server --host 127.0.0.1 --port 8765
 ```
 
 如果使用源码开发环境运行：
 
 ```bash
-CCODE_REMOTE_SERVER_ADMIN_TOKEN="admin-secret" \
-CCODE_REMOTE_SERVER_CLIENT_TOKEN="client-secret" \
+CCODE_REMOTE_SERVER_ADMIN_APP_ID="admin-app" \
+CCODE_REMOTE_SERVER_ADMIN_APP_KEY="admin-secret" \
+CCODE_REMOTE_SERVER_CLIENT_APP_ID="client-app" \
+CCODE_REMOTE_SERVER_CLIENT_APP_KEY="client-secret" \
 uv run --extra remote-server ccode-remote-server --host 127.0.0.1 --port 8765
 ```
 
-浏览器访问 server 页面时输入 `admin-secret`。如果未设置 `CCODE_REMOTE_SERVER_ADMIN_TOKEN`，管理 API 会返回 401，页面上任何 token 都无法通过认证。
+浏览器访问 server 页面时输入 admin appId/appKey。前端只保存 24 小时有效的 HMAC 签名票据，不保存 appKey。如果未设置 `CCODE_REMOTE_SERVER_ADMIN_APP_ID` / `CCODE_REMOTE_SERVER_ADMIN_APP_KEY`，管理 API 会返回 401。
 
 #### 客户端设备配置
 
@@ -301,7 +309,7 @@ uv tool install 'ccoding[remote-client]'
 
 - `MODE`：`server`
 - `SERVER URL`：中心 server 地址，例如 `http://127.0.0.1:8765`；如果只填 `127.0.0.1:8765`，会自动按 `http://127.0.0.1:8765` 处理
-- `CLIENT TOKEN`：与 server 的 `CCODE_REMOTE_SERVER_CLIENT_TOKEN` 一致
+- `CLIENT APP ID` / `CLIENT APP KEY`：与 server 的 `CCODE_REMOTE_SERVER_CLIENT_APP_ID` / `CCODE_REMOTE_SERVER_CLIENT_APP_KEY` 一致
 - `DEVICE NAME`：设备显示名，可留空后由配置迁移填充 hostname
 - `DEVICE ID`：稳定设备 ID，可留空后自动生成
 - `AUTO CONNECT`：是否默认自动连接中心 server
@@ -333,7 +341,7 @@ server 只做 registry/router/relay，不保存 terminal frame data，不保存
 
 #### Cloudflare Tunnel / 反向代理
 
-如果用 Cloudflare Tunnel 暴露中心 server，只需要 tunnel server 这一处入口，多台客户端设备都配置同一个 `SERVER URL` 和 `CLIENT TOKEN`：
+如果用 Cloudflare Tunnel 暴露中心 server，只需要 tunnel server 这一处入口，多台客户端设备都配置同一个 `SERVER URL` 和 `CLIENT APP ID` / `CLIENT APP KEY`：
 
 ```bash
 cloudflared tunnel --url http://127.0.0.1:8765

{ccoding-0.2.2 → ccoding-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ccoding"
-version = "0.2.2"
+version = "0.2.4"
 description = "Curses-based Claude Code launcher"
 readme = "README.md"
 license = { file = "LICENSE" }

{ccoding-0.2.2 → ccoding-0.2.4}/src/ccode/config.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import json
+import secrets
 import socket
 import uuid
 from pathlib import Path
@@ -32,11 +33,13 @@ DEFAULT_REMOTE: dict[str, Any] = {
     "local": {
         "host": "127.0.0.1",
         "port": 8765,
-        "token": "",
+        "appId": "",
+        "appKey": "",
     },
     "server": {
         "url": "",
-        "token": "",
+        "appId": "",
+        "appKey": "",
         "device_name": "",
         "device_id": "",
         "auto_connect": True,
@@ -103,6 +106,10 @@ def _new_device_id() -> str:
     return f"ccode-{uuid.uuid4().hex}"
 
 
+def _new_app_id() -> str:
+    return f"app_{secrets.token_urlsafe(9)}"
+
+
 def normalize_remote(remote: Any) -> dict[str, Any]:
     normalized = copy.deepcopy(DEFAULT_REMOTE)
     if not isinstance(remote, dict):
@@ -132,18 +139,31 @@ def normalize_remote(remote: Any) -> dict[str, Any]:
         port = remote.get("port")
     if isinstance(port, int):
         normalized["local"]["port"] = port
-    token = local.get("token") if isinstance(local, dict) else None
-    if not isinstance(token, str):
-        token = remote.get("token")
-    if isinstance(token, str):
-        normalized["local"]["token"] = token
+    local_app_id = local.get("appId") if isinstance(local, dict) else None
+    local_app_key = local.get("appKey") if isinstance(local, dict) else None
+    local_token = local.get("token") if isinstance(local, dict) else None
+    if not isinstance(local_token, str):
+        local_token = remote.get("token")
+    if isinstance(local_app_id, str):
+        normalized["local"]["appId"] = local_app_id
+    elif isinstance(local_token, str) and local_token:
+        normalized["local"]["appId"] = _new_app_id()
+    if isinstance(local_app_key, str):
+        normalized["local"]["appKey"] = local_app_key
+    elif isinstance(local_token, str):
+        normalized["local"]["appKey"] = local_token
 
     server = remote.get("server") if isinstance(remote.get("server"), dict) else {}
     if isinstance(server, dict):
-        for key in ("url", "token", "device_name", "device_id"):
+        server_token = server.get("token")
+        for key in ("url", "appId", "appKey", "device_name", "device_id"):
             value = server.get(key)
             if isinstance(value, str):
                 normalized["server"][key] = value
+        if not normalized["server"].get("appId") and isinstance(server_token, str) and server_token:
+            normalized["server"]["appId"] = _new_app_id()
+        if not normalized["server"].get("appKey") and isinstance(server_token, str):
+            normalized["server"]["appKey"] = server_token
         for key in ("auto_connect", "verify_tls"):
             value = server.get(key)
             if isinstance(value, bool):

{ccoding-0.2.2 → ccoding-0.2.4}/src/ccode/remote.py

@@ -15,20 +15,20 @@ from .remote_common import (
     _new_session_id,
     _sanitize_session_name,
     _utc_now,
+    AuthResult,
     asset_text,
-    auth_token_matches,
     file_lock,
     missing_extra_message,
+    remote_local_app_id,
+    remote_local_app_key,
     remote_local_host_port,
-    remote_local_token,
     remote_local_url,
     remote_mode,
     remote_server_config,
     remote_server_url,
     rotate_log,
-    token_matches,
+    verify_auth_payload,
     web_asset_text,
-    websocket_auth_token,
 )
 
 REMOTE_SESSIONS_PATH = CONFIG_DIR / "remote_sessions.json"
@@ -321,29 +321,33 @@ def ensure_remote_hub(config: dict[str, Any]) -> str | None:
         return f"Failed to start remote hub. See {REMOTE_SERVER_LOG_PATH} for details."
 
 
-_TOKEN_CACHE: tuple[float | None, str] = (None, "")
+_AUTH_CACHE: tuple[float | None, str, str] = (None, "", "")
 
 
-def _current_remote_token() -> str:
-    global _TOKEN_CACHE
+def _current_remote_credentials() -> tuple[str, str]:
+    global _AUTH_CACHE
     try:
         mtime = CONFIG_PATH.stat().st_mtime
     except FileNotFoundError:
         mtime = None
-    cached_mtime, cached_token = _TOKEN_CACHE
+    cached_mtime, app_id, app_key = _AUTH_CACHE
     if cached_mtime == mtime:
-        return cached_token
-    token = remote_local_token(load_config()).strip()
-    _TOKEN_CACHE = (mtime, token)
-    return token
+        return app_id, app_key
+    config = load_config()
+    app_id = remote_local_app_id(config).strip()
+    app_key = remote_local_app_key(config).strip()
+    _AUTH_CACHE = (mtime, app_id, app_key)
+    return app_id, app_key
 
 
-def _valid_token(token: str | None) -> bool:
-    return token_matches(_current_remote_token(), token)
+def _valid_auth_payload(payload: dict[str, Any], scope: str) -> AuthResult:
+    app_id, app_key = _current_remote_credentials()
+    return verify_auth_payload(app_id, app_key, payload, scope)
 
 
-def _valid_auth_token(token: str | None, authorization: str | None = None) -> bool:
-    return auth_token_matches(_current_remote_token(), token, authorization)
+def _auth_response(result: AuthResult, response_class: Any) -> Any:
+    status_code = 401 if result.error in {"auth_required", "reauth_required"} else 403
+    return response_class({"error": result.error or "auth_failed", "message": result.message}, status_code=status_code)
 
 
 async def _attach_websocket_to_session(websocket: Any, session: dict[str, Any]) -> None:
@@ -402,11 +406,11 @@ def create_app() -> Any:
 
     @app.get("/app.js")
     async def app_js() -> Response:
-        return Response(asset_text("app.js"), media_type="application/javascript")
+        return Response(asset_text("app.js"), media_type="application/javascript", headers={"Cache-Control": "no-store"})
 
     @app.get("/style.css")
     async def style_css() -> Response:
-        return Response(asset_text("style.css"), media_type="text/css")
+        return Response(asset_text("style.css"), media_type="text/css", headers={"Cache-Control": "no-store"})
 
     @app.get("/assets/{asset_name}")
     async def web_asset(asset_name: str) -> Response:
@@ -418,20 +422,22 @@ def create_app() -> Any:
         media_type = media_types.get(asset_name)
         if media_type is None:
             return Response(status_code=404)
-        return Response(web_asset_text(asset_name), media_type=media_type)
+        return Response(web_asset_text(asset_name), media_type=media_type, headers={"Cache-Control": "no-store"})
 
     @app.get("/health")
     async def health() -> dict[str, Any]:
-        return {"ok": True, "name": REMOTE_HUB_NAME, "multi_session": True}
+        return {"ok": True, "name": REMOTE_HUB_NAME, "multi_session": True, "remote_kind": "local"}
 
     @app.get("/api/sessions")
     async def sessions(
-        token: str | None = None,
-        authorization: str | None = Header(default=None),
+        x_ccode_app_id: str | None = Header(default=None),
+        x_ccode_timestamp: str | None = Header(default=None),
+        x_ccode_sign: str | None = Header(default=None),
     ) -> Response:
-        if not _valid_auth_token(token, authorization):
-            _log_event("api sessions unauthorized")
-            return JSONResponse({"error": "unauthorized"}, status_code=401)
+        auth_result = _valid_auth_payload({"appId": x_ccode_app_id, "timestamp": x_ccode_timestamp, "sign": x_ccode_sign}, "local.api")
+        if not auth_result.ok:
+            _log_event(f"api sessions unauthorized error={auth_result.error}")
+            return _auth_response(auth_result, JSONResponse)
         sessions = list_remote_sessions()
         _log_event(f"api sessions returned count={len(sessions)}")
         return JSONResponse({"sessions": sessions})
@@ -439,12 +445,14 @@ def create_app() -> Any:
     @app.get("/api/sessions/{session_id}")
     async def session_detail(
         session_id: str,
-        token: str | None = None,
-        authorization: str | None = Header(default=None),
+        x_ccode_app_id: str | None = Header(default=None),
+        x_ccode_timestamp: str | None = Header(default=None),
+        x_ccode_sign: str | None = Header(default=None),
     ) -> Response:
-        if not _valid_auth_token(token, authorization):
-            _log_event(f"api session detail unauthorized session_id={session_id}")
-            return JSONResponse({"error": "unauthorized"}, status_code=401)
+        auth_result = _valid_auth_payload({"appId": x_ccode_app_id, "timestamp": x_ccode_timestamp, "sign": x_ccode_sign}, "local.api")
+        if not auth_result.ok:
+            _log_event(f"api session detail unauthorized session_id={session_id} error={auth_result.error}")
+            return _auth_response(auth_result, JSONResponse)
         session = get_remote_session(session_id)
         if session is None or not _session_is_running(session):
             _log_event(f"api session detail not_found session_id={session_id}")
@@ -454,12 +462,14 @@ def create_app() -> Any:
 
     @app.get("/api/session")
     async def legacy_session(
-        token: str | None = None,
-        authorization: str | None = Header(default=None),
+        x_ccode_app_id: str | None = Header(default=None),
+        x_ccode_timestamp: str | None = Header(default=None),
+        x_ccode_sign: str | None = Header(default=None),
     ) -> Response:
-        if not _valid_auth_token(token, authorization):
-            _log_event("legacy api session unauthorized")
-            return JSONResponse({"error": "unauthorized"}, status_code=401)
+        auth_result = _valid_auth_payload({"appId": x_ccode_app_id, "timestamp": x_ccode_timestamp, "sign": x_ccode_sign}, "local.api")
+        if not auth_result.ok:
+            _log_event(f"legacy api session unauthorized error={auth_result.error}")
+            return _auth_response(auth_result, JSONResponse)
         sessions = list_remote_sessions()
         _log_event(f"legacy api session requested running_count={len(sessions)}")
         if len(sessions) == 1:
@@ -471,9 +481,10 @@ def create_app() -> Any:
     async def websocket_session(websocket: FastAPIWebSocket, session_id: str) -> None:
         await websocket.accept()
         _log_event(f"websocket accepted session_id={session_id}")
-        if not _valid_token(await websocket_auth_token(websocket)):
-            _log_event(f"websocket unauthorized session_id={session_id}")
-            await websocket.send_json({"type": "status", "message": "unauthorized: invalid token"})
+        auth_result = _valid_auth_payload(dict(websocket.query_params), "local.ws")
+        if not auth_result.ok:
+            _log_event(f"websocket unauthorized session_id={session_id} error={auth_result.error}")
+            await websocket.send_json({"type": "error", "error": auth_result.error, "message": auth_result.message})
             await websocket.close(code=1008)
             return
         session = get_remote_session(session_id)
@@ -488,9 +499,10 @@ def create_app() -> Any:
     async def legacy_websocket(websocket: FastAPIWebSocket) -> None:
         await websocket.accept()
         _log_event("legacy websocket accepted")
-        if not _valid_token(await websocket_auth_token(websocket)):
-            _log_event("legacy websocket unauthorized")
-            await websocket.send_json({"type": "status", "message": "unauthorized: invalid token"})
+        auth_result = _valid_auth_payload(dict(websocket.query_params), "local.ws")
+        if not auth_result.ok:
+            _log_event(f"legacy websocket unauthorized error={auth_result.error}")
+            await websocket.send_json({"type": "error", "error": auth_result.error, "message": auth_result.message})
             await websocket.close(code=1008)
             return
         sessions = list_remote_sessions()
@@ -530,11 +542,11 @@ def run_remote_hub_forever(config: dict[str, Any]) -> str | None:
 
 def run_remote_session(config: dict[str, Any], args: list[str]) -> str | None:
     mode = remote_mode(config)
-    if mode == "local" and not remote_local_token(config).strip():
-        return "Remote token is required. Set it in the config screen or press g on the TOKEN field to generate one."
+    if mode == "local" and (not remote_local_app_id(config).strip() or not remote_local_app_key(config).strip()):
+        return "Remote app ID and app key are required. Set them in the config screen or press g on the APP ID / APP KEY fields to generate them."
     server = remote_server_config(config)
-    if mode == "server" and (not remote_server_url(config) or not str(server.get("token") or "").strip()):
-        return "Remote server URL and client token are required in server mode."
+    if mode == "server" and (not remote_server_url(config) or not str(server.get("appId") or "").strip() or not str(server.get("appKey") or "").strip()):
+        return "Remote server URL, client app ID, and client app key are required in server mode."
     error = _check_runtime()
     if error is not None:
         return error
@@ -604,7 +616,7 @@ def run_remote_session(config: dict[str, Any], args: list[str]) -> str | None:
         print(f"  {session_name}\n")
         if host == "0.0.0.0":
             print("Security warning:")
-            print("  Listening on 0.0.0.0 exposes all remote sessions to your network. Protect the access URL and token.\n")
+            print("  Listening on 0.0.0.0 exposes all remote sessions to your network. Protect the access URL and app credentials.\n")
         print("This terminal will attach to this tmux session. The web hub stays running independently.")
         print("Detach with Ctrl+B then D. Browser users can choose this session from the session list.\n")
 

{ccoding-0.2.2 → ccoding-0.2.4}/src/ccode/remote_cli.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from .config import load_config, mask_secret
-from .remote_common import pid_from_path, remote_display_url, remote_local_host_port, remote_local_token, remote_mode, remote_server_config, remote_server_url
+from .remote_common import pid_from_path, remote_display_url, remote_local_app_id, remote_local_app_key, remote_local_host_port, remote_mode, remote_server_config, remote_server_url
 
 
 def _format_bytes(value: int) -> str:
@@ -90,12 +90,14 @@ def print_status(kind: str | None = None) -> int:
         server = remote_server_config(config)
         print(f"  device name: {server.get('device_name') or '<unset>'}")
         print(f"  device id: {server.get('device_id') or '<unset>'}")
-        print(f"  client token: {mask_secret(str(server.get('token') or ''))}")
+        print(f"  client app id: {server.get('appId') or '<unset>'}")
+        print(f"  client app key: {mask_secret(str(server.get('appKey') or ''))}")
     else:
         host, port = remote_local_host_port(config)
         print(f"  host: {host}")
         print(f"  port: {port}")
-        print(f"  token: {mask_secret(remote_local_token(config))}")
+        print(f"  app id: {remote_local_app_id(config) or '<unset>'}")
+        print(f"  app key: {mask_secret(remote_local_app_key(config))}")
     print()
 
     if effective == "client":