@clawos-dev/clawd 0.2.143-beta.302.5df5cc1 → 0.2.143-beta.303.ab28945

package/dist/persona-defaults/persona-dataclaw-builder/CLAUDE.md

@@ -13,7 +13,7 @@ daemon 启动你时已注入两个 env：
 所有调用都是 `POST $CLAWD_DAEMON_URL/api/rpc/<method>` + JSON body + `X-Clawd-Session-Id` header。
 
 **状态 A：未绑 project（fresh session）** —— 起手三步：
-1. 主动问「老板想看什么数据的页？」（一句话，别长 prompt）
+1. 主动问「老板想看什么数据的页？」（一句话，别长 prompt）。顺带提醒：稍后需要老板给一把 dataclaw apikey（向刘浩索取；只要冒号后的 secret 段）。
 2. 老板描述需求 → **反问「项目叫什么名字」**（不擅自命名）
 3. 拿到名字后建 project：
 
@@ -24,7 +24,7 @@ curl -sS -X POST "$CLAWD_DAEMON_URL/api/rpc/appBuilder.createProject" \
 ```
 返回 `result.projectDir` 就是项目目录绝对路径，**记住它**，后续 cd / 写文件都用它。重名报 `VALIDATION_ERROR` → 让老板换名。createProject 后 daemon 自动 scaffold 模板（dataclaw 起手 app）+ 设 stage='install-pending'。
 
-**状态 B：已绑 project** —— UI 双栏（左 chat + 右实时预览）。接着按顺序做 3 步：
+**状态 B：已绑 project** —— UI 双栏（左 chat + 右实时预览）。接着按顺序做：
 
 1. 上报安装 + 装依赖：
 ```bash
@@ -34,13 +34,23 @@ curl -sS -X POST "$CLAWD_DAEMON_URL/api/rpc/appBuilder.reportStage" \
 ```
 然后 `cd <projectDir>` → `pnpm install`（模板有 server/ 和 web/ 两套 deps）。
 
-2. 起 dev server（双栏预览）：
+2. 写入 apikey（**起 dev server 之前**，否则预览查不到数）：向老板要 dataclaw apikey（只要冒号后的 secret 段），写进 `<projectDir>/server/.env`：
+```bash
+cat > "<projectDir>/server/.env" <<EOF
+DATACLAW_SERVICE_URL=https://120.48.21.36
+DATACLAW_API_KEY=<老板给的 secret>
+PORT=3000
+EOF
+```
+key 只存这里：dev 由 dotenv 加载、发布 FC 时 pre-deploy 自动从这读出注入 FC（`.env` 被 `.fcignore` 排除、不进部署包）。老板要换 key → 重写本文件后重启 dev server。
+
+3. 起 dev server（双栏预览）：
 ```bash
 curl -sS -X POST "$CLAWD_DAEMON_URL/api/rpc/appBuilder.startDevServer" \
   -H "Content-Type: application/json" -H "X-Clawd-Session-Id: $CLAWD_SESSION_ID" -d '{}'
 ```
 
-3. 任一步失败上报 failed：
+4. 任一步失败上报 failed：
 ```bash
 curl -sS -X POST "$CLAWD_DAEMON_URL/api/rpc/appBuilder.reportStage" \
   -H "Content-Type: application/json" -H "X-Clawd-Session-Id: $CLAWD_SESSION_ID" \
@@ -51,16 +61,26 @@ curl -sS -X POST "$CLAWD_DAEMON_URL/api/rpc/appBuilder.reportStage" \
 
 **发布上线**：老板点 PreviewPane「发布上线」按钮走 daemon RPC，happy path 完全跳过你。只有失败时 daemon 才发来一条以 `发布失败：[` 开头的消息（含 `.publish.log` 路径），那时你读日志、修问题、重跑发布。改完代码即时 HMR 刷新，不重新部署。
 
-## 数据来源：dataclaw-service（只读，通路 A）
-生成的 app 后端直调 dataclaw-service HTTP（`/api/flexible-query`、`/api/intent-execute`、`/api/schema`），用**建页人(builder)的身份**取数、纯展示、不写数据。具体查询能力见 §「dataclaw 查询能力」。
+## 数据来源：dataclaw 公网查询 API（只读，Bearer）
+生成的 app 后端用**老板提供的 apikey** 以 `Authorization: Bearer <secret>` 调 dataclaw 公网 service（`https://120.48.21.36`，自签证书，后端已放开 TLS 校验），纯展示、不写数据。前端只调本 app 的 `/api/*`，apikey 由后端注入、绝不下发浏览器。有 key 即全量只读查询（无身份裁剪）。具体端点见 §「dataclaw 查询能力」。
+
+## dataclaw 查询能力（公网端点速查）
+模板后端 BFF（`server/src/dataclaw`）已封好以下端点，前端经本 app `/api/*` 调用：
+
+| 端点 | 方法 | 入参 | 返回要点 |
+|---|---|---|---|
+| `/api/schema` | GET | `dataset?` | 数据集字段定义（metadata_user / consultant_progress / performance），字段带 aliases + operators |
+| `/api/performance` | POST | `{startDate,endDate}` 必填 | `total` / `queryRange` / `byDateField`(billing/invoice/payment 各 total+amount) / `items[]` 明细 |
+| `/api/ppl` | POST | `{startDate,endDate}` 必填 | `total` / `byStatus` / `byCustomer` 聚合（**只聚合无明细**） |
+| `/api/consultants` | GET | `keyword` | `matches[]`（顾问基本信息） |
+| `/api/intent` | POST | 意图 JSON（domain+intent+过滤，字段见 schema） | 结构化查询结果 |
 
-## dataclaw 查询能力
-本章节在后续模板/知识充实阶段填全（来源：dataclaw-src 仓库 workspace/docs/dataclaw-builder-architecture.md）。当前仅建骨架。
+约定：所有返回都带 `_provenance` 溯源字段，前端用 `INTERNAL_FIELDS` 过滤不展示；业绩 / 进展广查询慢，务必带较短时间窗或收窄条件。起手页（业绩查询）是范例，按老板需求改数据集 / 端点 / 展示即可。
 
 ## 双客户
 业务用户自助建简单页（语气业务化、屏蔽技术细节）；管理员代建复杂页（可技术化）。
 
 ## 红线
 - 只读：绝不让生成的 app 往 dataclaw 写数据 / 不接 Supabase 写库。
-- 数据范围是隐式 AND（按建页人身份兜），**绝不把 scope（self/team/all）做成用户可选下拉**——等于越权。
+- apikey 只存 `server/.env`、只在后端用，**绝不下发到前端 / 不硬编码进代码 / 不写进会被打包的文件**。
 - persona 目录只读；项目路径以 createProject 返回的 projectDir 为准。

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/README.md

@@ -1,13 +1,13 @@
 # extension-kit —— 从零到发布的 extension 流水线
 
-把「前端 + 后端 + Supabase 的 extension 发布到阿里云 FC(serverless,免 Docker)」固化成可复用流水线。开发靠人/agent,发布全自动。
+把「前端 + 后端的 extension 发布到阿里云 FC(serverless,免 Docker)」固化成可复用流水线。开发靠人/agent,发布全自动。
 
 ## 设计理念:契约层 + 可插拔技术栈
 
 FC 对应用只有一条要求:**一个监听 `$PORT` 的 HTTP server**。所以固化的是「发布管道」,不是技术栈。
 
 - **共享 deploy-kit(凭证 + 脚本骨架 + bootstrap,全 FC persona 一份)**:`$HOME/.clawd/deploy-kit/`(`scripts/` + `contract/bootstrap` + `.secrets/aliyun.env`)
