nmemmertandClaude Sonnet 5.5
bfd37967c3
build-container / build (push) Successful in 7m31s
- read every JSON value in a frame (lines, arrays), binary frames too - a person seen by number and by private id is one conversation (merged) - delivery/read receipts match on message time, not on who sent them - reconnect every 1-5 s; the chat list says when the link was down - /api/signal/debug: kinds of messages seen lately (no text) - edit a contact (kept in the app and sent to Signal), clear messages, remove a chat; right-click menu in the list; name for a new number - tests: 54 checks Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
365 lines
26 KiB
JavaScript
365 lines
26 KiB
JavaScript
// Signal messages inside the hub, through signal-cli-rest-api (an unofficial but widely used bridge that links to your Signal account as
|
|
// one more linked device, like Signal Desktop). The hub keeps the conversations it receives in /data/signal so they survive restarts.
|
|
// Everything here is behind the hub's passkey sign-in and the "Signal" tab permission.
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const crypto = require('crypto');
|
|
const { Readable } = require('stream');
|
|
|
|
const MAX_PER_CONV = 1500;
|
|
const trace = []; // what has been seen lately (kinds of messages and connection changes, never the text), for working out why a message did not show
|
|
const note = (kind, extra) => { trace.push({ at: new Date().toISOString(), kind, ...extra }); if (trace.length > 300) trace.shift(); };
|
|
const ids = () => (state.db.ids = state.db.ids || {}); // a contact can show up by phone number or only by Signal's private id (uuid); this remembers which is whose
|
|
const state = { api: '', dir: '', account: '', db: { account: '', convs: {}, msgs: {} }, ws: null, wsUp: false, backoff: 1000, clients: new Set(), saveT: null,
|
|
contacts: { at: 0, map: new Map() }, groups: { at: 0, list: [] }, started: false };
|
|
|
|
const file = () => path.join(state.dir, 'store.json');
|
|
function load() { try { state.db = { account: '', convs: {}, msgs: {}, ...JSON.parse(fs.readFileSync(file(), 'utf8')) }; } catch { /* first run */ } }
|
|
function flushNow() {
|
|
if (!state.saveT) return;
|
|
clearTimeout(state.saveT); state.saveT = null;
|
|
try { const f = file(), tmp = f + '.tmp'; fs.writeFileSync(tmp, JSON.stringify(state.db), { mode: 0o600 }); fs.renameSync(tmp, f); } catch (e) { console.error('[signal] could not save:', e.message); }
|
|
}
|
|
function saveSoon() {
|
|
if (state.saveT) return;
|
|
state.saveT = setTimeout(() => {
|
|
state.saveT = null;
|
|
try { const f = file(), tmp = f + '.tmp'; fs.writeFileSync(tmp, JSON.stringify(state.db), { mode: 0o600 }); fs.renameSync(tmp, f); } catch (e) { console.error('[signal] could not save:', e.message); }
|
|
}, 400);
|
|
state.saveT.unref && state.saveT.unref();
|
|
}
|
|
|
|
// ---- talking to signal-cli-rest-api
|
|
async function api(method, p, body, timeout = 30000) {
|
|
const r = await fetch(state.api + p, { method, signal: AbortSignal.timeout(timeout), headers: body ? { 'content-type': 'application/json' } : undefined, body: body ? JSON.stringify(body) : undefined });
|
|
return r;
|
|
}
|
|
async function apiJson(method, p, body) {
|
|
const r = await api(method, p, body); const t = await r.text(); let j = null; try { j = JSON.parse(t); } catch { /* not json */ }
|
|
if (!r.ok) throw Object.assign(new Error((j && j.error) || ('Signal service answered ' + r.status)), { status: r.status });
|
|
return j;
|
|
}
|
|
|
|
// ---- who is who
|
|
async function loadContacts(force) {
|
|
if (!state.account) return;
|
|
if (!force && Date.now() - state.contacts.at < 10 * 60e3) return;
|
|
state.contacts.at = Date.now();
|
|
try {
|
|
const list = await apiJson('GET', '/v1/contacts/' + encodeURIComponent(state.account));
|
|
const m = new Map();
|
|
for (const c of list || []) { const n = c.name || c.nickname && c.nickname.name || [c.given_name, c.family_name].filter(Boolean).join(' ') || c.profile_name || (c.profile && c.profile.given_name) || ''; if (c.number) m.set(c.number, n); if (c.number && c.uuid && ids()[c.uuid] !== c.number) { ids()[c.uuid] = c.number; mergeConv(c.uuid, c.number); } }
|
|
state.contacts.map = m;
|
|
for (const c of Object.values(state.db.convs)) if (c.type === 'direct') { const n = displayName(c.id, c.name !== c.id ? c.name : ''); if (n && c.name !== n) c.name = n; }
|
|
saveSoon();
|
|
} catch (e) { state.contacts.at = Date.now() - 9 * 60e3; /* try again in a minute */ }
|
|
}
|
|
async function loadGroups(force) {
|
|
if (!state.account) return;
|
|
if (!force && Date.now() - state.groups.at < 5 * 60e3) return;
|
|
state.groups.at = Date.now();
|
|
try {
|
|
state.groups.list = (await apiJson('GET', '/v1/groups/' + encodeURIComponent(state.account))) || [];
|
|
for (const g of state.groups.list) { const c = state.db.convs['g:' + g.internal_id]; if (c && g.name && c.name !== g.name) c.name = g.name; }
|
|
saveSoon();
|
|
} catch (e) { state.groups.at = Date.now() - 4 * 60e3; }
|
|
}
|
|
const groupApiId = internal => { const g = state.groups.list.find(x => x.internal_id === internal); return g ? g.id : 'group.' + Buffer.from(internal).toString('base64'); };
|
|
const nicks = () => (state.db.nick = state.db.nick || {}); // names you chose for contacts in this app
|
|
const displayName = (id, hint) => nicks()[id] || state.contacts.map.get(id) || hint || id;
|
|
|
|
function setNick(number, name) {
|
|
name = name.trim().slice(0, 80);
|
|
if (name) nicks()[number] = name; else delete nicks()[number];
|
|
const c = state.db.convs[number]; if (c) { c.name = displayName(number, ''); emit({ t: 'update', conv: number }); }
|
|
saveSoon(); return name;
|
|
}
|
|
function dropFiles(cid) { // pictures you sent that were kept here
|
|
for (const m of state.db.msgs[cid] || []) for (const a of m.att || []) if (a.local && /^local-[0-9a-f]+$/.test(a.id)) { try { fs.unlinkSync(path.join(state.dir, 'out', a.id)); } catch { /* already gone */ } }
|
|
}
|
|
|
|
// ---- keeping the conversations
|
|
function emit(ev) {
|
|
const s = 'data: ' + JSON.stringify({ ...ev, unread: totalUnread() }) + '\n\n';
|
|
for (const res of state.clients) { try { res.write(s); } catch { state.clients.delete(res); } }
|
|
}
|
|
const totalUnread = () => Object.values(state.db.convs).reduce((a, c) => a + (c.unread || 0), 0);
|
|
function conv(id, type, nameHint) {
|
|
let c = state.db.convs[id];
|
|
if (!c) {
|
|
c = state.db.convs[id] = { id, type, name: type === 'group' ? (nameHint || 'Group') : displayName(id, nameHint), ts: 0, preview: '', unread: 0 };
|
|
state.db.msgs[id] = state.db.msgs[id] || [];
|
|
if (type === 'direct') loadContacts(true); else loadGroups(true);
|
|
} else if (type === 'direct' && nameHint && (c.name === id || !c.name)) c.name = displayName(id, nameHint);
|
|
else if (type === 'group' && nameHint && c.name === 'Group') c.name = nameHint;
|
|
return c;
|
|
}
|
|
const findMsg = (cid, ts) => (state.db.msgs[cid] || []).find(m => m.ts === ts);
|
|
const attOf = a => ({ id: a.id, type: a.contentType, name: a.filename, size: a.size, w: a.width, h: a.height, voice: !!a.isVoiceNote });
|
|
const previewOf = m => m.deleted ? 'Message deleted' : m.text || (m.att && m.att[0] ? (/^image\//.test(m.att[0].type) ? 'Photo' : /^audio\//.test(m.att[0].type) ? 'Voice message' : m.att[0].name || 'Attachment') : '');
|
|
|
|
function addMessage(cid, c, m) {
|
|
const list = state.db.msgs[cid] = state.db.msgs[cid] || [];
|
|
if (list.some(x => x.id === m.id)) return false;
|
|
list.push(m); list.sort((a, b) => a.ts - b.ts);
|
|
if (list.length > MAX_PER_CONV) list.splice(0, list.length - MAX_PER_CONV);
|
|
if (m.ts >= c.ts) { c.ts = m.ts; c.preview = (m.out ? 'You: ' : '') + previewOf(m); }
|
|
if (!m.out) c.unread = (c.unread || 0) + 1;
|
|
saveSoon();
|
|
return true;
|
|
}
|
|
|
|
// One person, one conversation, whether Signal names them by number or only by private id.
|
|
function peer(number, uuid) {
|
|
const map = ids();
|
|
if (number && uuid && map[uuid] !== number) { map[uuid] = number; mergeConv(uuid, number); saveSoon(); }
|
|
return number || (uuid && map[uuid]) || uuid || '';
|
|
}
|
|
function mergeConv(from, to) {
|
|
const a = state.db.convs[from]; if (!a || from === to) return;
|
|
const b = state.db.convs[to] || (state.db.convs[to] = { id: to, type: 'direct', name: a.name, ts: 0, preview: '', unread: 0 });
|
|
const list = (state.db.msgs[to] = state.db.msgs[to] || []);
|
|
for (const m of state.db.msgs[from] || []) if (!list.some(x => x.id === m.id || (x.ts === m.ts && x.out === m.out))) list.push(m);
|
|
list.sort((x, y) => x.ts - y.ts); b.unread = (b.unread || 0) + (a.unread || 0);
|
|
const last = list[list.length - 1]; if (last) { b.ts = last.ts; b.preview = (last.out ? 'You: ' : '') + previewOf(last); }
|
|
if (b.name === to && a.name !== from) b.name = a.name;
|
|
delete state.db.convs[from]; delete state.db.msgs[from]; emit({ t: 'update', conv: to });
|
|
}
|
|
function ingestData(dm, from, fromName, ts, out, dest) {
|
|
const gid = dm.groupInfo && dm.groupInfo.groupId;
|
|
const cid = gid ? 'g:' + gid : (out ? dest : from);
|
|
if (!cid) return;
|
|
const c = conv(cid, gid ? 'group' : 'direct', gid ? dm.groupInfo.groupName : (out ? '' : fromName));
|
|
if (dm.reaction) {
|
|
const m = findMsg(cid, dm.reaction.targetSentTimestamp); if (!m) return;
|
|
m.react = m.react || {}; if (dm.reaction.isRemove) delete m.react[from]; else m.react[from] = dm.reaction.emoji;
|
|
saveSoon(); return emit({ t: 'update', conv: cid });
|
|
}
|
|
if (dm.remoteDelete) {
|
|
const m = findMsg(cid, dm.remoteDelete.timestamp); if (!m) return;
|
|
m.deleted = true; m.text = ''; m.att = []; saveSoon(); return emit({ t: 'update', conv: cid });
|
|
}
|
|
const text = dm.message || '', att = (dm.attachments || []).map(attOf);
|
|
if (!text && !att.length && !dm.sticker) return;
|
|
const m = { id: ts + ':' + from, ts, out: !!out, from, name: out ? '' : fromName || displayName(from, ''), text, att };
|
|
if (dm.sticker) m.text = m.text || '(sticker)';
|
|
if (dm.quote) m.quote = { author: dm.quote.authorNumber || dm.quote.author, text: dm.quote.text || '', ts: dm.quote.id };
|
|
if (addMessage(cid, c, m)) emit({ t: 'msg', conv: cid, out: !!out, name: c.name, preview: previewOf(m) });
|
|
}
|
|
|
|
function ingestEdit(ed, from, ts, out, dest) {
|
|
const dm = ed.dataMessage || {}, gid = dm.groupInfo && dm.groupInfo.groupId, cid = gid ? 'g:' + gid : (out ? dest : from);
|
|
const m = cid && findMsg(cid, ed.targetSentTimestamp); if (!m) return;
|
|
m.text = dm.message || m.text; m.edited = true;
|
|
const c = state.db.convs[cid]; if (c && m.ts >= c.ts) c.preview = (m.out ? 'You: ' : '') + previewOf(m);
|
|
saveSoon(); emit({ t: 'update', conv: cid });
|
|
}
|
|
|
|
function ingestReceipt(r, who) {
|
|
const status = r.isRead || r.isViewed ? 'read' : r.isDelivery ? 'delivered' : '';
|
|
if (!status) return;
|
|
let changed = null;
|
|
for (const [cid, list] of Object.entries(state.db.msgs)) {
|
|
for (const m of list) if (m.out && (r.timestamps || []).includes(m.ts) && (m.status !== 'read')) { m.status = status; changed = cid; }
|
|
}
|
|
if (changed) { saveSoon(); emit({ t: 'update', conv: changed }); }
|
|
}
|
|
|
|
function ingest(env) {
|
|
if (!env) return;
|
|
const ts = env.timestamp || Date.now(), who = peer(env.sourceNumber, env.sourceUuid || (/^[0-9a-f-]{36}$/i.test(env.source || '') ? env.source : '')) || env.source || '', name = env.sourceName || '';
|
|
if (env.dataMessage) ingestData(env.dataMessage, who, name, env.dataMessage.timestamp || ts, false);
|
|
else if (env.editMessage) ingestEdit(env.editMessage, who, ts, false);
|
|
else if (env.syncMessage && env.syncMessage.sentMessage) {
|
|
const sm = env.syncMessage.sentMessage;
|
|
if (sm.editMessage) ingestEdit(sm.editMessage, state.account, ts, true, peer(sm.destinationNumber, sm.destinationUuid) || sm.destination);
|
|
else ingestData(sm, state.account, '', sm.timestamp || ts, true, peer(sm.destinationNumber, sm.destinationUuid) || sm.destination);
|
|
} else if (env.receiptMessage) ingestReceipt(env.receiptMessage, who);
|
|
else if (env.typingMessage) emit({ t: 'typing', conv: env.typingMessage.groupId ? 'g:' + env.typingMessage.groupId : who, stop: env.typingMessage.action === 'STOPPED' });
|
|
}
|
|
|
|
// A frame normally holds one message, but messages that arrive close together could come glued together (one JSON per line, an array, or
|
|
// back to back), so read every JSON value in it instead of giving up when the whole thing is not one value.
|
|
function jsonValues(text) {
|
|
try { const v = JSON.parse(text); return Array.isArray(v) ? v : [v]; } catch { /* more than one value, or damaged */ }
|
|
const out = []; let depth = 0, start = -1, inStr = false, esc = false;
|
|
for (let i = 0; i < text.length; i++) {
|
|
const c = text[i];
|
|
if (inStr) { if (esc) esc = false; else if (c === '\\') esc = true; else if (c === '"') inStr = false; continue; }
|
|
if (c === '"') inStr = true;
|
|
else if (c === '{') { if (depth++ === 0) start = i; }
|
|
else if (c === '}' && depth > 0 && --depth === 0) { try { out.push(JSON.parse(text.slice(start, i + 1))); } catch { /* skip this one */ } }
|
|
}
|
|
return out;
|
|
}
|
|
function handleRaw(text) {
|
|
const values = jsonValues(text);
|
|
if (!values.length) { note('unreadable', { bytes: String(text).length }); return; }
|
|
if (values.length > 1) note('several-in-one-frame', { count: values.length });
|
|
for (const m of values) {
|
|
const env = m && (m.envelope || (m.params && m.params.envelope) || (m.result && m.result.envelope));
|
|
const kinds = env ? Object.keys(env).filter(k => /Message$/.test(k)) : ['no-envelope:' + Object.keys(m || {}).join(',')];
|
|
note('envelope', { kinds, from: env && (env.sourceNumber || env.source || '').slice(-4), group: !!(env && env.dataMessage && env.dataMessage.groupInfo), text: !!(env && ((env.dataMessage && env.dataMessage.message) || (env.syncMessage && env.syncMessage.sentMessage && env.syncMessage.sentMessage.message))), att: !!(env && env.dataMessage && (env.dataMessage.attachments || []).length) });
|
|
try { ingest(env); } catch (e) { note('error', { message: e.message }); console.error('[signal] could not read a message:', e.message); }
|
|
}
|
|
}
|
|
|
|
// ---- the link to signal-cli
|
|
// signal-cli hands a message only to whoever is listening at that moment, so the hub reconnects quickly and says so when it was away.
|
|
function connect() {
|
|
if (!state.account || state.ws || typeof WebSocket === 'undefined') return;
|
|
const url = state.api.replace(/^http/, 'ws') + '/v1/receive/' + encodeURIComponent(state.account);
|
|
let ws;
|
|
try { ws = new WebSocket(url); } catch (e) { return retrySoon(); }
|
|
state.ws = ws;
|
|
ws.onopen = () => {
|
|
state.wsUp = true; state.backoff = 1000; note('connected');
|
|
if (state.downSince) { const from = state.downSince; state.downSince = 0; if (Date.now() - from > 2500) state.gap = { from, to: Date.now() }; console.log(`[signal] connected again after ${Math.round((Date.now() - from) / 1000)} s`); } else console.log('[signal] connected');
|
|
emit({ t: 'status' });
|
|
};
|
|
const text = d => typeof d === 'string' ? handleRaw(d) : d && typeof d.text === 'function' ? d.text().then(handleRaw) : d instanceof ArrayBuffer ? handleRaw(Buffer.from(d).toString('utf8')) : handleRaw(String(d)); // (a binary frame is read as text too)
|
|
ws.onmessage = e => text(e.data);
|
|
const gone = ev => {
|
|
if (state.ws !== ws) return; state.ws = null; state.wsUp = false; if (!state.downSince) state.downSince = Date.now();
|
|
note('disconnected', { code: ev && ev.code, reason: ev && ev.reason }); console.log('[signal] connection lost' + (ev && ev.code ? ' (code ' + ev.code + ')' : '')); emit({ t: 'status' }); retrySoon();
|
|
};
|
|
ws.onclose = gone; ws.onerror = gone;
|
|
}
|
|
function retrySoon() { const t = setTimeout(connect, state.backoff); state.backoff = Math.min(state.backoff + 1000, 5000); t.unref && t.unref(); } // 1 s, 2 s ... never longer than 5 s
|
|
async function refreshAccount() {
|
|
try {
|
|
const list = await apiJson('GET', '/v1/accounts');
|
|
const want = process.env.SIGNAL_NUMBER || '';
|
|
const acct = (list || []).find(n => !want || n === want) || '';
|
|
if (acct !== state.account) {
|
|
state.account = acct; if (acct && state.db.account !== acct) { state.db = { account: acct, convs: {}, msgs: {} }; saveSoon(); } // a different number: start clean
|
|
if (!acct && state.ws) { try { state.ws.close(); } catch { /* already closed */ } }
|
|
emit({ t: 'status' });
|
|
}
|
|
if (state.account) { connect(); loadContacts(false); loadGroups(false); }
|
|
state.reachable = true;
|
|
} catch (e) { state.reachable = false; }
|
|
}
|
|
|
|
function init({ dataDir, apiUrl }) {
|
|
state.api = (apiUrl || '').replace(/\/$/, ''); state.dir = path.join(dataDir, 'signal');
|
|
if (!state.api || state.started) return;
|
|
state.started = true;
|
|
fs.mkdirSync(path.join(state.dir, 'out'), { recursive: true, mode: 0o700 });
|
|
load(); state.account = state.db.account || '';
|
|
for (const sig of ['SIGTERM', 'SIGINT']) process.once(sig, () => { flushNow(); process.exit(0); }); // do not lose the last moments of a chat when the container stops
|
|
refreshAccount();
|
|
const t = setInterval(refreshAccount, +process.env.SIGNAL_POLL_MS || 10000); t.unref && t.unref();
|
|
}
|
|
const enabled = () => !!state.api;
|
|
|
|
// ---- what the app asks for
|
|
const json = (res, code, o) => { res.writeHead(code, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(o)); };
|
|
const readBody = (req, max = 40e6) => new Promise((ok, no) => { const c = []; let n = 0; req.on('data', d => { n += d.length; if (n > max) { no(new Error('That is too large to send')); req.destroy(); } else c.push(d); }); req.on('end', () => ok(Buffer.concat(c).toString())); req.on('error', no); });
|
|
const safeId = s => /^[A-Za-z0-9+/=_.:-]{1,300}$/.test(s);
|
|
|
|
async function send(cid, text, atts, quoteTs) {
|
|
const c = state.db.convs[cid]; if (!c) throw new Error('Unknown conversation');
|
|
if (!state.account) throw new Error('Signal is not linked yet');
|
|
const recipients = c.type === 'group' ? [groupApiId(cid.slice(2))] : [cid];
|
|
const body = { message: text || '', number: state.account, recipients, base64_attachments: atts.map(a => `data:${a.type || 'application/octet-stream'};filename=${encodeURIComponent(a.name || 'file')};base64,${a.data}`) };
|
|
const q = quoteTs && findMsg(cid, quoteTs);
|
|
if (q) { body.quote_timestamp = q.ts; body.quote_author = q.out ? state.account : q.from; body.quote_message = q.text || ''; }
|
|
const r = await apiJson('POST', '/v2/send', body);
|
|
const ts = parseInt(r && r.timestamp, 10) || Date.now();
|
|
const saved = atts.map(a => { const id = 'local-' + crypto.randomBytes(8).toString('hex'); try { fs.writeFileSync(path.join(state.dir, 'out', id), Buffer.from(a.data, 'base64'), { mode: 0o600 }); } catch { /* attachment kept only in Signal */ } return { id, type: a.type, name: a.name, size: Buffer.from(a.data, 'base64').length, local: true }; });
|
|
const m = { id: ts + ':' + state.account, ts, out: true, from: state.account, name: '', text: text || '', att: saved, status: 'sent' };
|
|
if (q) m.quote = { author: q.out ? state.account : q.from, text: q.text || '', ts: q.ts };
|
|
addMessage(cid, c, m); emit({ t: 'msg', conv: cid, out: true, name: c.name, preview: previewOf(m) });
|
|
return m;
|
|
}
|
|
|
|
async function handle(req, res) {
|
|
const u = new URL(req.url, 'http://x'), p = u.pathname.replace(/^\/api\/signal/, '') || '/';
|
|
try {
|
|
if (p === '/status') return json(res, 200, { linked: !!state.account, number: state.account, connected: state.wsUp, reachable: state.reachable !== false, unread: totalUnread(), gap: state.gap || null });
|
|
if (p === '/debug') return json(res, 200, { account: state.account ? '…' + state.account.slice(-4) : '', connected: state.wsUp, gap: state.gap || null, convs: Object.keys(state.db.convs).length, trace }); // what arrived lately: kinds only, no message text
|
|
if (p === '/qr') { // a new link code each time; scanned in Signal -> Settings -> Linked devices
|
|
const r = await api('GET', '/v1/qrcodelink?device_name=' + encodeURIComponent('NE Hub'), null, 60000);
|
|
if (!r.ok) return json(res, 502, { error: 'Could not get a link code from the Signal service' });
|
|
res.writeHead(200, { 'content-type': r.headers.get('content-type') || 'image/png', 'cache-control': 'no-store' }); return res.end(Buffer.from(await r.arrayBuffer()));
|
|
}
|
|
if (p === '/events') {
|
|
res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive', 'x-accel-buffering': 'no' });
|
|
res.write(': hello\n\n'); state.clients.add(res);
|
|
const ka = setInterval(() => { try { res.write(': \n\n'); } catch { /* closed */ } }, 25000);
|
|
res.on('close', () => { clearInterval(ka); state.clients.delete(res); }); return;
|
|
}
|
|
if (!state.account) return json(res, 409, { error: 'Signal is not linked yet' });
|
|
if (p === '/convs') return json(res, 200, { convs: Object.values(state.db.convs).sort((a, b) => b.ts - a.ts), unread: totalUnread() });
|
|
if (p === '/contacts') {
|
|
await loadContacts(false);
|
|
const all = new Map(state.contacts.map); for (const n of Object.keys(nicks())) if (!all.has(n)) all.set(n, '');
|
|
for (const c of Object.values(state.db.convs)) if (c.type === 'direct' && /^\+/.test(c.id) && !all.has(c.id)) all.set(c.id, '');
|
|
return json(res, 200, { contacts: [...all].map(([number, name]) => ({ number, name: nicks()[number] || name, mine: !!nicks()[number] })).sort((a, b) => (a.name || a.number).localeCompare(b.name || b.number)) });
|
|
}
|
|
let m;
|
|
if ((m = /^\/conv\/(.+)$/.exec(p)) && req.method === 'GET') {
|
|
const id = decodeURIComponent(m[1]), c = state.db.convs[id]; if (!c) return json(res, 404, { error: 'Unknown conversation' });
|
|
const before = +u.searchParams.get('before') || Infinity, limit = Math.min(+u.searchParams.get('limit') || 100, 300);
|
|
const all = (state.db.msgs[id] || []).filter(x => x.ts < before), msgs = all.slice(-limit);
|
|
return json(res, 200, { conv: c, msgs, more: all.length > msgs.length, names: Object.fromEntries([...state.contacts.map]) });
|
|
}
|
|
if (p === '/new' && req.method === 'POST') {
|
|
const b = JSON.parse(await readBody(req, 10000)), n = String(b.number || '').replace(/[\s()-]/g, '');
|
|
if (!/^\+\d{6,15}$/.test(n)) return json(res, 400, { error: 'Enter a phone number with its country code, like +15551234567' });
|
|
if (String(b.name || '').trim()) setNick(n, String(b.name));
|
|
const c = conv(n, 'direct', ''); saveSoon(); return json(res, 200, { conv: c });
|
|
}
|
|
if (p === '/contact' && req.method === 'POST') { // rename a contact (an empty name goes back to the name Signal has)
|
|
const b = JSON.parse(await readBody(req, 10000)), n = String(b.number || '').replace(/[\s()-]/g, '');
|
|
if (!/^\+\d{6,15}$/.test(n) && !/^[0-9a-f-]{36}$/i.test(n)) return json(res, 400, { error: 'That is not a phone number' });
|
|
const name = setNick(n, String(b.name || ''));
|
|
let bridge = false;
|
|
if (name && /^\+/.test(n)) { try { await apiJson('PUT', '/v1/contacts/' + encodeURIComponent(state.account), { recipient: n, name }); bridge = true; } catch { /* kept in this app anyway */ } }
|
|
return json(res, 200, { ok: true, name: displayName(n, ''), bridge });
|
|
}
|
|
if (p === '/conv/delete' && req.method === 'POST') { // remove a chat from this app (it stays on your phone; a new message starts it again)
|
|
const b = JSON.parse(await readBody(req, 10000)); if (!state.db.convs[b.id]) return json(res, 404, { error: 'Unknown conversation' });
|
|
dropFiles(b.id); delete state.db.convs[b.id]; delete state.db.msgs[b.id]; saveSoon(); emit({ t: 'gone', conv: b.id }); return json(res, 200, { ok: true });
|
|
}
|
|
if (p === '/conv/clear' && req.method === 'POST') { // empty a chat but keep it in the list
|
|
const b = JSON.parse(await readBody(req, 10000)), c = state.db.convs[b.id]; if (!c) return json(res, 404, { error: 'Unknown conversation' });
|
|
dropFiles(b.id); state.db.msgs[b.id] = []; c.preview = ''; c.unread = 0; saveSoon(); emit({ t: 'update', conv: b.id }); return json(res, 200, { ok: true });
|
|
}
|
|
if (p === '/read' && req.method === 'POST') {
|
|
const b = JSON.parse(await readBody(req, 10000)), c = state.db.convs[b.id]; if (!c) return json(res, 404, { error: 'Unknown conversation' });
|
|
c.unread = 0; saveSoon(); emit({ t: 'read', conv: c.id });
|
|
if (c.type === 'direct') for (const msg of (state.db.msgs[c.id] || [])) if (!msg.out && !msg.rs) { msg.rs = true; api('POST', '/v1/receipts/' + encodeURIComponent(state.account), { receipt_type: 'read', recipient: c.id, timestamp: msg.ts }).catch(() => {}); }
|
|
return json(res, 200, { ok: true });
|
|
}
|
|
if (p === '/send' && req.method === 'POST') {
|
|
const b = JSON.parse(await readBody(req));
|
|
if (!String(b.text || '').trim() && !(b.attachments || []).length) return json(res, 400, { error: 'Write a message or add a file' });
|
|
const msg = await send(b.to, String(b.text || ''), (b.attachments || []).slice(0, 10), b.quote); return json(res, 200, { msg });
|
|
}
|
|
if (p === '/react' && req.method === 'POST') {
|
|
const b = JSON.parse(await readBody(req, 10000)), c = state.db.convs[b.to], tm = c && findMsg(b.to, b.ts); if (!tm) return json(res, 404, { error: 'Unknown message' });
|
|
const author = tm.out ? state.account : tm.from, mine = state.account;
|
|
await apiJson(b.emoji ? 'POST' : 'DELETE', '/v1/reactions/' + encodeURIComponent(state.account), { reaction: b.emoji || (tm.react && tm.react[mine]) || '👍', recipient: c.type === 'group' ? groupApiId(b.to.slice(2)) : b.to, target_author: author, timestamp: tm.ts });
|
|
tm.react = tm.react || {}; if (b.emoji) tm.react[mine] = b.emoji; else delete tm.react[mine]; saveSoon(); emit({ t: 'update', conv: b.to }); return json(res, 200, { ok: true });
|
|
}
|
|
if ((m = /^\/attachment\/(.+)$/.exec(p))) {
|
|
const id = decodeURIComponent(m[1]); if (!safeId(id) || id.includes('..')) return json(res, 400, { error: 'Bad attachment' });
|
|
let meta = null; for (const list of Object.values(state.db.msgs)) { for (const x of list) { const a = (x.att || []).find(q => q.id === id); if (a) { meta = a; break; } } if (meta) break; }
|
|
if (!meta) return json(res, 404, { error: 'Unknown attachment' });
|
|
const head = { 'content-type': meta.type || 'application/octet-stream', 'cache-control': 'private, max-age=86400', 'content-disposition': (/^(image|audio|video)\//.test(meta.type || '') ? 'inline' : 'attachment') + `; filename*=UTF-8''${encodeURIComponent(meta.name || 'file')}`, 'x-content-type-options': 'nosniff' };
|
|
if (meta.local) { const f = path.join(state.dir, 'out', id); if (!fs.existsSync(f)) return json(res, 404, { error: 'Gone' }); res.writeHead(200, head); return fs.createReadStream(f).pipe(res); }
|
|
const r = await api('GET', '/v1/attachments/' + encodeURIComponent(id), null, 120000);
|
|
if (!r.ok) return json(res, 404, { error: 'Gone' });
|
|
res.writeHead(200, head); return Readable.fromWeb(r.body).on('error', () => res.destroy()).pipe(res);
|
|
}
|
|
return json(res, 404, { error: 'Not found' });
|
|
} catch (e) {
|
|
if (res.headersSent) return res.destroy();
|
|
json(res, e.status && e.status < 500 ? e.status : 502, { error: e.message || 'Signal service error' });
|
|
}
|
|
}
|
|
|
|
module.exports = { init, handle, enabled, _state: state };
|