@soffits/dsh-notify-inbox 0.4.0 → 0.5.0
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 +9 -0
- package/README.md +23 -3
- package/client.js +272 -203
- package/docs/ui.md +36 -0
- package/index.js +21 -2
- package/locale/en.json +14 -6
- package/locale/fr.json +15 -7
- package/locale/zh.json +13 -5
- package/package.json +24 -4
- package/src/changes.js +75 -0
- package/src/domains.js +49 -0
- package/src/routes.js +67 -14
- package/src/store.js +100 -6
- package/src/view.js +75 -0
package/src/store.js
CHANGED
|
@@ -5,6 +5,7 @@
|
|
|
5
5
|
* <dataDir>/<person>/inbox.jsonl one record per line; written by the router only
|
|
6
6
|
* <dataDir>/<person>/files/<id>/<name> attachments the router copied in
|
|
7
7
|
* <dataDir>/<person>/read.json read marks; written by this plugin only
|
|
8
|
+
* <dataDir>/<person>/summary.json the line shown above the items; written by the router's side
|
|
8
9
|
*
|
|
9
10
|
* Records are re-read incrementally: only the bytes appended since the last
|
|
10
11
|
* look are parsed, and the whole file again when it shrank or was replaced
|
|
@@ -18,18 +19,62 @@ export const PERSON_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/
|
|
|
18
19
|
export const RECORD_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/
|
|
19
20
|
const INBOX = 'inbox.jsonl'
|
|
20
21
|
const READ = 'read.json'
|
|
22
|
+
const SUMMARY = 'summary.json'
|
|
21
23
|
|
|
22
24
|
const text = value => (typeof value === 'string' ? value : '')
|
|
23
25
|
const list = value => (Array.isArray(value) ? value : [])
|
|
24
26
|
/** Text a person reads: a string, or a map from language tag to text (the page picks the language). */
|
|
25
27
|
const words = value => (typeof value === 'string' ? value : value !== null && typeof value === 'object' && !Array.isArray(value) && Object.values(value).every(v => typeof v === 'string') ? value : '')
|
|
26
28
|
|
|
29
|
+
export const GROUPS = ['needs-you', 'live', 'handled', 'info']
|
|
30
|
+
const ASKING = ['done', 'snooze']
|
|
31
|
+
const MAX_THREAD = 120
|
|
32
|
+
|
|
33
|
+
const isoTime = value => {
|
|
34
|
+
const at = Date.parse(text(value))
|
|
35
|
+
return Number.isNaN(at) ? undefined : new Date(at).toISOString()
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
/** `live` as `{ until?, progress?: { from, to } }`, or null. */
|
|
39
|
+
function liveOf(raw) {
|
|
40
|
+
if (raw === true) return {}
|
|
41
|
+
if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return null
|
|
42
|
+
const out = {}
|
|
43
|
+
const until = isoTime(raw.until)
|
|
44
|
+
if (until !== undefined) out.until = until
|
|
45
|
+
const from = isoTime(raw.progress?.from)
|
|
46
|
+
const to = isoTime(raw.progress?.to)
|
|
47
|
+
if (from !== undefined && to !== undefined && from < to) out.progress = { from, to }
|
|
48
|
+
return out
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** `handled` as `{ text, at? }`, or null. */
|
|
52
|
+
function handledOf(raw) {
|
|
53
|
+
const value = typeof raw === 'string' ? { text: raw } : raw
|
|
54
|
+
if (value === null || typeof value !== 'object' || Array.isArray(value) || text(value.text).trim() === '') return null
|
|
55
|
+
const at = isoTime(value.at)
|
|
56
|
+
return at === undefined ? { text: value.text.trim() } : { text: value.text.trim(), at }
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
/**
|
|
60
|
+
* The group a record belongs in. A writer usually says (`attention`); for a record that doesn't,
|
|
61
|
+
* the same default the router documents: handled, then live, then needs-you for an interrupt or a
|
|
62
|
+
* record with done or snooze buttons, else info.
|
|
63
|
+
*/
|
|
64
|
+
export function attentionOf(record) {
|
|
65
|
+
if (GROUPS.includes(record.attention)) return record.attention
|
|
66
|
+
if (record.handled !== null) return 'handled'
|
|
67
|
+
if (record.live !== null) return 'live'
|
|
68
|
+
if (record.lane === 'interrupt' || record.actions.some(action => ASKING.includes(action.kind))) return 'needs-you'
|
|
69
|
+
return 'info'
|
|
70
|
+
}
|
|
71
|
+
|
|
27
72
|
/** A record as the page gets it, or undefined when the line is not one. */
|
|
28
73
|
export function normalize(raw, person) {
|
|
29
74
|
if (typeof raw !== 'object' || raw === null || !RECORD_ID_PATTERN.test(text(raw.id))) return undefined
|
|
30
75
|
const time = Date.parse(text(raw.time))
|
|
31
76
|
if (Number.isNaN(time)) return undefined
|
|
32
|
-
|
|
77
|
+
const record = {
|
|
33
78
|
id: raw.id,
|
|
34
79
|
person,
|
|
35
80
|
time: new Date(time).toISOString(),
|
|
@@ -53,6 +98,10 @@ export function normalize(raw, person) {
|
|
|
53
98
|
label: words(action.label) || undefined,
|
|
54
99
|
payload: typeof action.payload === 'object' && action.payload !== null && !Array.isArray(action.payload) ? action.payload : {},
|
|
55
100
|
})),
|
|
101
|
+
attention: text(raw.attention),
|
|
102
|
+
thread: text(raw.thread).trim().slice(0, MAX_THREAD),
|
|
103
|
+
live: liveOf(raw.live),
|
|
104
|
+
handled: handledOf(raw.handled),
|
|
56
105
|
test: raw.test === true,
|
|
57
106
|
push: raw.push !== false,
|
|
58
107
|
routed: list(raw.routed).filter(row => typeof row?.destination === 'string').map(row => ({
|
|
@@ -62,6 +111,9 @@ export function normalize(raw, person) {
|
|
|
62
111
|
detail: text(row.detail) || undefined,
|
|
63
112
|
})),
|
|
64
113
|
}
|
|
114
|
+
record.attention = attentionOf(record)
|
|
115
|
+
if (record.live === null && record.attention === 'live') record.live = {}
|
|
116
|
+
return record
|
|
65
117
|
}
|
|
66
118
|
|
|
67
119
|
/** A "this press was handled" line the router appends after acting on a press, or undefined. */
|
|
@@ -114,6 +166,24 @@ export async function readFrom(path, offset) {
|
|
|
114
166
|
}
|
|
115
167
|
}
|
|
116
168
|
|
|
169
|
+
const HEAD_BYTES = 256
|
|
170
|
+
|
|
171
|
+
/** The first bytes of a file, as text (empty when it can't be read). */
|
|
172
|
+
async function readHead(path, length) {
|
|
173
|
+
try {
|
|
174
|
+
const handle = await open(path, 'r')
|
|
175
|
+
try {
|
|
176
|
+
const buffer = Buffer.alloc(length)
|
|
177
|
+
const { bytesRead } = await handle.read(buffer, 0, length, 0)
|
|
178
|
+
return buffer.subarray(0, bytesRead).toString('latin1')
|
|
179
|
+
} finally {
|
|
180
|
+
await handle.close()
|
|
181
|
+
}
|
|
182
|
+
} catch {
|
|
183
|
+
return ''
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
|
|
117
187
|
async function atomicWrite(path, value) {
|
|
118
188
|
const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
|
|
119
189
|
await writeFile(tmp, JSON.stringify(value), { mode: 0o600 })
|
|
@@ -154,11 +224,14 @@ export function createStore(dataDir) {
|
|
|
154
224
|
return { records: [], handled: [], bad: 0 }
|
|
155
225
|
}
|
|
156
226
|
let entry = cache.get(person)
|
|
157
|
-
|
|
158
|
-
|
|
227
|
+
// A file rewritten in place (same inode, someone removed a line by hand) starts differently.
|
|
228
|
+
const replaced = entry !== undefined && entry.head !== '' && (await readHead(path, entry.head.length)) !== entry.head
|
|
229
|
+
if (entry === undefined || entry.ino !== info.ino || info.size < entry.offset || replaced) {
|
|
230
|
+
entry = { ino: info.ino, offset: 0, head: '', records: [], handled: [], bad: 0 }
|
|
159
231
|
cache.set(person, entry)
|
|
160
232
|
}
|
|
161
233
|
if (info.size > entry.offset) {
|
|
234
|
+
if (entry.offset === 0) entry.head = await readHead(path, HEAD_BYTES)
|
|
162
235
|
const parsed = parseLines(await readFrom(path, entry.offset), person)
|
|
163
236
|
entry.records.push(...parsed.records)
|
|
164
237
|
entry.handled.push(...parsed.handled)
|
|
@@ -214,7 +287,7 @@ export function createStore(dataDir) {
|
|
|
214
287
|
await saveMarks(person, { readBefore, read: current.read.filter(id => byId.has(id) && byId.get(id).time > readBefore), unread: [] })
|
|
215
288
|
}
|
|
216
289
|
|
|
217
|
-
/** The records of these people, newest first, each with `read
|
|
290
|
+
/** The records of these people, newest first, each with `read` and the `outcomes` of presses on it. */
|
|
218
291
|
async function view(people) {
|
|
219
292
|
const out = []
|
|
220
293
|
let bad = 0
|
|
@@ -223,12 +296,33 @@ export function createStore(dataDir) {
|
|
|
223
296
|
bad += skipped
|
|
224
297
|
const byRecord = new Map()
|
|
225
298
|
for (const status of handled) byRecord.set(status.record, [...(byRecord.get(status.record) ?? []), status])
|
|
226
|
-
for (const record of rows) out.push({ ...record, read: isRead(marked, record),
|
|
299
|
+
for (const record of rows) out.push({ ...record, read: isRead(marked, record), outcomes: byRecord.get(record.id) ?? [] })
|
|
227
300
|
}
|
|
228
301
|
out.sort((a, b) => (a.time === b.time ? 0 : a.time < b.time ? 1 : -1))
|
|
229
302
|
return { items: out, bad }
|
|
230
303
|
}
|
|
231
304
|
|
|
305
|
+
/**
|
|
306
|
+
* The newest summary line of these people (`<person>/summary.json`, `{ text, at }`, written by
|
|
307
|
+
* whatever keeps the inbox), or null when there is none or it is older than `maxHours`.
|
|
308
|
+
*/
|
|
309
|
+
async function summaryLine(people, maxHours, now = Date.now()) {
|
|
310
|
+
let best = null
|
|
311
|
+
for (const person of people) {
|
|
312
|
+
let value
|
|
313
|
+
try {
|
|
314
|
+
value = JSON.parse(await readFile(join(dataDir, person, SUMMARY), 'utf8'))
|
|
315
|
+
} catch {
|
|
316
|
+
continue
|
|
317
|
+
}
|
|
318
|
+
const said = words(value?.text)
|
|
319
|
+
const at = isoTime(value?.at)
|
|
320
|
+
if (said === '' || at === undefined || now - Date.parse(at) > maxHours * 3600 * 1000) continue
|
|
321
|
+
if (best === null || at > best.at) best = { text: said, at }
|
|
322
|
+
}
|
|
323
|
+
return best
|
|
324
|
+
}
|
|
325
|
+
|
|
232
326
|
/** Where a stored attachment lives, or undefined. */
|
|
233
327
|
async function file(people, id, name) {
|
|
234
328
|
if (!RECORD_ID_PATTERN.test(id) || typeof name !== 'string' || name === '' || name.includes('/') || name.includes('\\') || name.startsWith('.')) return undefined
|
|
@@ -240,5 +334,5 @@ export function createStore(dataDir) {
|
|
|
240
334
|
return undefined
|
|
241
335
|
}
|
|
242
336
|
|
|
243
|
-
return { persons, records, marks, setRead, markAllRead, view, file }
|
|
337
|
+
return { persons, records, marks, setRead, markAllRead, view, summaryLine, file }
|
|
244
338
|
}
|
package/src/view.js
ADDED
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* What the page lists: items, not records. Records of one person with the same
|
|
3
|
+
* `thread` fold into one item, the newest on top and the older ones as its
|
|
4
|
+
* history; a live thread's newest record simply replaces the item. Each item
|
|
5
|
+
* gets the group it shows in now, which can differ from what its writer said:
|
|
6
|
+
* a needs-you item the person marked done is handled, a snoozed one waits
|
|
7
|
+
* under info until it comes back as a new record, and a live item whose time
|
|
8
|
+
* is over is info.
|
|
9
|
+
*/
|
|
10
|
+
import { createHash } from 'node:crypto'
|
|
11
|
+
import { GROUPS } from './store.js'
|
|
12
|
+
|
|
13
|
+
/** A live item without `until` stops being live this long after its last update. */
|
|
14
|
+
export const LIVE_IDLE_MS = 6 * 60 * 60 * 1000
|
|
15
|
+
const HISTORY_MAX = 20
|
|
16
|
+
|
|
17
|
+
/** A stable key for an item: the record id, or a hash of person and thread (safe in a query string). */
|
|
18
|
+
export function itemKey(record) {
|
|
19
|
+
if (record.thread === '') return record.id
|
|
20
|
+
return `t-${createHash('sha256').update(`${record.person}\n${record.thread}`).digest('hex').slice(0, 20)}`
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
/** Whether a record's live state still runs at `now` (ms). */
|
|
24
|
+
export function liveNow(record, now) {
|
|
25
|
+
if (record.live === null) return false
|
|
26
|
+
const end = record.live.until !== undefined ? Date.parse(record.live.until) : Date.parse(record.time) + LIVE_IDLE_MS
|
|
27
|
+
return now < end
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
/**
|
|
31
|
+
* The group an item's newest record shows in at `now`, with `moved` saying why when it isn't the
|
|
32
|
+
* writer's: 'done' (the person marked it done), 'snoozed', or 'ended' (a live item past its time).
|
|
33
|
+
*/
|
|
34
|
+
export function groupOf(record, now) {
|
|
35
|
+
if (record.attention === 'needs-you') {
|
|
36
|
+
const last = record.outcomes.findLast(row => row.result === 'done' || row.result === 'snoozed')
|
|
37
|
+
if (last?.result === 'done') return { group: 'handled', moved: 'done' }
|
|
38
|
+
if (last?.result === 'snoozed' && (last.until === undefined || Date.parse(last.until) > now)) return { group: 'info', moved: 'snoozed' }
|
|
39
|
+
}
|
|
40
|
+
if (record.attention === 'live' && !liveNow(record, now)) return { group: 'info', moved: 'ended' }
|
|
41
|
+
return { group: record.attention, moved: null }
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/**
|
|
45
|
+
* Fold records (newest first, each with `read` and `outcomes`) into items, ordered by group
|
|
46
|
+
* (needs-you, live, handled, info) and newest first within a group.
|
|
47
|
+
*/
|
|
48
|
+
export function buildItems(records, now) {
|
|
49
|
+
const byKey = new Map()
|
|
50
|
+
for (const record of records) {
|
|
51
|
+
const key = itemKey(record)
|
|
52
|
+
const item = byKey.get(key)
|
|
53
|
+
if (item === undefined) {
|
|
54
|
+
byKey.set(key, { ...record, key, ids: [record.id], history: [] })
|
|
55
|
+
continue
|
|
56
|
+
}
|
|
57
|
+
item.ids.push(record.id)
|
|
58
|
+
item.read &&= record.read
|
|
59
|
+
if (item.history.length < HISTORY_MAX) item.history.push({ id: record.id, time: record.time, title: record.title, spoken: record.spoken })
|
|
60
|
+
}
|
|
61
|
+
const items = [...byKey.values()].map(item => ({ ...item, ...groupOf(item, now), liveNow: liveNow(item, now) }))
|
|
62
|
+
const rank = group => GROUPS.indexOf(group)
|
|
63
|
+
return items.sort((a, b) => rank(a.group) - rank(b.group) || (a.time === b.time ? 0 : a.time < b.time ? 1 : -1))
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/** How many items each group has, and how many are unread. */
|
|
67
|
+
export function countItems(items) {
|
|
68
|
+
const groups = Object.fromEntries(GROUPS.map(group => [group, 0]))
|
|
69
|
+
let unread = 0
|
|
70
|
+
for (const item of items) {
|
|
71
|
+
groups[item.group] += 1
|
|
72
|
+
if (!item.read) unread += 1
|
|
73
|
+
}
|
|
74
|
+
return { groups, unread }
|
|
75
|
+
}
|