-- **persona 特化(本目录)**:`config.env`(dataclaw/TTC 注入值) + `contract/s.yaml.tmpl`(占位符清单) + `hooks/pre-deploy.sh`(发布前置) + `examples/`(默认 `nestjs-react`)
+- **persona 特化(本目录)**:`config.env`(dataclaw 注入值) + `contract/s.yaml.tmpl`(占位符清单) + `hooks/pre-deploy.sh`(发布前置) + `examples/`(默认 `nestjs-react`)
 
 ## 目录
 
@@ -24,9 +24,9 @@ deploy-kit/
 
 # 本 persona 的 extension-kit(只放特化资产)
 extension-kit/
-├── config.env              dataclaw/TTC 注入值(region / Node层 / DATACLAW_SERVICE_URL / TTC_*)
+├── config.env              dataclaw 注入值(region / Node层 / DATACLAW_SERVICE_URL)
 ├── contract/s.yaml.tmpl    FC 部署模板(占位符,publish.sh 通用扫描替换)
-├── hooks/pre-deploy.sh     发布前置(校验 dataclaw.env、生成 SESSION_SECRET、推导 APP_BASE_URL)
+├── hooks/pre-deploy.sh     发布前置(从生成 app 的 server/.env 读出 DATACLAW_API_KEY、注入 FC)
 └── examples/nestjs-react/  默认示例(含模板自带 ext.conf)
 ```
 
@@ -38,8 +38,8 @@ extension-kit/
 PR="$HOME/.clawd/personas/persona-dataclaw-builder"; DK="$HOME/.clawd/deploy-kit"
 
 # 1) scaffold(daemon 已自动跑;手动签名: new-extension.sh <name> <模板源目录> <目标目录>)
-# 2) 改 web/ 和 server/ 业务逻辑(只读查 dataclaw-service,不接 Supabase 写库)
-# 3) 一键发布到 FC,输出公网地址(发布前需在 $PR/.secrets/dataclaw.env 填 DATACLAW_INTERNAL_SECRET)
+# 2) 改 web/ 和 server/ 业务逻辑(只读查 dataclaw 公网 API,不接 Supabase 写库)
+# 3) 一键发布到 FC,输出公网地址(apikey 在建页时已写进生成 app 的 server/.env,无需额外配置)
 "$DK/scripts/publish.sh" <projDir> "$PR"
 # 4) 不要了就一键清理 FC 资源
 "$DK/scripts/remove-extension.sh" <projDir> "$PR"
@@ -50,10 +50,9 @@ PR="$HOME/.clawd/personas/persona-dataclaw-builder"; DK="$HOME/.clawd/deploy-kit
 | 步骤 | 谁做 |
 |------|------|
 | new-extension 脚手架 | 🟢 脚本 |
-| 设计 Supabase schema | 🔴 人/agent(每个 extension 不同) |
 | 写前后端业务 | 🔴 人/agent |
 | publish(build/部署/域名/验证) | 🟢 脚本 |
-| remove(清 FC + 表) | 🟢 脚本 |
+| remove(清 FC) | 🟢 脚本 |
 
 ## 清理一个 extension
 
@@ -61,13 +60,7 @@ PR="$HOME/.clawd/personas/persona-dataclaw-builder"; DK="$HOME/.clawd/deploy-kit
 "$HOME/.clawd/deploy-kit/scripts/remove-extension.sh" <projDir> "$HOME/.clawd/personas/persona-dataclaw-builder"
 ```
 
-先 `s remove` 删 FC 函数+触发器+自定义域名，再按 `ext.conf` 的 `SUPABASE_TABLES` 删它的表。
-
-**脚本怎么知道删哪个表**:靠 `ext.conf` 里显式声明的 `SUPABASE_TABLES="myapp_xxx"`(建表时填进去,extension 的"自描述")。三道安全锁:
-
-1. 每个表必须 `<app>_` 前缀,否则**拒绝删**(物理上防误伤 clawos 共享库)
-2. 删前列出所有要删的表
-3. 要手输 `yes` 确认(数据不可逆,不用 `-y` 静默删)
+`s remove` 删 FC 函数+触发器+自定义域名。
 
 > SLS 日志 project / OSS 代码桶是**账号级共享**(多 extension 共用),不随单个 extension 删。
 
@@ -89,11 +82,10 @@ PR="$HOME/.clawd/personas/persona-dataclaw-builder"; DK="$HOME/.clawd/deploy-kit
 
 ## 红线(都是踩坑换来的,见记忆 fc-nodejs-deploy-recipe)
 
-- **Supabase 是 clawos 共享生产库**:新表必须 `<app>_` 前缀,**绝不 drop/alter clawos 已有表**
 - **必须绑自定义域名**(fc3-domain auto),否则 `fcapp.run` 默认 URL 强制下载网页、浏览器不渲染
 - **不用 SAE**(Node 无代码包,只能镜像=要 Docker);不用 `custom.debian10`/裸 command(node 找不到 / CAExited)
-- **长连接 / WebSocket 推送不适合 FC** → 用 Supabase Realtime(FC 不维持长连接)
+- **长连接 / WebSocket 推送不适合 FC**(FC 不维持长连接)
 
 ## 不固化的(留给人/agent)
 
-数据模型设计、业务逻辑、建表前的归属判断、发布失败时的异常排查。
+业务逻辑、发布失败时的异常排查。

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/config.env

@@ -8,11 +8,8 @@ REGION=cn-hangzhou
 FC_RUNTIME=custom.debian12
 NODE_LAYER=acs:fc:cn-hangzhou:official:layers/Nodejs22/versions/1
 
-# dataclaw-service（通路 A，只读）—— 部署后填实际可达地址
-DATACLAW_SERVICE_URL=
-# TTC 飞书登录门禁（无密钥经纪，只重定向到 TTC）
-TTC_AUTH_BASE=https://app.ttcadvisory.com
-TTC_API_BASE=https://api.ttcadvisory.com
+# dataclaw 公网查询 API（只读，Bearer）—— ext.conf 可覆盖；apikey 走生成 app 的 server/.env，不在这里
+DATACLAW_SERVICE_URL=https://120.48.21.36
 
 # FC 资源规格(够跑轻量 extension;按需改)
 FC_CPU=0.35

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/contract/s.yaml.tmpl

@@ -32,12 +32,7 @@ resources:
         PORT: '9000'
         APP_ENTRY: __FC_ENTRY__
         DATACLAW_SERVICE_URL: __DATACLAW_SERVICE_URL__
-        DATACLAW_AS_UNION_ID: __DATACLAW_AS_UNION_ID__
-        DATACLAW_INTERNAL_SECRET: __DATACLAW_INTERNAL_SECRET__
-        TTC_AUTH_BASE: __TTC_AUTH_BASE__
-        TTC_API_BASE: __TTC_API_BASE__
-        APP_BASE_URL: __APP_BASE_URL__
-        SESSION_SECRET: __SESSION_SECRET__
+        DATACLAW_API_KEY: __DATACLAW_API_KEY__
       triggers:
         - triggerName: httpTrigger
           triggerType: http

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/ext.conf

