git ssb

16+

cel / patchfoo



Tree: a36543131c127121355391b4c743f49b7280b2aa

Files: a36543131c127121355391b4c743f49b7280b2aa / lib / app.js

41558 bytesRaw
1var http = require('http')
2var memo = require('asyncmemo')
3var lru = require('hashlru')
4var pkg = require('../package')
5var u = require('./util')
6var pull = require('pull-stream')
7var multicb = require('multicb')
8var paramap = require('pull-paramap')
9var Contacts = require('./contacts')
10var PrivateBox = require('private-box')
11var About = require('./about')
12var Follows = require('./follows')
13var Serve = require('./serve')
14var Render = require('./render')
15var Git = require('ssb-git')
16var cat = require('pull-cat')
17var proc = require('child_process')
18var toPull = require('stream-to-pull-stream')
19var BoxStream = require('pull-box-stream')
20var crypto = require('crypto')
21var SsbNpmRegistry = require('ssb-npm-registry')
22var os = require('os')
23var path = require('path')
24var fs = require('fs')
25var mkdirp = require('mkdirp')
26var Base64URL = require('base64-url')
27var ssbKeys = require('ssb-keys')
28
29var zeros = new Buffer(24); zeros.fill(0)
30
31module.exports = App
32
33function App(sbot, config) {
34 this.sbot = sbot
35 this.config = config
36
37 var conf = config.patchfoo || {}
38 this.port = conf.port || 8027
39 this.host = conf.host || 'localhost'
40 this.msgFilter = conf.filter == null ? 'all' : conf.filter
41 this.showPrivates = conf.showPrivates == null ? true : conf.showPrivates
42 this.previewVotes = conf.previewVotes == null ? false : conf.previewVotes
43 this.previewContacts = conf.previewContacts == null ? false : conf.previewContacts
44 this.useOoo = conf.ooo == null ? false : conf.ooo
45 this.ssbPort = 8008
46 this.portRegexp = new RegExp(':' + this.ssbPort + '$')
47 this.caps = config.caps || {}
48 this.peerInviteCap = this.caps.peerInvite
49 || new Buffer('HT0wIYuk3OWc2FtaCfHNnakV68jSGRrjRMP9Kos7IQc=', 'base64') // sha256('peer-invites')
50 this.devPeerInviteCap = new Buffer('pmr+IzM+4VAZgi5H5bOopXkwnzqrNussS7DtAJsfbf0=', 'base64') // sha256('peer-invites:DEVELOPMENT')
51 this.voteBranches = !!config.voteBranches
52 this.copyableIds = config.copyableIds == null ? true : config.copyableIds
53
54 this.hostname = (/:/.test(this.host) ? '[' + this.host + ']' : this.host) + this.port
55 this.dir = path.join(config.path, conf.dir || 'patchfoo')
56 this.scriptDir = path.join(this.dir, conf.scriptDir || 'script')
57 this.draftsDir = path.join(this.dir, conf.draftsDir || 'drafts')
58
59 var base = conf.base || '/'
60 this.opts = {
61 base: base,
62 blob_base: conf.blob_base || conf.img_base || base,
63 img_base: conf.img_base || (base + 'image/'),
64 emoji_base: conf.emoji_base || (base + 'emoji/'),
65 encode_msgids: conf.encode_msgids == null ? true : Boolean(conf.encode_msgids),
66 codeInTextareas: conf.codeInTextareas,
67 }
68
69 this.msgCache = lru(100)
70 this.getMsg = memo({cache: this.msgCache}, getMsgWithValue, sbot)
71 this.getMsgOoo = memo({cache: this.msgCache}, this.getMsgOoo)
72 this.getAbout = memo({cache: this.aboutCache = lru(500)},
73 this._getAbout.bind(this))
74 this.unboxContent = memo({cache: lru(100)}, this.unboxContent.bind(this))
75 this.reverseNameCache = lru(500)
76 this.reverseEmojiNameCache = lru(500)
77 this.getBlobSize = memo({cache: this.blobSizeCache = lru(100)},
78 sbot.blobs.size.bind(sbot.blobs))
79 this.getVotes = memo({cache: lru(100)}, this._getVotes.bind(this))
80 this.getIdeaTitle = memo({cache: lru(100)}, this.getIdeaTitle)
81
82 this.unboxMsg = this.unboxMsg.bind(this)
83
84 this.render = new Render(this, this.opts)
85 this.git = new Git(this.sbot, this.config)
86 this.contacts = new Contacts(this.sbot)
87 this.follows = new Follows(this.sbot, this.contacts)
88 this.about = new About(this, sbot.id, this.follows)
89 this.serveSsbNpmRegistry = SsbNpmRegistry.respond(this.sbot, this.config)
90
91 this.mtimes = {}
92 this.getScript = memo({cache: false}, this.getScript)
93
94 this.monitorBlobWants()
95 this.navLinks = conf.nav || [
96 'new',
97 'public',
98 this.sbot.private && 'private',
99 'mentions',
100 'peers',
101 this.sbot.status && 'status',
102 'channels',
103 'tags',
104 this.sbot.friends && 'friends',
105 'search',
106 'live',
107 'compose',
108 'drafts',
109 'emojis',
110 'self',
111 'searchbox'
112 ]
113}
114
115App.prototype.go = function () {
116 var self = this
117 var server = http.createServer(function (req, res) {
118 new Serve(self, req, res).go()
119 })
120 server.listen(self.port, self.host, onListening)
121 function onListening() {
122 var addr = server.address()
123 var host = addr.family === 'IPv6' ? '[' + addr.address + ']' : addr.address
124 self.log('Listening on http://' + host + ':' + addr.port)
125 }
126
127 // invalidate cached About info when new About messages come in
128 if (!self.sbot.links) return console.error('missing sbot.links')
129 else pull(
130 self.sbot.links({rel: 'about', old: false, values: true}),
131 pull.drain(function (link) {
132 self.aboutCache.remove(link.dest)
133 }, function (err) {
134 if (err) throw err
135 })
136 )
137
138 // keep alive ssb client connection
139 setInterval(self.sbot.whoami, 10e3)
140}
141
142var logPrefix = '[' + pkg.name + ']'
143App.prototype.log = console.log.bind(console, logPrefix)
144App.prototype.error = console.error.bind(console, logPrefix)
145
146App.prototype.unboxContent = function (content, cb) {
147 if (this.sbot.private && this.sbot.private.unbox) return this.sbot.private.unbox(content, cb)
148 if (typeof content !== 'string') return cb(new TypeError('content must be string'))
149 // Missing ssb-private and privat key
150 var keys = this.config.keys || {}
151 if (!keys.private) {
152 // Missing ssb-private and private key, so cannot decrypt here.
153 // ssb-server may do decryption anyway, with private:true RPC option.
154 return cb(null, null)
155 }
156 var data
157 try { data = ssbKeys.unbox(content, this.config.keys.private) }
158 catch(e) { return cb(e) }
159 cb(null, data)
160}
161
162App.prototype.unboxContentWithKey = function (content, key, cb) {
163 if (!key) return this.unboxContent(content, cb)
164 var data
165 try {
166 var contentBuf = new Buffer(content.replace(/\.box.*$/, ''), 'base64')
167 var keyBuf = new Buffer(key, 'base64')
168 data = PrivateBox.multibox_open_body(contentBuf, keyBuf)
169 if (!data) return cb(new Error('failed to decrypt'))
170 data = JSON.parse(data.toString('utf8'))
171 } catch(e) {
172 return cb(new Error(e.stack || e))
173 }
174 cb(null, data)
175}
176
177App.prototype.unboxMsgWithKey = function (msg, key, cb) {
178 var self = this
179 var c = msg && msg.value && msg.value.content
180 if (typeof c !== 'string') cb(null, msg)
181 else self.unboxContentWithKey(c, key, function (err, content) {
182 if (err) {
183 self.error('unbox:', err)
184 return cb(null, msg)
185 } else if (!content) {
186 return cb(null, msg)
187 }
188 var m = {}
189 for (var k in msg) m[k] = msg[k]
190 m.value = {}
191 for (var k in msg.value) m.value[k] = msg.value[k]
192 m.value.content = content
193 m.value.private = true
194 cb(null, m)
195 })
196}
197
198App.prototype.unboxMsg = function (msg, cb) {
199 return this.unboxMsgWithKey(msg, null, cb)
200}
201
202App.prototype.search = function (query) {
203 var fsearch = this.sbot.fulltext && this.sbot.fulltext.search
204 if (fsearch) return fsearch(query)
205 var search = this.sbot.search && this.sbot.search.query
206 if (search) return search({query: String(query).toLowerCase()})
207 return pull.error(new Error('Search needs ssb-fulltext or ssb-search plugin'))
208}
209
210App.prototype.advancedSearch = function (opts) {
211 return pull(
212 opts.channel ?
213 this.sbot.backlinks.read({
214 dest: '#' + opts.channel,
215 reverse: true,
216 })
217 : opts.dest ?
218 this.sbot.backlinks ? this.sbot.backlinks.read({
219 reverse: true,
220 query: [
221 {$filter: {
222 dest: opts.dest,
223 value: {
224 author: opts.source || undefined
225 }
226 }}
227 ]
228 }) : this.sbotLinks({
229 values: true,
230 dest: opts.dest,
231 source: opts.source || undefined,
232 reverse: true,
233 meta: false,
234 })
235 : opts.source ?
236 this.sbotCreateUserStream({
237 reverse: true,
238 private: true,
239 id: opts.source
240 })
241 :
242 this.sbot.createFeedStream({
243 reverse: true,
244 private: true,
245 }),
246 this.unboxMessages(),
247 opts.text && pull.filter(filterByText(opts.text))
248 )
249}
250
251function forSome(each) {
252 return function some(obj) {
253 if (obj == null) return false
254 if (typeof obj === 'string') return each(obj)
255 if (Array.isArray(obj)) return obj.some(some)
256 if (typeof obj === 'object') for (var k in obj) {
257 if (each(k)) return true
258 if (some(obj[k])) return true
259 }
260 return false
261 }
262}
263
264function filterByText(str) {
265 if (!str) return function () { return true }
266 var matcher
267 try {
268 var search = new RegExp(str, 'i')
269 matcher = search.test.bind(search)
270 } catch(e) {
271 matcher = function (value) {
272 return String(value).indexOf(str) !== -1
273 }
274 }
275 var matches = forSome(matcher)
276 return function (msg) {
277 var c = msg.value.content
278 return c && matches(c)
279 }
280}
281
282App.prototype.getMsgDecrypted = function (key, cb) {
283 var self = this
284 this.getMsg(key, function (err, msg) {
285 if (err) return cb(err)
286 self.unboxMsg(msg, cb)
287 })
288}
289
290App.prototype.getMsgOoo = function (key, cb) {
291 var ooo = this.sbot.ooo
292 if (!ooo) return cb(new Error('missing ssb-ooo plugin'))
293 ooo.get(key, cb)
294}
295
296App.prototype.getMsgDecryptedOoo = function (key, cb) {
297 var self = this
298 this.getMsgOoo(key, function (err, msg) {
299 if (err) return cb(err)
300 self.unboxMsg(msg, cb)
301 })
302}
303
304App.prototype.privatePublish = function (content, recps, cb) {
305 if (this.private && typeof this.private.publish === 'function') {
306 return this.sbot.private.publish(content, recps, cb)
307 } else {
308 try { content = ssbKeys.box(content, recps) }
309 catch(e) { return cb(e) }
310 return this.sbot.publish(content, cb)
311 }
312}
313
314App.prototype.publish = function (content, cb) {
315 var self = this
316 function tryPublish(triesLeft) {
317 if (Array.isArray(content.recps)) {
318 var recps = content.recps.map(u.linkDest)
319 self.privatePublish(content, recps, next)
320 } else {
321 self.sbot.publish(content, next)
322 }
323 function next(err, msg) {
324 if (err) {
325 if (triesLeft > 0) {
326 if (/^expected previous:/.test(err.message)) {
327 return tryPublish(triesLeft-1)
328 }
329 }
330 }
331 return cb(err, msg)
332 }
333 }
334 tryPublish(2)
335}
336
337App.prototype.wantSizeBlob = function (id, cb) {
338 // only want() the blob if we don't already have it
339 var self = this
340 var blobs = this.sbot.blobs
341 blobs.size(id, function (err, size) {
342 if (size != null) return cb(null, size)
343 self.blobWants[id] = true
344 blobs.want(id, function (err) {
345 if (err) return cb(err)
346 blobs.size(id, cb)
347 })
348 })
349}
350
351App.prototype.addBlobRaw = function (cb) {
352 var done = multicb({pluck: 1, spread: true})
353 var sink = pull(
354 u.pullLength(done()),
355 this.sbot.blobs.add(done())
356 )
357 done(function (err, size, hash) {
358 if (err) return cb(err)
359 cb(null, {link: hash, size: size})
360 })
361 return sink
362}
363
364App.prototype.addBlob = function (isPrivate, cb) {
365 if (!isPrivate) return this.addBlobRaw(cb)
366 else return this.addBlobPrivate(cb)
367}
368
369App.prototype.addBlobPrivate = function (cb) {
370 var bufs = []
371 var self = this
372 // use the hash of the cleartext as the key to encrypt the blob
373 var hash = crypto.createHash('sha256')
374 return pull.drain(function (buf) {
375 bufs.push(buf)
376 hash.update(buf)
377 }, function (err) {
378 if (err) return cb(err)
379 var secret = hash.digest()
380 pull(
381 pull.values(bufs),
382 BoxStream.createBoxStream(secret, zeros),
383 self.addBlobRaw(function (err, link) {
384 if (err) return cb(err)
385 link.key = secret.toString('base64')
386 cb(null, link)
387 })
388 )
389 })
390}
391
392App.prototype.getBlob = function (id, key) {
393 if (!key) {
394 var m = /^(.*)\?unbox=(.*)$/.exec(id)
395 if (m) {
396 id = m[1]
397 key = m[2]
398 }
399 }
400 if (!key) return this.sbot.blobs.get(id)
401 if (typeof key === 'string') key = new Buffer(key, 'base64')
402 return pull(
403 this.sbot.blobs.get(id),
404 BoxStream.createUnboxStream(key, zeros)
405 )
406}
407
408App.prototype.getHasBlob = function (id, cb) {
409 id = id.replace(/\?unbox=.*/, '')
410 if (!this.sbot.blobs) return cb(new TypeError('missing ssb-blobs plugin'))
411 if (!this.sbot.blobs.size) return cb(new TypeError('missing blobs.size method'))
412 this.sbot.blobs.size(id, function (err, size) {
413 if (err) return cb(err)
414 cb(null, size != null)
415 })
416}
417
418App.prototype.pushBlob = function (id, cb) {
419 console.error('pushing blob', id)
420 this.sbot.blobs.push(id, cb)
421}
422
423App.prototype.readBlob = function (link) {
424 link = u.toLink(link)
425 return this.sbot.blobs.get({
426 hash: link.link,
427 size: link.size,
428 })
429}
430
431App.prototype.readBlobSlice = function (link, opts) {
432 if (this.sbot.blobs.getSlice) return this.sbot.blobs.getSlice({
433 hash: link.link,
434 size: link.size,
435 start: opts.start,
436 end: opts.end,
437 })
438 return pull(
439 this.readBlob(link),
440 u.pullSlice(opts.start, opts.end)
441 )
442}
443
444App.prototype.ensureHasBlobs = function (links, cb) {
445 var self = this
446 var done = multicb({pluck: 1})
447 links.filter(Boolean).forEach(function (link) {
448 var cb = done()
449 self.sbot.blobs.size(link.link, function (err, size) {
450 if (err) cb(err)
451 else if (size == null) cb(null, link)
452 else cb()
453 })
454 })
455 done(function (err, missingLinks) {
456 if (err) console.trace(err)
457 missingLinks = missingLinks.filter(Boolean)
458 if (missingLinks.length == 0) return cb()
459 return cb({name: 'BlobNotFoundError', links: missingLinks})
460 })
461}
462
463App.prototype.getReverseNameSync = function (name) {
464 var id = this.reverseNameCache.get(name)
465 return id
466}
467
468App.prototype.getReverseEmojiNameSync = function (name) {
469 return this.reverseEmojiNameCache.get(name)
470}
471
472App.prototype.getNameSync = function (name) {
473 var about = this.aboutCache.get(name)
474 return about && about.name
475}
476
477function sbotGet(sbot, id, cb) {
478 // ssb-ooo@1.0.1 (a50da3928500f3ac0fbead0a1b335a3dd5bbc096): raw=true
479 // ssb-ooo@1.1.0 (f7302d12e56d566b84205bbc0c8b882ae6fd9b12): ooo=false
480 if (sbot.ooo) {
481 sbot.get({id: id, raw: true, ooo: false, private: true}, cb)
482 } else {
483 if (!sbot.private) {
484 // if no sbot.private, assume we have newer sbot that supports private:true
485 return sbot.get({id: id, private: true}, cb)
486 }
487 sbot.get(id, cb)
488 }
489}
490
491function getMsgWithValue(sbot, id, cb) {
492 var self = this
493 if (!id) return cb()
494 var parts = id.split('?unbox=')
495 id = parts[0]
496 var unbox = parts[1] && parts[1].replace(/ /g, '+')
497 try {
498 sbotGet(sbot, id, function (err, value) {
499 if (err) return cb(err)
500 var msg = {key: id, value: value}
501 if (unbox && value && typeof value.content === 'string')
502 return self.app.unboxMsgWithKey(msg, unbox, cb)
503 cb(null, msg)
504 })
505 } catch(e) {
506 return cb(e)
507 }
508}
509
510App.prototype._getAbout = function (id, cb) {
511 var self = this
512 if (!u.isRef(id)) return cb(null, {})
513 self.about.get(id, function (err, about) {
514 if (err) return cb(err)
515 var sigil = id[0] || '@'
516 if (about.name && about.name[0] !== sigil) {
517 about.name = sigil + about.name
518 }
519 self.reverseNameCache.set(about.name, id)
520 cb(null, about)
521 })
522}
523
524App.prototype.pullGetMsg = function (id) {
525 return pull.asyncMap(this.getMsg)(pull.once(id))
526}
527
528App.prototype.createLogStream = function (opts) {
529 opts = opts || {}
530 return opts.sortByTimestamp
531 ? this.createFeedStream(opts)
532 : this.sbot.createLogStream(opts)
533}
534
535App.prototype.createFeedStream = function (opts) {
536 // work around opts.gt being treated as opts.gte sometimes
537 return pull(
538 this.sbot.createFeedStream(opts),
539 pull.filter(function (msg) {
540 var ts = msg && msg.value && msg.value.timestamp
541 return typeof ts === 'number' && ts !== opts.gt && ts !== opts.lt
542 })
543 )
544}
545
546var stateVals = {
547 connected: 3,
548 connecting: 2,
549 disconnecting: 1,
550}
551
552function comparePeers(a, b) {
553 var aState = stateVals[a.state] || 0
554 var bState = stateVals[b.state] || 0
555 return (bState - aState)
556 || (b.stateChange|0 - a.stateChange|0)
557}
558
559App.prototype.streamPeers = function (opts) {
560 var gossip = this.sbot.gossip
561 return u.readNext(function (cb) {
562 gossip.peers(function (err, peers) {
563 if (err) return cb(err)
564 if (opts) peers = peers.filter(function (peer) {
565 for (var k in opts) if (opts[k] !== peer[k]) return false
566 return true
567 })
568 peers.sort(comparePeers)
569 cb(null, pull.values(peers))
570 })
571 })
572}
573
574App.prototype.getContact = function (source, dest, cb) {
575 var self = this
576 pull(
577 self.sbot.links({source: source, dest: dest, rel: 'contact', reverse: true,
578 values: true, meta: false, keys: false}),
579 pull.filter(function (value) {
580 var c = value && !value.private && value.content
581 return c && c.type === 'contact'
582 }),
583 pull.take(1),
584 pull.reduce(function (acc, value) {
585 // trinary logic from ssb-friends
586 return value.content.following ? true
587 : value.content.flagged || value.content.blocking ? false
588 : null
589 }, null, cb)
590 )
591}
592
593App.prototype.isMuted = function (id, cb) {
594 var self = this
595 pull(
596 self.sbot.links({source: self.sbot.id, dest: id, rel: 'contact', reverse: true,
597 values: true, meta: false}), // meta:false to emulate private:true
598 pull.filter(function (msg) {
599 return msg && msg.value && typeof msg.value.content === 'string'
600 }),
601 this.unboxMessages(),
602 pull.filter(function (msg) {
603 var c = msg && msg.value && msg && msg.value.content
604 return c && c.type === 'contact'
605 }),
606 pull.take(1),
607 pull.reduce(function (acc, msg) {
608 var c = msg && msg.value && msg.value.content
609 return c.following ? false : c.flagged || c.blocking ? true : null
610 }, null, cb)
611 )
612}
613
614App.prototype.unboxMessages = function () {
615 return paramap(this.unboxMsg, 16)
616}
617
618App.prototype.streamChannels = function (opts) {
619 return pull(
620 this.sbotMessagesByType({type: 'channel', reverse: true}),
621 this.unboxMessages(),
622 pull.filter(function (msg) {
623 return msg.value.content.subscribed
624 }),
625 pull.map(function (msg) {
626 return msg.value.content.channel
627 }),
628 pull.unique()
629 )
630}
631
632App.prototype.streamMyChannels = function (id, opts) {
633 // use ssb-query plugin if it is available, since it has an index for
634 // author + type
635 if (this.sbot.query) return pull(
636 this.sbot.query.read({
637 reverse: true,
638 query: [
639 {$filter: {
640 value: {
641 author: id,
642 content: {type: 'channel'}
643 }
644 }},
645 {$map: ['value', 'content']}
646 ]
647 }),
648 pull.unique('channel'),
649 pull.filter('subscribed'),
650 pull.map('channel')
651 )
652
653 return pull(
654 this.sbotCreateUserStream({id: id, reverse: true}),
655 this.unboxMessages(),
656 pull.map(function (msg) {
657 return msg.value.content
658 }),
659 pull.filter(function (c) {
660 return c.type === 'channel'
661 }),
662 pull.unique('channel'),
663 pull.filter('subscribed'),
664 pull.map('channel')
665 )
666}
667
668App.prototype.streamTags = function () {
669 return pull(
670 this.sbotMessagesByType({type: 'tag', reverse: true}),
671 this.unboxMessages(),
672 pull.filter(function (msg) {
673 return !msg.value.content.message
674 })
675 )
676}
677
678function compareVoted(a, b) {
679 return b.value - a.value
680}
681
682App.prototype.getVoted = function (_opts, cb) {
683 if (isNaN(_opts.limit)) return pull.error(new Error('missing limit'))
684 var self = this
685 var opts = {
686 type: 'vote',
687 limit: _opts.limit * 100,
688 reverse: !!_opts.reverse,
689 gt: _opts.gt || undefined,
690 lt: _opts.lt || undefined,
691 }
692
693 var votedObj = {}
694 var votedArray = []
695 var numItems = 0
696 var firstTimestamp, lastTimestamp
697 pull(
698 self.sbotMessagesByType(opts),
699 self.unboxMessages(),
700 pull.take(function () {
701 return numItems < _opts.limit
702 }),
703 pull.drain(function (msg) {
704 if (!firstTimestamp) firstTimestamp = msg.timestamp
705 lastTimestamp = msg.timestamp
706 var vote = msg.value.content.vote
707 if (!vote) return
708 var target = u.linkDest(vote)
709 var votes = votedObj[target]
710 if (!votes) {
711 numItems++
712 votes = {id: target, value: 0, feedsObj: {}, feeds: []}
713 votedObj[target] = votes
714 votedArray.push(votes)
715 }
716 if (msg.value.author in votes.feedsObj) {
717 if (!opts.reverse) return // leave latest vote value as-is
718 // remove old vote value
719 votes.value -= votes.feedsObj[msg.value.author]
720 } else {
721 votes.feeds.push(msg.value.author)
722 }
723 var value = vote.value > 0 ? 1 : vote.value < 0 ? -1 : 0
724 votes.feedsObj[msg.value.author] = value
725 votes.value += value
726 }, function (err) {
727 if (err && err !== true) return cb(err)
728 var items = votedArray
729 if (opts.reverse) items.reverse()
730 items.sort(compareVoted)
731 cb(null, {items: items,
732 firstTimestamp: firstTimestamp,
733 lastTimestamp: lastTimestamp})
734 })
735 )
736}
737
738App.prototype.createAboutStreams = function (id) {
739 return this.about.createAboutStreams(id)
740}
741
742App.prototype.streamEmojis = function () {
743 return pull(
744 cat([
745 this.sbot.links({
746 rel: 'mentions',
747 source: this.sbot.id,
748 dest: '&',
749 values: true,
750 meta: false // emulate private:true
751 }),
752 this.sbot.links({rel: 'mentions', dest: '&', values: true, meta: false})
753 ]),
754 this.unboxMessages(),
755 pull.map(function (msg) { return msg.value.content.mentions }),
756 pull.flatten(),
757 pull.filter('emoji'),
758 pull.unique('link')
759 )
760}
761
762App.prototype.filter = function (plugin, opts, filter) {
763 // work around flumeview-query not picking the best index.
764 // %b+QdyLFQ21UGYwvV3AiD8FEr7mKlB8w9xx3h8WzSUb0=.sha256
765 var limit = Number(opts.limit)
766 var index
767 if (plugin === this.sbot.backlinks) {
768 var c = filter && filter.value && filter.value.content
769 var filteringByType = c && c.type
770 if (opts.sortByTimestamp) index = 'DTA'
771 else if (filteringByType) index = 'DTS'
772 }
773 var filterOpts = {
774 $gt: opts.gt,
775 $lt: opts.lt,
776 }
777 return plugin.read({
778 index: index,
779 reverse: opts.reverse,
780 limit: limit || undefined,
781 query: [{$filter: u.mergeOpts(filter, opts.sortByTimestamp ? {
782 value: {
783 timestamp: filterOpts
784 }
785 } : {
786 timestamp: filterOpts
787 })}]
788 })
789}
790
791App.prototype.filterMessages = function (opts) {
792 var self = this
793 var limit = Number(opts.limit)
794 return pull(
795 paramap(function (msg, cb) {
796 self.filterMsg(msg, opts, function (err, show) {
797 if (err) return cb(err)
798 cb(null, show ? msg : null)
799 })
800 }, 4),
801 pull.filter(Boolean),
802 limit && pull.take(limit)
803 )
804}
805
806App.prototype.streamChannel = function (opts) {
807 // prefer ssb-backlinks to ssb-query because it also handles hashtag mentions
808 if (this.sbot.backlinks) return this.filter(this.sbot.backlinks, opts, {
809 dest: '#' + opts.channel,
810 })
811
812 if (this.sbot.query) return this.filter(this.sbot.query, opts, {
813 value: {content: {channel: opts.channel}},
814 })
815
816 return pull.error(new Error(
817 'Viewing channels/tags requires the ssb-backlinks or ssb-query plugin'))
818}
819
820App.prototype.streamMentions = function (opts) {
821 if (!this.sbot.backlinks) return pull.error(new Error(
822 'Viewing mentions requires the ssb-backlinks plugin'))
823
824 if (this.sbot.backlinks) return this.filter(this.sbot.backlinks, opts, {
825 dest: this.sbot.id,
826 })
827}
828
829App.prototype.streamPrivate = function (opts) {
830 if (this.sbot.private && this.sbot.private.read)
831 return this.filter(this.sbot.private, opts, {})
832
833 return pull(
834 this.createLogStream(u.mergeOpts(opts, {private: true})),
835 pull.filter(u.isMsgEncrypted),
836 this.unboxMessages(),
837 pull.filter(u.isMsgReadable)
838 )
839}
840
841App.prototype.blobMentions = function (opts) {
842 if (!this.sbot.links2) return pull.error(new Error(
843 'missing ssb-links plugin'))
844 var filter = {rel: ['mentions', opts.name]}
845 if (opts.author) filter.source = opts.author
846 return this.sbot.links2.read({
847 query: [
848 {$filter: filter},
849 {$filter: {dest: {$prefix: '&'}}},
850 {$map: {
851 name: ['rel', 1],
852 size: ['rel', 2],
853 link: 'dest',
854 author: 'source',
855 time: 'ts'
856 }}
857 ]
858 })
859}
860
861App.prototype.monitorBlobWants = function () {
862 var self = this
863 self.blobWants = {}
864 pull(
865 this.sbot.blobs.createWants(),
866 pull.drain(function (wants) {
867 for (var id in wants) {
868 if (wants[id] < 0) self.blobWants[id] = true
869 else delete self.blobWants[id]
870 self.blobSizeCache.remove(id)
871 }
872 }, function (err) {
873 if (err) console.trace(err)
874 })
875 )
876}
877
878App.prototype.getBlobState = function (id, cb) {
879 var self = this
880 if (self.blobWants[id]) return cb(null, 'wanted')
881 self.getBlobSize(id, function (err, size) {
882 if (err) return cb(err)
883 cb(null, size != null)
884 })
885}
886
887App.prototype.getNpmReadme = function (tarballId, cb) {
888 var self = this
889 // TODO: make this portable, and handle plaintext readmes
890 var tar = proc.spawn('tar', ['--ignore-case', '-Oxz',
891 'package/README.md', 'package/readme.markdown', 'package/readme.mkd'])
892 var done = multicb({pluck: 1, spread: true})
893 pull(
894 self.sbot.blobs.get(tarballId),
895 toPull.sink(tar.stdin, done())
896 )
897 pull(
898 toPull.source(tar.stdout),
899 pull.collect(done())
900 )
901 done(function (err, _, bufs) {
902 if (err) return cb(err)
903 var text = Buffer.concat(bufs).toString('utf8')
904 cb(null, text, true)
905 })
906}
907
908App.prototype.filterMsg = function (msg, opts, cb) {
909 var self = this
910 var myId = self.sbot.id
911 var author = msg.value && msg.value.author
912 var filter = opts.filter || self.msgFilter
913 if (filter === 'all') return cb(null, true)
914 var show = (filter !== 'invert')
915 var isPrivate = msg.value && typeof msg.value.content === 'string'
916 if (isPrivate && !self.showPrivates) return cb(null, !show)
917 if (author === myId
918 || author === opts.feed
919 || msg.key === opts.msgId) return cb(null, show)
920 self.follows.getFollows(myId, function (err, follows) {
921 if (err) return cb(err)
922 if (follows[author]) return cb(null, show)
923 self.getVotes(msg.key, function (err, votes) {
924 if (err) return cb(err)
925 for (var author in votes) {
926 if (follows[author] && votes[author] > 0) {
927 return cb(null, show)
928 }
929 }
930 return cb(null, !show)
931 })
932 })
933}
934
935App.prototype.isFollowing = function (src, dest, cb) {
936 var self = this
937 self.follows.getFollows(src, function (err, follows) {
938 if (err) return cb(err)
939 return cb(null, follows[dest])
940 })
941}
942
943App.prototype.getVotesStream = function (id) {
944 var links2 = this.sbot.links2
945 if (links2 && links2.read) return links2.read({
946 query: [
947 {$filter: {
948 dest: id,
949 rel: [{$prefix: 'vote'}]
950 }},
951 {$map: {
952 value: ['rel', 1],
953 author: 'source'
954 }}
955 ]
956 })
957
958 var backlinks = this.sbot.backlinks
959 if (backlinks && backlinks.read) return backlinks.read({
960 query: [
961 {$filter: {
962 dest: id,
963 value: {
964 content: {
965 type: 'vote',
966 vote: {
967 link: id
968 }
969 }
970 }
971 }},
972 {$map: {
973 author: ['value', 'author'],
974 value: ['value', 'content', 'vote', 'value']
975 }}
976 ]
977 })
978
979 return pull(
980 this.sbot.links({
981 dest: id,
982 rel: 'vote',
983 keys: false,
984 meta: false,
985 values: true
986 }),
987 pull.map(function (value) {
988 var vote = value && value.content && value.content.vote
989 return {
990 author: value && value.author,
991 vote: vote && vote.value
992 }
993 })
994 )
995}
996
997App.prototype._getVotes = function (id, cb) {
998 var votes = {}
999 pull(
1000 this.getVotesStream(),
1001 pull.drain(function (vote) {
1002 votes[vote.author] = vote.value
1003 }, function (err) {
1004 cb(err, votes)
1005 })
1006 )
1007}
1008
1009App.prototype.getAddresses = function (id) {
1010 if (!this.sbot.backlinks) {
1011 if (!this.warned1) {
1012 this.warned1 = true
1013 console.trace('Getting peer addresses requires the ssb-backlinks plugin')
1014 }
1015 return pull.empty()
1016 }
1017
1018 var pubMsgAddresses = pull(
1019 this.sbot.backlinks.read({
1020 reverse: true,
1021 query: [
1022 {$filter: {
1023 dest: id,
1024 value: {
1025 content: {
1026 type: 'pub',
1027 address: {
1028 key: id,
1029 host: {$truthy: true},
1030 port: {$truthy: true},
1031 }
1032 }
1033 }
1034 }},
1035 {$map: ['value', 'content', 'address']}
1036 ]
1037 }),
1038 pull.map(function (addr) {
1039 return addr.host + ':' + addr.port
1040 })
1041 )
1042
1043 var newerAddresses = pull(
1044 cat([
1045 this.sbot.query.read({
1046 reverse: true,
1047 query: [
1048 {$filter: {
1049 value: {
1050 author: id,
1051 content: {
1052 type: 'address',
1053 address: {$truthy: true}
1054 }
1055 }
1056 }},
1057 {$map: ['value', 'content', 'address']}
1058 ]
1059 }),
1060 this.sbot.query.read({
1061 reverse: true,
1062 query: [
1063 {$filter: {
1064 value: {
1065 author: id,
1066 content: {
1067 type: 'pub-owner-confirm',
1068 address: {$truthy: true}
1069 }
1070 }
1071 }},
1072 {$map: ['value', 'content', 'address']}
1073 ]
1074 })
1075 ]),
1076 pull.map(u.extractHostPort.bind(this, id))
1077 )
1078
1079 return pull(
1080 cat([newerAddresses, pubMsgAddresses]),
1081 pull.unique()
1082 )
1083}
1084
1085App.prototype.isPub = function (id, cb) {
1086 if (!this.sbot.backlinks) {
1087 return pull(
1088 this.sbot.links({
1089 dest: id,
1090 rel: 'pub'
1091 }),
1092 pull.take(1),
1093 pull.collect(function (err, links) {
1094 if (err) return cb(err)
1095 cb(null, links.length == 1)
1096 })
1097 )
1098 }
1099 return pull(
1100 this.sbot.backlinks.read({
1101 limit: 1,
1102 query: [
1103 {$filter: {
1104 dest: id,
1105 value: {
1106 content: {
1107 type: 'pub',
1108 address: {
1109 key: id,
1110 host: {$truthy: true},
1111 port: {$truthy: true},
1112 }
1113 }
1114 }
1115 }}
1116 ]
1117 }),
1118 pull.collect(function (err, msgs) {
1119 if (err) return cb(err)
1120 cb(null, msgs.length == 1)
1121 })
1122 )
1123}
1124
1125App.prototype.getIdeaTitle = function (id, cb) {
1126 if (!this.sbot.backlinks) return cb(null, String(id).substr(0, 8) + '…')
1127 pull(
1128 this.sbot.backlinks.read({
1129 reverse: true,
1130 query: [
1131 {$filter: {
1132 dest: id,
1133 value: {
1134 content: {
1135 type: 'talenet-idea-update',
1136 ideaKey: id,
1137 title: {$truthy: true}
1138 }
1139 }
1140 }},
1141 {$map: ['value', 'content', 'title']}
1142 ]
1143 }),
1144 pull.take(1),
1145 pull.collect(function (err, titles) {
1146 if (err) return cb(err)
1147 var title = titles && titles[0]
1148 || (String(id).substr(0, 8) + '…')
1149 cb(null, title)
1150 })
1151 )
1152}
1153
1154function traverse(obj, emit) {
1155 emit(obj)
1156 if (obj !== null && typeof obj === 'object') {
1157 for (var k in obj) {
1158 traverse(obj[k], emit)
1159 }
1160 }
1161}
1162
1163App.prototype.expandOoo = function (opts, cb) {
1164 var self = this
1165 var dest = opts.dest
1166 var msgs = opts.msgs
1167 if (!Array.isArray(msgs)) return cb(new TypeError('msgs should be array'))
1168
1169 // algorithm:
1170 // traverse all links in the initial message set.
1171 // find linked-to messages not in the set.
1172 // fetch those messages.
1173 // if one links to the dest, add it to the set
1174 // and look for more missing links to fetch.
1175 // done when no more links to fetch
1176
1177 var msgsO = {}
1178 var getting = {}
1179 var waiting = 0
1180
1181 function checkDone() {
1182 if (waiting) return
1183 var msgs = Object.keys(msgsO).map(function (key) {
1184 return msgsO[key]
1185 })
1186 cb(null, msgs)
1187 }
1188
1189 function getMsg(id) {
1190 if (msgsO[id] || getting[id]) return
1191 getting[id] = true
1192 waiting++
1193 self.getMsgDecryptedOoo(id, function (err, msg) {
1194 waiting--
1195 if (err) console.trace(err)
1196 else gotMsg(msg)
1197 checkDone()
1198 })
1199 }
1200
1201 var links = {}
1202 function addLink(id) {
1203 if (typeof id === 'string' && id[0] === '%' && u.isRef(id)) {
1204 links[id] = true
1205 }
1206 }
1207
1208 msgs.forEach(function (msg) {
1209 if (msgs[msg.key]) return
1210 if (msg.value.content === false) return // missing root
1211 msgsO[msg.key] = msg
1212 traverse(msg, addLink)
1213 })
1214 waiting++
1215 for (var id in links) {
1216 getMsg(id)
1217 }
1218 waiting--
1219 checkDone()
1220
1221 function gotMsg(msg) {
1222 if (msgsO[msg.key]) return
1223 var links = []
1224 var linkedToDest = msg.key === dest
1225 traverse(msg, function (id) {
1226 if (id === dest) linkedToDest = true
1227 links.push(id)
1228 })
1229 if (linkedToDest) {
1230 msgsO[msg.key] = msg
1231 links.forEach(addLink)
1232 }
1233 }
1234}
1235
1236App.prototype.getLineComments = function (opts, cb) {
1237 // get line comments for a git-update message and git object id.
1238 // line comments include message id, commit id and path
1239 // but we have message id and git object hash.
1240 // look up the git object hash for each line-comment
1241 // to verify that it is for the git object file we want
1242 var updateId = opts.obj.msg.key
1243 var objId = opts.hash
1244 var self = this
1245 var lineComments = {}
1246 pull(
1247 self.sbot.backlinks ? self.sbot.backlinks.read({
1248 query: [
1249 {$filter: {
1250 dest: updateId,
1251 value: {
1252 content: {
1253 type: 'line-comment',
1254 updateId: updateId,
1255 }
1256 }
1257 }}
1258 ]
1259 }) : pull(
1260 self.sbot.links({
1261 dest: updateId,
1262 rel: 'updateId',
1263 values: true,
1264 meta: false,
1265 }),
1266 pull.filter(function (msg) {
1267 var c = msg && msg.value && msg.value.content
1268 return c && c.type === 'line-comment'
1269 && c.updateId === updateId
1270 })
1271 ),
1272 paramap(function (msg, cb) {
1273 var c = msg.value.content
1274 self.git.getObjectAtPath({
1275 msg: updateId,
1276 obj: c.commitId,
1277 path: c.filePath,
1278 }, function (err, info) {
1279 if (err) return cb(err)
1280 cb(null, {
1281 obj: info.obj,
1282 hash: info.hash,
1283 msg: msg,
1284 })
1285 })
1286 }, 4),
1287 pull.filter(function (info) {
1288 return info.hash === objId
1289 }),
1290 pull.drain(function (info) {
1291 lineComments[info.msg.value.content.line] = info
1292 }, function (err) {
1293 cb(err, lineComments)
1294 })
1295 )
1296}
1297
1298App.prototype.sbotLinks = function (opts) {
1299 if (!this.sbot.links) return pull.error(new Error('missing sbot.links'))
1300 return this.sbot.links(opts)
1301}
1302
1303App.prototype.sbotCreateUserStream = function (opts) {
1304 if (!this.sbot.createUserStream) return pull.error(new Error('missing sbot.createUserStream'))
1305 return this.sbot.createUserStream(opts)
1306}
1307
1308App.prototype.sbotMessagesByType = function (opts) {
1309 if (!this.sbot.messagesByType) return pull.error(new Error('missing sbot.messagesByType'))
1310 return this.sbot.messagesByType(opts)
1311}
1312
1313App.prototype.getThread = function (msg) {
1314 return cat([
1315 pull.once(msg),
1316 this.sbot.backlinks ? this.sbot.backlinks.read({
1317 query: [
1318 {$filter: {dest: msg.key}}
1319 ]
1320 }) : this.sbotLinks({
1321 dest: msg.key,
1322 meta: false,
1323 values: true
1324 })
1325 ])
1326}
1327
1328App.prototype.getLinks = function (id) {
1329 return this.sbot.backlinks ? this.sbot.backlinks.read({
1330 query: [
1331 {$filter: {dest: id}}
1332 ]
1333 }) : this.sbotLinks({
1334 dest: id,
1335 meta: false,
1336 values: true
1337 })
1338}
1339
1340App.prototype.getLinks2 = function (id, relOrType) {
1341 return this.sbot.backlinks ? this.sbot.backlinks.read({
1342 query: [
1343 {$filter: {
1344 dest: id,
1345 value: {
1346 content: {
1347 type: relOrType
1348 }
1349 }
1350 }}
1351 ]
1352 }) : this.sbotLinks({
1353 dest: id,
1354 meta: false,
1355 values: true,
1356 rel: relOrType
1357 })
1358}
1359
1360App.prototype.getShard = function (id, cb) {
1361 var self = this
1362 this.getMsgDecrypted(id, function (err, msg) {
1363 if (err) return cb(new Error('Unable to get shard message: ' + err.stack))
1364 var c = msg.value.content || {}
1365 if (!c.shard) return cb(new Error('Message missing shard: ' + id))
1366 self.unboxContent(c.shard, function (err, shard) {
1367 if (err) return cb(new Error('Unable to decrypt shard: ' + err.stack))
1368 cb(null, shard)
1369 })
1370 })
1371}
1372
1373App.prototype.sbotStatus = function (cb) {
1374 /* sbot.status is a "sync" method. if we are a plugin, it is sync. if we are
1375 * calling over muxrpc, it is async. */
1376 var status
1377 try {
1378 status = this.sbot.status(cb)
1379 } catch(err) {
1380 return cb(err)
1381 }
1382 if (typeof status === 'object' && status !== null) return cb(null, status)
1383}
1384
1385function writeAll(fd, buf, cb) {
1386 var offset = 0
1387 var remaining = buf.length
1388 fs.write(fd, buf, function onWrite(err, bytesWritten) {
1389 if (err) return cb(err)
1390 offset += bytesWritten
1391 remaining -= bytesWritten
1392 if (remaining > 0) fs.write(fd, buf, offset, remaining, null, onWrite)
1393 else cb()
1394 })
1395}
1396
1397App.prototype.verifyGitObjectSignature = function (obj, cb) {
1398 var self = this
1399 var tmpPath = path.join(os.tmpdir(), '.git_vtag_tmp' + Math.random().toString('36'))
1400 // use a temp file to work around https://github.com/nodejs/node/issues/13542
1401 function closeEnd(err) {
1402 fs.close(fd, function (err1) {
1403 fs.unlink(tmpPath, function (err2) {
1404 cb(err2 || err1 || err)
1405 })
1406 })
1407 }
1408 fs.open(tmpPath, 'w+', function (err, fd) {
1409 if (err) return cb(err)
1410 self.git.extractSignature(obj, function (err, parts) {
1411 if (err) return closeEnd(err)
1412 writeAll(fd, parts.signature, function (err) {
1413 if (err) return closeEnd(err)
1414 try { next(fd, parts) }
1415 catch(e) { closeEnd(e) }
1416 })
1417 })
1418 })
1419 function next(fd, parts) {
1420 var readSig = fs.createReadStream(null, {fd: fd, start: 0})
1421 var done = multicb({pluck: 1, spread: true})
1422 var gpg = proc.spawn('gpg', ['--status-fd=1', '--keyid-format=long',
1423 '--verify', '/dev/fd/3', '-'], {
1424 stdio: ['pipe', 'pipe', 'pipe', readSig]
1425 }).on('close', done().bind(null, null))
1426 .on('error', console.error.bind(console, 'gpg'))
1427 gpg.stdin.end(parts.payload)
1428 pull(toPull.source(gpg.stdout), u.pullConcat(done()))
1429 pull(toPull.source(gpg.stderr), u.pullConcat(done()))
1430 done(function (err, code, status, output) {
1431 if (err) return closeEnd(err)
1432 fs.unlink(tmpPath, function (err) {
1433 if (err) return cb(err)
1434 cb(null, {
1435 goodsig: status.includes('\n[GNUPG:] GOODSIG '),
1436 status: status.toString(),
1437 output: output.toString()
1438 })
1439 })
1440 })
1441 }
1442}
1443
1444App.prototype.getScript = function (filepath, cb) {
1445 var filename = path.join(this.scriptDir, filepath)
1446 var self = this
1447 fs.stat(filename, function (err, stat) {
1448 if (err) return cb(err)
1449 var resolved
1450 try { resolved = require.resolve(filename) }
1451 catch(e) { return cb(e) }
1452 var prevMtime = self.mtimes[resolved]
1453 var mtime = stat.mtime.getTime()
1454 if (mtime !== prevMtime) {
1455 delete require.cache[resolved]
1456 self.mtimes[filename] = mtime
1457 }
1458 var module
1459 try { module = require(resolved) }
1460 catch(e) { return cb(e) }
1461 cb(null, module)
1462 })
1463}
1464
1465function writeNewFile(dir, data, tries, cb) {
1466 var id = Base64URL.encode(crypto.randomBytes(8))
1467 fs.writeFile(path.join(dir, id), data, {flag: 'wx'}, function (err) {
1468 if (err && err.code === 'EEXIST' && tries > 0) return writeNewFile(dir, data, tries-1, cb)
1469 if (err) return cb(err)
1470 cb(null, id)
1471 })
1472}
1473
1474App.prototype.saveDraft = function (id, url, form, content, cb) {
1475 var self = this
1476 if (!self.madeDraftsDir) {
1477 mkdirp.sync(self.draftsDir)
1478 self.madeDraftsDir = true
1479 }
1480 if (/[\/:\\]/.test(id)) return cb(new Error('draft id cannot contain path seperators'))
1481 var draft = {
1482 url: url,
1483 form: form,
1484 content: content
1485 }
1486 var data = JSON.stringify(draft)
1487 if (id) fs.writeFile(path.join(self.draftsDir, id), data, cb)
1488 else writeNewFile(self.draftsDir, data, 32, cb)
1489}
1490
1491App.prototype.getDraft = function (id, cb) {
1492 var self = this
1493 fs.readFile(path.join(self.draftsDir, id), 'utf8', function (err, data) {
1494 if (err) return cb(err)
1495 var draft
1496 try { draft = JSON.parse(data) }
1497 catch(e) { return cb(e) }
1498 draft.id = id
1499 cb(null, draft)
1500 })
1501}
1502
1503App.prototype.discardDraft = function (id, cb) {
1504 fs.unlink(path.join(this.draftsDir, id), cb)
1505}
1506
1507function compareMtime(a, b) {
1508 return b.mtime.getTime() - a.mtime.getTime()
1509}
1510
1511function statAll(files, dir, cb) {
1512 pull(
1513 pull.values(files),
1514 paramap(function (file, cb) {
1515 fs.stat(path.join(dir, file), function (err, stats) {
1516 if (err) return cb(err)
1517 stats.name = file
1518 cb(null, stats)
1519 })
1520 }, 8),
1521 pull.collect(cb)
1522 )
1523}
1524
1525App.prototype.listDrafts = function () {
1526 var self = this
1527 return u.readNext(function (cb) {
1528 fs.readdir(self.draftsDir, function (err, files) {
1529 if (err && err.code === 'ENOENT') return cb(null, pull.empty())
1530 if (err) return cb(err)
1531 statAll(files, self.draftsDir, function (err, stats) {
1532 if (err) return cb(err)
1533 stats.sort(compareMtime)
1534 cb(null, pull(
1535 pull.values(stats),
1536 paramap(function (stat, cb) {
1537 self.getDraft(stat.name, cb)
1538 }, 4)
1539 ))
1540 })
1541 })
1542 })
1543}
1544
1545App.prototype.removeDefaultPort = function (addr) {
1546 return addr.replace(this.portRegexp, '')
1547}
1548

Built with git-ssb-web