investdesk-quotes 0.2.1 → 0.4.0

package/README.md

@@ -45,10 +45,14 @@ A 股与场外公募基金行情查询 + 飞书多维表格持仓读写的 MCP
 两层，都不经过 MCP 参数：
 
 1. **客户端 → MCP**：无认证，绑定 `127.0.0.1`，仅供本机客户端使用
-2. **MCP → 飞书**：复用部署机上已认证的 `lark-cli` profile，凭据存在 lark-cli 自己的凭据库里
+2. **MCP → 飞书**：飞书**自建应用**的 `tenant_access_token`，用 `FEISHU_APP_ID` / `FEISHU_APP_SECRET` 换取
 
 行情接口免认证。
 
+> 0.3.0 起移除了 lark-cli 后端。此前迁移期同时支持「本机用户令牌」和「应用令牌」两套，
+> 收敛成单后端是因为两条路会带来行为差异——OpenAPI 与 lark-cli 的记录形状完全不同，
+> 曾导致字段全部解析为空。现在本机、云端、CI 走的是同一条路径。
+
 ## 配置
 
 工作目录默认 `~/.investdesk`，可用 `INVESTDESK_HOME` 覆盖。**代码在 Store 检出目录，状态在工作目录**，
@@ -63,7 +67,7 @@ INVESTDESK_PLATFORMS_TABLE=...       # 平台表 table id
 MCP_PORT=8787                        # 可选
 ```
 
-`.cache/` 与 `inbox/` 会自动创建，用于存放 lark-cli 的中间产物和邮件附件。
+`.cache/` 与 `inbox/` 会自动创建，用于存放运行日志和邮件附件。
 
 ## 运行
 
@@ -84,10 +88,10 @@ npm run quote -- f:008284               # 手动查场外（f: 前缀）
 所以 `prepare` 会在发布前自动 `tsc`，`bin` 指向 `dist/`。运行时零依赖，构建期只需要 `typescript`。
 本地开发仍然可以直接 `node src/mcp/server.ts`（不在 `node_modules` 下，类型擦除可用）。
 
-## 云端运行（脱离本机）
+## 认证配置（跑起来的前置条件）
 
-本机跑依赖 `lark-cli` 的用户令牌——它躺在 macOS keychain 里，**云端没有 keychain，也就拿不到**。
-所以要把定时任务搬到服务器 / CI，必须换成飞书**自建应用**：
+用飞书**自建应用**的 `tenant_access_token` 访问 Base，不依赖任何本机凭据，
+所以本机、服务器、CI 的配置完全一样：
 
 1. 在[飞书开发者后台](https://open.feishu.cn/app)创建企业自建应用，记下 `app_id` / `app_secret`
 2. 「权限管理」开通多维表格权限：`bitable:app`（包含记录读写）
@@ -99,19 +103,14 @@ FEISHU_APP_ID=cli_xxxxxxxxxxxx
 FEISHU_APP_SECRET=xxxxxxxxxxxxxxxx
 ```
 
-**代码不需要改。** 访问层按环境变量自动切换后端：
-
-| 环境变量 | 后端 | 能跑在哪 |
-|---|---|---|
-| 不设置 | `lark-cli`（用户令牌） | 仅本机 |
-| `FEISHU_APP_ID` + `FEISHU_APP_SECRET` | OpenAPI（`tenant_access_token`） | 云端 / CI / 容器 |
-
-验证当前生效的后端：
+验证配置是否生效：
 
 ```bash
 node -e "import('./dist/feishu/base.js').then(async m=>{console.log('backend:',m.backendName());console.log('records:',(await m.listHoldings()).length)})"
 ```
 
+期望输出 `backend: openapi` 与 `records: <你的持仓数>`。
+
 > `tenant_access_token` 是应用身份，看到的数据范围由「应用被授权访问哪些资源」决定，
 > 与某个人的可见范围无关。换 Base 或换表时，协作者授权要同步更新。
 