@@ -1,5 +1,6 @@
 CODE_DIR=./server
 FC_ENTRY=dist/main.js
 BUILD_CMD="cd web && pnpm install && pnpm build && cd ../server && pnpm install && pnpm build && mkdir -p dist/public && cp -R ../web/dist/. dist/public/"
-# 建页人 union_id（dataclaw 数据范围按它裁剪）；persona 建页时调 auth.getIdentity 取到后填入。
-DATACLAW_AS_UNION_ID=""
+# dataclaw 公网查询 API（只读，Bearer）。apikey 不在这里——走 server/.env 的 DATACLAW_API_KEY，
+# 发布时 pre-deploy.sh 从 server/.env 读出、注入 FC（避免 key 落入随项目走的非密文件）。
+DATACLAW_SERVICE_URL=https://120.48.21.36

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/.env.example

@@ -1,15 +1,6 @@
-# dataclaw 通路 A（后端直调 dataclaw-service HTTP，只读）
-DATACLAW_SERVICE_URL=http://dataclaw-service:8080
-# 建页人 builder 的 union_id —— 数据范围按此身份在 dataclaw 侧自动裁剪
-DATACLAW_AS_UNION_ID=on_xxxxxxxxxxxxxxxx
-# 服务间共享密钥（与 dataclaw-service 的 internal secret 对齐）；勿提交真实值
-DATACLAW_INTERNAL_SECRET=replace-me
-# 本地起页跳过门禁（仅 dev；上线删或置 0）
-DATACLAW_AUTH_DISABLED=1
+# dataclaw 公网查询 API（只读，Bearer 鉴权；自签证书，后端已放开 TLS 校验）
+DATACLAW_SERVICE_URL=https://120.48.21.36
+# 建页人提供的 dataclaw apikey —— 只填冒号后的 secret 段（如拿到 colleague-a:xxxx 则填 xxxx）。
+# dev 预览由 dotenv 加载本文件；发布 FC 时 pre-deploy.sh 从这里读出、注入 FC 环境变量（.env 不进部署包）。
+DATACLAW_API_KEY=
 PORT=3000
-
-# TTC 飞书登录门禁（无密钥经纪：重定向到 TTC，不持飞书密钥）
-TTC_AUTH_BASE=https://app.ttcadvisory.com
-TTC_API_BASE=https://api.ttcadvisory.com
-APP_BASE_URL=https://your-app.example.com   # 发布后的公网地址，回调用；HTTPS（cookie secure）
-SESSION_SECRET=replace-with-openssl-rand-hex-32

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "scripts": {
     "build": "nest build",
-    "start": "node --env-file=.env dist/main.js",
+    "start": "node dist/main.js",
     "start:dev": "nest start --watch",
     "dev": "nest start --watch"
   },
@@ -12,7 +12,6 @@
     "@nestjs/common": "^10.4.0",
     "@nestjs/core": "^10.4.0",
     "@nestjs/platform-express": "^10.4.0",
-    "cookie-parser": "^1.4.6",
     "dotenv": "^16.4.5",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1"
@@ -20,7 +19,6 @@
   "devDependencies": {
     "@nestjs/cli": "^10.4.0",
     "@nestjs/schematics": "^10.2.0",
-    "@types/cookie-parser": "^1.4.7",
     "@types/node": "^22.0.0",
     "@vitejs/plugin-react": "^4.4.0",
     "typescript": "^5.5.0",

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/app.module.ts

@@ -1,8 +1,8 @@
 import { Module } from '@nestjs/common';
 import { DataclawModule } from './dataclaw/dataclaw.module';
 
-// dataclaw 只读后端 BFF 起手骨架：默认只注册 DataclawModule（schema / query / intent /
-// consultants 四个只读端点，直调 dataclaw-service，身份按建页人 union_id 裁剪）。
+// dataclaw 只读后端 BFF 起手骨架：默认只注册 DataclawModule（schema / performance / ppl /
+// consultants / intent 五个只读端点，用建页人提供的 apikey 以 Bearer 调公网 dataclaw service）。
 // 业务逻辑由 assistant 按用户需求从零加（添 controller/module 进 imports 即可）。
 //
 // vite middleware / 静态资源 serve 路径仍由 main.ts 处理（dev mount vite，prod express.static），

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/dataclaw/dataclaw.client.ts

@@ -1,7 +1,11 @@
 import { Injectable, HttpException, OnModuleInit } from '@nestjs/common'
 import { DataclawConfig, loadDataclawConfig } from './dataclaw.config'
 
-// 端点超时（架构文档 §8.10）：schema / flexible-query 走默认；intent-execute 可能跑 LLM 编排，给 90s。
+// dataclaw 公网 service 用自签证书（文档要求 curl -k）。Node fetch(undici) 默认校验 TLS 会握手失败。
+// 本 app 唯一出站目标就是 dataclaw 这一个自签 https，进程级放开 TLS 校验即可（最小改动、零依赖）。
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+
+// 端点超时：schema / 固定查询走默认；intent-execute 可能跑 LLM 编排，给 90s。
 const TIMEOUT_MS = { default: 30_000, intent: 90_000 }
 
 @Injectable()
@@ -33,9 +37,8 @@ export class DataclawClient implements OnModuleInit {
         signal: ctrl.signal,
         headers: {
           'Content-Type': 'application/json',
-          // 身份注入：数据范围按建页人 union_id 在 dataclaw 侧裁剪 + 服务间共享密钥校验。
-          'X-User-UnionId': this.cfg.asUnionId,
-          'X-Internal-Secret': this.cfg.internalSecret,
+          // 鉴权：建页人提供的 dataclaw apikey，Bearer 传给公网 service（有 key 即全量只读查询）。
+          Authorization: `Bearer ${this.cfg.apiKey}`,
         },
         body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
       })
@@ -69,15 +72,22 @@ export class DataclawClient implements OnModuleInit {
     return this.call<any>('GET', '/api/schema', { query: { dataset } })
   }
 
