1084 lines
47 KiB
JavaScript
1084 lines
47 KiB
JavaScript
const pull = require("../server/node_modules/pull-stream")
|
|
const crypto = require("crypto")
|
|
const { getConfig } = require("../configs/config-manager.js")
|
|
const { buildValidatedTombstoneSet } = require('./tombstone_validator')
|
|
const { collabContent, openInviteOf } = require('../backend/collab_content')
|
|
const calCollab = collabContent({ membersField: 'participants', undecField: 'encrypted', contentFields: ['title', 'deadline', 'status'], listFields: ['tags', 'invites'] })
|
|
const logLimit = getConfig().ssbLogStream?.limit || 1000
|
|
const INVITE_CODE_BYTES = 16
|
|
|
|
const safeText = (v) => String(v || "").trim()
|
|
const normalizeTags = (raw) => {
|
|
if (!raw) return []
|
|
if (Array.isArray(raw)) return raw.map(t => String(t || "").trim()).filter(Boolean)
|
|
return String(raw).split(",").map(t => t.trim()).filter(Boolean)
|
|
}
|
|
const hasAnyInterval = (w, m, y) => !!(w || m || y)
|
|
const expandRecurrence = (firstDate, deadline, weekly, monthly, yearly) => {
|
|
const start = new Date(firstDate)
|
|
const out = [start]
|
|
if (!deadline || !hasAnyInterval(weekly, monthly, yearly)) return out
|
|
const end = new Date(deadline).getTime()
|
|
const seen = new Set([start.getTime()])
|
|
const walk = (mutate) => {
|
|
const n = new Date(start)
|
|
mutate(n)
|
|
while (n.getTime() <= end) {
|
|
const t = n.getTime()
|
|
if (!seen.has(t)) { seen.add(t); out.push(new Date(n)) }
|
|
mutate(n)
|
|
}
|
|
}
|
|
if (weekly) walk((d) => d.setDate(d.getDate() + 7))
|
|
if (monthly) walk((d) => d.setMonth(d.getMonth() + 1))
|
|
if (yearly) walk((d) => d.setFullYear(d.getFullYear() + 1))
|
|
return out.sort((a, b) => a.getTime() - b.getTime())
|
|
}
|
|
|
|
module.exports = ({ cooler, pmModel, tribeCrypto, calendarCrypto, tribesModel }) => {
|
|
let ssb
|
|
const openSsb = async () => { if (!ssb) ssb = await cooler.open(); return ssb }
|
|
|
|
const ownCrypto = calendarCrypto || tribeCrypto
|
|
const lookupKey = (rid) => (ownCrypto && ownCrypto.getKey(rid)) || (tribeCrypto && tribeCrypto.getKey(rid)) || null
|
|
const lookupKeys = (rid) => {
|
|
const a = (ownCrypto && ownCrypto.getKeys(rid)) || []
|
|
if (a.length) return a
|
|
return (tribeCrypto && tribeCrypto.getKeys(rid)) || []
|
|
}
|
|
const lookupGen = (rid) => ((ownCrypto && ownCrypto.getGen(rid)) || (tribeCrypto && tribeCrypto.getGen(rid)) || 0)
|
|
|
|
const rotateCalendarKey = async (rootId, remainingMembers) => {
|
|
if (!ownCrypto || !tribeCrypto || !rootId) return
|
|
const existing = lookupKey(rootId)
|
|
if (!existing) return
|
|
const newKey = ownCrypto.generateTribeKey()
|
|
const newGen = ownCrypto.addNewKey(rootId, newKey)
|
|
if (!Array.isArray(remainingMembers) || !remainingMembers.length) return
|
|
const ssbClient = await openSsb()
|
|
const ssbKeys = require("../server/node_modules/ssb-keys")
|
|
const memberKeys = {}
|
|
for (const m of remainingMembers) {
|
|
try { memberKeys[m] = tribeCrypto.boxKeyForMember(newKey, m, ssbKeys) } catch (_) {}
|
|
}
|
|
if (Object.keys(memberKeys).length) {
|
|
await new Promise((resolve) => {
|
|
ssbClient.publish({ type: "tribe-keys", tribeId: rootId, generation: newGen, memberKeys }, () => resolve())
|
|
})
|
|
}
|
|
}
|
|
|
|
const ingestOwnTribeKeys = async () => {
|
|
if (!ownCrypto) return
|
|
try {
|
|
const ssbClient = await openSsb()
|
|
const ssbKeys = require("../server/node_modules/ssb-keys")
|
|
const config = require("../server/ssb_config")
|
|
const msgs = await readAll(ssbClient)
|
|
for (const m of msgs) {
|
|
const c = m.value && m.value.content
|
|
if (!c || c.type !== "tribe-keys") continue
|
|
const memberKeys = c.memberKeys
|
|
if (!memberKeys || typeof memberKeys !== "object") continue
|
|
const boxed = memberKeys[ssbClient.id]
|
|
if (!boxed) continue
|
|
try {
|
|
const unboxed = ssbKeys.unbox(boxed, config.keys)
|
|
const key = typeof unboxed === "string" ? unboxed : (unboxed && unboxed.toString ? unboxed.toString() : null)
|
|
if (key && c.tribeId) ownCrypto.addNewKey(c.tribeId, key)
|
|
} catch (_) {}
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
|
|
const readAll = async (ssbClient) =>
|
|
new Promise((resolve, reject) =>
|
|
pull(ssbClient.createLogStream({ limit: logLimit }), pull.collect((err, msgs) => err ? reject(err) : resolve(msgs)))
|
|
)
|
|
|
|
const tribeHelpers = tribeCrypto ? tribeCrypto.createHelpers(tribesModel) : null
|
|
const encryptIfTribe = tribeHelpers ? tribeHelpers.encryptIfTribe : async (c) => c
|
|
const decryptIfTribe = tribeHelpers ? tribeHelpers.decryptIfTribe : async (c) => c
|
|
const assertReadable = tribeHelpers ? tribeHelpers.assertReadable : () => {}
|
|
|
|
const encryptStandalone = (content, rootId) => {
|
|
if (!tribeCrypto || !rootId) return content
|
|
const key = lookupKey(rootId)
|
|
if (!key) return content
|
|
return tribeCrypto.encryptContent(content, [key], true)
|
|
}
|
|
|
|
const decryptCalendarRoot = (content, rootId) => {
|
|
if (!content || !content.encryptedPayload) return content
|
|
if (!tribeCrypto) return content
|
|
const keys = lookupKeys(rootId)
|
|
if (!keys || !keys.length) return { ...content, _undecryptable: true }
|
|
return tribeCrypto.decryptContent(content, keys.map(k => [k]))
|
|
}
|
|
|
|
const tryDecryptPublicInviteKey = (invites) => {
|
|
if (!tribeCrypto || !Array.isArray(invites)) return null
|
|
for (const inv of invites) {
|
|
if (!inv || typeof inv !== "object" || inv.public !== true) continue
|
|
if (typeof inv.code !== "string") continue
|
|
if (typeof inv.ek === "string") {
|
|
try { const k = tribeCrypto.decryptFromInvite(inv.ek, inv.code, inv.salt); if (k) return k } catch (_) {}
|
|
}
|
|
if (typeof inv.ekChain === "string") {
|
|
try { const chain = tribeCrypto.decryptChainFromInvite(inv.ekChain, inv.code, inv.salt); if (Array.isArray(chain) && chain.length && chain[0].key) return chain[0].key } catch (_) {}
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
const decryptIndexNodes = async (idx) => {
|
|
if (!tribeCrypto) return
|
|
for (const [k, n] of idx.nodes.entries()) {
|
|
if (!n.c || !n.c.encryptedPayload) continue
|
|
let root = k
|
|
while (idx.parent.has(root)) root = idx.parent.get(root)
|
|
let dec = null
|
|
if (n.c.tribeId && tribesModel) {
|
|
try {
|
|
const r = await tribeCrypto.decryptFromTribe(n.c, tribesModel)
|
|
if (r && !r._undecryptable) dec = r
|
|
} catch (_) {}
|
|
}
|
|
if (!dec) {
|
|
const r = decryptCalendarRoot(n.c, root)
|
|
if (r && !r._undecryptable) dec = r
|
|
}
|
|
if (!dec) {
|
|
const pubKey = tryDecryptPublicInviteKey(n.c.invites)
|
|
if (pubKey) {
|
|
try { const r = tribeCrypto.decryptContent(n.c, [[pubKey]]); if (r && !r._undecryptable) dec = r } catch (_) {}
|
|
}
|
|
}
|
|
if (dec) {
|
|
idx.nodes.set(k, { ...n, c: { ...dec, _decrypted: true } })
|
|
} else {
|
|
idx.nodes.set(k, { ...n, c: { ...n.c, _decrypted: false } })
|
|
}
|
|
}
|
|
}
|
|
|
|
const buildIndex = (messages) => {
|
|
const tomb = new Set()
|
|
const nodes = new Map()
|
|
const parent = new Map()
|
|
const child = new Map()
|
|
const strictChild = new Map()
|
|
const authorByKey = new Map()
|
|
const tombRequests = []
|
|
const participantMsgs = []
|
|
|
|
for (const m of messages) {
|
|
const k = m.key
|
|
const v = m.value || {}
|
|
const c = v.content
|
|
if (!c) continue
|
|
if (c.type === "tombstone" && c.target) { tombRequests.push({ target: c.target, author: v.author }); continue }
|
|
if (c.type === "calendarParticipant" && c.target) { participantMsgs.push({ target: c.target, author: v.author, on: c.on !== false, ts: v.timestamp || m.timestamp || 0 }); continue }
|
|
if (c.type === "calendar") {
|
|
nodes.set(k, { key: k, ts: v.timestamp || m.timestamp || 0, c, author: v.author })
|
|
authorByKey.set(k, v.author)
|
|
if (c.replaces) { parent.set(k, c.replaces); child.set(c.replaces, k) }
|
|
}
|
|
}
|
|
|
|
for (const t of tombRequests) {
|
|
const targetAuthor = authorByKey.get(t.target)
|
|
if (targetAuthor && t.author === targetAuthor) tomb.add(t.target)
|
|
}
|
|
|
|
for (const [k, node] of nodes.entries()) {
|
|
const t = node.c.replaces
|
|
if (!t) continue
|
|
const orig = nodes.get(t)
|
|
if (orig && orig.author === node.author) strictChild.set(t, k)
|
|
}
|
|
|
|
const rootOf = (id) => { let cur = id; while (parent.has(cur)) cur = parent.get(cur); return cur }
|
|
const tipOf = (id) => { let cur = id; while (child.has(cur)) cur = child.get(cur); return cur }
|
|
const contentTipOf = (root) => {
|
|
const rn = nodes.get(root)
|
|
if (!rn) return root
|
|
let cur = root
|
|
let best = root
|
|
const seen = new Set()
|
|
while (child.has(cur) && !seen.has(cur)) {
|
|
seen.add(cur)
|
|
const next = child.get(cur)
|
|
const n = nodes.get(next)
|
|
if (!n) break
|
|
if (n.author === rn.author && !tomb.has(next)) best = next
|
|
cur = next
|
|
}
|
|
return best
|
|
}
|
|
|
|
const roots = new Set()
|
|
for (const id of nodes.keys()) roots.add(rootOf(id))
|
|
|
|
const participantsByRoot = new Map()
|
|
for (const pm of participantMsgs) {
|
|
if (!nodes.has(pm.target)) continue
|
|
const r = rootOf(pm.target)
|
|
if (!participantsByRoot.has(r)) participantsByRoot.set(r, new Map())
|
|
const m2 = participantsByRoot.get(r)
|
|
const prev = m2.get(pm.author)
|
|
if (!prev || pm.ts >= prev.ts) m2.set(pm.author, { on: pm.on, ts: pm.ts })
|
|
}
|
|
|
|
const resolveParticipants = (root) => {
|
|
const ownerNode = nodes.get(root)
|
|
const oc = ownerNode ? ownerNode.c : {}
|
|
const set = new Set(Array.isArray(oc.participants) ? oc.participants : [])
|
|
for (const [au, st] of (participantsByRoot.get(root) || new Map())) {
|
|
if (st.on) set.add(au); else set.delete(au)
|
|
}
|
|
return [...set]
|
|
}
|
|
|
|
const tipByRoot = new Map()
|
|
for (const r of roots) tipByRoot.set(r, tipOf(r))
|
|
const contentTipByRoot = new Map()
|
|
for (const r of roots) contentTipByRoot.set(r, contentTipOf(r))
|
|
|
|
return { tomb, nodes, parent, child, rootOf, tipOf, contentTipOf, tipByRoot, contentTipByRoot, resolveParticipants }
|
|
}
|
|
|
|
const buildCalendar = (node, rootId, participants) => {
|
|
const c = node.c || {}
|
|
if (c.type !== "calendar") return null
|
|
const undec = c.encryptedPayload && c._decrypted === false
|
|
return {
|
|
key: node.key,
|
|
rootId,
|
|
title: undec ? "" : safeText(c.title),
|
|
status: c.status || "OPEN",
|
|
deadline: undec ? "" : (c.deadline || ""),
|
|
tags: Array.isArray(c.tags) ? c.tags : [],
|
|
author: c.author || node.author,
|
|
participants: Array.isArray(participants) ? participants : (Array.isArray(c.participants) ? c.participants : []),
|
|
invites: Array.isArray(c.invites) ? c.invites : [],
|
|
createdAt: c.createdAt || new Date(node.ts).toISOString(),
|
|
updatedAt: c.updatedAt || null,
|
|
tribeId: c.tribeId || null,
|
|
encrypted: !!undec
|
|
}
|
|
}
|
|
|
|
|
|
const isClosed = (calendar) => {
|
|
if (calendar.status === "CLOSED") return true
|
|
if (!calendar.deadline) return false
|
|
return new Date(calendar.deadline).getTime() <= Date.now()
|
|
}
|
|
|
|
const collectCalendars = async () => {
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const idx = buildIndex(messages)
|
|
await decryptIndexNodes(idx)
|
|
const items = []
|
|
for (const rootId of idx.contentTipByRoot.keys()) {
|
|
const contentTip = idx.contentTipByRoot.get(rootId) || rootId
|
|
if (idx.tomb.has(contentTip)) continue
|
|
const node = idx.nodes.get(contentTip)
|
|
if (!node || node.c.type !== "calendar") continue
|
|
const cal = buildCalendar(node, rootId, idx.resolveParticipants(rootId))
|
|
if (!cal) continue
|
|
cal.isClosed = isClosed(cal)
|
|
items.push(cal)
|
|
}
|
|
return items
|
|
}
|
|
|
|
return {
|
|
type: "calendar",
|
|
|
|
async ingestKeys() { await ingestOwnTribeKeys() },
|
|
|
|
async pruneOrphanKeys() {
|
|
if (!ownCrypto || typeof ownCrypto.getAllRootIds !== "function") return 0
|
|
try {
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const live = new Set()
|
|
const tomb = buildValidatedTombstoneSet(messages)
|
|
for (const m of messages) {
|
|
const c = m.value && m.value.content
|
|
if (!c) continue
|
|
if (c.type === "calendar") live.add(m.key)
|
|
}
|
|
const all = ownCrypto.getAllRootIds()
|
|
let removed = 0
|
|
for (const rid of all) {
|
|
if (!live.has(rid) || tomb.has(rid)) {
|
|
try { ownCrypto.dropKey(rid); removed += 1 } catch (_) {}
|
|
}
|
|
}
|
|
return removed
|
|
} catch (_) { return 0 }
|
|
},
|
|
|
|
async resolveRootId(id) {
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const idx = buildIndex(messages)
|
|
let tip = id
|
|
while (idx.child.has(tip)) tip = idx.child.get(tip)
|
|
if (idx.tomb.has(tip)) throw new Error("Not found")
|
|
let root = tip
|
|
while (idx.parent.has(root)) root = idx.parent.get(root)
|
|
return root
|
|
},
|
|
|
|
async resolveCurrentId(id) {
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const idx = buildIndex(messages)
|
|
let tip = id
|
|
while (idx.child.has(tip)) tip = idx.child.get(tip)
|
|
if (idx.tomb.has(tip)) throw new Error("Not found")
|
|
return tip
|
|
},
|
|
|
|
async createCalendar({ title, status, deadline, tags, firstDate, firstDateLabel, firstNote, intervalWeekly, intervalMonthly, intervalYearly, tribeId }) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const now = new Date().toISOString()
|
|
const validStatus = ["OPEN", "CLOSED"].includes(String(status).toUpperCase()) ? String(status).toUpperCase() : "OPEN"
|
|
|
|
if (deadline && new Date(deadline).getTime() <= Date.now()) throw new Error("Deadline must be in the future")
|
|
if (!firstDate || new Date(firstDate).getTime() <= Date.now()) throw new Error("First date must be in the future")
|
|
|
|
let plainContent = {
|
|
type: "calendar",
|
|
title: safeText(title),
|
|
status: validStatus,
|
|
deadline: deadline || "",
|
|
tags: normalizeTags(tags),
|
|
author: userId,
|
|
participants: [userId],
|
|
invites: [],
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
...(tribeId ? { tribeId } : {})
|
|
}
|
|
|
|
let calKey = null
|
|
let content = plainContent
|
|
if (tribeId) {
|
|
content = await encryptIfTribe(plainContent)
|
|
} else if (tribeCrypto) {
|
|
calKey = ownCrypto.generateTribeKey()
|
|
content = tribeCrypto.encryptContent(plainContent, [calKey], true)
|
|
}
|
|
|
|
const calMsg = await new Promise((resolve, reject) => {
|
|
ssbClient.publish(content, (err, msg) => err ? reject(err) : resolve(msg))
|
|
})
|
|
|
|
const calendarId = calMsg.key
|
|
|
|
if (calKey && tribeCrypto) {
|
|
ownCrypto.setKey(calendarId, calKey, 1)
|
|
try {
|
|
const ssbKeys = require("../server/node_modules/ssb-keys")
|
|
const boxedKey = tribeCrypto.boxKeyForMember(calKey, userId, ssbKeys)
|
|
await new Promise((resolve) => {
|
|
ssbClient.publish({ type: "tribe-keys", tribeId: calendarId, generation: 1, memberKeys: { [userId]: boxedKey } }, () => resolve())
|
|
})
|
|
} catch (_) {}
|
|
if (validStatus === "OPEN") {
|
|
try {
|
|
const pubCode = crypto.randomBytes(INVITE_CODE_BYTES).toString("hex")
|
|
const inviteSalt = tribeCrypto.generateInviteSalt()
|
|
const ek = tribeCrypto.encryptForInvite(calKey, pubCode, inviteSalt)
|
|
const tipId = await this.resolveCurrentId(calendarId)
|
|
const item = await new Promise((resolve, reject) => ssbClient.get(tipId, (e, it) => e ? reject(e) : resolve(it)))
|
|
const dec = decryptCalendarRoot(item.content, calendarId)
|
|
let updated = {
|
|
type: "calendar",
|
|
title: dec.title || "",
|
|
status: validStatus,
|
|
deadline: dec.deadline || "",
|
|
tags: Array.isArray(dec.tags) ? dec.tags : [],
|
|
author: userId,
|
|
participants: [userId],
|
|
invites: [{ code: pubCode, ek, salt: inviteSalt, gen: 1, public: true }],
|
|
createdAt: dec.createdAt,
|
|
updatedAt: new Date().toISOString(),
|
|
replaces: tipId
|
|
}
|
|
updated = encryptStandalone(updated, calendarId)
|
|
await new Promise((resolve, reject) => ssbClient.publish(updated, (e, res) => e ? reject(e) : resolve(res)))
|
|
await new Promise((resolve, reject) => ssbClient.publish({ type: "tombstone", target: tipId, deletedAt: new Date().toISOString(), author: userId }, e => e ? reject(e) : resolve()))
|
|
} catch (_) {}
|
|
}
|
|
}
|
|
|
|
let dateContent = {
|
|
type: "calendarDate",
|
|
calendarId,
|
|
date: new Date(firstDate).toISOString(),
|
|
label: safeText(firstDateLabel),
|
|
author: userId,
|
|
createdAt: new Date().toISOString(),
|
|
...(intervalWeekly ? { intervalWeekly: true } : {}),
|
|
...(intervalMonthly ? { intervalMonthly: true } : {}),
|
|
...(intervalYearly ? { intervalYearly: true } : {}),
|
|
...(deadline && hasAnyInterval(intervalWeekly, intervalMonthly, intervalYearly) ? { intervalDeadline: deadline } : {}),
|
|
...(tribeId ? { tribeId } : {})
|
|
}
|
|
if (tribeId) dateContent = await encryptIfTribe(dateContent)
|
|
else if (calKey) dateContent = tribeCrypto.encryptContent(dateContent, [calKey], true)
|
|
const dateMsg = await new Promise((resolve, reject) => {
|
|
ssbClient.publish(dateContent, (err, msg) => err ? reject(err) : resolve(msg))
|
|
})
|
|
|
|
if (firstNote && safeText(firstNote)) {
|
|
let noteContent = {
|
|
type: "calendarNote",
|
|
calendarId,
|
|
dateId: dateMsg.key,
|
|
text: safeText(firstNote),
|
|
author: userId,
|
|
createdAt: new Date().toISOString(),
|
|
...(tribeId ? { tribeId } : {})
|
|
}
|
|
if (tribeId) noteContent = await encryptIfTribe(noteContent)
|
|
else if (calKey) noteContent = tribeCrypto.encryptContent(noteContent, [calKey], true)
|
|
await new Promise((resolve, reject) => {
|
|
ssbClient.publish(noteContent, (err, msg) => err ? reject(err) : resolve(msg))
|
|
})
|
|
}
|
|
|
|
return calMsg
|
|
},
|
|
|
|
async updateCalendarById(id, data) {
|
|
const tipId = await this.resolveCurrentId(id)
|
|
const rootId = await this.resolveRootId(id)
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const item = await new Promise((resolve, reject) => {
|
|
ssbClient.get(tipId, (err, it) => err ? reject(err) : resolve(it))
|
|
})
|
|
if (!item || !item.content) throw new Error("Calendar not found")
|
|
const oldDec = item.content.tribeId
|
|
? await decryptIfTribe(item.content)
|
|
: decryptCalendarRoot(item.content, rootId)
|
|
assertReadable(oldDec, "Calendar")
|
|
if ((oldDec.author || item.content.author) !== userId) throw new Error("Not the author")
|
|
let updated = {
|
|
type: "calendar",
|
|
title: data.title !== undefined ? safeText(data.title) : (oldDec.title || ""),
|
|
status: data.status !== undefined ? (["OPEN","CLOSED"].includes(String(data.status).toUpperCase()) ? String(data.status).toUpperCase() : oldDec.status) : (oldDec.status || "OPEN"),
|
|
deadline: data.deadline !== undefined ? data.deadline : (oldDec.deadline || ""),
|
|
tags: data.tags !== undefined ? normalizeTags(data.tags) : (Array.isArray(oldDec.tags) ? oldDec.tags : []),
|
|
author: oldDec.author || userId,
|
|
participants: oldDec.participants || [userId],
|
|
invites: Array.isArray(oldDec.invites) ? oldDec.invites : [],
|
|
...(item.content.tribeId ? { tribeId: item.content.tribeId } : {}),
|
|
createdAt: oldDec.createdAt,
|
|
updatedAt: new Date().toISOString(),
|
|
replaces: tipId
|
|
}
|
|
if (item.content.tribeId) updated = await encryptIfTribe(updated)
|
|
else updated = encryptStandalone(updated, rootId)
|
|
const result = await new Promise((resolve, reject) => ssbClient.publish(updated, (e, res) => e ? reject(e) : resolve(res)))
|
|
const tombstone = { type: "tombstone", target: tipId, deletedAt: new Date().toISOString(), author: userId }
|
|
await new Promise((resolve, reject) => ssbClient.publish(tombstone, e => e ? reject(e) : resolve()))
|
|
return result
|
|
},
|
|
|
|
async deleteCalendarById(id) {
|
|
const tipId = await this.resolveCurrentId(id)
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const item = await new Promise((resolve, reject) => ssbClient.get(tipId, (e, it) => e ? reject(e) : resolve(it)))
|
|
if (!item || !item.content) throw new Error("Calendar not found")
|
|
const dec = await decryptIfTribe(item.content)
|
|
assertReadable(dec, "Calendar")
|
|
const contentAuthor = (dec && dec.author) || (typeof item.content === 'object' && item.content.author)
|
|
if (contentAuthor !== userId) throw new Error("Not the author")
|
|
const tombstone = { type: "tombstone", target: tipId, deletedAt: new Date().toISOString(), author: userId }
|
|
return new Promise((resolve, reject) => ssbClient.publish(tombstone, e => e ? reject(e) : resolve()))
|
|
},
|
|
|
|
async joinCalendar(calendarId) {
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const cal = await this.getCalendarById(rootId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
const participants = Array.isArray(cal.participants) ? cal.participants : []
|
|
if (participants.includes(userId)) return
|
|
if (tribeCrypto && Array.isArray(cal.invites)) {
|
|
const pub = cal.invites.find(inv => typeof inv === "object" && inv.public === true && inv.code && (inv.ek || inv.ekChain))
|
|
if (pub) return await this.joinByInvite(pub.code)
|
|
}
|
|
const content = { type: "calendarParticipant", target: rootId, on: true, createdAt: new Date().toISOString() }
|
|
return new Promise((resolve, reject) => ssbClient.publish(content, (e, res) => e ? reject(e) : resolve(res)))
|
|
},
|
|
|
|
async leaveCalendar(calendarId) {
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const cal = await this.getCalendarById(rootId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
if (cal.author === userId) throw new Error("Author cannot leave")
|
|
const participants = Array.isArray(cal.participants) ? cal.participants : []
|
|
if (!participants.includes(userId)) return
|
|
const content = { type: "calendarParticipant", target: rootId, on: false, createdAt: new Date().toISOString() }
|
|
const result = await new Promise((resolve, reject) => ssbClient.publish(content, (e, res) => e ? reject(e) : resolve(res)))
|
|
try { await rotateCalendarKey(rootId, participants.filter(p => p !== userId)) } catch (_) {}
|
|
return result
|
|
},
|
|
|
|
async findCalendarByLinkText(linkSubstring) {
|
|
if (!linkSubstring) return null
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const idx = buildIndex(messages)
|
|
await decryptIndexNodes(idx)
|
|
for (const node of idx.nodes.values()) {
|
|
const c = node && node.c
|
|
if (!c || c.type !== "calendarNote") continue
|
|
if (typeof c.text === "string" && c.text.includes(linkSubstring)) {
|
|
return c.calendarId || null
|
|
}
|
|
}
|
|
return null
|
|
},
|
|
|
|
async getCalendarById(id) {
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const idx = buildIndex(messages)
|
|
await decryptIndexNodes(idx)
|
|
let root = id
|
|
while (idx.parent.has(root)) root = idx.parent.get(root)
|
|
const contentTip = idx.contentTipOf(root)
|
|
if (idx.tomb.has(contentTip)) return null
|
|
const node = idx.nodes.get(contentTip)
|
|
if (!node || node.c.type !== "calendar") return null
|
|
const cal = buildCalendar(node, root, idx.resolveParticipants(root))
|
|
if (!cal) return null
|
|
cal.isClosed = isClosed(cal)
|
|
return calCollab.fold(cal, await collectCalendars())
|
|
},
|
|
|
|
async listAll({ filter = "all", viewerId } = {}) {
|
|
const ssbClient = await openSsb()
|
|
const uid = viewerId || ssbClient.id
|
|
let list = calCollab.visibleThenCollapsed(await collectCalendars(), uid)
|
|
if (filter === "mine") list = list.filter(c => c.author === uid)
|
|
else if (filter === "recent") {
|
|
const now = Date.now()
|
|
list = list.filter(c => new Date(c.createdAt).getTime() >= now - 86400000)
|
|
}
|
|
else if (filter === "open") list = list.filter(c => !c.isClosed)
|
|
else if (filter === "closed") list = list.filter(c => c.isClosed)
|
|
return list.slice().sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
|
|
},
|
|
|
|
async addDate(calendarId, date, label, intervalWeekly, intervalMonthly, intervalYearly, intervalDeadline) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const cal = await this.getCalendarById(rootId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
if (cal.status === "CLOSED" && userId !== cal.author) throw new Error("Only the author can add dates to a CLOSED calendar")
|
|
if (!date || new Date(date).getTime() <= Date.now()) throw new Error("Date must be in the future")
|
|
|
|
const hasInterval = hasAnyInterval(intervalWeekly, intervalMonthly, intervalYearly)
|
|
const ruleDeadline = hasInterval ? (intervalDeadline || cal.deadline || "") : ""
|
|
let dateContent = {
|
|
type: "calendarDate",
|
|
calendarId: rootId,
|
|
date: new Date(date).toISOString(),
|
|
label: safeText(label),
|
|
author: userId,
|
|
createdAt: new Date().toISOString(),
|
|
...(intervalWeekly ? { intervalWeekly: true } : {}),
|
|
...(intervalMonthly ? { intervalMonthly: true } : {}),
|
|
...(intervalYearly ? { intervalYearly: true } : {}),
|
|
...(ruleDeadline ? { intervalDeadline: ruleDeadline } : {}),
|
|
...(cal.tribeId ? { tribeId: cal.tribeId } : {})
|
|
}
|
|
if (cal.tribeId) dateContent = await encryptIfTribe(dateContent)
|
|
else dateContent = encryptStandalone(dateContent, rootId)
|
|
const msg = await new Promise((resolve, reject) => {
|
|
ssbClient.publish(dateContent, (err, m) => err ? reject(err) : resolve(m))
|
|
})
|
|
return [msg]
|
|
},
|
|
|
|
async getDatesForCalendar(calendarId) {
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const cal = await this.getCalendarById(rootId)
|
|
const calDeadline = cal && cal.deadline ? cal.deadline : ""
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const authorByKey = new Map()
|
|
for (const m of messages) authorByKey.set(m.key, (m.value || {}).author)
|
|
const tombstoned = new Set()
|
|
for (const m of messages) {
|
|
const c = (m.value || {}).content
|
|
if (c && c.type === "tombstone" && c.target) {
|
|
const targetAuthor = authorByKey.get(c.target)
|
|
if (targetAuthor && (m.value || {}).author === targetAuthor) tombstoned.add(c.target)
|
|
}
|
|
}
|
|
const dates = []
|
|
for (const m of messages) {
|
|
if (tombstoned.has(m.key)) continue
|
|
const v = m.value || {}
|
|
const c = v.content
|
|
if (!c || c.type !== "calendarDate") continue
|
|
if (c.calendarId !== rootId) continue
|
|
let dec = c
|
|
if (c.encryptedPayload && tribeCrypto) {
|
|
if (c.tribeId && tribesModel) {
|
|
const r = await tribeCrypto.decryptFromTribe(c, tribesModel)
|
|
dec = r && !r._undecryptable ? r : c
|
|
if (r && r._undecryptable) continue
|
|
} else {
|
|
const keys = lookupKeys(c.calendarId)
|
|
if (keys && keys.length) {
|
|
const r = tribeCrypto.decryptContent(c, keys.map(k => [k]))
|
|
dec = r && !r._undecryptable ? r : c
|
|
if (r && r._undecryptable) continue
|
|
}
|
|
}
|
|
}
|
|
const baseEntry = {
|
|
key: m.key,
|
|
calendarId: dec.calendarId || c.calendarId,
|
|
label: dec.label || "",
|
|
author: dec.author || v.author,
|
|
createdAt: dec.createdAt || new Date(v.timestamp || 0).toISOString()
|
|
}
|
|
const hasInterval = !!(dec.intervalWeekly || dec.intervalMonthly || dec.intervalYearly)
|
|
const ruleDeadline = dec.intervalDeadline || calDeadline
|
|
if (hasInterval && ruleDeadline) {
|
|
const occurrences = expandRecurrence(dec.date, ruleDeadline, dec.intervalWeekly, dec.intervalMonthly, dec.intervalYearly)
|
|
for (const occ of occurrences) {
|
|
dates.push({ ...baseEntry, date: occ.toISOString() })
|
|
}
|
|
} else {
|
|
dates.push({ ...baseEntry, date: dec.date })
|
|
}
|
|
}
|
|
dates.sort((a, b) => new Date(a.date) - new Date(b.date))
|
|
return dates
|
|
},
|
|
|
|
async deleteDate(dateId, calendarId) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const cal = await this.getCalendarById(rootId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
const messages = await readAll(ssbClient)
|
|
const authorByKey = new Map()
|
|
for (const m of messages) authorByKey.set(m.key, (m.value || {}).author)
|
|
const tombstoned = new Set()
|
|
for (const m of messages) {
|
|
const c = (m.value || {}).content
|
|
if (c && c.type === "tombstone" && c.target) {
|
|
const targetAuthor = authorByKey.get(c.target)
|
|
if (targetAuthor && (m.value || {}).author === targetAuthor) tombstoned.add(c.target)
|
|
}
|
|
}
|
|
let dateAuthor = null
|
|
for (const m of messages) {
|
|
if (m.key !== dateId) continue
|
|
const c = (m.value || {}).content
|
|
if (!c || c.type !== "calendarDate") continue
|
|
if (tombstoned.has(m.key)) break
|
|
let dec = c
|
|
if (c.encryptedPayload && tribeCrypto && tribesModel) {
|
|
const r = await tribeCrypto.decryptFromTribe(c, tribesModel)
|
|
if (r && !r._undecryptable) dec = r
|
|
}
|
|
dateAuthor = dec.author || (m.value || {}).author
|
|
break
|
|
}
|
|
if (!dateAuthor) throw new Error("Date not found")
|
|
if (dateAuthor !== userId && cal.author !== userId) throw new Error("Not authorized")
|
|
for (const m of messages) {
|
|
const c = (m.value || {}).content
|
|
if (!c || c.type !== "calendarNote") continue
|
|
if (tombstoned.has(m.key)) continue
|
|
if (c.dateId !== dateId) continue
|
|
await new Promise((resolve, reject) => {
|
|
ssbClient.publish({ type: "tombstone", target: m.key, deletedAt: new Date().toISOString(), author: userId }, (e) => e ? reject(e) : resolve())
|
|
})
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
ssbClient.publish({ type: "tombstone", target: dateId, deletedAt: new Date().toISOString(), author: userId }, (e) => e ? reject(e) : resolve())
|
|
})
|
|
},
|
|
|
|
async addNote(calendarId, dateId, text) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const cal = await this.getCalendarById(rootId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
if (!cal.participants.includes(userId)) throw new Error("Only participants can add notes")
|
|
let noteContent = {
|
|
type: "calendarNote",
|
|
calendarId: rootId,
|
|
dateId,
|
|
text: safeText(text),
|
|
author: userId,
|
|
createdAt: new Date().toISOString(),
|
|
...(cal.tribeId ? { tribeId: cal.tribeId } : {})
|
|
}
|
|
if (cal.tribeId) noteContent = await encryptIfTribe(noteContent)
|
|
else noteContent = encryptStandalone(noteContent, rootId)
|
|
return new Promise((resolve, reject) => {
|
|
ssbClient.publish(noteContent, (err, msg) => err ? reject(err) : resolve(msg))
|
|
})
|
|
},
|
|
|
|
async deleteNote(noteId) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const item = await new Promise((resolve, reject) => ssbClient.get(noteId, (e, it) => e ? reject(e) : resolve(it)))
|
|
if (!item || !item.content) throw new Error("Note not found")
|
|
const dec = await decryptIfTribe(item.content)
|
|
if ((dec.author || item.content.author) !== userId) throw new Error("Not the author")
|
|
return new Promise((resolve, reject) => {
|
|
ssbClient.publish({ type: "tombstone", target: noteId, deletedAt: new Date().toISOString(), author: userId }, (e, msg) => e ? reject(e) : resolve(msg))
|
|
})
|
|
},
|
|
|
|
async getNotesForDate(calendarId, dateId) {
|
|
const rootId = await this.resolveRootId(calendarId)
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const authorByKey = new Map()
|
|
for (const m of messages) authorByKey.set(m.key, (m.value || {}).author)
|
|
const tombstoned = new Set()
|
|
for (const m of messages) {
|
|
const c = (m.value || {}).content
|
|
if (c && c.type === "tombstone" && c.target) {
|
|
const targetAuthor = authorByKey.get(c.target)
|
|
if (targetAuthor && (m.value || {}).author === targetAuthor) tombstoned.add(c.target)
|
|
}
|
|
}
|
|
const notes = []
|
|
for (const m of messages) {
|
|
const v = m.value || {}
|
|
const c = v.content
|
|
if (!c || c.type !== "calendarNote") continue
|
|
if (tombstoned.has(m.key)) continue
|
|
if (c.calendarId !== rootId || c.dateId !== dateId) continue
|
|
let dec = c
|
|
if (c.encryptedPayload && tribeCrypto && tribesModel) {
|
|
const r = await tribeCrypto.decryptFromTribe(c, tribesModel)
|
|
if (r && !r._undecryptable) dec = r
|
|
else continue
|
|
}
|
|
notes.push({
|
|
key: m.key,
|
|
calendarId: dec.calendarId || c.calendarId,
|
|
dateId: dec.dateId || c.dateId,
|
|
text: dec.text || "",
|
|
author: dec.author || v.author,
|
|
createdAt: dec.createdAt || new Date(v.timestamp || 0).toISOString()
|
|
})
|
|
}
|
|
notes.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt))
|
|
return notes
|
|
},
|
|
|
|
async checkDueReminders() {
|
|
if (!pmModel) return
|
|
const ssbClient = await openSsb()
|
|
const messages = await readAll(ssbClient)
|
|
const now = Date.now()
|
|
|
|
const sentMarkers = new Set()
|
|
for (const m of messages) {
|
|
const c = (m.value || {}).content
|
|
if (!c || c.type !== "calendarReminderSent") continue
|
|
const sig = c.occurrence ? `${c.calendarId}::${c.dateId}::${c.occurrence}` : `${c.calendarId}::${c.dateId}`
|
|
sentMarkers.add(sig)
|
|
}
|
|
|
|
const authorByKey = new Map()
|
|
for (const m of messages) authorByKey.set(m.key, (m.value || {}).author)
|
|
const tombstoned = new Set()
|
|
for (const m of messages) {
|
|
const c = (m.value || {}).content
|
|
if (c && c.type === "tombstone" && c.target) {
|
|
const targetAuthor = authorByKey.get(c.target)
|
|
if (targetAuthor && (m.value || {}).author === targetAuthor) tombstoned.add(c.target)
|
|
}
|
|
}
|
|
|
|
const calendarDeadlines = new Map()
|
|
const dueByCalendar = new Map()
|
|
for (const m of messages) {
|
|
if (tombstoned.has(m.key)) continue
|
|
const v = m.value || {}
|
|
const c = v.content
|
|
if (!c || c.type !== "calendarDate") continue
|
|
let dec = c
|
|
if (c.encryptedPayload && tribeCrypto && tribesModel) {
|
|
const r = await tribeCrypto.decryptFromTribe(c, tribesModel)
|
|
if (!r || r._undecryptable) continue
|
|
dec = r
|
|
}
|
|
if (!dec.date) continue
|
|
const calId = c.calendarId
|
|
let calDeadline = calendarDeadlines.get(calId)
|
|
if (calDeadline === undefined) {
|
|
try {
|
|
const cc = await this.getCalendarById(calId)
|
|
calDeadline = (cc && cc.deadline) || ""
|
|
} catch (_) { calDeadline = "" }
|
|
calendarDeadlines.set(calId, calDeadline)
|
|
}
|
|
const hasInterval = !!(dec.intervalWeekly || dec.intervalMonthly || dec.intervalYearly)
|
|
const ruleDeadline = dec.intervalDeadline || calDeadline
|
|
const occurrences = (hasInterval && ruleDeadline)
|
|
? expandRecurrence(dec.date, ruleDeadline, dec.intervalWeekly, dec.intervalMonthly, dec.intervalYearly)
|
|
: [new Date(dec.date)]
|
|
for (const occ of occurrences) {
|
|
if (occ.getTime() > now) continue
|
|
const occIso = occ.toISOString()
|
|
const sig = hasInterval ? `${calId}::${m.key}::${occIso}` : `${calId}::${m.key}`
|
|
if (sentMarkers.has(sig)) continue
|
|
const entry = { key: m.key, calendarId: calId, date: occIso, label: dec.label || "", recurring: hasInterval }
|
|
const list = dueByCalendar.get(calId) || []
|
|
list.push(entry)
|
|
dueByCalendar.set(calId, list)
|
|
}
|
|
}
|
|
|
|
const publishMarker = (calendarId, dateId, occurrence) => new Promise((resolve, reject) => {
|
|
const payload = {
|
|
type: "calendarReminderSent",
|
|
calendarId,
|
|
dateId,
|
|
sentAt: new Date().toISOString()
|
|
}
|
|
if (occurrence) payload.occurrence = occurrence
|
|
ssbClient.publish(payload, (err) => err ? reject(err) : resolve())
|
|
})
|
|
|
|
for (const [calendarId, list] of dueByCalendar.entries()) {
|
|
try {
|
|
list.sort((a, b) => new Date(b.date) - new Date(a.date))
|
|
const primary = list[0]
|
|
const cal = await this.getCalendarById(calendarId)
|
|
if (!cal) continue
|
|
const participants = cal.participants.filter(p => typeof p === "string" && p.length > 0)
|
|
if (participants.length > 0) {
|
|
const notesForDay = await this.getNotesForDate(calendarId, primary.key)
|
|
const notesBlock = notesForDay.length > 0
|
|
? notesForDay.map(n => ` - ${n.text}`).join("\n\n")
|
|
: " (no notes)"
|
|
const subject = `Calendar Reminder: ${cal.title}`
|
|
const text =
|
|
`Reminder from: ${cal.author}\n` +
|
|
`Title: ${cal.title}\n` +
|
|
`Date: ${primary.label || primary.date}\n\n` +
|
|
`Notes for this day:\n\n${notesBlock}\n\n` +
|
|
`Visit Calendar: /calendars/${cal.rootId}`
|
|
const chunkSize = 6
|
|
for (let i = 0; i < participants.length; i += chunkSize) {
|
|
await pmModel.sendMessage(participants.slice(i, i + chunkSize), subject, text)
|
|
}
|
|
}
|
|
for (const dd of list) {
|
|
try { await publishMarker(calendarId, dd.key, dd.recurring ? dd.date : null) } catch (_) {}
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
},
|
|
|
|
async generateInvite(calendarId, opts = {}) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const cal = await this.getCalendarById(calendarId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
if (cal.author !== userId) throw new Error("Only the author can generate invites")
|
|
const code = crypto.randomBytes(INVITE_CODE_BYTES).toString("hex")
|
|
let invite = code
|
|
const pubFlag = opts.public ? { public: true } : {}
|
|
if (tribeCrypto && !cal.tribeId) {
|
|
const inviteSalt = tribeCrypto.generateInviteSalt()
|
|
const ekChain = tribeCrypto.encryptChainForInvite([cal.rootId], code, inviteSalt)
|
|
if (ekChain) invite = { code, ekChain, salt: inviteSalt, gen: lookupGen(cal.rootId), ...pubFlag }
|
|
}
|
|
if (opts.public && typeof invite !== "object") invite = { code, public: true }
|
|
const tipId = await this.resolveCurrentId(calendarId)
|
|
const item = await new Promise((resolve, reject) => ssbClient.get(tipId, (e, it) => e ? reject(e) : resolve(it)))
|
|
const dec = item.content.tribeId
|
|
? await decryptIfTribe(item.content)
|
|
: decryptCalendarRoot(item.content, cal.rootId)
|
|
const invites = [...(Array.isArray(dec.invites) ? dec.invites : []), invite]
|
|
let updated = {
|
|
type: "calendar",
|
|
title: dec.title || "",
|
|
status: dec.status || "OPEN",
|
|
deadline: dec.deadline || "",
|
|
tags: Array.isArray(dec.tags) ? dec.tags : [],
|
|
author: dec.author,
|
|
participants: Array.isArray(dec.participants) ? dec.participants : [userId],
|
|
invites,
|
|
...(item.content.tribeId ? { tribeId: item.content.tribeId } : {}),
|
|
createdAt: dec.createdAt,
|
|
updatedAt: new Date().toISOString(),
|
|
replaces: tipId
|
|
}
|
|
if (item.content.tribeId) updated = await encryptIfTribe(updated)
|
|
else updated = encryptStandalone(updated, cal.rootId)
|
|
await new Promise((resolve, reject) => ssbClient.publish(updated, (e, res) => e ? reject(e) : resolve(res)))
|
|
const tombstone = { type: "tombstone", target: tipId, deletedAt: new Date().toISOString(), author: userId }
|
|
await new Promise((resolve, reject) => ssbClient.publish(tombstone, e => e ? reject(e) : resolve()))
|
|
return code
|
|
},
|
|
|
|
async getOpenInvite(calendarId) {
|
|
return openInviteOf(await this.getCalendarById(calendarId).catch(() => null))
|
|
},
|
|
|
|
async generateOpenInvite(calendarId) {
|
|
const cal = await this.getCalendarById(calendarId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
const existing = (Array.isArray(cal.invites) ? cal.invites : []).find(inv => typeof inv === "object" && inv.public === true)
|
|
if (existing) throw new Error("An open invitation already exists")
|
|
return this.generateInvite(calendarId, { public: true })
|
|
},
|
|
|
|
async removeOpenInvite(calendarId) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const cal = await this.getCalendarById(calendarId)
|
|
if (!cal) throw new Error("Calendar not found")
|
|
if (cal.author !== userId) throw new Error("Only the author can remove invites")
|
|
const tipId = await this.resolveCurrentId(calendarId)
|
|
const item = await new Promise((resolve, reject) => ssbClient.get(tipId, (e, it) => e ? reject(e) : resolve(it)))
|
|
const dec = item.content.tribeId
|
|
? await decryptIfTribe(item.content)
|
|
: decryptCalendarRoot(item.content, cal.rootId)
|
|
const invites = (Array.isArray(dec.invites) ? dec.invites : []).filter(inv => !(typeof inv === "object" && inv.public === true))
|
|
let updated = {
|
|
type: "calendar",
|
|
title: dec.title || "",
|
|
status: dec.status || "OPEN",
|
|
deadline: dec.deadline || "",
|
|
tags: Array.isArray(dec.tags) ? dec.tags : [],
|
|
author: dec.author,
|
|
participants: Array.isArray(dec.participants) ? dec.participants : [userId],
|
|
invites,
|
|
...(item.content.tribeId ? { tribeId: item.content.tribeId } : {}),
|
|
createdAt: dec.createdAt,
|
|
updatedAt: new Date().toISOString(),
|
|
replaces: tipId
|
|
}
|
|
if (item.content.tribeId) updated = await encryptIfTribe(updated)
|
|
else updated = encryptStandalone(updated, cal.rootId)
|
|
await new Promise((resolve, reject) => ssbClient.publish(updated, (e, res) => e ? reject(e) : resolve(res)))
|
|
const tombstone = { type: "tombstone", target: tipId, deletedAt: new Date().toISOString(), author: userId }
|
|
await new Promise((resolve, reject) => ssbClient.publish(tombstone, e => e ? reject(e) : resolve()))
|
|
},
|
|
|
|
async joinByInvite(code) {
|
|
const ssbClient = await openSsb()
|
|
const userId = ssbClient.id
|
|
const calendars = await collectCalendars()
|
|
let matched = null
|
|
let matchedInvite = null
|
|
for (const cal of calendars) {
|
|
const invs = Array.isArray(cal.invites) ? cal.invites : []
|
|
for (const inv of invs) {
|
|
if (typeof inv === "string" && inv === code) { matched = cal; matchedInvite = inv; break }
|
|
if (typeof inv === "object" && inv.code === code) { matched = cal; matchedInvite = inv; break }
|
|
}
|
|
if (matched) break
|
|
}
|
|
if (!matched) throw new Error("Invalid or expired invite code")
|
|
if (matched.participants.includes(userId)) throw new Error("Already a participant")
|
|
let calKey = null
|
|
if (tribeCrypto && typeof matchedInvite === "object") {
|
|
if (matchedInvite.ekChain) {
|
|
const chain = tribeCrypto.decryptChainFromInvite(matchedInvite.ekChain, code, matchedInvite.salt)
|
|
if (Array.isArray(chain) && chain.length) {
|
|
for (const entry of chain) {
|
|
if (Array.isArray(entry.keys) && entry.keys.length) {
|
|
tribeCrypto.setKeys(entry.rootId, entry.keys, entry.gen || entry.keys.length)
|
|
} else if (entry.key) {
|
|
tribeCrypto.setKey(entry.rootId, entry.key, entry.gen || 1)
|
|
}
|
|
}
|
|
calKey = chain[0].key
|
|
}
|
|
} else if (matchedInvite.ek) {
|
|
calKey = tribeCrypto.decryptFromInvite(matchedInvite.ek, code, matchedInvite.salt)
|
|
ownCrypto.setKey(matched.rootId, calKey, matchedInvite.gen || 1)
|
|
}
|
|
}
|
|
const tipId = await this.resolveCurrentId(matched.rootId)
|
|
const item = await new Promise((resolve, reject) => ssbClient.get(tipId, (e, it) => e ? reject(e) : resolve(it)))
|
|
const dec = item.content.tribeId
|
|
? await decryptIfTribe(item.content)
|
|
: decryptCalendarRoot(item.content, matched.rootId)
|
|
const isPublicInvite = typeof matchedInvite === "object" && matchedInvite.public === true
|
|
const invites = isPublicInvite
|
|
? (Array.isArray(dec.invites) ? dec.invites : [])
|
|
: (Array.isArray(dec.invites) ? dec.invites : []).filter(inv => {
|
|
if (typeof inv === "string") return inv !== code
|
|
return inv.code !== code
|
|
})
|
|
let updated = {
|
|
type: "calendar",
|
|
title: dec.title || "",
|
|
status: dec.status || "OPEN",
|
|
deadline: dec.deadline || "",
|
|
tags: Array.isArray(dec.tags) ? dec.tags : [],
|
|
author: dec.author,
|
|
participants: [...(Array.isArray(dec.participants) ? dec.participants : []), userId],
|
|
invites,
|
|
...(item.content.tribeId ? { tribeId: item.content.tribeId } : {}),
|
|
createdAt: dec.createdAt,
|
|
updatedAt: new Date().toISOString(),
|
|
replaces: tipId
|
|
}
|
|
if (item.content.tribeId) updated = await encryptIfTribe(updated)
|
|
else updated = encryptStandalone(updated, matched.rootId)
|
|
await new Promise((resolve, reject) => ssbClient.publish(updated, (e, res) => e ? reject(e) : resolve(res)))
|
|
const tombstone = { type: "tombstone", target: tipId, deletedAt: new Date().toISOString(), author: userId }
|
|
await new Promise((resolve, reject) => ssbClient.publish(tombstone, e => e ? reject(e) : resolve()))
|
|
if (tribeCrypto && calKey) {
|
|
try {
|
|
const ssbKeys = require("../server/node_modules/ssb-keys")
|
|
const memberKeys = {}
|
|
try { memberKeys[userId] = tribeCrypto.boxKeyForMember(calKey, userId, ssbKeys) } catch (_) {}
|
|
if (matched.author && matched.author !== userId) {
|
|
try { memberKeys[matched.author] = tribeCrypto.boxKeyForMember(calKey, matched.author, ssbKeys) } catch (_) {}
|
|
}
|
|
if (Object.keys(memberKeys).length) {
|
|
await new Promise((resolve) => {
|
|
ssbClient.publish({ type: "tribe-keys", tribeId: matched.rootId, generation: lookupGen(matched.rootId) || 1, memberKeys }, () => resolve())
|
|
})
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
await new Promise((resolve, reject) => ssbClient.publish({ type: "calendarParticipant", target: matched.rootId, on: true, createdAt: new Date().toISOString() }, (e, res) => e ? reject(e) : resolve(res)))
|
|
return matched.rootId
|
|
}
|
|
}
|
|
}
|