@@ -122,6 +121,6 @@ URL 填 `http://127.0.0.1:8787/mcp` → 保存并打开开关。
 
 ## 限制
 
-- `status: limited`：依赖本机已认证的 lark-cli profile，不是装上即用
+- `status: limited`：需要先创建飞书自建应用、开通 `bitable:app` 并加为 Base 协作者，不是装上即用
 - 只覆盖公开行情，**没有** Level-2、资金流、公告正文等付费数据
 - 不做投资建议；输出只有数据口径，不产出买卖结论

package/dist/config.js

@@ -37,7 +37,6 @@ function loadDotEnv() {
 loadDotEnv();
 mkdirSync(WORK_DIR, { recursive: true });
 mkdirSync(CACHE_DIR, { recursive: true });
-export const LARK_CLI = process.env.LARK_CLI ?? 'lark-cli';
 /** 飞书多维表格坐标。换库时用环境变量覆盖。 */
 export const BASE_TOKEN = process.env.INVESTDESK_BASE_TOKEN ?? '';
 export const HOLDINGS_TABLE = process.env.INVESTDESK_HOLDINGS_TABLE ?? '';
@@ -47,19 +46,18 @@ export const MCP_PORT = Number(process.env.MCP_PORT ?? 8787);
 /**
  * 飞书自建应用凭据。
  *
- * 填了 → 走 OpenAPI（tenant_access_token），可在云端 / CI 跑；
- * 不填 → 走本机 lark-cli（用户令牌在 keychain 里）。
- *
- * 切换后端只改环境变量，代码不动。
+ * 0.3.0 起这是**唯一**的认证方式：用 tenant_access_token 调 OpenAPI，
+ * 不依赖任何本机凭据，本机与云端行为一致。
  */
 export const FEISHU_APP_ID = process.env.FEISHU_APP_ID ?? '';
 export const FEISHU_APP_SECRET = process.env.FEISHU_APP_SECRET ?? '';
 export const FEISHU_BASE_URL = process.env.FEISHU_BASE_URL ?? 'https://open.feishu.cn';
-export function hasAppCredentials() {
-    return Boolean(FEISHU_APP_ID && FEISHU_APP_SECRET);
-}
 export function assertFeishuConfigured() {
     const missing = [];
+    if (!FEISHU_APP_ID)
+        missing.push('FEISHU_APP_ID');
+    if (!FEISHU_APP_SECRET)
+        missing.push('FEISHU_APP_SECRET');
     if (!BASE_TOKEN)
         missing.push('INVESTDESK_BASE_TOKEN');
     if (!HOLDINGS_TABLE)

package/dist/feishu/backend.js

@@ -1,10 +1,8 @@
 /**
- * 飞书后端接口。
+ * 飞书后端的记录形状定义。
  *
- * 两种实现，按环境变量自动选择：
- *   - larkCliBackend  ：复用本机已登录的 lark-cli，零配置，但只能在本机跑
- *   - openapiBackend  ：飞书自建应用 + tenant_access_token，可在云端/CI 跑
- *
- * 上层（base.ts）只依赖这个接口，不关心背后是谁。
+ * 0.3.0 起只有一种实现（OpenAPI + tenant_access_token）。
+ * 保留这个接口是为了约束「后端返回的记录长什么样」，
+ * 上层（base.ts）直接消费 RawRecord。
  */
 export {};

package/dist/feishu/base.js

@@ -1,36 +1,34 @@
 /**
- * 飞书多维表格访问层 —— 对上层暴露稳定的记录接口，底层可切换后端。
+ * 飞书多维表格访问层。
  *
- * 后端选择只看环境变量：
- *   有 FEISHU_APP_ID + FEISHU_APP_SECRET → OpenAPI（云端 / CI 可用）
- *   没有                                 → 本机 lark-cli（用户令牌在 keychain）
+ * **只使用飞书 OpenAPI**（自建应用 tenant_access_token）：
+ * 不依赖任何本机凭据，所以本机、云端、CI 走的是同一条路径，
+ * 不存在「两套后端行为不一致」的问题。
  *
- * 上层代码（quotes / sync / mcp）完全不需要知道用的是哪种。
+ * 历史：0.2.x 曾保留 lark-cli（本机用户令牌）作为迁移期后备，
+ * 0.3.0 起移除。
  */
-import { BASE_TOKEN, FEISHU_APP_ID, FEISHU_APP_SECRET, FEISHU_BASE_URL, HOLDINGS_TABLE, PLATFORMS_TABLE, assertFeishuConfigured, hasAppCredentials, } from '../config.js';
-import { LarkCliBackend } from './larkCli.js';
+import { BASE_TOKEN, FEISHU_APP_ID, FEISHU_APP_SECRET, FEISHU_BASE_URL, HOLDINGS_TABLE, PLATFORMS_TABLE, assertFeishuConfigured, } from '../config.js';
 import { OpenApiBackend } from './openapi.js';
 let cachedBackend = null;
-/** 当前生效的后端（按环境变量选择，结果缓存） */
+/** 当前后端（只有一种，结果缓存） */
 export function getBackend() {
     if (cachedBackend)
         return cachedBackend;
     assertFeishuConfigured();
-    cachedBackend = hasAppCredentials()
-        ? new OpenApiBackend({
-            appId: FEISHU_APP_ID,
-            appSecret: FEISHU_APP_SECRET,
-            appToken: BASE_TOKEN,
-            baseUrl: FEISHU_BASE_URL,
-        })
-        : new LarkCliBackend();
+    cachedBackend = new OpenApiBackend({
+        appId: FEISHU_APP_ID,
+        appSecret: FEISHU_APP_SECRET,
+        appToken: BASE_TOKEN,
+        baseUrl: FEISHU_BASE_URL,
+    });
     return cachedBackend;
 }
-/** 后端名，用于日志 */
+/** 后端名，用于日志（固定值，保留是为了让日志继续可读） */
 export function backendName() {
-    return hasAppCredentials() ? 'openapi' : 'lark-cli';
+    return 'openapi';
 }
-/** 单选字段：lark-cli 返回数组，OpenAPI 返回字符串，两种都要兼容 */
+/** 单选字段：OpenAPI 返回字符串，兼容数组形态 */
 function firstOf(value) {
     if (Array.isArray(value))
         return String(value[0] ?? '');
@@ -82,9 +80,20 @@ export async function listPlatformNames() {
     }
     return map;
 }
-/** 把价格写回「最新持仓」的「最新价格」字段（写入后「最新市值」公式自动重算） */
+/**
+ * 把行情写回「最新持仓」：
+ *   最新价格 / 昨收价 / 日涨跌幅(%)
+ * 「最新市值」「日盈亏」是公式字段，写完后自动重算。
+ */
 export async function updateLatestPrices(updates) {
     if (updates.length === 0)
         return 0;
-    return getBackend().batchUpdateRecords(HOLDINGS_TABLE, updates.map((update) => ({ recordId: update.recordId, fields: { 最新价格: update.price } })));
+    return getBackend().batchUpdateRecords(HOLDINGS_TABLE, updates.map((update) => {
+        const fields = { 最新价格: update.price };
+        if (update.previousPrice != null)
+            fields.昨收价 = update.previousPrice;
+        if (update.changePct != null)
+            fields['日涨跌幅(%)'] = update.changePct;
+        return { recordId: update.recordId, fields };
+    }));
 }

package/dist/feishu/openapi.js

@@ -1,7 +1,8 @@
 /**
  * 飞书 OpenAPI 后端 —— 用自建应用的 tenant_access_token 直接调接口。
  *
- * 相比 lark-cli 后端，它不依赖本机 keychain，因此可以在云端 / CI / 定时函数里跑。
+ * 用自建应用的 tenant_access_token，不依赖本机 keychain，
+ * 因此本机 / 云端 / CI / 定时函数用的是同一条路径。
  * 代价是需要一次性配置：
  *   1. 在飞书开发者后台创建自建应用，拿到 app_id / app_secret
  *   2. 开通多维表格权限（bitable:app 或对应的记录读写 scope）
@@ -56,12 +57,12 @@ export class OpenApiBackend {
         return payload.data;
     }
     /**
-     * OpenAPI 的记录形状和 lark-cli 的 ndjson 不一样：
+     * OpenAPI 返回的原始记录不能直接给上层用：
      *   - 字段值包在 `fields` 里
      *   - 单选返回字符串（不是数组）
      *   - 数字返回字符串
      *   - 关联字段是 `[{record_ids: [...], text}]`（不是 `[{id}]`）
-     * 这里统一归一化成 lark-cli 的形状，让上层 base.ts 不用关心后端。
+     * 这里归一化成扁平、稳定的形状，让 base.ts 不用关心平台细节。
      */
     static normalize(record) {
         const rawFields = record.fields;

package/dist/quotes/eastmoney.js

@@ -12,7 +12,7 @@ const DEFAULT_TIMEOUT_MS = 10_000;
  * 网络或接口异常则抛错，由调用方重试。
  */
 export async function fetchFundNav(code, timeoutMs = DEFAULT_TIMEOUT_MS) {
-    const url = `${ENDPOINT}?fundCode=${encodeURIComponent(code)}&pageIndex=1&pageSize=1`;
+    const url = `${ENDPOINT}?fundCode=${encodeURIComponent(code)}&pageIndex=1&pageSize=2`;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
@@ -26,16 +26,19 @@ export async function fetchFundNav(code, timeoutMs = DEFAULT_TIMEOUT_MS) {
         if (!res.ok)
             throw new Error(`东财净值 HTTP ${res.status}`);
         const payload = (await res.json());
-        const row = payload.Data?.LSJZList?.[0];
+        const rows = payload.Data?.LSJZList ?? [];
+        const row = rows[0];
         if (!row?.DWJZ || !row.FSRQ)
             return null;
         const nav = Number(row.DWJZ);
         if (!Number.isFinite(nav) || nav <= 0)
             return null;
         const pct = Number(row.JZZZL);
+        const prevNav = Number(rows[1]?.DWJZ);
         return {
             code,
             nav,
+            previousNav: Number.isFinite(prevNav) && prevNav > 0 ? prevNav : null,
             date: row.FSRQ,
             changePct: Number.isFinite(pct) ? pct : null,
         };

package/dist/quotes/index.js

@@ -87,6 +87,7 @@ export async function fetchQuotes(targets, options = {}) {
                     name: target.name || q.name,
                     price: q.price,
                     changePct: q.changePct,
+                    previousPrice: Number.isFinite(q.prevClose) && q.prevClose > 0 ? q.prevClose : null,
                     tradeTime: q.tradeTime,
                     source: 'tencent',
                 });
@@ -125,6 +126,7 @@ export async function fetchQuotes(targets, options = {}) {
                 name: target.name,
                 price: nav.nav,
                 changePct: nav.changePct,
+                previousPrice: nav.previousNav,
                 tradeTime: nav.date,
                 source: 'eastmoney-fund',
             });

package/dist/sync.js

@@ -20,6 +20,8 @@ export async function syncPortfolioPrices(options = {}) {
     const updates = [...byRecord.entries()].map(([recordId, quote]) => ({
         recordId,
         price: quote.price,
+        previousPrice: quote.previousPrice,
+        changePct: quote.changePct,
     }));
     const written = await updateLatestPrices(updates);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "investdesk-quotes",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "A 股与场外公募基金行情查询 + 飞书多维表格持仓读写的 MCP 服务。可装进豆包工作 / Claude Desktop 等支持 MCP 的 AI 宿主。",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,7 @@
     "directory": "external-capabilities/mcp/investdesk-quotes"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "prepare": "npm run build",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "mcp": "node dist/mcp/server.js",
@@ -43,4 +43,4 @@
     "@types/node": "^26.6.5",
     "typescript": "^7.0.2"
   }
-}
+}

package/dist/feishu/larkCli.js

@@ -1,93 +0,0 @@
-/**
- * lark-cli 后端 —— 复用本机已登录的 lark-cli。
- *
- * 优点：零配置，凭证在 lark-cli 自己的凭据库里，项目里不存任何 secret。
- * 限制：只能在本机跑，云端没有 keychain 拿不到用户令牌。
- *
- * 注意：lark-cli 的 --output / @file 只接受相对路径，所以所有命令的 cwd
- * 固定为工作目录 WORK_DIR，产物也落在 WORK_DIR/.cache 下。
- */
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { BASE_TOKEN, CACHE_DIR, LARK_CLI, WORK_DIR, assertFeishuConfigured } from '../config.js';
-const execFileAsync = promisify(execFile);
-export class LarkCliBackend {
-    name = 'lark-cli';
-    async run(args) {
-        assertFeishuConfigured();
-        try {
-            const { stdout } = await execFileAsync(LARK_CLI, args, {
-                cwd: WORK_DIR,
-                maxBuffer: 64 * 1024 * 1024,
-                env: { ...process.env },
-            });
-            return stdout;
-        }
-        catch (error) {
-            const err = error;
-            const detail = (err.stderr || err.stdout || err.message || '').slice(0, 800);
-            throw new Error(`lark-cli 执行失败：${detail}`);
-        }
-    }
-    static parseEnvelope(stdout) {
-        const envelope = JSON.parse(stdout);
-        if (!envelope.ok) {
-            throw new Error(`飞书接口返回失败：${envelope.error?.message ?? 'unknown'}`);
-        }
-        return envelope.data;
-    }
-    async listRecords(tableId, limit) {
-        await mkdir(CACHE_DIR, { recursive: true });
-        const relativeOut = `.cache/${tableId}.ndjson`;
-        // --output 模式下 stdout 是 ndjson manifest（没有 ok 字段），
-        // 真正的记录写在文件里；命令失败时 run 会抛错。
-        await this.run([
-            'base', '+record-list',
-            '--base-token', BASE_TOKEN,
-            '--table-id', tableId,
-            '--limit', String(limit),
-            '--format', 'ndjson',
-            '--output', relativeOut,
-            '--overwrite',
-            '--as', 'user',
-        ]);
-        const ndjson = await readFile(path.join(WORK_DIR, relativeOut), 'utf8');
-        return ndjson
-            .split('\n')
-            .filter((line) => line.trim().length > 0)
-            .map((line) => JSON.parse(line));
-    }
-    async batchUpdateRecords(tableId, updates) {
-        if (updates.length === 0)
-            return 0;
-        await mkdir(CACHE_DIR, { recursive: true });
-        const CHUNK = 200;
-        let written = 0;
-        for (let i = 0; i < updates.length; i += CHUNK) {
-            const chunk = updates.slice(i, i + CHUNK);
-            const patch = {};
-            for (const update of chunk)
-                patch[update.recordId] = update.fields;
-            const fileName = `.cache/patch-${Date.now()}-${i}.json`;
-            const absolute = path.join(WORK_DIR, fileName);
-            await writeFile(absolute, JSON.stringify({ update_records: patch }), 'utf8');
-            try {
-                const stdout = await this.run([
-                    'base', '+record-batch-update',
-                    '--base-token', BASE_TOKEN,
-                    '--table-id', tableId,
-                    '--json', `@./${fileName}`,
-                    '--as', 'user',
-                ]);
-                LarkCliBackend.parseEnvelope(stdout);
-                written += chunk.length;
-            }
-            finally {
-                await rm(absolute, { force: true });
-            }
-        }
-        return written;
-    }
-}