-  flexibleQuery(body: unknown) {
-    return this.call<any>('POST', '/api/flexible-query', { body })
+  // 业绩查询（必填 startDate/endDate；可按顾问/团队/办公地点等收窄，参数名见 dataclaw 文档）。
+  performance(body: unknown) {
+    return this.call<any>('POST', '/api/performance', { body })
   }
 
-  intentExecute(body: unknown) {
-    return this.call<any>('POST', '/api/intent-execute', { body, timeout: TIMEOUT_MS.intent })
+  // 候选人进展 pipeline（必填 startDate/endDate）。返回聚合 byStatus/byCustomer。
+  ppl(body: unknown) {
+    return this.call<any>('POST', '/api/ppl', { body })
   }
 
   consultants(keyword: string) {
     return this.call<any>('GET', '/api/consultants', { query: { keyword } })
   }
+
+  // 结构化意图查询（高级）：上游已抽好的意图 JSON（domain+intent+过滤），字段定义见 /api/schema。
+  intentExecute(body: unknown) {
+    return this.call<any>('POST', '/api/intent-execute', { body, timeout: TIMEOUT_MS.intent })
+  }
 }

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/dataclaw/dataclaw.config.ts

@@ -1,18 +1,15 @@
 export interface DataclawConfig {
   baseUrl: string
-  asUnionId: string
-  internalSecret: string
+  apiKey: string
 }
 
 export function loadDataclawConfig(): DataclawConfig {
-  const baseUrl = (process.env.DATACLAW_SERVICE_URL || '').replace(/\/+$/, '')
-  const asUnionId = process.env.DATACLAW_AS_UNION_ID || ''
-  const internalSecret = process.env.DATACLAW_INTERNAL_SECRET || ''
-  const missing = [
-    !baseUrl && 'DATACLAW_SERVICE_URL',
-    !asUnionId && 'DATACLAW_AS_UNION_ID',
-    !internalSecret && 'DATACLAW_INTERNAL_SECRET',
-  ].filter(Boolean)
-  if (missing.length) throw new Error(`[dataclaw] 缺少必需 env: ${missing.join(', ')}`)
-  return { baseUrl, asUnionId, internalSecret }
+  const baseUrl = (process.env.DATACLAW_SERVICE_URL || 'https://120.48.21.36').replace(/\/+$/, '')
+  // 建页人提供的 dataclaw apikey（Bearer token，只填冒号后的 secret 段）。写进 server/.env，
+  // dev 由 dotenv 加载、FC 由 s.yaml 注入。缺失则拒启动（app 没它查不到数）。
+  const apiKey = process.env.DATACLAW_API_KEY || ''
+  if (!apiKey) {
+    throw new Error('[dataclaw] 缺少必需 env DATACLAW_API_KEY（建页人提供的 dataclaw apikey，写进 server/.env）')
+  }
+  return { baseUrl, apiKey }
 }

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/dataclaw/dataclaw.controller.ts

@@ -2,8 +2,7 @@ import { Body, Controller, Get, Post, Query } from '@nestjs/common'
 import { DataclawClient } from './dataclaw.client'
 
 // app 自己的只读 BFF。main.ts 已 setGlobalPrefix（'api' 或子路径 'preview/<port>/api'），
-// 故这里的路径不带 /api。
-// 登录门禁由 main.ts 的 Express authGate 中间件统一覆盖（含 /api/*），不再用 Nest guard。
+// 故这里的路径不带 /api。前端只调本 app 的 /api/*，apikey 由后端注入，绝不下发浏览器。
 @Controller()
 export class DataclawController {
   constructor(private readonly dc: DataclawClient) {}
@@ -13,18 +12,23 @@ export class DataclawController {
     return this.dc.getSchema(dataset)
   }
 
-  @Post('query')
-  query(@Body() body: unknown) {
-    return this.dc.flexibleQuery(body)
+  @Post('performance')
+  performance(@Body() body: unknown) {
+    return this.dc.performance(body)
   }
 
-  @Post('intent')
-  intent(@Body() body: unknown) {
-    return this.dc.intentExecute(body)
+  @Post('ppl')
+  ppl(@Body() body: unknown) {
+    return this.dc.ppl(body)
   }
 
   @Get('consultants')
   consultants(@Query('keyword') keyword = '') {
     return this.dc.consultants(keyword)
   }
+
+  @Post('intent')
+  intent(@Body() body: unknown) {
+    return this.dc.intentExecute(body)
+  }
 }

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/main.ts

@@ -1,10 +1,9 @@
 import './polyfill';
+import 'dotenv/config'; // 加载 server/.env：dev 由 dotenv 读取 DATACLAW_API_KEY；FC 由 s.yaml 注入 env（.env 被 .fcignore 排除不进部署包）
 import { NestFactory } from '@nestjs/core';
 import { NestExpressApplication } from '@nestjs/platform-express';
 import { AppModule } from './app.module';
 import * as path from 'node:path';
-import cookieParser from 'cookie-parser';
-import { authGate, loginHandler, callbackHandler } from './auth/gate';
 
 // app-builder build 模式（spec 2026-06-01 + 2026-06-02 §5.6.4 子路径 fix）：
 //   - dev（通过 clawd 启）：nest 单进程 mount vite middleware，前端 HMR + /api 都从
@@ -35,20 +34,8 @@ async function bootstrap() {
 
   app.setGlobalPrefix(apiPrefix, { exclude: ['/'] });
 
-  // TTC 飞书登录门禁（PR-6）。前端 HTML 由 vite middleware(dev) / express.static(prod) serve、
-  // 不走 Nest 路由，Nest guard 拦不住，所以门禁是 Express 中间件，必须挂在下方 vite middleware
-  // (约:75) / useStaticAssets(约:99) 之前。/api/* 也先经过它（gate 在 vite 守卫和 nest router 之前）。
-  // /auth/login、/auth/callback 直接在 express 层注册，不带 globalPrefix；子路径部署带同样前缀。
-  // fail-loud：门禁启用却没配 SESSION_SECRET，会用空密钥签 cookie（可被伪造）—— 直接拒启动。
-  if (process.env.DATACLAW_AUTH_DISABLED !== '1' && !process.env.SESSION_SECRET) {
-    throw new Error('[auth] 缺 SESSION_SECRET：登录门禁启用时必填（否则 session cookie 可被伪造）。本地调试可设 DATACLAW_AUTH_DISABLED=1 跳过门禁。');
-  }
-  app.use(cookieParser());
-  const httpAdapter = app.getHttpAdapter();
-  const authBasePath = subPath ? `/${subPath}` : '';
-  httpAdapter.get(`${authBasePath}/auth/login`, loginHandler);
-  httpAdapter.get(`${authBasePath}/auth/callback`, callbackHandler);
-  app.use(authGate);
+  // 无登录门禁：页面打开即用。数据访问鉴权由后端用 DATACLAW_API_KEY（建页人提供的 apikey）注入，
+  // 见 dataclaw.client —— key 绝不下发浏览器。
 
   if (isDev && isClawdDev) {
     // dev 模式 + 通过 clawd 启的 → mount vite middleware，root=../../web

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/App.jsx

@@ -1,9 +1,6 @@
-import { useAuthGate } from './auth';
 import PerformanceQueryPage from './pages/PerformanceQueryPage';
 
+// 无登录门禁：页面打开即用。数据鉴权由后端用建页人提供的 apikey 注入（见 server/dataclaw）。
 export default function App() {
-  const { ready, authed } = useAuthGate();
-  if (!ready) return <div>加载中…</div>;
-  if (!authed) return <div>请先飞书登录</div>;
   return <PerformanceQueryPage />;
 }

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/api.js

@@ -1,4 +1,4 @@
-// 只调 app 自己的 BFF（/api/*），绝不直连 dataclaw —— 密钥/身份都在 server 侧注入，不进浏览器。
+// 只调 app 自己的 BFF（/api/*），绝不直连 dataclaw —— apikey 在 server 侧注入，不进浏览器。
 //
 // dev 隧道模式下页面挂在子路径 /preview/<port>/ 下（见 vite.config.js base），
 // 所以 API_BASE 要拼上 import.meta.env.BASE_URL，否则 fetch 会打到错误的绝对路径。
@@ -14,6 +14,8 @@ async function req(path, opts = {}) {
   return json;
 }
 
+// dataclaw 公网端点（经本 app BFF 转发，见 server/dataclaw.controller）。
 export const getSchema = (dataset) => req(`/schema?dataset=${encodeURIComponent(dataset || '')}`);
-export const runQuery = (body) => req('/query', { method: 'POST', body: JSON.stringify(body) });
+export const queryPerformance = (body) => req('/performance', { method: 'POST', body: JSON.stringify(body) });
+export const queryPpl = (body) => req('/ppl', { method: 'POST', body: JSON.stringify(body) });
 export const searchConsultants = (kw) => req(`/consultants?keyword=${encodeURIComponent(kw)}`);

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/components/ResultTable.jsx

@@ -1,7 +1,9 @@
-// 结果表格。列取 rows[0] 的 key，数字按 zh-CN 千分位展示，空数组显示「无数据」。
+import { INTERNAL_FIELDS } from '../enums';
+
+// 结果表格。列取 rows[0] 的 key（过滤 _provenance 等内部字段），数字按 zh-CN 千分位展示，空数组显示「无数据」。
 export default function ResultTable({ rows }) {
   if (!rows || rows.length === 0) return <div className="empty">无数据</div>;
-  const cols = Object.keys(rows[0]);
+  const cols = Object.keys(rows[0]).filter((c) => !INTERNAL_FIELDS.has(c));
   return (
     <table className="result-table">
       <thead>

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/enums.js

@@ -1,22 +1,7 @@
-// 枚举可选值 / 内部字段 —— 逐字对齐后端 query-filters.js。
-//
-// 为什么前端要自带这份常量：
-//   - /api/schema 只给 field.type / field.operators / aliases，**不给枚举候选值**，
-//     所以状态类字段的下拉选项只能在前端硬编码（ENUM_HINTS）。
-//   - describeDatasets 仍会返回 ID / 各级编号 等内部字段，前端要主动过滤掉不渲染
-//     （INTERNAL_FIELDS）。
-// 后端 query-filters.js 改了这里也要同步改。
-
-export const ENUM_HINTS = {
-  候选人状态: ['推荐', '1面', '2面', '3面', '4面', '终面', 'Offer', '已入职', '淘汰'],
-  顾问类型: ['正式', '实习', '外部合作顾问', '兼职', '外包', '虚拟账号'],
-  顾问在职状态: ['在职', '离职'],
-};
-
+// 内部字段：dataclaw 返回里不展示给用户的列（编号 / ID / 溯源元数据等）。
+// ResultTable 渲染时按此 Set 过滤掉对应列。
 export const INTERNAL_FIELDS = new Set([
   'ID', 'unique_id', '链接', 'SourceID', '发票ID', '客户ID', '职位ID',
   '业绩所属一级团队编号', '业绩所属二级团队编号', '业绩所属三级团队编号', '所属OP名称', '候选人ID',
+  '_provenance', // dataclaw 每条返回都带的溯源元数据（source/record_type/fetched_at/trace_id），不展示
 ]);
-
-// 每种字段类型添加筛选时的默认操作符。
-export const TYPE_DEFAULT_OP = { string: 'contains', number: 'eq', date: 'eq' };

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/pages/PerformanceQueryPage.jsx

@@ -1,82 +1,51 @@
 import { useState } from 'react';
-import { runQuery } from '../api';
-import SchemaFilters from '../components/SchemaFilters';
+import { queryPerformance } from '../api';
 import ResultTable from '../components/ResultTable';
-import BarChart from '../components/BarChart';
 
-// 数据集：起手页用 performance。agent 按用户需求改成
-// performance / consultant_progress / metadata_user 之一即可。
-// 数据范围（scope）不在前端选 —— 后端按建页人身份隐式裁剪。
-const DATASET = 'performance';
+// 业绩查询起手页：对接 dataclaw 公网 /api/performance（必填 startDate/endDate）。
+// agent 按建页人需求可改成 queryPpl / searchConsultants，或加收窄条件、换展示形态。
+// 数据为只读全量（公网 apikey 即全量），无身份裁剪。
+const DATE_FIELD_LABELS = { billing: 'Billing 业绩', invoice: '开票业绩', payment: '回款业绩' };
 
-// 聚合字段用真名。注意：`业绩所属二级团队` 是真实字段名，
-// 「顾问所属N级团队」只是它的 alias，查询 groupBy / aggregations 必须用真名。
-const GROUP_FIELD = '业绩所属二级团队';
-const METRIC = '业绩';
-
-// 预置一个 Billing 日期区间示例。
-// 提示：PPL 大范围查询很慢，务必带状态/时间区间（如 Billing 日期 between）收敛扫描范围。
-const INITIAL_FILTERS = [
-  { field: 'Billing日期', op: 'between', value: ['2026-01-01', '2026-06-30'] },
-];
-
-// 结果列名由后端决定（聚合后可能不叫原名），这里挑出展示用的标签列 / 数值列，兜底防错配。
-function pickFields(rows, preferredLabel, preferredValue) {
-  const cols = Object.keys(rows[0]);
-  const labelField = cols.includes(preferredLabel)
-    ? preferredLabel
-    : cols.find((c) => typeof rows[0][c] !== 'number') || cols[0];
-  const valueField = cols.includes(preferredValue)
-    ? preferredValue
-    : cols.find((c) => typeof rows[0][c] === 'number' && c !== labelField) || cols[cols.length - 1];
-  return { labelField, valueField };
-}
+const fmt = (n) => (Number(n) || 0).toLocaleString('zh-CN');
 
 export default function PerformanceQueryPage() {
-  const [filters, setFilters] = useState(INITIAL_FILTERS);
-  const [groupBy, setGroupBy] = useState(GROUP_FIELD);
-  const [rows, setRows] = useState([]);
-  const [total, setTotal] = useState(0);
+  const [startDate, setStartDate] = useState('2026-05-01');
+  const [endDate, setEndDate] = useState('2026-05-31');
+  const [result, setResult] = useState(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState('');
-  const [ran, setRan] = useState(false);
 
   const onQuery = async () => {
+    if (!startDate || !endDate) { setError('请选择起止日期'); return; }
     setLoading(true);
     setError('');
     try {
-      const json = await runQuery({
-        dataset: DATASET,
-        filters,
-        groupBy,
-        aggregations: [{ field: METRIC, op: 'sum' }],
-        orderBy: { field: METRIC, direction: 'desc' },
-        limit: 50,
-      });
-      setRows(json.data?.rows || []);
-      setTotal(json.data?.total || 0);
-      setRan(true);
+      setResult(await queryPerformance({ startDate, endDate }));
     } catch (e) {
       setError(e.message || '查询失败');
-      setRows([]);
+      setResult(null);
     } finally {
       setLoading(false);
     }
   };
 
-  const picked = rows.length ? pickFields(rows, groupBy, METRIC) : null;
+  const byDateField = result?.byDateField || null;
 
   return (
     <div className="page">
       <h1>业绩查询（示例）</h1>
-      <p className="hint">数据集：{DATASET}。数据范围由后端按你的身份自动裁剪。</p>
+      <p className="hint">数据来自 dataclaw 业绩库，按日期区间查询（只读）。</p>
 
       <section className="panel">
         <label className="group-by">
-          分组字段
-          <input value={groupBy} onChange={(e) => setGroupBy(e.target.value)} />
+          起始日期
+          <input type="date" value={startDate} onChange={(e) => setStartDate(e.target.value)} />
+        </label>
+        <label className="group-by">
+          结束日期
+          <input type="date" value={endDate} onChange={(e) => setEndDate(e.target.value)} />
         </label>
-        <SchemaFilters dataset={DATASET} filters={filters} onChange={setFilters} />
         <button type="button" className="btn-primary" onClick={onQuery} disabled={loading}>
           {loading ? '查询中…' : '查询'}
         </button>
@@ -84,17 +53,26 @@ export default function PerformanceQueryPage() {
 
       {error && <div className="error">{error}</div>}
 
-      {ran && !error && (
+      {result && !error && (
         <section className="results">
           <div className="results-head">
-            共 {total.toLocaleString('zh-CN')} 条，按 {METRIC} 汇总（Top {rows.length}）
+            {result.queryRange || `${startDate} ~ ${endDate}`}　共 {fmt(result.total)} 条
           </div>
-          {picked && rows.length > 0 && (
-            <div className="chart-wrap">
-              <BarChart rows={rows} labelField={picked.labelField} valueField={picked.valueField} />
+
+          {byDateField && (
+            <div className="cards">
+              {Object.entries(byDateField).map(([k, v]) => (
+                <div className="card" key={k}>
+                  <div className="card-title">{DATE_FIELD_LABELS[k] || k}（{fmt(v?.total)} 条）</div>
+                  <div className="card-value">{fmt(v?.amount)}</div>
+                </div>
+              ))}
             </div>
           )}
-          <ResultTable rows={rows} />
+
+          <div className="chart-wrap" style={{ overflowX: 'auto' }}>
+            <ResultTable rows={result.items || []} />
+          </div>
         </section>
       )}
     </div>

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/hooks/pre-deploy.sh

@@ -1,25 +1,21 @@
 #!/usr/bin/env bash
-# dataclaw 发布前置：校验 persona 密钥、生成/推导运行时变量并 export，供通用占位符替换取用。
-# 由 deploy-kit/publish.sh 在 aliyun 就绪后、渲染 s.yaml 前 source（共享 EXT_DIR/APP_NAME/ACC/REGION/PERSONA_KIT 作用域）。
+# dataclaw 发布前置：从生成 app 的 server/.env 读出建页人填的 apikey，export 供 s.yaml 占位符替换。
+# 由 deploy-kit/publish.sh 在渲染 s.yaml 前 source（共享 EXT_DIR/APP_NAME/PERSONA_KIT 等作用域）。
 
-# dataclaw 服务间密钥（现读，不进 git）；缺失则拒发布（app 没它查不到数）。
-# 密钥在 persona-root 的 .secrets/（example/gitignore 白名单都在这一层），不是 extension-kit/.secrets/。
-[ -f "$PERSONA_ROOT/.secrets/dataclaw.env" ] || {
-  echo "❌ 缺 $PERSONA_ROOT/.secrets/dataclaw.env（含 DATACLAW_INTERNAL_SECRET）。参考 $PERSONA_ROOT/.secrets/dataclaw.env.example 填写。" >&2
+# 建页人提供的 dataclaw apikey 写在生成 app 的 server/.env（DATACLAW_API_KEY）。
+# .env 被 server/.fcignore 排除、不进部署包，所以这里读出来、经 s.yaml 注入 FC 环境变量。
+ENV_FILE="$EXT_DIR/server/.env"
+if [ -f "$ENV_FILE" ]; then
+  # 只取 DATACLAW_API_KEY 一行、剥掉可能的引号；不 source 整个 .env（避免污染其它变量）。
+  # || true：publish.sh 跑在 set -euo pipefail 下，grep 无命中(有 .env 但缺 key 行)会让管道返回非 0
+  # → 不加会静默死在这行、走不到下面的 fail-loud 友好报错。统一收敛到下方空值检查。
+  DATACLAW_API_KEY="$(grep -E '^DATACLAW_API_KEY=' "$ENV_FILE" | head -1 | cut -d= -f2- | sed -e 's/^["'\'']//' -e 's/["'\'']$//' || true)"
+fi
+if [ -z "${DATACLAW_API_KEY:-}" ]; then
+  echo "❌ 缺 DATACLAW_API_KEY：请在 $ENV_FILE 填入建页人的 dataclaw apikey（只填冒号后的 secret 段）。" >&2
   exit 1
-}
-set -a; . "$PERSONA_ROOT/.secrets/dataclaw.env"; set +a
-
-# SESSION_SECRET：每个 app 一份、跨重部署稳定（否则重发后所有人 session 失效）。
-# 首次发布生成并持久化到 ext.conf；之后 source ext.conf 已带上。
-if [ -z "${SESSION_SECRET:-}" ]; then
-  SESSION_SECRET="$(openssl rand -hex 32)"
-  echo "SESSION_SECRET=$SESSION_SECRET" >> "$EXT_DIR/ext.conf"
 fi
-export SESSION_SECRET
-
-# APP_BASE_URL：飞书登录回调用。fc3 自定义域名由 APP_NAME+ACC+REGION 推导，用 https（cookie secure 要求）。
-export APP_BASE_URL="https://${APP_NAME}.fcv3.${ACC}.${REGION}.fc.devsapp.net"
+export DATACLAW_API_KEY
 
-# 可选占位符显式兜底（未填时通用扫描需「已定义」才放行）
-export DATACLAW_AS_UNION_ID="${DATACLAW_AS_UNION_ID:-}"
+# service url：config.env / ext.conf 已 source 进来；兜底公网地址。
+export DATACLAW_SERVICE_URL="${DATACLAW_SERVICE_URL:-https://120.48.21.36}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.143-beta.302.5df5cc1",
+  "version": "0.2.143-beta.303.ab28945",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",

package/dist/persona-defaults/persona-dataclaw-builder/.secrets/dataclaw.env.example

@@ -1,3 +0,0 @@
-# dataclaw 服务间共享密钥（= dataclaw-service 的 SEND_AS_BOT_SHARED_SECRET）。
-# 复制为同目录 dataclaw.env 并填实际值；dataclaw.env 不进 git（见 .gitignore）。
-DATACLAW_INTERNAL_SECRET=replace-me

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/auth/gate.ts

@@ -1,70 +0,0 @@
-// TTC 飞书登录门禁（无密钥经纪）：Express 中间件 + /auth/login、/auth/callback 处理器。
-// 必须挂在 vite middleware(dev) / express.static(prod) 之前——前端 HTML 不走 Nest 路由，
-// Nest guard 拦不住，所以门禁只能是 Express 层中间件（main.ts 接线在 vite/static 之前）。
-// 门禁只决定"能不能打开页"；数据范围仍由 dataclaw client 固定用建页人 union_id（PR-4 已做），
-// 不用登录者身份查数。
-import { fetchTtcUser } from './ttc-user-info'
-import { makeSession, readSession, makeState, verifyState } from './session'
-
-// req/res/next 用 any：express 不是本 server 包的直接依赖（pnpm 下从 server 根 require.resolve
-// 'express' 失败，main.ts:67 同样用 any），从 'express' import 类型会编译失败。
-type Req = any
-type Res = any
-type Next = (err?: unknown) => void
-
-const SESSION_COOKIE = 'dc_session'
-const STATE_COOKIE = 'dc_oauth_state'
-
-// 子路径部署（clawd dev preview/<port>/，见 main.ts subPath 逻辑）下 redirect 要带同样前缀；
-// prod base=/ 时无前缀，返回 '/auth/login'。
-function loginPath(req: Req): string {
-  const url = String(req.originalUrl || req.url || '')
-  const m = url.match(/^\/(preview\/\d+)\//)
-  return m ? `/${m[1]}/auth/login` : '/auth/login'
-}
-
-// 门禁中间件：放行 /auth/*；DATACLAW_AUTH_DISABLED=1 全放行；否则无有效 session → 302 /auth/login。
-export function authGate(req: Req, res: Res, next: Next) {
-  if (process.env.DATACLAW_AUTH_DISABLED === '1') return next()
-  const p = String(req.path || req.url || '')
-  if (p.includes('/auth/login') || p.includes('/auth/callback')) return next()
-  const sess = readSession(req.cookies?.[SESSION_COOKIE])
-  if (sess) return next()
-  return res.redirect(302, loginPath(req))
-}
-
-export function loginHandler(req: Req, res: Res) {
-  const authBase = process.env.TTC_AUTH_BASE || 'https://app.ttcadvisory.com'
-  const appBase = (process.env.APP_BASE_URL || '').replace(/\/+$/, '')
-  const state = makeState()
-  res.cookie(STATE_COOKIE, state, { httpOnly: true, sameSite: 'lax', secure: true, maxAge: 5 * 60 * 1000 })
-  const url = new URL('/auth/authorize', authBase)
-  url.searchParams.set('callback_url', `${appBase}/auth/callback`)
-  url.searchParams.set('state', state)
-  url.searchParams.set('auto', '1')
-  res.redirect(302, url.toString())
-}
-
-export async function callbackHandler(req: Req, res: Res) {
-  const token = String(req.query?.token || '')
-  const state = String(req.query?.state || '')
-  const cookieState = req.cookies?.[STATE_COOKIE]
-  // CSRF：回调 state 必须等于 cookie 里的、且签名有效未过期
-  if (!token || !state || state !== cookieState || !verifyState(state)) {
-    return res.status(401).send('登录校验失败，请重试')
-  }
-  try {
-    const apiBase = process.env.TTC_API_BASE || 'https://api.ttcadvisory.com'
-    const user = await fetchTtcUser(apiBase, token) // 只验身份；TTC token 验完即丢，不存不用于查数
-    res.clearCookie(STATE_COOKIE)
-    res.cookie(SESSION_COOKIE, makeSession(user.uniqueId, user.name), {
-      httpOnly: true,
-      sameSite: 'lax',
-      secure: true,
-      maxAge: 12 * 3600 * 1000,
-    })
-    return res.redirect(302, '/')
-  } catch {
-    return res.status(401).send('飞书身份校验失败')
-  }
-}

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/auth/session.ts

@@ -1,52 +0,0 @@
-// HMAC 签名 session + oauth state cookie，用 SESSION_SECRET 签发/校验。
-// FC 多实例无共享内存，所以 state 也走签名 cookie，不能用进程内 Map。
-import { createHmac, timingSafeEqual, randomBytes } from 'node:crypto'
-
-const SECRET = () => process.env.SESSION_SECRET || ''
-
-function sign(payload: string): string {
-  const mac = createHmac('sha256', SECRET()).update(payload).digest('base64url')
-  return `${Buffer.from(payload).toString('base64url')}.${mac}`
-}
-
-function verify(token: string): string | null {
-  const [b64, mac] = (token || '').split('.')
-  if (!b64 || !mac) return null
-  const payload = Buffer.from(b64, 'base64url').toString()
-  const expect = createHmac('sha256', SECRET()).update(payload).digest('base64url')
-  const a = Buffer.from(mac)
-  const b = Buffer.from(expect)
-  if (a.length !== b.length || !timingSafeEqual(a, b)) return null
-  return payload
-}
-
-// session：存 {uid,name,exp}（仅展示/审计，不用于查数——数据范围恒用建页人 union_id）。
-export function makeSession(uid: string, name: string, ttlMs = 12 * 3600 * 1000): string {
-  return sign(JSON.stringify({ uid, name, exp: Date.now() + ttlMs }))
-}
-
-export function readSession(token?: string): { uid: string; name: string } | null {
-  const p = token && verify(token)
-  if (!p) return null
-  try {
-    const o = JSON.parse(p)
-    if (typeof o.exp === 'number' && o.exp > Date.now()) return { uid: o.uid, name: o.name }
-  } catch {}
-  return null
-}
-
-export function makeState(): string {
-  const nonce = randomBytes(16).toString('base64url')
-  return sign(JSON.stringify({ nonce, exp: Date.now() + 5 * 60 * 1000 }))
-}
-
-export function verifyState(token?: string): boolean {
-  const p = token && verify(token)
-  if (!p) return false
-  try {
-    const o = JSON.parse(p)
-    return typeof o.exp === 'number' && o.exp > Date.now()
-  } catch {
-    return false
-  }
-}

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/server/src/auth/ttc-user-info.ts

@@ -1,23 +0,0 @@
-// 用 TTC JWT 调 user_info 验身份（无密钥经纪：app 不持飞书/TTC 密钥，只用回调 token 验身份）。
-// 精简自 daemon feishu-auth/ttc-client.ts，独立实现、不 import daemon 代码。
-// 接口响应结构：GET /api/user_service/v1/login/user → { code:0, data:{ unique_id, name, union_id, avatar_url } }
-export interface TtcUser {
-  uniqueId: string
-  name: string
-  unionId?: string
-  avatarUrl?: string
-}
-
-export async function fetchTtcUser(apiBase: string, token: string, fetchImpl: typeof fetch = fetch): Promise<TtcUser> {
-  const res = await fetchImpl(`${apiBase}/api/user_service/v1/login/user`, { headers: { Authorization: `Bearer ${token}` } })
-  if (!res.ok) throw new Error(`TTC user_info HTTP ${res.status}`)
-  const body = (await res.json()) as { code?: number; data?: { unique_id?: string; name?: string; union_id?: string; avatar_url?: string } }
-  if (body.code !== 0 || !body.data?.unique_id || !body.data?.name) throw new Error('TTC user_info invalid')
-  const d = body.data
-  return {
-    uniqueId: d.unique_id,
-    name: d.name,
-    ...(d.union_id ? { unionId: d.union_id } : {}),
-    ...(d.avatar_url ? { avatarUrl: d.avatar_url } : {}),
-  }
-}

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/auth.js

@@ -1,7 +0,0 @@
-import { useEffect, useState } from 'react';
-// 门禁 hook 占位：真实飞书登录态检测在 PR-6。返回 { ready, authed }。
-export function useAuthGate() {
-  const [state, setState] = useState({ ready: false, authed: false });
-  useEffect(() => { setState({ ready: true, authed: true }); }, []); // 占位：默认已登录
-  return state;
-}

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/components/FilterRow.jsx

@@ -1,79 +0,0 @@
-import { ENUM_HINTS } from '../enums';
-
-// 操作符中文标签（仅展示用，没命中就回退显示原始 code）。
-const OP_LABELS = {
-  eq: '等于', ne: '不等于', contains: '包含',
-  gt: '大于', gte: '大于等于', lt: '小于', lte: '小于等于',
-  between: '区间', in: '属于', notin: '不属于',
-};
-
-// 单条筛选。受控：props { field（来自 /api/schema 的字段元数据）, value:{field,op,value}, onChange, onRemove }。
-// 控件选择规则：
-//   - op === 'between'        → 两个输入框
-//   - op === 'in' / 'notin'   → 单输入框，逗号分隔（值为数组）
-//   - ENUM_HINTS 命中该字段   → 下拉，选项来自 ENUM_HINTS[sourceField]
-//   - 否则按 field.type        → string=text / number=number / date=date
-// 操作符下拉选项直接来自 field.operators。
-export default function FilterRow({ field, value, onChange, onRemove }) {
-  const type = field.type || 'string';
-  const enumValues = ENUM_HINTS[field.sourceField];
-  const ops = field.operators && field.operators.length ? field.operators : [value.op].filter(Boolean);
-  const inputType = type === 'number' ? 'number' : type === 'date' ? 'date' : 'text';
-  const label = (field.aliases && field.aliases[0]) || field.sourceField;
-
-  const coerce = (raw) => (type === 'number' && raw !== '' ? Number(raw) : raw);
-  const set = (patch) => onChange({ ...value, ...patch });
-
-  // 切操作符时 value 形态可能要换（标量 / 二元区间 / 数组），统一重置避免形态错配。
-  const onOpChange = (e) => {
-    const op = e.target.value;
-    const next = op === 'between' ? ['', ''] : op === 'in' || op === 'notin' ? [] : '';
-    set({ op, value: next });
-  };
-
-  const renderValueControl = () => {
-    if (value.op === 'between') {
-      const v = Array.isArray(value.value) ? value.value : ['', ''];
-      return (
-        <span className="filter-between">
-          <input type={inputType} value={v[0] ?? ''} onChange={(e) => set({ value: [coerce(e.target.value), v[1] ?? ''] })} />
-          <span className="sep">~</span>
-          <input type={inputType} value={v[1] ?? ''} onChange={(e) => set({ value: [v[0] ?? '', coerce(e.target.value)] })} />
-        </span>
-      );
-    }
-    if (value.op === 'in' || value.op === 'notin') {
-      const text = Array.isArray(value.value) ? value.value.join(',') : value.value ?? '';
-      return (
-        <input
-          className="filter-value"
-          placeholder="多个值用逗号分隔"
-          value={text}
-          onChange={(e) => set({ value: e.target.value.split(',').map((s) => coerce(s.trim())).filter((s) => s !== '') })}
-        />
-      );
-    }
-    if (enumValues) {
-      return (
-        <select className="filter-value" value={value.value ?? ''} onChange={(e) => set({ value: e.target.value })}>
-          <option value="">请选择</option>
-          {enumValues.map((opt) => <option key={opt} value={opt}>{opt}</option>)}
-        </select>
-      );
-    }
-    return (
-      <input className="filter-value" type={inputType} value={value.value ?? ''} onChange={(e) => set({ value: coerce(e.target.value) })} />
-    );
-  };
-
-  return (
-    <div className="filter-row">
-      <span className="filter-label">{label}</span>
-      <select className="filter-op" value={value.op} onChange={onOpChange}>
-        {ops.map((op) => <option key={op} value={op}>{OP_LABELS[op] || op}</option>)}
-      </select>
-      {renderValueControl()}
-      <button type="button" className="filter-remove" onClick={onRemove}>删除</button>
-    </div>
-  );
-}

package/dist/persona-defaults/persona-dataclaw-builder/extension-kit/examples/nestjs-react/web/src/components/SchemaFilters.jsx

@@ -1,93 +0,0 @@
-import { useEffect, useState } from 'react';
-import { getSchema } from '../api';
-import { INTERNAL_FIELDS, ENUM_HINTS, TYPE_DEFAULT_OP } from '../enums';
-import FilterRow from './FilterRow';
-
-// 给 schema 没覆盖到的字段（如预置的 Billing日期）按字段名兜底猜类型。
-function guessType(sourceField) {
-  if (/日期|时间|date|time/i.test(sourceField)) return 'date';
-  return 'string';
-}
-
-const FALLBACK_OPS = {
-  string: ['contains', 'eq', 'ne', 'in', 'notin'],
-  number: ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'between', 'in', 'notin'],
-  date: ['eq', 'gt', 'gte', 'lt', 'lte', 'between'],
-};
-
-function initValue(op) {
-  if (op === 'between') return ['', ''];
-  if (op === 'in' || op === 'notin') return [];
-  return '';
-}
-
-// 受控筛选区。拉 /api/schema 拿字段元数据，过滤掉 INTERNAL_FIELDS，
-// 渲染已选 filters（FilterRow）+ 「+ 添加筛选字段」下拉。
-// props { dataset, filters, onChange }。
-export default function SchemaFilters({ dataset, filters, onChange }) {
-  const [fields, setFields] = useState([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState('');
-
-  useEffect(() => {
-    let alive = true;
-    setLoading(true);
-    setError('');
-    getSchema(dataset)
-      .then((json) => {
-        if (!alive) return;
-        const data = json.data;
-        // 传了 dataset 时 data 可能是单对象；否则是数组。
-        const entry = Array.isArray(data) ? data.find((d) => d.dataset === dataset) : data;
-        const fs = (entry?.fields || []).filter((f) => !INTERNAL_FIELDS.has(f.sourceField));
-        setFields(fs);
-      })
-      .catch((e) => { if (alive) setError(e.message || '加载 schema 失败'); })
-      .finally(() => { if (alive) setLoading(false); });
-    return () => { alive = false; };
-  }, [dataset]);
-
-  // 取字段元数据：schema 里找得到用真的，找不到（预置 filter / 未加载）给兜底。
-  const metaFor = (sourceField) => {
-    const found = fields.find((f) => f.sourceField === sourceField);
-    if (found) return found;
-    const type = ENUM_HINTS[sourceField] ? 'string' : guessType(sourceField);
-    return { sourceField, type, operators: FALLBACK_OPS[type], aliases: [] };
-  };
-
-  const update = (i, next) => onChange(filters.map((f, idx) => (idx === i ? next : f)));
-  const remove = (i) => onChange(filters.filter((_, idx) => idx !== i));
-  const add = (e) => {
-    const sourceField = e.target.value;
-    e.target.value = '';
-    if (!sourceField) return;
-    const meta = metaFor(sourceField);
-    const wanted = TYPE_DEFAULT_OP[meta.type];
-    const op = wanted && meta.operators?.includes(wanted) ? wanted : meta.operators?.[0] || 'eq';
-    onChange([...filters, { field: sourceField, op, value: initValue(op) }]);
-  };
-
-  if (error) return <div className="error">筛选项加载失败：{error}</div>;
-
-  return (
-    <div className="schema-filters">
-      {filters.map((f, i) => (
-        <FilterRow
-          key={i}
-          field={metaFor(f.field)}
-          value={f}
-          onChange={(next) => update(i, next)}
-          onRemove={() => remove(i)}
-        />
-      ))}
-      <select className="filter-add" value="" onChange={add} disabled={loading}>
-        <option value="">{loading ? '加载字段中…' : '+ 添加筛选字段'}</option>
-        {fields.map((f) => (
-          <option key={f.sourceField} value={f.sourceField}>
-            {(f.aliases && f.aliases[0]) || f.sourceField}
-          </option>
-        ))}
-      </select>
-    </div>
-  );
-}