@angelyeye/dsh-cost-tracker 1.8.14 → 1.9.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +237 -0
- package/README.en.md +101 -1
- package/README.md +106 -3
- package/client.js +837 -160
- package/config.js +132 -1
- package/credstore.js +248 -0
- package/docs/THIRD-PARTY-NOTICES.md +60 -0
- package/docs/provider-pricing.json +777 -0
- package/import.js +363 -0
- package/index.js +703 -97
- package/package.json +11 -3
- package/price-sync.js +216 -0
- package/pricing.js +111 -8
- package/schema.js +4 -0
- package/sync.js +25 -4
- package/vendor-catalog.js +198 -0
package/import.js
ADDED
|
@@ -0,0 +1,363 @@
|
|
|
1
|
+
// ============================================================
|
|
2
|
+
// DSH 花费统计插件 —— 历史导入(回放宿主会话日志,纯 Node,可独立测试)
|
|
3
|
+
//
|
|
4
|
+
// 目标:把「装插件之前」的 DSH 对话调用补录进账本。宿主会话日志位于
|
|
5
|
+
// $DSH_HOME/sessions/<项目>/<会话>/session.v3.jsonl[.zstd](旧版无 v3 段)
|
|
6
|
+
// 每个追加批次是独立的 zstd frame;成功调用的用量在 assistant/message 的
|
|
7
|
+
// data.usage 里(provider/model 在 data.message.source),流式样本在
|
|
8
|
+
// assistant/chunk 的 usage 块里 —— 同一 (turn, step) 以最终 message 为准。
|
|
9
|
+
//
|
|
10
|
+
// 幂等与防重复计数(三层):
|
|
11
|
+
// 1. 会话清单(manifest)按文件 mtime+size 快跳未变化的日志;
|
|
12
|
+
// 2. 覆盖判定:只有「插件不可能记到」的调用才导入 ——
|
|
13
|
+
// ts < 本机最早一条**实时**记录的时刻(插件安装点),
|
|
14
|
+
// 或该调用所在日完全没有实时覆盖(明细 + 日汇总都没有,停机缺口);
|
|
15
|
+
// 且 ts 早于该会话首条实时记录(会话跨安装点的切割线);
|
|
16
|
+
// 3. 逐调用键去重:sessionId|ts|model|五桶 tokens,与已导入明细比对。
|
|
17
|
+
// 导入记录带 source:'import',与实时记录(source:'live')在任何聚合中都可区分;
|
|
18
|
+
// 覆盖判定只看实时记录 —— 导入记录既不当覆盖面,也不影响重跑判定。
|
|
19
|
+
//
|
|
20
|
+
// Zstd frame 扫描算法改编自 dsh-cost-meter(MIT)lib/backfill.js 的
|
|
21
|
+
// scanZstdFrames —— 与宿主 dsh-session-persistence-jsonl 容器格式一致;
|
|
22
|
+
// 逐帧解压、逐帧按行切片,任一时刻只保留单帧解压结果(防大日志 OOM)。
|
|
23
|
+
// ============================================================
|
|
24
|
+
import { readdirSync, readFileSync, statSync } from 'node:fs'
|
|
25
|
+
import { join } from 'node:path'
|
|
26
|
+
import * as zlib from 'node:zlib'
|
|
27
|
+
|
|
28
|
+
export const IMPORT_SOURCE = 'import'
|
|
29
|
+
|
|
30
|
+
const ZSTD_MAGIC = 4247762216
|
|
31
|
+
/** 打包行(文本/推理/工具调用增量游程)不含 header 与 usage,回放时跳过 */
|
|
32
|
+
const PACKED_ROW_TYPES = new Set(['text-chunks', 'reasoning-chunks', 'tool-call-chunks'])
|
|
33
|
+
|
|
34
|
+
/**
|
|
35
|
+
* 结构化扫描拼接的 zstd frame 边界(不解压块内容)。残缺尾帧(崩溃截断)忽略。
|
|
36
|
+
* @param {Buffer} buffer
|
|
37
|
+
* @returns {{start:number,end:number}[]}
|
|
38
|
+
*/
|
|
39
|
+
export function scanZstdFrames(buffer) {
|
|
40
|
+
const frames = []
|
|
41
|
+
let offset = 0
|
|
42
|
+
while (offset < buffer.length) {
|
|
43
|
+
const start = offset
|
|
44
|
+
if (buffer.length - offset < 4) return frames
|
|
45
|
+
if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) return frames
|
|
46
|
+
offset += 4
|
|
47
|
+
if (offset === buffer.length) return frames
|
|
48
|
+
const descriptor = buffer.readUInt8(offset)
|
|
49
|
+
offset += 1
|
|
50
|
+
if ((descriptor & 24) !== 0) return frames // 保留位:结构非法,停止扫描
|
|
51
|
+
const contentSizeFlag = descriptor >>> 6
|
|
52
|
+
const singleSegment = (descriptor & 32) !== 0
|
|
53
|
+
const checksum = (descriptor & 4) !== 0
|
|
54
|
+
const dictionaryFlag = descriptor & 3
|
|
55
|
+
const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag
|
|
56
|
+
const contentSizeBytes = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag
|
|
57
|
+
const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes
|
|
58
|
+
if (buffer.length - offset < remainingHeaderBytes) return frames
|
|
59
|
+
offset += remainingHeaderBytes
|
|
60
|
+
for (;;) {
|
|
61
|
+
if (buffer.length - offset < 3) return frames
|
|
62
|
+
const blockHeader = buffer.readUIntLE(offset, 3)
|
|
63
|
+
offset += 3
|
|
64
|
+
const lastBlock = (blockHeader & 1) !== 0
|
|
65
|
+
const blockType = (blockHeader >>> 1) & 3
|
|
66
|
+
const blockSize = blockHeader >>> 3
|
|
67
|
+
if (blockType === 3) return frames // 保留块类型:结构非法
|
|
68
|
+
const payloadBytes = blockType === 1 ? 1 : blockSize
|
|
69
|
+
if (buffer.length - offset < payloadBytes) return frames
|
|
70
|
+
offset += payloadBytes
|
|
71
|
+
if (lastBlock) break
|
|
72
|
+
}
|
|
73
|
+
if (checksum) {
|
|
74
|
+
if (buffer.length - offset < 4) return frames
|
|
75
|
+
offset += 4
|
|
76
|
+
}
|
|
77
|
+
frames.push({ start, end: offset })
|
|
78
|
+
}
|
|
79
|
+
return frames
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
/**
|
|
83
|
+
* 读取一份会话日志的全部事件行:zstd 逐帧解压、逐帧按行切片(防 OOM);
|
|
84
|
+
* 明文 .jsonl 直接按行。坏行跳过。
|
|
85
|
+
* @param {string} path
|
|
86
|
+
* @returns {object[]}
|
|
87
|
+
*/
|
|
88
|
+
export function readSessionRecords(path) {
|
|
89
|
+
const buffer = readFileSync(path)
|
|
90
|
+
const records = []
|
|
91
|
+
let pending = '' // 跨帧行缓冲:上一帧末尾未换行的残行拼进下一帧首行
|
|
92
|
+
const consumeText = (text) => {
|
|
93
|
+
if (!text.length) return
|
|
94
|
+
const lines = text.split('\n')
|
|
95
|
+
lines[0] = pending + lines[0]
|
|
96
|
+
pending = lines[lines.length - 1]
|
|
97
|
+
for (let i = 0; i < lines.length - 1; i += 1) {
|
|
98
|
+
const line = lines[i]
|
|
99
|
+
if (!line.length) continue
|
|
100
|
+
try { records.push(JSON.parse(line)) } catch (e) { /* 坏行跳过 */ }
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
if (path.endsWith('.zstd')) {
|
|
104
|
+
if (typeof zlib.zstdDecompressSync !== 'function') return []
|
|
105
|
+
for (const f of scanZstdFrames(buffer)) {
|
|
106
|
+
consumeText(zlib.zstdDecompressSync(buffer.subarray(f.start, f.end)).toString('utf8'))
|
|
107
|
+
}
|
|
108
|
+
} else {
|
|
109
|
+
consumeText(buffer.toString('utf8'))
|
|
110
|
+
}
|
|
111
|
+
if (pending.length > 0) {
|
|
112
|
+
try { records.push(JSON.parse(pending)) } catch (e) { /* 尽力而为 */ }
|
|
113
|
+
}
|
|
114
|
+
return records
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* 枚举会话根目录下全部会话日志(<root>/<项目>/<会话>/session*.jsonl[.zstd])。
|
|
119
|
+
* @param {string} root - 会话根目录($DSH_HOME/sessions)
|
|
120
|
+
*/
|
|
121
|
+
export function listSessionLogs(root) {
|
|
122
|
+
const paths = []
|
|
123
|
+
let projects
|
|
124
|
+
try { projects = readdirSync(root, { withFileTypes: true }) } catch (e) { return paths }
|
|
125
|
+
for (const project of projects) {
|
|
126
|
+
if (!project.isDirectory()) continue
|
|
127
|
+
let sessions
|
|
128
|
+
try { sessions = readdirSync(join(root, project.name), { withFileTypes: true }) } catch (e) { continue }
|
|
129
|
+
for (const session of sessions) {
|
|
130
|
+
if (!session.isDirectory()) continue
|
|
131
|
+
for (const name of ['session.v3.jsonl.zstd', 'session.v3.jsonl', 'session.jsonl.zstd', 'session.jsonl']) {
|
|
132
|
+
const path = join(root, project.name, session.name, name)
|
|
133
|
+
try {
|
|
134
|
+
if (statSync(path).isFile()) { paths.push(path); break } // 同一会话多种编码互斥,取先命中者
|
|
135
|
+
} catch (e) { /* 继续尝试另一后缀 */ }
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
return paths
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
const num = (v) => { const n = Number(v); return Number.isFinite(n) ? n : 0 }
|
|
143
|
+
const str = (v) => (v === undefined || v === null ? '' : String(v).trim())
|
|
144
|
+
|
|
145
|
+
/**
|
|
146
|
+
* 回放单个会话日志,重建逐次调用(时间升序)。
|
|
147
|
+
*
|
|
148
|
+
* provider/model 来源优先级:assistant/message.data.message.source(每次调用
|
|
149
|
+
* 自带,最权威)→ request/header.data.header.config 状态机 → request/context。usage 按 (turn,step)
|
|
150
|
+
* 去重,最终 message 覆盖流式样本;全部桶为 0 的调用(失败尝试)不产出。
|
|
151
|
+
* fork 种子段(time < createdAt 的拷贝事件)跳过 —— 父会话已计过。
|
|
152
|
+
*
|
|
153
|
+
* @param {object[]} records - readSessionRecords 的输出
|
|
154
|
+
* @param {{fallbackSessionId?:string}} [opts]
|
|
155
|
+
* @returns {{sessionId:string, createdAt:number, isSeeded:boolean, calls:Array}}
|
|
156
|
+
*/
|
|
157
|
+
export function replaySessionCalls(records, opts) {
|
|
158
|
+
const o = opts || {}
|
|
159
|
+
let sessionId = str(o.fallbackSessionId)
|
|
160
|
+
let createdAt = 0
|
|
161
|
+
let isSeeded = false
|
|
162
|
+
let provider = ''
|
|
163
|
+
let model = ''
|
|
164
|
+
const byTurnStep = new Map() // `${turn}|${step}` → {ts, provider, model, usage, seq}
|
|
165
|
+
for (const ev of records) {
|
|
166
|
+
if (!ev || typeof ev !== 'object' || !ev.type) continue
|
|
167
|
+
const t = ev.type
|
|
168
|
+
if (t === 'session') {
|
|
169
|
+
if (str(ev.id)) sessionId = str(ev.id)
|
|
170
|
+
createdAt = num(ev.createdAt) || createdAt
|
|
171
|
+
isSeeded = ev.isSeeded === true
|
|
172
|
+
continue
|
|
173
|
+
}
|
|
174
|
+
const ts = num(ev.time)
|
|
175
|
+
if (createdAt && ts && ts < createdAt) continue // fork 种子段:父会话已计过
|
|
176
|
+
if (t === 'request/header') {
|
|
177
|
+
// 真实形状:data.header.config.{provider,model}(实测 2026-09 会话日志);
|
|
178
|
+
// 兼容 data.{provider,model} 的扁平写法
|
|
179
|
+
const d = ev.data || {}
|
|
180
|
+
const cfg = (d.header && d.header.config) || d
|
|
181
|
+
provider = str(cfg.provider) || provider
|
|
182
|
+
model = str(cfg.model) || model
|
|
183
|
+
continue
|
|
184
|
+
}
|
|
185
|
+
if (t === 'request/context') {
|
|
186
|
+
const d = ev.data || {}
|
|
187
|
+
provider = str(d.provider) || provider
|
|
188
|
+
model = str(d.model) || model
|
|
189
|
+
continue
|
|
190
|
+
}
|
|
191
|
+
if (PACKED_ROW_TYPES.has(t)) continue
|
|
192
|
+
if (t === 'assistant/chunk') {
|
|
193
|
+
const chunk = ev.data && ev.data.chunk
|
|
194
|
+
if (chunk && chunk.type === 'usage' && chunk.usage) {
|
|
195
|
+
const key = num(ev.data.turn) + '|' + num(ev.data.step)
|
|
196
|
+
const prev = byTurnStep.get(key)
|
|
197
|
+
byTurnStep.set(key, {
|
|
198
|
+
ts: ts || (prev && prev.ts) || 0,
|
|
199
|
+
provider: (prev && prev.provider) || provider,
|
|
200
|
+
model: (prev && prev.model) || model,
|
|
201
|
+
usage: chunk.usage,
|
|
202
|
+
source: (prev && prev.source) || null,
|
|
203
|
+
final: false,
|
|
204
|
+
})
|
|
205
|
+
}
|
|
206
|
+
continue
|
|
207
|
+
}
|
|
208
|
+
if (t === 'assistant/message' || t === 'assistant/attempt') {
|
|
209
|
+
const d = ev.data || {}
|
|
210
|
+
const usage = d.usage
|
|
211
|
+
const src = d.message && d.message.source ? d.message.source : null
|
|
212
|
+
const key = num(d.turn) + '|' + num(d.step)
|
|
213
|
+
const prev = byTurnStep.get(key)
|
|
214
|
+
byTurnStep.set(key, {
|
|
215
|
+
ts: ts || (prev && prev.ts) || 0,
|
|
216
|
+
provider: (src && str(src.provider)) || (prev && prev.provider) || provider,
|
|
217
|
+
model: (src && str(src.model)) || (prev && prev.model) || model,
|
|
218
|
+
usage: usage || (prev && prev.usage) || null,
|
|
219
|
+
source: src || (prev && prev.source) || null,
|
|
220
|
+
final: true,
|
|
221
|
+
})
|
|
222
|
+
continue
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
const calls = []
|
|
226
|
+
for (const [key, item] of byTurnStep) {
|
|
227
|
+
const u = item.usage
|
|
228
|
+
if (!u) continue
|
|
229
|
+
const tokens = {
|
|
230
|
+
input: num(u.inputTokens),
|
|
231
|
+
output: num(u.outputTokens),
|
|
232
|
+
cacheRead: num(u.cacheReadTokens),
|
|
233
|
+
cacheWrite: num(u.cacheWriteTokens),
|
|
234
|
+
reasoning: num(u.reasoningTokens),
|
|
235
|
+
}
|
|
236
|
+
const total = tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite + tokens.reasoning
|
|
237
|
+
if (!total) continue // 失败尝试 / 空调用:不产出
|
|
238
|
+
if (!item.provider && !item.model) continue
|
|
239
|
+
calls.push({
|
|
240
|
+
ts: item.ts,
|
|
241
|
+
provider: item.provider,
|
|
242
|
+
model: item.model,
|
|
243
|
+
turn: Number(key.split('|')[0]) || 0,
|
|
244
|
+
step: Number(key.split('|')[1]) || 0,
|
|
245
|
+
tokens,
|
|
246
|
+
})
|
|
247
|
+
}
|
|
248
|
+
calls.sort((a, b) => (a.ts - b.ts) || (a.turn - b.turn) || (a.step - b.step))
|
|
249
|
+
return { sessionId, createdAt, isSeeded, calls }
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
/** 导入判定所需的实时覆盖面(全部只看 source!=='import' 的记录) */
|
|
253
|
+
export function buildLiveCoverage(allRecords, rollups) {
|
|
254
|
+
let firstLiveTs = Infinity
|
|
255
|
+
const sessionMin = new Map()
|
|
256
|
+
const coveredDays = new Set()
|
|
257
|
+
for (const r of allRecords) {
|
|
258
|
+
if (!r || r.source === IMPORT_SOURCE) continue
|
|
259
|
+
if (typeof r.ts === 'number' && r.ts < firstLiveTs) firstLiveTs = r.ts
|
|
260
|
+
if (typeof r.ts === 'number' && r.sessionId) {
|
|
261
|
+
const cur = sessionMin.get(r.sessionId)
|
|
262
|
+
if (cur === undefined || r.ts < cur) sessionMin.set(r.sessionId, r.ts)
|
|
263
|
+
}
|
|
264
|
+
coveredDays.add(dayKeyOf(r.ts))
|
|
265
|
+
}
|
|
266
|
+
for (const dk of Object.keys(rollups || {})) coveredDays.add(dk)
|
|
267
|
+
return { firstLiveTs, sessionMin, coveredDays }
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
/** 与 store.js dayKey 同实现(北京 UTC+8),避免相互依赖 */
|
|
271
|
+
export function dayKeyOf(ts) {
|
|
272
|
+
const d = new Date(ts + 28800000)
|
|
273
|
+
const p = (n) => (n < 10 ? '0' + n : '' + n)
|
|
274
|
+
return d.getUTCFullYear() + '-' + p(d.getUTCMonth() + 1) + '-' + p(d.getUTCDate())
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
/**
|
|
278
|
+
* 逐调用去重键(与已导入明细比对)。
|
|
279
|
+
*
|
|
280
|
+
* **刻意不含模型名**:导入记录入账时模型会被计价层改写为「计费模型规范名」
|
|
281
|
+
* (如 deepseek-v4-pro → deepseek-flash、旧名 → 现役名),拿改写后的名字
|
|
282
|
+
* 去算键必然与日志里的原始名对不上,重跑就会把同一次调用再导一遍。
|
|
283
|
+
* (sessionId, 事件时刻, 五桶 tokens) 三元组已足以唯一标识一次调用
|
|
284
|
+
* (ts 直接取自日志事件时间,跨重跑稳定)。
|
|
285
|
+
*/
|
|
286
|
+
export function importKeyOf(sessionId, call) {
|
|
287
|
+
const t = call.tokens
|
|
288
|
+
return [str(sessionId), call.ts, t.input, t.output, t.cacheRead, t.cacheWrite, t.reasoning].join('|')
|
|
289
|
+
}
|
|
290
|
+
|
|
291
|
+
/**
|
|
292
|
+
* 规划一次导入:决定每个日志文件要不要读、读出来哪些调用可入库。
|
|
293
|
+
* @param {object[]} allRecords - 账本全部明细(含已导入)
|
|
294
|
+
* @param {object} rollups - 日汇总(覆盖面用)
|
|
295
|
+
* @param {{path:string}[]} logs - listSessionLogs 的输出
|
|
296
|
+
* @param {object} manifest - 清单(loadManifest 的输出,会被就地更新引用)
|
|
297
|
+
* @param {{priceFn:Function, normProvider:Function, now?:number}} hooks
|
|
298
|
+
* priceFn(np, model, ts, tokens) → {cost, estimated, subscription, period, model}
|
|
299
|
+
* @returns {Promise<Array>} 每个文件的结果 {path, sessionId, status, calls, imported, skipped, reason}
|
|
300
|
+
*/
|
|
301
|
+
export async function planAndBuildImports(allRecords, rollups, logs, manifest, hooks) {
|
|
302
|
+
const files = manifest.files || (manifest.files = {})
|
|
303
|
+
const coverage = buildLiveCoverage(allRecords, rollups)
|
|
304
|
+
const importedKeys = new Set()
|
|
305
|
+
for (const r of allRecords) {
|
|
306
|
+
if (r && r.source === IMPORT_SOURCE) importedKeys.add(importKeyOf(r.sessionId, { ts: r.ts, model: r.model, tokens: r.tokens }))
|
|
307
|
+
}
|
|
308
|
+
const results = []
|
|
309
|
+
for (const log of logs) {
|
|
310
|
+
const path = typeof log === 'string' ? log : log.path
|
|
311
|
+
let st = null
|
|
312
|
+
try { st = statSync(path) } catch (e) { results.push({ path, status: 'missing', imported: 0 }); continue }
|
|
313
|
+
const prev = files[path]
|
|
314
|
+
const unchanged = prev && prev.mtime === st.mtimeMs && prev.size === st.size
|
|
315
|
+
if (unchanged && prev.status === 'done') {
|
|
316
|
+
results.push({ path, status: 'unchanged', imported: 0, calls: 0, sessionId: prev.sessionId || '' })
|
|
317
|
+
continue
|
|
318
|
+
}
|
|
319
|
+
let records
|
|
320
|
+
try { records = readSessionRecords(path) } catch (e) {
|
|
321
|
+
results.push({ path, status: 'error', error: String((e && e.message) || e), imported: 0 })
|
|
322
|
+
continue
|
|
323
|
+
}
|
|
324
|
+
const dirId = path.split(/[\\/]/).slice(-2)[0] || ''
|
|
325
|
+
const replay = replaySessionCalls(records, { fallbackSessionId: dirId })
|
|
326
|
+
const sid = replay.sessionId || dirId
|
|
327
|
+
const sessionCut = coverage.sessionMin.has(sid) ? coverage.sessionMin.get(sid) : Infinity
|
|
328
|
+
const picked = []
|
|
329
|
+
for (const call of replay.calls) {
|
|
330
|
+
if (!(call.ts < sessionCut)) continue // 会话实时已覆盖(含跨安装点切割线)
|
|
331
|
+
const covered = call.ts < coverage.firstLiveTs || !coverage.coveredDays.has(dayKeyOf(call.ts))
|
|
332
|
+
if (!covered) continue // 实时面已覆盖该日(含日汇总吸收口径)
|
|
333
|
+
if (importedKeys.has(importKeyOf(sid, call))) continue // 之前已导入过
|
|
334
|
+
const np = hooks.normProvider(call.provider)
|
|
335
|
+
if (!np && !call.model) continue
|
|
336
|
+
const price = hooks.priceFn(np, call.model, call.ts, call.tokens)
|
|
337
|
+
picked.push({
|
|
338
|
+
ts: call.ts,
|
|
339
|
+
provider: call.provider,
|
|
340
|
+
model: price.model || call.model,
|
|
341
|
+
sessionId: sid,
|
|
342
|
+
purpose: '',
|
|
343
|
+
cost: price.cost,
|
|
344
|
+
estimated: price.estimated === true,
|
|
345
|
+
period: price.period,
|
|
346
|
+
tokens: call.tokens,
|
|
347
|
+
subscription: price.subscription === true,
|
|
348
|
+
source: IMPORT_SOURCE,
|
|
349
|
+
})
|
|
350
|
+
}
|
|
351
|
+
results.push({ path, sessionId: sid, status: 'planned', records: picked, calls: replay.calls.length })
|
|
352
|
+
}
|
|
353
|
+
return results
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
/** 清单读写(与 sync.js 的游标文件同风格) */
|
|
357
|
+
export function loadManifest(file) {
|
|
358
|
+
try {
|
|
359
|
+
const j = JSON.parse(readFileSync(file, 'utf8'))
|
|
360
|
+
if (j && typeof j === 'object' && j.v === 1) return j
|
|
361
|
+
} catch (e) { /* 首次运行 */ }
|
|
362
|
+
return { v: 1, files: {}, lastRunAt: 0, totalImported: 0 }
|
|
363
|
+
}
|