aljaz/bakery
1
0
Fork 0
mirror of https://github.com/aljazceru/bakery.git synced 2025-12-17 04:35:13 +01:00
Code Issues Packages Projects Releases Wiki Activity

format

Browse Source
This commit is contained in:
hzrd149
2025-02-06 16:11:00 -06:00
parent c3216e43a9
commit 9efd5019e3
66 changed files with 3759 additions and 3201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.prettierignore Normal file
View File

@@ -0,0 +1,4 @@
dist
data
nostrudel
node_modules

2
nostrudel

Submodule nostrudel updated: 5b2113b3b9...e623c7b4aa

29
package.json
View File

@@ -11,7 +11,7 @@
"start": "node .", "start": "node .",
"dev": "nodemon --loader @swc-node/register/esm src/index.ts", "dev": "nodemon --loader @swc-node/register/esm src/index.ts",
"build": "tsc", "build": "tsc",
"format": "prettier -w . --ignore-path .gitignore" "format": "prettier -w ."
}, },
"files": [ "files": [
"dist", "dist",
@@ -24,12 +24,14 @@
"author": "hzrd149", "author": "hzrd149",
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"@diva.exchange/i2p-sam": "^5.4.1", "@diva.exchange/i2p-sam": "^5.4.2",
"@noble/hashes": "^1.7.0", "@noble/hashes": "^1.7.1",
"@satellite-earth/core": "^0.5.0", "@satellite-earth/core": "^0.5.0",
"applesauce-core": "^0.10.0", "applesauce-core": "next",
"applesauce-signer": "^0.10.0", "applesauce-factory": "0.0.0-next-20250206174509",
"better-sqlite3": "^11.7.2", "applesauce-loaders": "^0.10.0",
"applesauce-signers": "next",
"better-sqlite3": "^11.8.1",
"blossom-client-sdk": "^2.1.1", "blossom-client-sdk": "^2.1.1",
"cors": "^2.8.5", "cors": "^2.8.5",
"dayjs": "^1.11.13", "dayjs": "^1.11.13",
@@ -49,23 +51,25 @@
"nostr-tools": "^2.10.4", "nostr-tools": "^2.10.4",
"pac-proxy-agent": "^7.1.0", "pac-proxy-agent": "^7.1.0",
"process-streams": "^1.0.3", "process-streams": "^1.0.3",
"streamx": "^2.21.1", "rx-nostr": "^3.5.0",
"rxjs": "^7.8.1",
"streamx": "^2.22.0",
"unique-names-generator": "^4.7.1", "unique-names-generator": "^4.7.1",
"web-push": "^3.6.7", "web-push": "^3.6.7",
"ws": "^8.18.0" "ws": "^8.18.0"
}, },
"devDependencies": { "devDependencies": {
"@changesets/cli": "^2.27.11", "@changesets/cli": "^2.27.12",
"@swc-node/register": "^1.10.9", "@swc-node/register": "^1.10.9",
"@swc/core": "^1.10.7", "@swc/core": "^1.10.14",
"@types/better-sqlite3": "^7.6.12", "@types/better-sqlite3": "^7.6.12",
"@types/cors": "^2.8.17", "@types/cors": "^2.8.17",
"@types/debug": "^4.1.12", "@types/debug": "^4.1.12",
"@types/express": "^4.17.21", "@types/express": "^4.17.21",
"@types/lodash.throttle": "^4.1.9", "@types/lodash.throttle": "^4.1.9",
"@types/node": "^22.10.6", "@types/node": "^22.13.1",
"@types/web-push": "^3.6.4", "@types/web-push": "^3.6.4",
"@types/ws": "^8.5.13", "@types/ws": "^8.5.14",
"nodemon": "^3.1.9", "nodemon": "^3.1.9",
"prettier": "^3.4.2", "prettier": "^3.4.2",
"typescript": "^5.7.3" "typescript": "^5.7.3"
@@ -76,5 +80,6 @@
], ],
"exec": "node", "exec": "node",
"signal": "SIGTERM" "signal": "SIGTERM"
} },
"packageManager": "pnpm@9.14.4"
} }

1032
pnpm-lock.yaml generated
View File

File diff suppressed because it is too large Load Diff

2
src/app/index.ts
View File

@@ -7,7 +7,7 @@ import { kinds } from "nostr-tools";
import { AbstractRelay } from "nostr-tools/abstract-relay"; import { AbstractRelay } from "nostr-tools/abstract-relay";
import express, { Express } from "express"; import express, { Express } from "express";
import { EventEmitter } from "events"; import { EventEmitter } from "events";
import { SimpleSigner } from "applesauce-signer/signers/simple-signer"; import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
import cors from "cors"; import cors from "cors";
import { logger } from "../logger.js"; import { logger } from "../logger.js";

23
src/core.ts Normal file
View File

@@ -0,0 +1,23 @@
import { createRxNostr, noopVerifier } from "rx-nostr";
import { verifyEvent } from "nostr-tools/wasm";
import { EventStore, QueryStore } from "applesauce-core";
import { logger } from "./logger.js";
const log = logger.extend("rx-nostr");
export const rxNostr = createRxNostr({
verifier: async (event) => {
try {
return verifyEvent(event);
} catch (error) {
return false;
}
},
});
rxNostr.createConnectionStateObservable().subscribe((packet) => {
log(`${packet.state} ${packet.from}`);
});
export const eventStore = new EventStore();
export const queryStore = new QueryStore(eventStore);

4
src/helpers/array.ts Normal file
View File

@@ -0,0 +1,4 @@
export function arrayFallback<T>(arr: T[], fallback: T[]): T[] {
if (arr.length === 0) return fallback;
else return arr;
}

2
src/helpers/ip.ts
View File

@@ -1,4 +1,4 @@
import os from 'node:os'; import os from "node:os";
export function getIPAddresses() { export function getIPAddresses() {
var ifaces = os.networkInterfaces(); var ifaces = os.networkInterfaces();

6
src/helpers/network.ts
View File

@@ -1,4 +1,4 @@
import net from 'net'; import net from "net";
export function testTCPConnection(host: string, port: number, timeout = 5000) { export function testTCPConnection(host: string, port: number, timeout = 5000) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
@@ -6,7 +6,7 @@ export function testTCPConnection(host: string, port: number, timeout = 5000) {
const timer = setTimeout(() => { const timer = setTimeout(() => {
socket.destroy(); socket.destroy();
reject(new Error('Connection timed out')); reject(new Error("Connection timed out"));
}, timeout); }, timeout);
socket.connect(port, host, () => { socket.connect(port, host, () => {
@@ -15,7 +15,7 @@ export function testTCPConnection(host: string, port: number, timeout = 5000) {
resolve(true); resolve(true);
}); });
socket.on('error', (err) => { socket.on("error", (err) => {
clearTimeout(timer); clearTimeout(timer);
reject(err); reject(err);
}); });

7
src/index.ts
View File

@@ -1,4 +1,5 @@
#!/usr/bin/env node #!/usr/bin/env node
import "./polyfill.js";
import process from "node:process"; import process from "node:process";
import path from "node:path"; import path from "node:path";
@@ -7,9 +8,7 @@ import { mkdirp } from "mkdirp";
import dayjs from "dayjs"; import dayjs from "dayjs";
import duration from "dayjs/plugin/duration.js"; import duration from "dayjs/plugin/duration.js";
import localizedFormat from "dayjs/plugin/localizedFormat.js"; import localizedFormat from "dayjs/plugin/localizedFormat.js";
import { useWebSocketImplementation } from "nostr-tools/relay";
import OutboundProxyWebSocket from "./modules/network/outbound/websocket.js";
import App from "./app/index.js"; import App from "./app/index.js";
import { DATA_PATH, PUBLIC_ADDRESS } from "./env.js"; import { DATA_PATH, PUBLIC_ADDRESS } from "./env.js";
import { addListener, logger } from "./logger.js"; import { addListener, logger } from "./logger.js";
@@ -19,10 +18,6 @@ import { pathExists } from "./helpers/fs.js";
dayjs.extend(duration); dayjs.extend(duration);
dayjs.extend(localizedFormat); dayjs.extend(localizedFormat);
// @ts-expect-error
global.WebSocket = OutboundProxyWebSocket;
useWebSocketImplementation(OutboundProxyWebSocket);
// create app // create app
await mkdirp(DATA_PATH); await mkdirp(DATA_PATH);
const app = new App(DATA_PATH); const app = new App(DATA_PATH);

18
src/modules/address-book.ts
View File

@@ -1,14 +1,14 @@
import { NostrEvent, kinds } from 'nostr-tools'; import { NostrEvent, kinds } from "nostr-tools";
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import { getInboxes, getOutboxes } from '@satellite-earth/core/helpers/nostr/mailboxes.js'; import { getInboxes, getOutboxes } from "@satellite-earth/core/helpers/nostr/mailboxes.js";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import App from '../app/index.js'; import App from "../app/index.js";
import PubkeyBatchLoader from './pubkey-batch-loader.js'; import PubkeyBatchLoader from "./pubkey-batch-loader.js";
/** Loads 10002 events for pubkeys */ /** Loads 10002 events for pubkeys */
export default class AddressBook { export default class AddressBook {
log = logger.extend('AddressBook'); log = logger.extend("AddressBook");
app: App; app: App;
loader: PubkeyBatchLoader; loader: PubkeyBatchLoader;
@@ -26,8 +26,8 @@ export default class AddressBook {
return this.app.eventStore.getEventsForFilters([{ kinds: [kinds.RelayList], authors: [pubkey] }])?.[0]; return this.app.eventStore.getEventsForFilters([{ kinds: [kinds.RelayList], authors: [pubkey] }])?.[0];
}); });
this.loader.on('event', (event) => this.app.eventStore.addEvent(event)); this.loader.on("event", (event) => this.app.eventStore.addEvent(event));
this.loader.on('batch', (found, failed) => { this.loader.on("batch", (found, failed) => {
this.log(`Found ${found}, failed ${failed}, pending ${this.loader.queue}`); this.log(`Found ${found}, failed ${failed}, pending ${this.loader.queue}`);
}); });
} }

30
src/modules/cautious-pool.ts
View File

@@ -1,9 +1,9 @@
import EventEmitter from 'events'; import EventEmitter from "events";
import { SimplePool, VerifiedEvent } from 'nostr-tools'; import { SimplePool, VerifiedEvent } from "nostr-tools";
import { AbstractRelay } from 'nostr-tools/relay'; import { AbstractRelay } from "nostr-tools/relay";
import { normalizeURL } from 'nostr-tools/utils'; import { normalizeURL } from "nostr-tools/utils";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
export type TestRelay = (relay: AbstractRelay, challenge: string) => boolean; export type TestRelay = (relay: AbstractRelay, challenge: string) => boolean;
@@ -14,7 +14,7 @@ type EventMap = {
}; };
export default class CautiousPool extends SimplePool { export default class CautiousPool extends SimplePool {
log = logger.extend('CautiousPool'); log = logger.extend("CautiousPool");
isSelf?: TestRelay; isSelf?: TestRelay;
blacklist = new Set<string>(); blacklist = new Set<string>();
@@ -32,20 +32,20 @@ export default class CautiousPool extends SimplePool {
url = normalizeURL(url); url = normalizeURL(url);
const parsed = new URL(url); const parsed = new URL(url);
if (parsed.host === 'localhost' || parsed.host === '127.0.0.1') throw new Error('Cant connect to localhost'); if (parsed.host === "localhost" || parsed.host === "127.0.0.1") throw new Error("Cant connect to localhost");
if (this.blacklist.has(url)) throw new Error('Cant connect to self'); if (this.blacklist.has(url)) throw new Error("Cant connect to self");
const relay = await super.ensureRelay(url, params); const relay = await super.ensureRelay(url, params);
if (this.checkRelay(relay)) throw new Error('Cant connect to self'); if (this.checkRelay(relay)) throw new Error("Cant connect to self");
this.emitter.emit('connected', relay); this.emitter.emit("connected", relay);
relay._onauth = (challenge) => { relay._onauth = (challenge) => {
if (this.checkRelay(relay, challenge)) { if (this.checkRelay(relay, challenge)) {
this.authenticated.set(relay.url, false); this.authenticated.set(relay.url, false);
this.challenges.set(relay.url, challenge); this.challenges.set(relay.url, challenge);
this.emitter.emit('challenge', relay, challenge); this.emitter.emit("challenge", relay, challenge);
} }
}; };
@@ -54,7 +54,7 @@ export default class CautiousPool extends SimplePool {
relay.onclose = () => { relay.onclose = () => {
this.challenges.delete(relay.url); this.challenges.delete(relay.url);
this.authenticated.delete(relay.url); this.authenticated.delete(relay.url);
this.emitter.emit('closed', relay); this.emitter.emit("closed", relay);
}; };
return relay; return relay;
@@ -70,7 +70,7 @@ export default class CautiousPool extends SimplePool {
this.blacklist.add(relay.url); this.blacklist.add(relay.url);
relay.close(); relay.close();
relay.connect = () => { relay.connect = () => {
throw new Error('Cant connect to self'); throw new Error("Cant connect to self");
}; };
return true; return true;
} }
@@ -80,11 +80,11 @@ export default class CautiousPool extends SimplePool {
} }
isAuthenticated(relay: string | AbstractRelay) { isAuthenticated(relay: string | AbstractRelay) {
return !!this.authenticated.get(typeof relay === 'string' ? relay : relay.url); return !!this.authenticated.get(typeof relay === "string" ? relay : relay.url);
} }
async authenticate(url: string | AbstractRelay, auth: VerifiedEvent) { async authenticate(url: string | AbstractRelay, auth: VerifiedEvent) {
const relay = typeof url === 'string' ? await this.ensureRelay(url) : url; const relay = typeof url === "string" ? await this.ensureRelay(url) : url;
return await relay.auth(async (draft) => auth); return await relay.auth(async (draft) => auth);
} }

38
src/modules/community-multiplexer.ts
View File

@@ -1,16 +1,16 @@
import { type Database } from 'better-sqlite3'; import { type Database } from "better-sqlite3";
import { WebSocket, WebSocketServer } from 'ws'; import { WebSocket, WebSocketServer } from "ws";
import { type IncomingMessage } from 'http'; import { type IncomingMessage } from "http";
import { randomBytes } from 'crypto'; import { randomBytes } from "crypto";
import { NostrEvent, SimplePool } from 'nostr-tools'; import { NostrEvent, SimplePool } from "nostr-tools";
import { HyperConnectionManager } from './hyper-connection-manager.js'; import { HyperConnectionManager } from "./hyper-connection-manager.js";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import { CommunityProxy } from './community-proxy.js'; import { CommunityProxy } from "./community-proxy.js";
import { IEventStore } from '@satellite-earth/core'; import { IEventStore } from "@satellite-earth/core";
export class CommunityMultiplexer { export class CommunityMultiplexer {
log = logger.extend('community-multiplexer'); log = logger.extend("community-multiplexer");
db: Database; db: Database;
eventStore: IEventStore; eventStore: IEventStore;
pool: SimplePool; pool: SimplePool;
@@ -23,20 +23,20 @@ export class CommunityMultiplexer {
this.eventStore = eventStore; this.eventStore = eventStore;
this.pool = new SimplePool(); this.pool = new SimplePool();
this.connectionManager = new HyperConnectionManager(randomBytes(32).toString('hex')); this.connectionManager = new HyperConnectionManager(randomBytes(32).toString("hex"));
this.syncCommunityDefinitions(); this.syncCommunityDefinitions();
} }
attachToServer(wss: WebSocketServer) { attachToServer(wss: WebSocketServer) {
wss.on('connection', this.handleConnection.bind(this)); wss.on("connection", this.handleConnection.bind(this));
} }
handleConnection(ws: WebSocket, req: IncomingMessage) { handleConnection(ws: WebSocket, req: IncomingMessage) {
if (!req.url) return false; if (!req.url) return false;
const url = new URL(req.url, `http://${req.headers.host}`); const url = new URL(req.url, `http://${req.headers.host}`);
const pubkey = url.pathname.split('/')[1] as string | undefined; const pubkey = url.pathname.split("/")[1] as string | undefined;
if (!pubkey || pubkey.length !== 64) return false; if (!pubkey || pubkey.length !== 64) return false;
try { try {
@@ -47,30 +47,30 @@ export class CommunityMultiplexer {
community.relay.handleConnection(ws, req); community.relay.handleConnection(ws, req);
return true; return true;
} catch (error) { } catch (error) {
this.log('Failed handle ws connection to', pubkey); this.log("Failed handle ws connection to", pubkey);
console.log(error); console.log(error);
return false; return false;
} }
} }
syncCommunityDefinitions() { syncCommunityDefinitions() {
this.log('Syncing community definitions'); this.log("Syncing community definitions");
const sub = this.pool.subscribeMany(['wss://nostrue.com'], [{ kinds: [12012] }], { const sub = this.pool.subscribeMany(["wss://nostrue.com"], [{ kinds: [12012] }], {
onevent: (event) => this.eventStore.addEvent(event), onevent: (event) => this.eventStore.addEvent(event),
oneose: () => sub.close(), oneose: () => sub.close(),
}); });
} }
getCommunityProxy(pubkey: string) { getCommunityProxy(pubkey: string) {
this.log('Looking for community definition', pubkey); this.log("Looking for community definition", pubkey);
let definition: NostrEvent | undefined = undefined; let definition: NostrEvent | undefined = undefined;
const local = this.eventStore.getEventsForFilters([{ kinds: [12012], authors: [pubkey] }]); const local = this.eventStore.getEventsForFilters([{ kinds: [12012], authors: [pubkey] }]);
if (local[0]) definition = local[0]; if (local[0]) definition = local[0];
if (!definition) throw new Error('Failed to find community definition'); if (!definition) throw new Error("Failed to find community definition");
this.log('Creating community proxy', pubkey); this.log("Creating community proxy", pubkey);
const community = new CommunityProxy(this.db, definition, this.connectionManager); const community = new CommunityProxy(this.db, definition, this.connectionManager);
community.connect(); community.connect();

20
src/modules/contact-book.ts
View File

@@ -1,14 +1,14 @@
import { NostrEvent, kinds } from 'nostr-tools'; import { NostrEvent, kinds } from "nostr-tools";
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import { COMMON_CONTACT_RELAYS } from '../env.js'; import { COMMON_CONTACT_RELAYS } from "../env.js";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import App from '../app/index.js'; import App from "../app/index.js";
import PubkeyBatchLoader from './pubkey-batch-loader.js'; import PubkeyBatchLoader from "./pubkey-batch-loader.js";
/** Loads 3 contact lists for pubkeys */ /** Loads 3 contact lists for pubkeys */
export default class ContactBook { export default class ContactBook {
log = logger.extend('ContactsBook'); log = logger.extend("ContactsBook");
app: App; app: App;
loader: PubkeyBatchLoader; loader: PubkeyBatchLoader;
extraRelays = COMMON_CONTACT_RELAYS; extraRelays = COMMON_CONTACT_RELAYS;
@@ -20,8 +20,8 @@ export default class ContactBook {
return this.app.eventStore.getEventsForFilters([{ kinds: [kinds.Contacts], authors: [pubkey] }])?.[0]; return this.app.eventStore.getEventsForFilters([{ kinds: [kinds.Contacts], authors: [pubkey] }])?.[0];
}); });
this.loader.on('event', (event) => this.app.eventStore.addEvent(event)); this.loader.on("event", (event) => this.app.eventStore.addEvent(event));
this.loader.on('batch', (found, failed) => { this.loader.on("batch", (found, failed) => {
this.log(`Found ${found}, failed ${failed}, pending ${this.loader.queue}`); this.log(`Found ${found}, failed ${failed}, pending ${this.loader.queue}`);
}); });
} }
@@ -35,7 +35,7 @@ export default class ContactBook {
if (contacts) { if (contacts) {
return contacts.tags return contacts.tags
.filter((tag) => { .filter((tag) => {
return tag[0] === 'p'; return tag[0] === "p";
}) })
.map((tag) => { .map((tag) => {
return tag[1]; return tag[1];

22
src/modules/control/config-actions.ts
View File

@@ -1,13 +1,13 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { ConfigMessage, ConfigResponse } from '@satellite-earth/core/types/control-api/config.js'; import { ConfigMessage, ConfigResponse } from "@satellite-earth/core/types/control-api/config.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
/** handles ['CONTROL', 'CONFIG', ...] messages */ /** handles ['CONTROL', 'CONFIG', ...] messages */
export default class ConfigActions implements ControlMessageHandler { export default class ConfigActions implements ControlMessageHandler {
app: App; app: App;
name = 'CONFIG'; name = "CONFIG";
private subscribed = new Set<WebSocket | NodeJS.Process>(); private subscribed = new Set<WebSocket | NodeJS.Process>();
@@ -15,9 +15,9 @@ export default class ConfigActions implements ControlMessageHandler {
this.app = app; this.app = app;
// when config changes send it to the subscribed sockets // when config changes send it to the subscribed sockets
this.app.config.on('changed', (config) => { this.app.config.on("changed", (config) => {
for (const sock of this.subscribed) { for (const sock of this.subscribed) {
this.send(sock, ['CONTROL', 'CONFIG', 'CHANGED', config]); this.send(sock, ["CONTROL", "CONFIG", "CHANGED", config]);
} }
}); });
} }
@@ -25,13 +25,13 @@ export default class ConfigActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: ConfigMessage) { handleMessage(sock: WebSocket | NodeJS.Process, message: ConfigMessage) {
const method = message[2]; const method = message[2];
switch (method) { switch (method) {
case 'SUBSCRIBE': case "SUBSCRIBE":
this.subscribed.add(sock); this.subscribed.add(sock);
sock.once('close', () => this.subscribed.delete(sock)); sock.once("close", () => this.subscribed.delete(sock));
this.send(sock, ['CONTROL', 'CONFIG', 'CHANGED', this.app.config.data]); this.send(sock, ["CONTROL", "CONFIG", "CHANGED", this.app.config.data]);
return true; return true;
case 'SET': case "SET":
const field = message[3]; const field = message[3];
const value = message[4]; const value = message[4];

46
src/modules/control/control-api.ts
View File

@@ -1,11 +1,11 @@
import { WebSocket, WebSocketServer } from 'ws'; import { WebSocket, WebSocketServer } from "ws";
import { type IncomingMessage } from 'http'; import { type IncomingMessage } from "http";
import { ControlResponse } from '@satellite-earth/core/types/control-api/index.js'; import { ControlResponse } from "@satellite-earth/core/types/control-api/index.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
export type ControlMessage = ['CONTROL', string, string, ...any[]]; export type ControlMessage = ["CONTROL", string, string, ...any[]];
export interface ControlMessageHandler { export interface ControlMessageHandler {
app: App; app: App;
name: string; name: string;
@@ -18,7 +18,7 @@ export interface ControlMessageHandler {
export default class ControlApi { export default class ControlApi {
app: App; app: App;
auth?: string; auth?: string;
log = logger.extend('ControlApi'); log = logger.extend("ControlApi");
handlers = new Map<string, ControlMessageHandler>(); handlers = new Map<string, ControlMessageHandler>();
authenticatedConnections = new Set<WebSocket | NodeJS.Process>(); authenticatedConnections = new Set<WebSocket | NodeJS.Process>();
@@ -37,11 +37,11 @@ export default class ControlApi {
/** start listening for incoming ws connections */ /** start listening for incoming ws connections */
attachToServer(wss: WebSocketServer) { attachToServer(wss: WebSocketServer) {
wss.on('connection', this.handleConnection.bind(this)); wss.on("connection", this.handleConnection.bind(this));
} }
handleConnection(ws: WebSocket, req: IncomingMessage) { handleConnection(ws: WebSocket, req: IncomingMessage) {
ws.on('message', (data, isBinary) => { ws.on("message", (data, isBinary) => {
this.handleRawMessage(ws, data as Buffer); this.handleRawMessage(ws, data as Buffer);
}); });
@@ -49,7 +49,7 @@ export default class ControlApi {
handler.handleConnection?.(ws); handler.handleConnection?.(ws);
} }
ws.once('close', () => this.handleDisconnect(ws)); ws.once("close", () => this.handleDisconnect(ws));
} }
handleDisconnect(ws: WebSocket) { handleDisconnect(ws: WebSocket) {
this.authenticatedConnections.delete(ws); this.authenticatedConnections.delete(ws);
@@ -60,12 +60,12 @@ export default class ControlApi {
} }
attachToProcess(p: NodeJS.Process) { attachToProcess(p: NodeJS.Process) {
p.on('message', (message) => { p.on("message", (message) => {
if ( if (
Array.isArray(message) && Array.isArray(message) &&
message[0] === 'CONTROL' && message[0] === "CONTROL" &&
typeof message[1] === 'string' && typeof message[1] === "string" &&
typeof message[2] === 'string' typeof message[2] === "string"
) { ) {
this.handleMessage(p, message as ControlMessage); this.handleMessage(p, message as ControlMessage);
} }
@@ -84,16 +84,16 @@ export default class ControlApi {
try { try {
if ( if (
Array.isArray(data) && Array.isArray(data) &&
data[0] === 'CONTROL' && data[0] === "CONTROL" &&
typeof data[1] === 'string' && typeof data[1] === "string" &&
typeof data[2] === 'string' typeof data[2] === "string"
) { ) {
if (this.authenticatedConnections.has(ws) || data[1] === 'AUTH') { if (this.authenticatedConnections.has(ws) || data[1] === "AUTH") {
await this.handleMessage(ws, data as ControlMessage); await this.handleMessage(ws, data as ControlMessage);
} }
} }
} catch (err) { } catch (err) {
this.log('Failed to handle Control message', message.toString('utf-8')); this.log("Failed to handle Control message", message.toString("utf-8"));
this.log(err); this.log(err);
} }
} catch (error) { } catch (error) {
@@ -104,13 +104,13 @@ export default class ControlApi {
/** handle a ['CONTROL', ...] message */ /** handle a ['CONTROL', ...] message */
async handleMessage(sock: WebSocket | NodeJS.Process, message: ControlMessage) { async handleMessage(sock: WebSocket | NodeJS.Process, message: ControlMessage) {
// handle ['CONTROL', 'AUTH', <code>] messages // handle ['CONTROL', 'AUTH', <code>] messages
if (message[1] === 'AUTH' && message[2] === 'CODE') { if (message[1] === "AUTH" && message[2] === "CODE") {
const code = message[3]; const code = message[3];
if (code === this.auth) { if (code === this.auth) {
this.authenticatedConnections.add(sock); this.authenticatedConnections.add(sock);
this.send(sock, ['CONTROL', 'AUTH', 'SUCCESS']); this.send(sock, ["CONTROL", "AUTH", "SUCCESS"]);
} else { } else {
this.send(sock, ['CONTROL', 'AUTH', 'INVALID', 'Invalid Auth Code']); this.send(sock, ["CONTROL", "AUTH", "INVALID", "Invalid Auth Code"]);
} }
return true; return true;
} }
@@ -120,7 +120,7 @@ export default class ControlApi {
return await handler.handleMessage(sock, message); return await handler.handleMessage(sock, message);
} }
this.log('Failed to handle Control message', message); this.log("Failed to handle Control message", message);
return false; return false;
} }

22
src/modules/control/decryption-cache.ts
View File

@@ -1,16 +1,16 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { import {
DecryptionCacheMessage, DecryptionCacheMessage,
DecryptionCacheResponse, DecryptionCacheResponse,
} from '@satellite-earth/core/types/control-api/decryption-cache.js'; } from "@satellite-earth/core/types/control-api/decryption-cache.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
/** handles ['CONTROL', 'DECRYPTION-CACHE', ...] messages */ /** handles ['CONTROL', 'DECRYPTION-CACHE', ...] messages */
export default class DecryptionCacheActions implements ControlMessageHandler { export default class DecryptionCacheActions implements ControlMessageHandler {
app: App; app: App;
name = 'DECRYPTION-CACHE'; name = "DECRYPTION-CACHE";
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -19,23 +19,23 @@ export default class DecryptionCacheActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: DecryptionCacheMessage) { handleMessage(sock: WebSocket | NodeJS.Process, message: DecryptionCacheMessage) {
const method = message[2]; const method = message[2];
switch (method) { switch (method) {
case 'ADD-CONTENT': case "ADD-CONTENT":
this.app.decryptionCache.addEventContent(message[3], message[4]); this.app.decryptionCache.addEventContent(message[3], message[4]);
return true; return true;
case 'CLEAR-PUBKEY': case "CLEAR-PUBKEY":
this.app.decryptionCache.clearPubkey(message[3]); this.app.decryptionCache.clearPubkey(message[3]);
return true; return true;
case 'CLEAR': case "CLEAR":
this.app.decryptionCache.clearAll(); this.app.decryptionCache.clearAll();
return true; return true;
case 'REQUEST': case "REQUEST":
this.app.decryptionCache.getEventsContent(message[3]).then((contents) => { this.app.decryptionCache.getEventsContent(message[3]).then((contents) => {
for (const { event, content } of contents) for (const { event, content } of contents)
this.send(sock, ['CONTROL', 'DECRYPTION-CACHE', 'CONTENT', event, content]); this.send(sock, ["CONTROL", "DECRYPTION-CACHE", "CONTENT", event, content]);
this.send(sock, ['CONTROL', 'DECRYPTION-CACHE', 'END']); this.send(sock, ["CONTROL", "DECRYPTION-CACHE", "END"]);
}); });
return true; return true;

14
src/modules/control/dm-actions.ts
View File

@@ -1,13 +1,13 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { DirectMessageMessage } from '@satellite-earth/core/types/control-api/direct-messages.js'; import { DirectMessageMessage } from "@satellite-earth/core/types/control-api/direct-messages.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
/** handles ['CONTROL', 'DM', ...] messages */ /** handles ['CONTROL', 'DM', ...] messages */
export default class DirectMessageActions implements ControlMessageHandler { export default class DirectMessageActions implements ControlMessageHandler {
app: App; app: App;
name = 'DM'; name = "DM";
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -16,11 +16,11 @@ export default class DirectMessageActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: DirectMessageMessage) { handleMessage(sock: WebSocket | NodeJS.Process, message: DirectMessageMessage) {
const method = message[2]; const method = message[2];
switch (method) { switch (method) {
case 'OPEN': case "OPEN":
this.app.directMessageManager.openConversation(message[3], message[4]); this.app.directMessageManager.openConversation(message[3], message[4]);
return true; return true;
case 'CLOSE': case "CLOSE":
this.app.directMessageManager.closeConversation(message[3], message[4]); this.app.directMessageManager.closeConversation(message[3], message[4]);
return true; return true;

12
src/modules/control/logs-actions.ts
View File

@@ -1,13 +1,13 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { LogsMessage } from '@satellite-earth/core/types/control-api/logs.js'; import { LogsMessage } from "@satellite-earth/core/types/control-api/logs.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
/** handles ['CONTROL', 'DM', ...] messages */ /** handles ['CONTROL', 'DM', ...] messages */
export default class LogsActions implements ControlMessageHandler { export default class LogsActions implements ControlMessageHandler {
app: App; app: App;
name = 'LOGS'; name = "LOGS";
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -16,7 +16,7 @@ export default class LogsActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: LogsMessage) { handleMessage(sock: WebSocket | NodeJS.Process, message: LogsMessage) {
const method = message[2]; const method = message[2];
switch (method) { switch (method) {
case 'CLEAR': case "CLEAR":
this.app.logStore.clearLogs(message[3] ? { service: message[3] } : undefined); this.app.logStore.clearLogs(message[3] ? { service: message[3] } : undefined);
return true; return true;

22
src/modules/control/notification-actions.ts
View File

@@ -1,13 +1,13 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { NotificationsMessage, NotificationsResponse } from '@satellite-earth/core/types/control-api/notifications.js'; import { NotificationsMessage, NotificationsResponse } from "@satellite-earth/core/types/control-api/notifications.js";
import { ControlMessageHandler } from './control-api.js'; import { ControlMessageHandler } from "./control-api.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
export default class NotificationActions implements ControlMessageHandler { export default class NotificationActions implements ControlMessageHandler {
app: App; app: App;
name = 'NOTIFICATIONS'; name = "NOTIFICATIONS";
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -16,20 +16,20 @@ export default class NotificationActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: NotificationsMessage): boolean { handleMessage(sock: WebSocket | NodeJS.Process, message: NotificationsMessage): boolean {
const action = message[2]; const action = message[2];
switch (action) { switch (action) {
case 'GET-VAPID-KEY': case "GET-VAPID-KEY":
this.send(sock, ['CONTROL', 'NOTIFICATIONS', 'VAPID-KEY', this.app.notifications.webPushKeys.publicKey]); this.send(sock, ["CONTROL", "NOTIFICATIONS", "VAPID-KEY", this.app.notifications.webPushKeys.publicKey]);
return true; return true;
case 'REGISTER': case "REGISTER":
this.app.notifications.addOrUpdateChannel(message[3]); this.app.notifications.addOrUpdateChannel(message[3]);
return true; return true;
case 'NOTIFY': case "NOTIFY":
const event: NostrEvent | undefined = this.app.eventStore.getEventsForFilters([{ ids: [message[3]] }])?.[0]; const event: NostrEvent | undefined = this.app.eventStore.getEventsForFilters([{ ids: [message[3]] }])?.[0];
if (event) this.app.notifications.notify(event); if (event) this.app.notifications.notify(event);
return true; return true;
case 'UNREGISTER': case "UNREGISTER":
this.app.notifications.removeChannel(message[3]); this.app.notifications.removeChannel(message[3]);
return true; return true;

14
src/modules/control/receiver-actions.ts
View File

@@ -1,12 +1,12 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { ReceiverMessage } from '@satellite-earth/core/types/control-api/receiver.js'; import { ReceiverMessage } from "@satellite-earth/core/types/control-api/receiver.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
export default class ReceiverActions implements ControlMessageHandler { export default class ReceiverActions implements ControlMessageHandler {
app: App; app: App;
name = 'RECEIVER'; name = "RECEIVER";
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -14,11 +14,11 @@ export default class ReceiverActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: ReceiverMessage): boolean { handleMessage(sock: WebSocket | NodeJS.Process, message: ReceiverMessage): boolean {
const action = message[2]; const action = message[2];
switch (action) { switch (action) {
case 'START': case "START":
this.app.receiver.start(); this.app.receiver.start();
return true; return true;
case 'STOP': case "STOP":
this.app.receiver.stop(); this.app.receiver.stop();
return true; return true;

32
src/modules/control/remote-auth-actions.ts
View File

@@ -1,14 +1,14 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { verifyEvent } from 'nostr-tools'; import { verifyEvent } from "nostr-tools";
import { RemoteAuthMessage, RemoteAuthResponse } from '@satellite-earth/core/types/control-api/remote-auth.js'; import { RemoteAuthMessage, RemoteAuthResponse } from "@satellite-earth/core/types/control-api/remote-auth.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
/** handles ['CONTROL', 'REMOTE-AUTH', ...] messages */ /** handles ['CONTROL', 'REMOTE-AUTH', ...] messages */
export default class RemoteAuthActions implements ControlMessageHandler { export default class RemoteAuthActions implements ControlMessageHandler {
app: App; app: App;
name = 'REMOTE-AUTH'; name = "REMOTE-AUTH";
private subscribed = new Set<WebSocket | NodeJS.Process>(); private subscribed = new Set<WebSocket | NodeJS.Process>();
@@ -16,12 +16,12 @@ export default class RemoteAuthActions implements ControlMessageHandler {
this.app = app; this.app = app;
// when config changes send it to the subscribed sockets // when config changes send it to the subscribed sockets
this.app.pool.emitter.on('challenge', (relay, challenge) => { this.app.pool.emitter.on("challenge", (relay, challenge) => {
for (const sock of this.subscribed) { for (const sock of this.subscribed) {
this.send(sock, [ this.send(sock, [
'CONTROL', "CONTROL",
'REMOTE-AUTH', "REMOTE-AUTH",
'STATUS', "STATUS",
relay.url, relay.url,
challenge, challenge,
!!this.app.pool.authenticated.get(relay.url), !!this.app.pool.authenticated.get(relay.url),
@@ -36,7 +36,7 @@ export default class RemoteAuthActions implements ControlMessageHandler {
const authenticated = this.app.pool.isAuthenticated(url); const authenticated = this.app.pool.isAuthenticated(url);
if (challenge) { if (challenge) {
this.send(sock, ['CONTROL', 'REMOTE-AUTH', 'STATUS', url, challenge, authenticated]); this.send(sock, ["CONTROL", "REMOTE-AUTH", "STATUS", url, challenge, authenticated]);
} }
} }
} }
@@ -44,18 +44,18 @@ export default class RemoteAuthActions implements ControlMessageHandler {
async handleMessage(sock: WebSocket | NodeJS.Process, message: RemoteAuthMessage) { async handleMessage(sock: WebSocket | NodeJS.Process, message: RemoteAuthMessage) {
const method = message[2]; const method = message[2];
switch (method) { switch (method) {
case 'SUBSCRIBE': case "SUBSCRIBE":
this.subscribed.add(sock); this.subscribed.add(sock);
sock.once('close', () => this.subscribed.delete(sock)); sock.once("close", () => this.subscribed.delete(sock));
this.sendAllStatuses(sock); this.sendAllStatuses(sock);
return true; return true;
case 'UNSUBSCRIBE': case "UNSUBSCRIBE":
this.subscribed.delete(sock); this.subscribed.delete(sock);
return true; return true;
case 'AUTHENTICATE': case "AUTHENTICATE":
const event = message[3]; const event = message[3];
if (verifyEvent(event)) { if (verifyEvent(event)) {
const relay = event.tags.find((t) => (t[0] = 'relay'))?.[1]; const relay = event.tags.find((t) => (t[0] = "relay"))?.[1];
if (relay) await this.app.pool.authenticate(relay, event); if (relay) await this.app.pool.authenticate(relay, event);
} }
default: default:

26
src/modules/control/report-actions.ts
View File

@@ -1,18 +1,18 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { ReportArguments } from '@satellite-earth/core/types'; import { ReportArguments } from "@satellite-earth/core/types";
import { ReportsMessage } from '@satellite-earth/core/types/control-api/reports.js'; import { ReportsMessage } from "@satellite-earth/core/types/control-api/reports.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
import Report from '../reports/report.js'; import Report from "../reports/report.js";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
import REPORT_CLASSES from '../reports/reports/index.js'; import REPORT_CLASSES from "../reports/reports/index.js";
/** handles ['CONTROL', 'REPORT', ...] messages */ /** handles ['CONTROL', 'REPORT', ...] messages */
export default class ReportActions implements ControlMessageHandler { export default class ReportActions implements ControlMessageHandler {
app: App; app: App;
name = 'REPORT'; name = "REPORT";
log = logger.extend('ReportActions'); log = logger.extend("ReportActions");
types: { types: {
[k in keyof ReportArguments]?: typeof Report<k>; [k in keyof ReportArguments]?: typeof Report<k>;
@@ -48,7 +48,7 @@ export default class ReportActions implements ControlMessageHandler {
async handleMessage(sock: WebSocket | NodeJS.Process, message: ReportsMessage) { async handleMessage(sock: WebSocket | NodeJS.Process, message: ReportsMessage) {
const method = message[2]; const method = message[2];
switch (method) { switch (method) {
case 'SUBSCRIBE': { case "SUBSCRIBE": {
const reports = this.getReportsForSocket(sock); const reports = this.getReportsForSocket(sock);
const id = message[3]; const id = message[3];
const type = message[4]; const type = message[4];
@@ -57,7 +57,7 @@ export default class ReportActions implements ControlMessageHandler {
let report = reports.get(id) as Report<typeof type> | undefined; let report = reports.get(id) as Report<typeof type> | undefined;
if (!report) { if (!report) {
const ReportClass = this.types[type]; const ReportClass = this.types[type];
if (!ReportClass) throw new Error('Missing class for report type: ' + type); if (!ReportClass) throw new Error("Missing class for report type: " + type);
this.log(`Creating ${type} ${id} report with args`, JSON.stringify(args)); this.log(`Creating ${type} ${id} report with args`, JSON.stringify(args));
@@ -68,7 +68,7 @@ export default class ReportActions implements ControlMessageHandler {
await report.run(args); await report.run(args);
return true; return true;
} }
case 'CLOSE': { case "CLOSE": {
const reports = this.getReportsForSocket(sock); const reports = this.getReportsForSocket(sock);
const id = message[3]; const id = message[3];
const report = reports.get(id); const report = reports.get(id);

18
src/modules/control/scrapper-actions.ts
View File

@@ -1,12 +1,12 @@
import { WebSocket } from 'ws'; import { WebSocket } from "ws";
import { ScrapperMessage } from '@satellite-earth/core/types/control-api/scrapper.js'; import { ScrapperMessage } from "@satellite-earth/core/types/control-api/scrapper.js";
import type App from '../../app/index.js'; import type App from "../../app/index.js";
import { type ControlMessageHandler } from './control-api.js'; import { type ControlMessageHandler } from "./control-api.js";
export default class ScrapperActions implements ControlMessageHandler { export default class ScrapperActions implements ControlMessageHandler {
app: App; app: App;
name = 'SCRAPPER'; name = "SCRAPPER";
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -14,19 +14,19 @@ export default class ScrapperActions implements ControlMessageHandler {
handleMessage(sock: WebSocket | NodeJS.Process, message: ScrapperMessage): boolean { handleMessage(sock: WebSocket | NodeJS.Process, message: ScrapperMessage): boolean {
const action = message[2]; const action = message[2];
switch (action) { switch (action) {
case 'START': case "START":
this.app.scrapper.start(); this.app.scrapper.start();
return true; return true;
case 'STOP': case "STOP":
this.app.scrapper.stop(); this.app.scrapper.stop();
return true; return true;
case 'ADD-PUBKEY': case "ADD-PUBKEY":
this.app.scrapper.addPubkey(message[3]); this.app.scrapper.addPubkey(message[3]);
return true; return true;
case 'REMOVE-PUBKEY': case "REMOVE-PUBKEY":
this.app.scrapper.removePubkey(message[3]); this.app.scrapper.removePubkey(message[3]);
return true; return true;

34
src/modules/decryption-cache/decryption-cache.ts
View File

@@ -1,13 +1,13 @@
import { mapParams } from '@satellite-earth/core/helpers/sql.js'; import { mapParams } from "@satellite-earth/core/helpers/sql.js";
import { MigrationSet } from '@satellite-earth/core/sqlite'; import { MigrationSet } from "@satellite-earth/core/sqlite";
import { type Database } from 'better-sqlite3'; import { type Database } from "better-sqlite3";
import { EventEmitter } from 'events'; import { EventEmitter } from "events";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
import { EventRow, parseEventRow } from '@satellite-earth/core/sqlite-event-store'; import { EventRow, parseEventRow } from "@satellite-earth/core/sqlite-event-store";
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
const migrations = new MigrationSet('decryption-cache'); const migrations = new MigrationSet("decryption-cache");
// Version 1 // Version 1
migrations.addScript(1, async (db, log) => { migrations.addScript(1, async (db, log) => {
@@ -59,7 +59,7 @@ type EventMap = {
export default class DecryptionCache extends EventEmitter<EventMap> { export default class DecryptionCache extends EventEmitter<EventMap> {
database: Database; database: Database;
log = logger.extend('DecryptionCache'); log = logger.extend("DecryptionCache");
constructor(database: Database) { constructor(database: Database) {
super(); super();
@@ -79,7 +79,7 @@ export default class DecryptionCache extends EventEmitter<EventMap> {
if (result.changes > 0) { if (result.changes > 0) {
this.log(`Saved content for ${id}`); this.log(`Saved content for ${id}`);
this.emit('cache', id, plaintext); this.emit("cache", id, plaintext);
} }
} }
@@ -95,7 +95,7 @@ export default class DecryptionCache extends EventEmitter<EventMap> {
async search( async search(
search: string, search: string,
filter?: { conversation?: [string, string]; order?: 'rank' | 'created_at' }, filter?: { conversation?: [string, string]; order?: "rank" | "created_at" },
): Promise<{ event: NostrEvent; plaintext: string }[]> { ): Promise<{ event: NostrEvent; plaintext: string }[]> {
const params: any[] = []; const params: any[] = [];
const andConditions: string[] = []; const andConditions: string[] = [];
@@ -104,7 +104,7 @@ export default class DecryptionCache extends EventEmitter<EventMap> {
INNER JOIN decryption_cache ON decryption_cache_fts.rowid = decryption_cache.rowid INNER JOIN decryption_cache ON decryption_cache_fts.rowid = decryption_cache.rowid
INNER JOIN events ON decryption_cache.event = events.id`; INNER JOIN events ON decryption_cache.event = events.id`;
andConditions.push('decryption_cache_fts MATCH ?'); andConditions.push("decryption_cache_fts MATCH ?");
params.push(search); params.push(search);
// filter down by authors // filter down by authors
@@ -115,17 +115,17 @@ export default class DecryptionCache extends EventEmitter<EventMap> {
} }
if (andConditions.length > 0) { if (andConditions.length > 0) {
sql += ` WHERE ${andConditions.join(' AND ')}`; sql += ` WHERE ${andConditions.join(" AND ")}`;
} }
switch (filter?.order) { switch (filter?.order) {
case 'rank': case "rank":
sql += ' ORDER BY rank'; sql += " ORDER BY rank";
break; break;
case 'created_at': case "created_at":
default: default:
sql += ' ORDER BY events.created_at DESC'; sql += " ORDER BY events.created_at DESC";
break; break;
} }

45
src/modules/direct-message-manager.ts
View File

@@ -1,12 +1,13 @@
import { NostrEvent, kinds } from 'nostr-tools'; import { NostrEvent, kinds } from "nostr-tools";
import { SubCloser } from 'nostr-tools/abstract-pool'; import { SubCloser } from "nostr-tools/abstract-pool";
import { Subscription } from 'nostr-tools/abstract-relay'; import { Subscription } from "nostr-tools/abstract-relay";
import { EventEmitter } from 'events'; import { getInboxes } from "applesauce-core/helpers";
import { EventEmitter } from "events";
import { getInboxes } from '@satellite-earth/core/helpers/nostr/mailboxes.js'; import { getRelaysFromContactList } from "@satellite-earth/core/helpers/nostr/contacts.js";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import type App from '../app/index.js'; import type App from "../app/index.js";
import { getRelaysFromContactList } from '@satellite-earth/core/helpers/nostr/contacts.js'; import { arrayFallback } from "../helpers/array.js";
type EventMap = { type EventMap = {
open: [string, string]; open: [string, string];
@@ -16,7 +17,7 @@ type EventMap = {
/** handles sending and receiving direct messages */ /** handles sending and receiving direct messages */
export default class DirectMessageManager extends EventEmitter<EventMap> { export default class DirectMessageManager extends EventEmitter<EventMap> {
log = logger.extend('DirectMessageManager'); log = logger.extend("DirectMessageManager");
app: App; app: App;
private explicitRelays: string[] = []; private explicitRelays: string[] = [];
@@ -27,14 +28,14 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
// Load profiles for participants when // Load profiles for participants when
// a conversation thread is opened // a conversation thread is opened
this.on('open', (a, b) => { this.on("open", (a, b) => {
this.app.profileBook.loadProfile(a, this.app.addressBook.getOutboxes(a)); this.app.profileBook.loadProfile(a, this.app.addressBook.getOutboxes(a));
this.app.profileBook.loadProfile(b, this.app.addressBook.getOutboxes(b)); this.app.profileBook.loadProfile(b, this.app.addressBook.getOutboxes(b));
}); });
// emit a "message" event when a new kind4 message is detected // emit a "message" event when a new kind4 message is detected
this.app.eventStore.on('event:inserted', (event) => { this.app.eventStore.on("event:inserted", (event) => {
if (event.kind === kinds.EncryptedDirectMessage) this.emit('message', event); if (event.kind === kinds.EncryptedDirectMessage) this.emit("message", event);
}); });
} }
@@ -42,7 +43,7 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
async forwardMessage(event: NostrEvent) { async forwardMessage(event: NostrEvent) {
if (event.kind !== kinds.EncryptedDirectMessage) return; if (event.kind !== kinds.EncryptedDirectMessage) return;
const addressedTo = event.tags.find((t) => t[0] === 'p')?.[1]; const addressedTo = event.tags.find((t) => t[0] === "p")?.[1];
if (!addressedTo) return; if (!addressedTo) return;
// get users inboxes // get users inboxes
@@ -70,8 +71,8 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
} }
private getConversationKey(a: string, b: string) { private getConversationKey(a: string, b: string) {
if (a < b) return a + ':' + b; if (a < b) return a + ":" + b;
else return b + ':' + a; else return b + ":" + a;
} }
watching = new Map<string, Map<string, Subscription>>(); watching = new Map<string, Map<string, Subscription>>();
@@ -85,13 +86,13 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
return; return;
} }
const relays = getInboxes(mailboxes, this.explicitRelays); const relays = arrayFallback(getInboxes(mailboxes), this.explicitRelays);
const subscriptions = new Map<string, Subscription>(); const subscriptions = new Map<string, Subscription>();
for (const url of relays) { for (const url of relays) {
const subscribe = async () => { const subscribe = async () => {
const relay = await this.app.pool.ensureRelay(url); const relay = await this.app.pool.ensureRelay(url);
const sub = relay.subscribe([{ kinds: [kinds.EncryptedDirectMessage], '#p': [pubkey] }], { const sub = relay.subscribe([{ kinds: [kinds.EncryptedDirectMessage], "#p": [pubkey] }], {
onevent: (event) => { onevent: (event) => {
this.app.eventStore.addEvent(event); this.app.eventStore.addEvent(event);
}, },
@@ -132,15 +133,15 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
// If inboxes for either user cannot be determined, either because nip65 // If inboxes for either user cannot be determined, either because nip65
// was not found, or nip65 had no listed read relays, fall back to explicit // was not found, or nip65 had no listed read relays, fall back to explicit
const aInboxes = aMailboxes ? getInboxes(aMailboxes, this.explicitRelays) : this.explicitRelays; const aInboxes = aMailboxes ? arrayFallback(getInboxes(aMailboxes), this.explicitRelays) : this.explicitRelays;
const bInboxes = bMailboxes ? getInboxes(bMailboxes, this.explicitRelays) : this.explicitRelays; const bInboxes = bMailboxes ? arrayFallback(getInboxes(bMailboxes), this.explicitRelays) : this.explicitRelays;
const relays = new Set([...aInboxes, ...bInboxes]); const relays = new Set([...aInboxes, ...bInboxes]);
let events = 0; let events = 0;
const sub = this.app.pool.subscribeMany( const sub = this.app.pool.subscribeMany(
Array.from(relays), Array.from(relays),
[{ kinds: [kinds.EncryptedDirectMessage], authors: [a, b], '#p': [a, b] }], [{ kinds: [kinds.EncryptedDirectMessage], authors: [a, b], "#p": [a, b] }],
{ {
onevent: (event) => { onevent: (event) => {
events += +this.app.eventStore.addEvent(event); events += +this.app.eventStore.addEvent(event);
@@ -153,7 +154,7 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
this.log(`Opened conversation ${key} on ${relays.size} relays`); this.log(`Opened conversation ${key} on ${relays.size} relays`);
this.subscriptions.set(key, sub); this.subscriptions.set(key, sub);
this.emit('open', a, b); this.emit("open", a, b);
} }
closeConversation(a: string, b: string) { closeConversation(a: string, b: string) {
const key = this.getConversationKey(a, b); const key = this.getConversationKey(a, b);
@@ -162,7 +163,7 @@ export default class DirectMessageManager extends EventEmitter<EventMap> {
if (sub) { if (sub) {
sub.close(); sub.close();
this.subscriptions.delete(key); this.subscriptions.delete(key);
this.emit('close', a, b); this.emit("close", a, b);
} }
} }
} }

50
src/modules/gossip.ts
View File

@@ -1,29 +1,29 @@
import { SimpleSigner } from 'applesauce-signer/signers/simple-signer'; import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
import { EventTemplate, SimplePool } from 'nostr-tools'; import { EventTemplate, SimplePool } from "nostr-tools";
import { getTagValue } from 'applesauce-core/helpers'; import { getTagValue } from "applesauce-core/helpers";
import { IEventStore, NostrRelay } from '@satellite-earth/core'; import { IEventStore, NostrRelay } from "@satellite-earth/core";
import dayjs, { Dayjs } from 'dayjs'; import dayjs, { Dayjs } from "dayjs";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import InboundNetworkManager from './network/inbound/index.js'; import InboundNetworkManager from "./network/inbound/index.js";
function buildGossipTemplate(self: string, address: string, network: string): EventTemplate { function buildGossipTemplate(self: string, address: string, network: string): EventTemplate {
return { return {
kind: 30166, kind: 30166,
content: '', content: "",
tags: [ tags: [
['d', address], ["d", address],
['n', network], ["n", network],
['p', self], ["p", self],
['T', 'PrivateInbox'], ["T", "PrivateInbox"],
...NostrRelay.SUPPORTED_NIPS.map((nip) => ['N', String(nip)]), ...NostrRelay.SUPPORTED_NIPS.map((nip) => ["N", String(nip)]),
], ],
created_at: dayjs().unix(), created_at: dayjs().unix(),
}; };
} }
export default class Gossip { export default class Gossip {
log = logger.extend('Gossip'); log = logger.extend("Gossip");
network: InboundNetworkManager; network: InboundNetworkManager;
signer: SimpleSigner; signer: SimpleSigner;
pool: SimplePool; pool: SimplePool;
@@ -55,26 +55,26 @@ export default class Gossip {
if (this.broadcastRelays.length === 0) return; if (this.broadcastRelays.length === 0) return;
if (this.network.hyper.available && this.network.hyper.address) { if (this.network.hyper.available && this.network.hyper.address) {
this.log('Publishing hyper gossip'); this.log("Publishing hyper gossip");
await this.pool.publish( await this.pool.publish(
this.broadcastRelays, this.broadcastRelays,
await this.signer.signEvent(buildGossipTemplate(pubkey, this.network.hyper.address, 'hyper')), await this.signer.signEvent(buildGossipTemplate(pubkey, this.network.hyper.address, "hyper")),
); );
} }
if (this.network.tor.available && this.network.tor.address) { if (this.network.tor.available && this.network.tor.address) {
this.log('Publishing tor gossip'); this.log("Publishing tor gossip");
await this.pool.publish( await this.pool.publish(
this.broadcastRelays, this.broadcastRelays,
await this.signer.signEvent(buildGossipTemplate(pubkey, this.network.tor.address, 'tor')), await this.signer.signEvent(buildGossipTemplate(pubkey, this.network.tor.address, "tor")),
); );
} }
if (this.network.i2p.available && this.network.i2p.address) { if (this.network.i2p.available && this.network.i2p.address) {
this.log('Publishing i2p gossip'); this.log("Publishing i2p gossip");
await this.pool.publish( await this.pool.publish(
this.broadcastRelays, this.broadcastRelays,
await this.signer.signEvent(buildGossipTemplate(pubkey, this.network.i2p.address, 'i2p')), await this.signer.signEvent(buildGossipTemplate(pubkey, this.network.i2p.address, "i2p")),
); );
} }
} }
@@ -90,12 +90,12 @@ export default class Gossip {
if (this.running) return; if (this.running) return;
this.running = true; this.running = true;
this.log(`Starting gossip on ${this.broadcastRelays.join(', ')}`); this.log(`Starting gossip on ${this.broadcastRelays.join(", ")}`);
setTimeout(this.update.bind(this), 5000); setTimeout(this.update.bind(this), 5000);
} }
stop() { stop() {
this.log('Stopping gossip'); this.log("Stopping gossip");
this.running = false; this.running = false;
} }
@@ -103,12 +103,12 @@ export default class Gossip {
async lookup(pubkey: string) { async lookup(pubkey: string) {
const last = this.lookups.get(pubkey); const last = this.lookups.get(pubkey);
const filter = { authors: [pubkey], '#p': [pubkey], kinds: [30166] }; const filter = { authors: [pubkey], "#p": [pubkey], kinds: [30166] };
// no cache or expired // no cache or expired
if (last === undefined || !last.isAfter(dayjs())) { if (last === undefined || !last.isAfter(dayjs())) {
await new Promise<void>((res) => { await new Promise<void>((res) => {
this.lookups.set(pubkey, dayjs().add(1, 'hour')); this.lookups.set(pubkey, dayjs().add(1, "hour"));
const sub = this.pool.subscribeMany(this.broadcastRelays, [filter], { const sub = this.pool.subscribeMany(this.broadcastRelays, [filter], {
onevent: (event) => this.eventStore.addEvent(event), onevent: (event) => this.eventStore.addEvent(event),
@@ -124,7 +124,7 @@ export default class Gossip {
const addresses: string[] = []; const addresses: string[] = [];
for (const event of events) { for (const event of events) {
const url = getTagValue(event, 'd'); const url = getTagValue(event, "d");
if (url) addresses.push(url); if (url) addresses.push(url);
} }
return addresses; return addresses;

6
src/modules/graph/index.ts
View File

@@ -1,5 +1,5 @@
import { NostrEvent, kinds } from 'nostr-tools'; import { NostrEvent, kinds } from "nostr-tools";
import App from '../../app/index.js'; import App from "../../app/index.js";
export type Node = { p: string; z: number; n: number }; export type Node = { p: string; z: number; n: number };
@@ -31,7 +31,7 @@ export default class Graph {
// Add or overwrite an existing (older) contacts list // Add or overwrite an existing (older) contacts list
if (!existing || existing.created_at < event.created_at) { if (!existing || existing.created_at < event.created_at) {
const following = new Set(event.tags.filter((tag) => tag[0] === 'p').map((tag) => tag[1])); const following = new Set(event.tags.filter((tag) => tag[0] === "p").map((tag) => tag[1]));
this.contacts[event.pubkey] = { this.contacts[event.pubkey] = {
created_at: event.created_at, created_at: event.created_at,

22
src/modules/hyper-connection-manager.ts
View File

@@ -1,7 +1,7 @@
import net from 'net'; import net from "net";
import HyperDHT from 'hyperdht'; import HyperDHT from "hyperdht";
import { pipeline } from 'streamx'; import { pipeline } from "streamx";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
const START_PORT = 25100; const START_PORT = 25100;
@@ -15,26 +15,26 @@ export class HyperConnectionManager {
constructor(privateKey: string) { constructor(privateKey: string) {
this.node = new HyperDHT({ this.node = new HyperDHT({
keyPair: HyperDHT.keyPair(Buffer.from(privateKey, 'hex')), keyPair: HyperDHT.keyPair(Buffer.from(privateKey, "hex")),
}); });
} }
protected bind(pubkey: string) { protected bind(pubkey: string) {
return new Promise<net.Server>((res) => { return new Promise<net.Server>((res) => {
const proxy = net.createServer({ allowHalfOpen: true }, (socket_) => { const proxy = net.createServer({ allowHalfOpen: true }, (socket_) => {
const socket = this.node.connect(Buffer.from(pubkey, 'hex'), { const socket = this.node.connect(Buffer.from(pubkey, "hex"), {
reusableSocket: true, reusableSocket: true,
}); });
// @ts-expect-error // @ts-expect-error
socket.setKeepAlive(5000); socket.setKeepAlive(5000);
socket.on('open', () => { socket.on("open", () => {
// connect the sockets // connect the sockets
pipeline(socket_, socket, socket_); pipeline(socket_, socket, socket_);
}); });
socket.on('error', (error) => { socket.on("error", (error) => {
this.log('Failed to connect to', pubkey); this.log("Failed to connect to", pubkey);
this.log(error); this.log(error);
}); });
}); });
@@ -42,8 +42,8 @@ export class HyperConnectionManager {
this.servers.set(pubkey, proxy); this.servers.set(pubkey, proxy);
const port = this.lastPort++; const port = this.lastPort++;
proxy.listen(port, '127.0.0.1', () => { proxy.listen(port, "127.0.0.1", () => {
this.log('Bound hyper address', pubkey, 'to port:', port); this.log("Bound hyper address", pubkey, "to port:", port);
res(proxy); res(proxy);
}); });
}); });

24
src/modules/labeled-event-store.ts
View File

@@ -1,14 +1,14 @@
import { Database } from 'better-sqlite3'; import { Database } from "better-sqlite3";
import { Filter, NostrEvent } from 'nostr-tools'; import { Filter, NostrEvent } from "nostr-tools";
import { IEventStore, SQLiteEventStore } from '@satellite-earth/core'; import { IEventStore, SQLiteEventStore } from "@satellite-earth/core";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import { MigrationSet } from '@satellite-earth/core/sqlite'; import { MigrationSet } from "@satellite-earth/core/sqlite";
export function mapParams(params: any[]) { export function mapParams(params: any[]) {
return `(${params.map(() => `?`).join(', ')})`; return `(${params.map(() => `?`).join(", ")})`;
} }
const migrations = new MigrationSet('labeled-event-store'); const migrations = new MigrationSet("labeled-event-store");
// Version 1 // Version 1
migrations.addScript(1, async (db, log) => { migrations.addScript(1, async (db, log) => {
@@ -22,8 +22,8 @@ migrations.addScript(1, async (db, log) => {
`, `,
).run(); ).run();
db.prepare('CREATE INDEX IF NOT EXISTS event_labels_label ON event_labels(label)').run(); db.prepare("CREATE INDEX IF NOT EXISTS event_labels_label ON event_labels(label)").run();
db.prepare('CREATE INDEX IF NOT EXISTS event_labels_event ON event_labels(event)').run(); db.prepare("CREATE INDEX IF NOT EXISTS event_labels_event ON event_labels(event)").run();
}); });
/** An event store that is can only see a subset of events int the database */ /** An event store that is can only see a subset of events int the database */
@@ -47,8 +47,8 @@ export class LabeledEventStore extends SQLiteEventStore implements IEventStore {
const parts = super.buildConditionsForFilters(filter); const parts = super.buildConditionsForFilters(filter);
if (!this.readAll) { if (!this.readAll) {
parts.joins.push('INNER JOIN event_labels ON events.id = event_labels.event'); parts.joins.push("INNER JOIN event_labels ON events.id = event_labels.event");
parts.conditions.push('event_labels.label = ?'); parts.conditions.push("event_labels.label = ?");
parts.parameters.push(this.label); parts.parameters.push(this.label);
return parts; return parts;
} }
@@ -60,7 +60,7 @@ export class LabeledEventStore extends SQLiteEventStore implements IEventStore {
const inserted = super.addEvent(event); const inserted = super.addEvent(event);
const hasLabel = !!this.db const hasLabel = !!this.db
.prepare('SELECT * FROM event_labels WHERE event = ? AND label = ?') .prepare("SELECT * FROM event_labels WHERE event = ? AND label = ?")
.get(event.id, this.label); .get(event.id, this.label);
if (!hasLabel) this.db.prepare(`INSERT INTO event_labels (event, label) VALUES (?, ?)`).run(event.id, this.label); if (!hasLabel) this.db.prepare(`INSERT INTO event_labels (event, label) VALUES (?, ?)`).run(event.id, this.label);

40
src/modules/log-store/log-store.ts
View File

@@ -1,10 +1,10 @@
import { type Database as SQLDatabase } from 'better-sqlite3'; import { type Database as SQLDatabase } from "better-sqlite3";
import { MigrationSet } from '@satellite-earth/core/sqlite'; import { MigrationSet } from "@satellite-earth/core/sqlite";
import EventEmitter from 'events'; import EventEmitter from "events";
import { nanoid } from 'nanoid'; import { nanoid } from "nanoid";
import { Debugger } from 'debug'; import { Debugger } from "debug";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
type EventMap = { type EventMap = {
log: [LogEntry]; log: [LogEntry];
@@ -21,7 +21,7 @@ export type DatabaseLogEntry = LogEntry & {
id: number | bigint; id: number | bigint;
}; };
const migrations = new MigrationSet('log-store'); const migrations = new MigrationSet("log-store");
// version 1 // version 1
migrations.addScript(1, async (db, log) => { migrations.addScript(1, async (db, log) => {
@@ -36,10 +36,10 @@ migrations.addScript(1, async (db, log) => {
); );
`, `,
).run(); ).run();
log('Created logs table'); log("Created logs table");
db.prepare('CREATE INDEX IF NOT EXISTS logs_service ON logs(service)'); db.prepare("CREATE INDEX IF NOT EXISTS logs_service ON logs(service)");
log('Created logs service index'); log("Created logs service index");
}); });
export default class LogStore extends EventEmitter<EventMap> { export default class LogStore extends EventEmitter<EventMap> {
@@ -66,7 +66,7 @@ export default class LogStore extends EventEmitter<EventMap> {
}; };
this.queue.push(entry); this.queue.push(entry);
this.emit('log', entry); this.emit("log", entry);
if (!this.running) this.write(); if (!this.running) this.write();
} }
@@ -121,17 +121,17 @@ export default class LogStore extends EventEmitter<EventMap> {
parameters.push(filter?.service); parameters.push(filter?.service);
} }
if (filter?.since) { if (filter?.since) {
conditions.push('timestamp>=?'); conditions.push("timestamp>=?");
parameters.push(filter?.since); parameters.push(filter?.since);
} }
if (filter?.until) { if (filter?.until) {
conditions.push('timestamp<=?'); conditions.push("timestamp<=?");
parameters.push(filter?.until); parameters.push(filter?.until);
} }
if (conditions.length > 0) sql += ` WHERE ${conditions.join(' AND ')}`; if (conditions.length > 0) sql += ` WHERE ${conditions.join(" AND ")}`;
if (filter?.limit) { if (filter?.limit) {
sql += ' LIMIT ?'; sql += " LIMIT ?";
parameters.push(filter.limit); parameters.push(filter.limit);
} }
return this.database.prepare<any[], DatabaseLogEntry>(sql).all(...parameters); return this.database.prepare<any[], DatabaseLogEntry>(sql).all(...parameters);
@@ -144,20 +144,20 @@ export default class LogStore extends EventEmitter<EventMap> {
let sql = `DELETE FROM logs`; let sql = `DELETE FROM logs`;
if (filter?.service) { if (filter?.service) {
conditions.push('service=?'); conditions.push("service=?");
parameters.push(filter?.service); parameters.push(filter?.service);
} }
if (filter?.since) { if (filter?.since) {
conditions.push('timestamp>=?'); conditions.push("timestamp>=?");
parameters.push(filter?.since); parameters.push(filter?.since);
} }
if (filter?.until) { if (filter?.until) {
conditions.push('timestamp<=?'); conditions.push("timestamp<=?");
parameters.push(filter?.until); parameters.push(filter?.until);
} }
if (conditions.length > 0) sql += ` WHERE ${conditions.join(' AND ')}`; if (conditions.length > 0) sql += ` WHERE ${conditions.join(" AND ")}`;
this.database.prepare<any[], DatabaseLogEntry>(sql).run(...parameters); this.database.prepare<any[], DatabaseLogEntry>(sql).run(...parameters);
this.emit('clear', filter?.service); this.emit("clear", filter?.service);
} }
} }

26
src/modules/network/inbound/hyper.ts
View File

@@ -1,17 +1,17 @@
import HolesailServer from 'holesail-server'; import HolesailServer from "holesail-server";
import { encodeAddress } from 'hyper-address'; import { encodeAddress } from "hyper-address";
import { hexToBytes } from '@noble/hashes/utils'; import { hexToBytes } from "@noble/hashes/utils";
import { AddressInfo } from 'net'; import { AddressInfo } from "net";
import App from '../../../app/index.js'; import App from "../../../app/index.js";
import { InboundInterface } from '../interfaces.js'; import { InboundInterface } from "../interfaces.js";
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
/** manages a holesail-server instance that points to the app.server http server */ /** manages a holesail-server instance that points to the app.server http server */
export default class HyperInbound implements InboundInterface { export default class HyperInbound implements InboundInterface {
app: App; app: App;
hyper?: HolesailServer; hyper?: HolesailServer;
log = logger.extend('Network:Inbound:Hyper'); log = logger.extend("Network:Inbound:Hyper");
get available() { get available() {
return true; return true;
@@ -31,8 +31,8 @@ export default class HyperInbound implements InboundInterface {
this.log(`Importing and starting hyperdht node`); this.log(`Importing and starting hyperdht node`);
const { default: HolesailServer } = await import('holesail-server'); const { default: HolesailServer } = await import("holesail-server");
const { getOrCreateNode } = await import('../../../sidecars/hyperdht.js'); const { getOrCreateNode } = await import("../../../sidecars/hyperdht.js");
const hyper = (this.hyper = new HolesailServer()); const hyper = (this.hyper = new HolesailServer());
hyper.dht = getOrCreateNode(); hyper.dht = getOrCreateNode();
@@ -43,10 +43,10 @@ export default class HyperInbound implements InboundInterface {
port: address.port, port: address.port,
address: address.address, address: address.address,
secure: false, secure: false,
buffSeed: this.app.secrets.get('hyperKey'), buffSeed: this.app.secrets.get("hyperKey"),
}, },
() => { () => {
const address = 'http://' + encodeAddress(hexToBytes(hyper.getPublicKey())); const address = "http://" + encodeAddress(hexToBytes(hyper.getPublicKey()));
this.address = address; this.address = address;
this.log(`Listening on ${address}`); this.log(`Listening on ${address}`);
@@ -61,7 +61,7 @@ export default class HyperInbound implements InboundInterface {
} }
async stop() { async stop() {
this.log('Shutting down'); this.log("Shutting down");
// disabled because holesail-server destroys the hyperdht node // disabled because holesail-server destroys the hyperdht node
// this.hyper?.destroy(); // this.hyper?.destroy();
this.running = false; this.running = false;

34
src/modules/network/inbound/i2p.ts
View File

@@ -1,14 +1,14 @@
import type { AddressInfo } from 'net'; import type { AddressInfo } from "net";
import type { I2pSamStream } from '@diva.exchange/i2p-sam'; import type { I2pSamStream } from "@diva.exchange/i2p-sam";
import App from '../../../app/index.js'; import App from "../../../app/index.js";
import { I2P_SAM_ADDRESS } from '../../../env.js'; import { I2P_SAM_ADDRESS } from "../../../env.js";
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import { InboundInterface } from '../interfaces.js'; import { InboundInterface } from "../interfaces.js";
export default class I2PInbound implements InboundInterface { export default class I2PInbound implements InboundInterface {
app: App; app: App;
log = logger.extend('Network:Inbound:I2P'); log = logger.extend("Network:Inbound:I2P");
available = !!I2P_SAM_ADDRESS; available = !!I2P_SAM_ADDRESS;
running = false; running = false;
@@ -26,17 +26,17 @@ export default class I2PInbound implements InboundInterface {
if (this.running) return; if (this.running) return;
this.running = true; this.running = true;
const [host, port] = I2P_SAM_ADDRESS?.split(':') ?? []; const [host, port] = I2P_SAM_ADDRESS?.split(":") ?? [];
if (!host || !port) throw new Error(`Malformed proxy address ${I2P_SAM_ADDRESS}`); if (!host || !port) throw new Error(`Malformed proxy address ${I2P_SAM_ADDRESS}`);
this.log('Importing I2P SAM package'); this.log("Importing I2P SAM package");
const { createForward } = await import('@diva.exchange/i2p-sam'); const { createForward } = await import("@diva.exchange/i2p-sam");
// try to get the last key pair that was used // try to get the last key pair that was used
const privateKey = this.app.secrets.get('i2pPrivateKey'); const privateKey = this.app.secrets.get("i2pPrivateKey");
const publicKey = this.app.secrets.get('i2pPublicKey'); const publicKey = this.app.secrets.get("i2pPublicKey");
this.log('Creating forwarding stream'); this.log("Creating forwarding stream");
this.forward = await createForward({ this.forward = await createForward({
sam: { sam: {
host: host, host: host,
@@ -50,13 +50,13 @@ export default class I2PInbound implements InboundInterface {
}, },
}); });
this.address = 'http://' + this.forward.getB32Address(); this.address = "http://" + this.forward.getB32Address();
this.log(`Listening on ${this.address}`); this.log(`Listening on ${this.address}`);
// save the key pair for later // save the key pair for later
this.app.secrets.set('i2pPrivateKey', this.forward.getPrivateKey()); this.app.secrets.set("i2pPrivateKey", this.forward.getPrivateKey());
this.app.secrets.set('i2pPublicKey', this.forward.getPublicKey()); this.app.secrets.set("i2pPublicKey", this.forward.getPublicKey());
} catch (error) { } catch (error) {
this.running = false; this.running = false;
if (error instanceof Error) this.error = error; if (error instanceof Error) this.error = error;
@@ -68,7 +68,7 @@ export default class I2PInbound implements InboundInterface {
this.running = false; this.running = false;
if (this.forward) { if (this.forward) {
this.log('Closing forwarding stream'); this.log("Closing forwarding stream");
this.forward.close(); this.forward.close();
this.forward = undefined; this.forward = undefined;
} }

22
src/modules/network/inbound/index.ts
View File

@@ -1,15 +1,15 @@
import App from '../../../app/index.js'; import App from "../../../app/index.js";
import HyperInbound from './hyper.js'; import HyperInbound from "./hyper.js";
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import { getIPAddresses } from '../../../helpers/ip.js'; import { getIPAddresses } from "../../../helpers/ip.js";
import TorInbound from './tor.js'; import TorInbound from "./tor.js";
import ConfigManager from '../../config-manager.js'; import ConfigManager from "../../config-manager.js";
import I2PInbound from './i2p.js'; import I2PInbound from "./i2p.js";
/** manages all inbound servers on other networks: hyper, tor, i2p, etc... */ /** manages all inbound servers on other networks: hyper, tor, i2p, etc... */
export default class InboundNetworkManager { export default class InboundNetworkManager {
app: App; app: App;
log = logger.extend('Network:Inbound'); log = logger.extend("Network:Inbound");
hyper: HyperInbound; hyper: HyperInbound;
tor: TorInbound; tor: TorInbound;
i2p: I2PInbound; i2p: I2PInbound;
@@ -36,8 +36,8 @@ export default class InboundNetworkManager {
private getAddress() { private getAddress() {
const address = this.app.server.address(); const address = this.app.server.address();
if (typeof address === 'string' || address === null) if (typeof address === "string" || address === null)
throw new Error('External servers started when server does not have an address'); throw new Error("External servers started when server does not have an address");
return address; return address;
} }
@@ -62,7 +62,7 @@ export default class InboundNetworkManager {
/** A helper method to make the manager run off of the app config */ /** A helper method to make the manager run off of the app config */
listenToAppConfig(config: ConfigManager) { listenToAppConfig(config: ConfigManager) {
config.on('updated', this.update.bind(this)); config.on("updated", this.update.bind(this));
} }
start() { start() {

12
src/modules/network/inbound/tor.ts
View File

@@ -1,13 +1,13 @@
import { AddressInfo } from 'net'; import { AddressInfo } from "net";
import App from '../../../app/index.js'; import App from "../../../app/index.js";
import { TOR_ADDRESS } from '../../../env.js'; import { TOR_ADDRESS } from "../../../env.js";
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import { InboundInterface } from '../interfaces.js'; import { InboundInterface } from "../interfaces.js";
export default class TorInbound implements InboundInterface { export default class TorInbound implements InboundInterface {
app: App; app: App;
log = logger.extend('Network:Inbound:Tor'); log = logger.extend("Network:Inbound:Tor");
readonly available = !!TOR_ADDRESS; readonly available = !!TOR_ADDRESS;
readonly running = !!TOR_ADDRESS; readonly running = !!TOR_ADDRESS;

4
src/modules/network/interfaces.ts
View File

@@ -1,4 +1,4 @@
import { AddressInfo } from 'net'; import { AddressInfo } from "net";
export interface InboundInterface { export interface InboundInterface {
available: boolean; available: boolean;
@@ -15,7 +15,7 @@ export interface OutboundInterface {
running: boolean; running: boolean;
error?: Error; error?: Error;
type: 'SOCKS5' | 'HTTP'; type: "SOCKS5" | "HTTP";
address?: string; address?: string;
start(): Promise<void>; start(): Promise<void>;
stop(): Promise<void>; stop(): Promise<void>;

28
src/modules/network/outbound/hyper.ts
View File

@@ -1,9 +1,9 @@
import type { createProxy } from 'hyper-socks5-proxy'; import type { createProxy } from "hyper-socks5-proxy";
import getPort from 'get-port'; import getPort from "get-port";
import EventEmitter from 'events'; import EventEmitter from "events";
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import { OutboundInterface } from '../interfaces.js'; import { OutboundInterface } from "../interfaces.js";
type EventMap = { type EventMap = {
started: []; started: [];
@@ -11,13 +11,13 @@ type EventMap = {
}; };
export default class HyperOutbound extends EventEmitter<EventMap> implements OutboundInterface { export default class HyperOutbound extends EventEmitter<EventMap> implements OutboundInterface {
log = logger.extend('Network:Outbound:Hyper'); log = logger.extend("Network:Outbound:Hyper");
private port?: number; private port?: number;
private proxy?: ReturnType<typeof createProxy>; private proxy?: ReturnType<typeof createProxy>;
running = false; running = false;
error?: Error; error?: Error;
readonly type = 'SOCKS5'; readonly type = "SOCKS5";
address?: string; address?: string;
get available() { get available() {
return true; return true;
@@ -28,17 +28,17 @@ export default class HyperOutbound extends EventEmitter<EventMap> implements Out
this.running = true; this.running = true;
try { try {
const { createProxy } = await import('hyper-socks5-proxy'); const { createProxy } = await import("hyper-socks5-proxy");
const { getOrCreateNode } = await import('../../../sidecars/hyperdht.js'); const { getOrCreateNode } = await import("../../../sidecars/hyperdht.js");
this.port = await getPort({ port: 1080 }); this.port = await getPort({ port: 1080 });
this.proxy = createProxy({ node: await getOrCreateNode() }); this.proxy = createProxy({ node: await getOrCreateNode() });
this.log('Starting SOCKS5 proxy'); this.log("Starting SOCKS5 proxy");
this.address = `127.0.0.1:${this.port}`; this.address = `127.0.0.1:${this.port}`;
this.proxy.listen(this.port, '127.0.0.1'); this.proxy.listen(this.port, "127.0.0.1");
this.log(`Proxy listening on ${this.address}`); this.log(`Proxy listening on ${this.address}`);
this.emit('started'); this.emit("started");
} catch (error) { } catch (error) {
this.running = false; this.running = false;
if (error instanceof Error) this.error = error; if (error instanceof Error) this.error = error;
@@ -49,9 +49,9 @@ export default class HyperOutbound extends EventEmitter<EventMap> implements Out
if (!this.running) return; if (!this.running) return;
this.running = false; this.running = false;
this.log('Stopping'); this.log("Stopping");
await new Promise<void>((res) => this.proxy?.close(() => res())); await new Promise<void>((res) => this.proxy?.close(() => res()));
this.proxy = undefined; this.proxy = undefined;
this.emit('stopped'); this.emit("stopped");
} }
} }

14
src/modules/network/outbound/i2p.ts
View File

@@ -1,10 +1,10 @@
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import { OutboundInterface } from '../interfaces.js'; import { OutboundInterface } from "../interfaces.js";
import { I2P_PROXY, I2P_PROXY_TYPE } from '../../../env.js'; import { I2P_PROXY, I2P_PROXY_TYPE } from "../../../env.js";
import { testTCPConnection } from '../../../helpers/network.js'; import { testTCPConnection } from "../../../helpers/network.js";
export default class I2POutbound implements OutboundInterface { export default class I2POutbound implements OutboundInterface {
log = logger.extend('Network:Outbound:I2P'); log = logger.extend("Network:Outbound:I2P");
running = false; running = false;
error?: Error; error?: Error;
@@ -18,8 +18,8 @@ export default class I2POutbound implements OutboundInterface {
this.running = true; this.running = true;
this.log(`Connecting to ${I2P_PROXY}`); this.log(`Connecting to ${I2P_PROXY}`);
const [host, port] = this.address?.split(':') ?? []; const [host, port] = this.address?.split(":") ?? [];
if (!host || !port) throw new Error('Malformed proxy address'); if (!host || !port) throw new Error("Malformed proxy address");
await testTCPConnection(host, parseInt(port), 3000); await testTCPConnection(host, parseInt(port), 3000);
} catch (error) { } catch (error) {
this.running = false; this.running = false;

28
src/modules/network/outbound/index.ts
View File

@@ -1,14 +1,14 @@
import { PacProxyAgent } from 'pac-proxy-agent'; import { PacProxyAgent } from "pac-proxy-agent";
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import ConfigManager from '../../config-manager.js'; import ConfigManager from "../../config-manager.js";
import HyperOutbound from './hyper.js'; import HyperOutbound from "./hyper.js";
import TorOutbound from './tor.js'; import TorOutbound from "./tor.js";
import I2POutbound from './i2p.js'; import I2POutbound from "./i2p.js";
export class OutboundNetworkManager { export class OutboundNetworkManager {
log = logger.extend('Network:Outbound'); log = logger.extend("Network:Outbound");
hyper: HyperOutbound; hyper: HyperOutbound;
tor: TorOutbound; tor: TorOutbound;
i2p: I2POutbound; i2p: I2POutbound;
@@ -68,7 +68,7 @@ if (shExpMatch(host, "*.hyper"))
if (this.routeAllTrafficThroughTor && this.tor.available) { if (this.routeAllTrafficThroughTor && this.tor.available) {
// if tor is available, route all traffic through it // if tor is available, route all traffic through it
statements.push(`${this.tor.type} ${this.tor.address}`); statements.push(`${this.tor.type} ${this.tor.address}`);
this.log('Routing all traffic through tor proxy'); this.log("Routing all traffic through tor proxy");
} else { } else {
statements.push('return "DIRECT";'); statements.push('return "DIRECT";');
} }
@@ -78,17 +78,17 @@ if (shExpMatch(host, "*.hyper"))
function FindProxyForURL(url, host) function FindProxyForURL(url, host)
{ {
${statements.join('\n')} ${statements.join("\n")}
} }
`.trim(); `.trim();
return 'pac+data:application/x-ns-proxy-autoconfig;base64,' + btoa(PACFile); return "pac+data:application/x-ns-proxy-autoconfig;base64," + btoa(PACFile);
} }
updateAgent(uri = this.buildPacURI()) { updateAgent(uri = this.buildPacURI()) {
this.log('Updating PAC proxy agent'); this.log("Updating PAC proxy agent");
// copied from https://github.com/TooTallNate/proxy-agents/blob/main/packages/pac-proxy-agent/src/index.ts#L79C22-L79C51 // copied from https://github.com/TooTallNate/proxy-agents/blob/main/packages/pac-proxy-agent/src/index.ts#L79C22-L79C51
this.agent.uri = new URL(uri.replace(/^pac\+/i, '')); this.agent.uri = new URL(uri.replace(/^pac\+/i, ""));
// forces the agent to refetch the resolver and pac file // forces the agent to refetch the resolver and pac file
this.agent.resolverPromise = undefined; this.agent.resolverPromise = undefined;
@@ -98,7 +98,7 @@ function FindProxyForURL(url, host)
/** A helper method to make the manager run off of the app config */ /** A helper method to make the manager run off of the app config */
listenToAppConfig(config: ConfigManager) { listenToAppConfig(config: ConfigManager) {
config.on('updated', (c) => { config.on("updated", (c) => {
this.enableHyperConnections = c.hyperEnabled && c.enableHyperConnections; this.enableHyperConnections = c.hyperEnabled && c.enableHyperConnections;
this.enableTorConnections = c.enableTorConnections; this.enableTorConnections = c.enableTorConnections;
this.enableI2PConnections = c.enableI2PConnections; this.enableI2PConnections = c.enableI2PConnections;

14
src/modules/network/outbound/tor.ts
View File

@@ -1,10 +1,10 @@
import { logger } from '../../../logger.js'; import { logger } from "../../../logger.js";
import { OutboundInterface } from '../interfaces.js'; import { OutboundInterface } from "../interfaces.js";
import { TOR_PROXY, TOR_PROXY_TYPE } from '../../../env.js'; import { TOR_PROXY, TOR_PROXY_TYPE } from "../../../env.js";
import { testTCPConnection } from '../../../helpers/network.js'; import { testTCPConnection } from "../../../helpers/network.js";
export default class TorOutbound implements OutboundInterface { export default class TorOutbound implements OutboundInterface {
log = logger.extend('Network:Outbound:Tor'); log = logger.extend("Network:Outbound:Tor");
running = false; running = false;
error?: Error; error?: Error;
@@ -18,8 +18,8 @@ export default class TorOutbound implements OutboundInterface {
this.running = true; this.running = true;
this.log(`Connecting to ${TOR_PROXY}`); this.log(`Connecting to ${TOR_PROXY}`);
const [host, port] = this.address?.split(':') ?? []; const [host, port] = this.address?.split(":") ?? [];
if (!host || !port) throw new Error('Malformed proxy address'); if (!host || !port) throw new Error("Malformed proxy address");
await testTCPConnection(host, parseInt(port), 3000); await testTCPConnection(host, parseInt(port), 3000);
} catch (error) { } catch (error) {
this.running = false; this.running = false;

6
src/modules/network/outbound/websocket.ts
View File

@@ -1,7 +1,7 @@
import { ClientRequestArgs } from 'http'; import { ClientRequestArgs } from "http";
import { ClientOptions, WebSocket } from 'ws'; import { ClientOptions, WebSocket } from "ws";
import outboundNetwork from './index.js'; import outboundNetwork from "./index.js";
/** extends the WebSocket class from ws to always use the custom http agent */ /** extends the WebSocket class from ws to always use the custom http agent */
export default class OutboundProxyWebSocket extends WebSocket { export default class OutboundProxyWebSocket extends WebSocket {

40
src/modules/notifications/notifications-manager.ts
View File

@@ -1,13 +1,13 @@
import { NotificationChannel, WebPushNotification } from '@satellite-earth/core/types/control-api/notifications.js'; import { NotificationChannel, WebPushNotification } from "@satellite-earth/core/types/control-api/notifications.js";
import { getDMRecipient, getDMSender, getUserDisplayName, parseKind0Event } from '@satellite-earth/core/helpers/nostr'; import { getDMRecipient, getDMSender, getUserDisplayName, parseKind0Event } from "@satellite-earth/core/helpers/nostr";
import { NostrEvent, kinds } from 'nostr-tools'; import { NostrEvent, kinds } from "nostr-tools";
import { npubEncode } from 'nostr-tools/nip19'; import { npubEncode } from "nostr-tools/nip19";
import EventEmitter from 'events'; import EventEmitter from "events";
import webPush from 'web-push'; import webPush from "web-push";
import dayjs from 'dayjs'; import dayjs from "dayjs";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
import App from '../../app/index.js'; import App from "../../app/index.js";
export type NotificationsManagerState = { export type NotificationsManagerState = {
channels: NotificationChannel[]; channels: NotificationChannel[];
@@ -20,7 +20,7 @@ type EventMap = {
}; };
export default class NotificationsManager extends EventEmitter<EventMap> { export default class NotificationsManager extends EventEmitter<EventMap> {
log = logger.extend('Notifications'); log = logger.extend("Notifications");
app: App; app: App;
lastRead: number = dayjs().unix(); lastRead: number = dayjs().unix();
@@ -39,7 +39,7 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
async setup() { async setup() {
this.state = ( this.state = (
await this.app.state.getMutableState<NotificationsManagerState>('notification-manager', { channels: [] }) await this.app.state.getMutableState<NotificationsManagerState>("notification-manager", { channels: [] })
).proxy; ).proxy;
} }
@@ -51,12 +51,12 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
if (c.id === channel.id) return channel; if (c.id === channel.id) return channel;
else return c; else return c;
}); });
this.emit('updateChannel', channel); this.emit("updateChannel", channel);
} else { } else {
// add channel // add channel
this.log(`Added new channel ${channel.id} (${channel.type})`); this.log(`Added new channel ${channel.id} (${channel.type})`);
this.state.channels = [...this.state.channels, channel]; this.state.channels = [...this.state.channels, channel];
this.emit('addChannel', channel); this.emit("addChannel", channel);
} }
} }
removeChannel(id: string) { removeChannel(id: string) {
@@ -64,7 +64,7 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
if (channel) { if (channel) {
this.log(`Removed channel ${id}`); this.log(`Removed channel ${id}`);
this.state.channels = this.state.channels.filter((s) => s.id !== id); this.state.channels = this.state.channels.filter((s) => s.id !== id);
this.emit('removeChannel', channel); this.emit("removeChannel", channel);
} }
} }
@@ -92,8 +92,8 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
senderName, senderName,
senderProfile, senderProfile,
title: `Message from ${senderName}`, title: `Message from ${senderName}`,
body: 'Tap on notification to read', body: "Tap on notification to read",
icon: 'https://app.satellite.earth/logo-64x64.png', icon: "https://app.satellite.earth/logo-64x64.png",
// TODO: switch this to a satellite:// link once the native app supports it // TODO: switch this to a satellite:// link once the native app supports it
url: `https://app.satellite.earth/messages/p/${npubEncode(sender)}`, url: `https://app.satellite.earth/messages/p/${npubEncode(sender)}`,
}; };
@@ -110,7 +110,7 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
this.log(`Sending notification "${notification.title}" to ${channel.id} (${channel.type})`); this.log(`Sending notification "${notification.title}" to ${channel.id} (${channel.type})`);
try { try {
switch (channel.type) { switch (channel.type) {
case 'web': case "web":
const pushNotification: WebPushNotification = { const pushNotification: WebPushNotification = {
title: notification.title, title: notification.title,
body: notification.body, body: notification.body,
@@ -121,14 +121,14 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
await webPush.sendNotification(channel, JSON.stringify(pushNotification), { await webPush.sendNotification(channel, JSON.stringify(pushNotification), {
vapidDetails: { vapidDetails: {
subject: 'mailto:admin@example.com', subject: "mailto:admin@example.com",
publicKey: this.webPushKeys.publicKey, publicKey: this.webPushKeys.publicKey,
privateKey: this.webPushKeys.privateKey, privateKey: this.webPushKeys.privateKey,
}, },
}); });
break; break;
case 'ntfy': case "ntfy":
const headers: HeadersInit = { const headers: HeadersInit = {
Title: notification.title, Title: notification.title,
Icon: notification.icon, Icon: notification.icon,
@@ -136,7 +136,7 @@ export default class NotificationsManager extends EventEmitter<EventMap> {
}; };
await fetch(new URL(channel.topic, channel.server), { await fetch(new URL(channel.topic, channel.server), {
method: 'POST', method: "POST",
body: notification.body, body: notification.body,
headers, headers,
}).then((res) => res.text()); }).then((res) => res.text());

18
src/modules/profile-book.ts
View File

@@ -1,14 +1,14 @@
import { NostrEvent, kinds } from 'nostr-tools'; import { NostrEvent, kinds } from "nostr-tools";
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import { COMMON_CONTACT_RELAYS } from '../env.js'; import { COMMON_CONTACT_RELAYS } from "../env.js";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
import App from '../app/index.js'; import App from "../app/index.js";
import PubkeyBatchLoader from './pubkey-batch-loader.js'; import PubkeyBatchLoader from "./pubkey-batch-loader.js";
/** loads kind 0 metadata for pubkeys */ /** loads kind 0 metadata for pubkeys */
export default class ProfileBook { export default class ProfileBook {
log = logger.extend('ProfileBook'); log = logger.extend("ProfileBook");
app: App; app: App;
loader: PubkeyBatchLoader; loader: PubkeyBatchLoader;
extraRelays = COMMON_CONTACT_RELAYS; extraRelays = COMMON_CONTACT_RELAYS;
@@ -20,8 +20,8 @@ export default class ProfileBook {
return this.app.eventStore.getEventsForFilters([{ kinds: [kinds.Metadata], authors: [pubkey] }])?.[0]; return this.app.eventStore.getEventsForFilters([{ kinds: [kinds.Metadata], authors: [pubkey] }])?.[0];
}); });
this.loader.on('event', (event) => this.app.eventStore.addEvent(event)); this.loader.on("event", (event) => this.app.eventStore.addEvent(event));
this.loader.on('batch', (found, failed) => { this.loader.on("batch", (found, failed) => {
this.log(`Found ${found}, failed ${failed}, pending ${this.loader.queue}`); this.log(`Found ${found}, failed ${failed}, pending ${this.loader.queue}`);
}); });
} }

66
src/modules/receiver/index.ts
View File

@@ -1,14 +1,14 @@
import EventEmitter from 'events'; import EventEmitter from "events";
import { NostrEvent, SimplePool, Filter } from 'nostr-tools'; import { NostrEvent, SimplePool, Filter } from "nostr-tools";
import SuperMap from '@satellite-earth/core/helpers/super-map.js'; import SuperMap from "@satellite-earth/core/helpers/super-map.js";
import { AbstractRelay, Subscription, SubscriptionParams } from 'nostr-tools/abstract-relay'; import { AbstractRelay, Subscription, SubscriptionParams } from "nostr-tools/abstract-relay";
import { getPubkeysFromList } from '@satellite-earth/core/helpers/nostr/lists.js'; import { getPubkeysFromList } from "@satellite-earth/core/helpers/nostr/lists.js";
import { getInboxes, getOutboxes } from '@satellite-earth/core/helpers/nostr/mailboxes.js'; import { getInboxes, getOutboxes } from "@satellite-earth/core/helpers/nostr/mailboxes.js";
import { getRelaysFromContactList } from '@satellite-earth/core/helpers/nostr/contacts.js'; import { getRelaysFromContactList } from "@satellite-earth/core/helpers/nostr/contacts.js";
import { BOOTSTRAP_RELAYS } from '../../env.js'; import { BOOTSTRAP_RELAYS } from "../../env.js";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
import App from '../../app/index.js'; import App from "../../app/index.js";
/** creates a new subscription and waits for it to get an event or close */ /** creates a new subscription and waits for it to get an event or close */
function asyncSubscription(relay: AbstractRelay, filters: Filter[], opts: SubscriptionParams) { function asyncSubscription(relay: AbstractRelay, filters: Filter[], opts: SubscriptionParams) {
@@ -43,18 +43,18 @@ type EventMap = {
event: [NostrEvent]; event: [NostrEvent];
}; };
type ReceiverStatus = 'running' | 'starting' | 'errored' | 'stopped'; type ReceiverStatus = "running" | "starting" | "errored" | "stopped";
export default class Receiver extends EventEmitter<EventMap> { export default class Receiver extends EventEmitter<EventMap> {
log = logger.extend('Receiver'); log = logger.extend("Receiver");
_status: ReceiverStatus = 'stopped'; _status: ReceiverStatus = "stopped";
get status() { get status() {
return this._status; return this._status;
} }
set status(v: ReceiverStatus) { set status(v: ReceiverStatus) {
this._status = v; this._status = v;
this.emit('status', v); this.emit("status", v);
} }
starting = true; starting = true;
@@ -81,15 +81,15 @@ export default class Receiver extends EventEmitter<EventMap> {
async fetchData() { async fetchData() {
const owner = this.app.config.data.owner; const owner = this.app.config.data.owner;
if (!owner) throw new Error('Missing owner'); if (!owner) throw new Error("Missing owner");
const ownerMailboxes = await this.app.addressBook.loadMailboxes(owner); const ownerMailboxes = await this.app.addressBook.loadMailboxes(owner);
const ownerInboxes = getInboxes(ownerMailboxes); const ownerInboxes = getInboxes(ownerMailboxes);
const ownerOutboxes = getOutboxes(ownerMailboxes); const ownerOutboxes = getOutboxes(ownerMailboxes);
this.log('Searching for owner kind:3 contacts'); this.log("Searching for owner kind:3 contacts");
const contacts = await this.app.contactBook.loadContacts(owner); const contacts = await this.app.contactBook.loadContacts(owner);
if (!contacts) throw new Error('Cant find contacts'); if (!contacts) throw new Error("Cant find contacts");
this.pubkeyRelays.clear(); this.pubkeyRelays.clear();
this.relayPubkeys.clear(); this.relayPubkeys.clear();
@@ -118,7 +118,7 @@ export default class Receiver extends EventEmitter<EventMap> {
this.log(`Failed to find mailboxes for ${person.pubkey}`); this.log(`Failed to find mailboxes for ${person.pubkey}`);
const contacts = await this.app.contactBook.loadContacts(person.pubkey, ownerInboxes ?? BOOTSTRAP_RELAYS); const contacts = await this.app.contactBook.loadContacts(person.pubkey, ownerInboxes ?? BOOTSTRAP_RELAYS);
if (contacts && contacts.content.startsWith('{')) { if (contacts && contacts.content.startsWith("{")) {
const parsed = getRelaysFromContactList(contacts); const parsed = getRelaysFromContactList(contacts);
if (parsed) { if (parsed) {
relays = parsed.filter((r) => r.write).map((r) => r.url); relays = parsed.filter((r) => r.write).map((r) => r.url);
@@ -155,13 +155,13 @@ export default class Receiver extends EventEmitter<EventMap> {
for (const url of sorted.slice(0, 2)) this.map.get(url).add(pubkey); for (const url of sorted.slice(0, 2)) this.map.get(url).add(pubkey);
} }
this.emit('rebuild'); this.emit("rebuild");
return this.map; return this.map;
} }
private handleEvent(event: NostrEvent) { private handleEvent(event: NostrEvent) {
this.emit('event', event); this.emit("event", event);
} }
async updateRelaySubscription(url: string) { async updateRelaySubscription(url: string) {
@@ -175,7 +175,7 @@ export default class Receiver extends EventEmitter<EventMap> {
const sub = relay.subscribe([{ authors: Array.from(pubkeys) }], { const sub = relay.subscribe([{ authors: Array.from(pubkeys) }], {
onevent: this.handleEvent.bind(this), onevent: this.handleEvent.bind(this),
onclose: () => { onclose: () => {
this.emit('closed', url, Array.from(pubkeys)); this.emit("closed", url, Array.from(pubkeys));
// wait 30 seconds then try to reconnect // wait 30 seconds then try to reconnect
setTimeout(() => { setTimeout(() => {
this.updateRelaySubscription(url); this.updateRelaySubscription(url);
@@ -183,7 +183,7 @@ export default class Receiver extends EventEmitter<EventMap> {
}, },
}); });
this.emit('subscribed', url, Array.from(pubkeys)); this.emit("subscribed", url, Array.from(pubkeys));
this.subscriptions.set(url, sub); this.subscriptions.set(url, sub);
this.log(`Subscribed to ${url} for ${pubkeys.size} pubkeys`); this.log(`Subscribed to ${url} for ${pubkeys.size} pubkeys`);
} else { } else {
@@ -216,40 +216,40 @@ export default class Receiver extends EventEmitter<EventMap> {
} }
async start() { async start() {
if (this.status === 'running' || this.status === 'starting') return; if (this.status === "running" || this.status === "starting") return;
try { try {
this.log('Starting'); this.log("Starting");
this.startupError = undefined; this.startupError = undefined;
this.status = 'starting'; this.status = "starting";
await this.fetchData(); await this.fetchData();
this.buildMap(); this.buildMap();
await this.ensureSubscriptions(); await this.ensureSubscriptions();
this.status = 'running'; this.status = "running";
this.emit('started', this); this.emit("started", this);
} catch (error) { } catch (error) {
this.status = 'errored'; this.status = "errored";
if (error instanceof Error) { if (error instanceof Error) {
this.startupError = error; this.startupError = error;
this.log(`Failed to start receiver`, error.message); this.log(`Failed to start receiver`, error.message);
this.emit('error', error); this.emit("error", error);
} }
} }
} }
/** stop receiving events and disconnect from all relays */ /** stop receiving events and disconnect from all relays */
stop() { stop() {
if (this.status === 'stopped') return; if (this.status === "stopped") return;
this.status = 'stopped'; this.status = "stopped";
for (const [relay, sub] of this.subscriptions) sub.close(); for (const [relay, sub] of this.subscriptions) sub.close();
this.subscriptions.clear(); this.subscriptions.clear();
this.log('Stopped'); this.log("Stopped");
this.emit('stopped', this); this.emit("stopped", this);
} }
destroy() { destroy() {

28
src/modules/reports/reports/conversations.ts
View File

@@ -1,12 +1,12 @@
import { ReportArguments, ReportResults } from '@satellite-earth/core/types'; import { ReportArguments, ReportResults } from "@satellite-earth/core/types";
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
import { getTagValue } from '@satellite-earth/core/helpers/nostr'; import { getTagValue } from "@satellite-earth/core/helpers/nostr";
import SuperMap from '@satellite-earth/core/helpers/super-map.js'; import SuperMap from "@satellite-earth/core/helpers/super-map.js";
import Report from '../report.js'; import Report from "../report.js";
export default class ConversationsReport extends Report<'CONVERSATIONS'> { export default class ConversationsReport extends Report<"CONVERSATIONS"> {
readonly type = 'CONVERSATIONS'; readonly type = "CONVERSATIONS";
private async getConversationResult(self: string, other: string) { private async getConversationResult(self: string, other: string) {
const sent = this.app.database.db const sent = this.app.database.db
@@ -27,7 +27,7 @@ export default class ConversationsReport extends Report<'CONVERSATIONS'> {
) )
.get(self, other); .get(self, other);
const result: ReportResults['CONVERSATIONS'] = { const result: ReportResults["CONVERSATIONS"] = {
pubkey: other, pubkey: other,
count: (received?.count ?? 0) + (sent?.count ?? 0), count: (received?.count ?? 0) + (sent?.count ?? 0),
sent: 0, sent: 0,
@@ -66,7 +66,7 @@ export default class ConversationsReport extends Report<'CONVERSATIONS'> {
) )
.all(self); .all(self);
const results = new SuperMap<string, ReportResults['CONVERSATIONS']>((pubkey) => ({ const results = new SuperMap<string, ReportResults["CONVERSATIONS"]>((pubkey) => ({
pubkey, pubkey,
count: sent.length + received.length, count: sent.length + received.length,
sent: 0, sent: 0,
@@ -89,10 +89,10 @@ export default class ConversationsReport extends Report<'CONVERSATIONS'> {
); );
} }
async setup(args: ReportArguments['CONVERSATIONS']) { async setup(args: ReportArguments["CONVERSATIONS"]) {
const listener = (event: NostrEvent) => { const listener = (event: NostrEvent) => {
const from = event.pubkey; const from = event.pubkey;
const to = getTagValue(event, 'p'); const to = getTagValue(event, "p");
if (!to) return; if (!to) return;
const self = args.pubkey; const self = args.pubkey;
@@ -101,11 +101,11 @@ export default class ConversationsReport extends Report<'CONVERSATIONS'> {
this.getConversationResult(self, self === from ? to : from).then((result) => this.send(result)); this.getConversationResult(self, self === from ? to : from).then((result) => this.send(result));
}; };
this.app.directMessageManager.on('message', listener); this.app.directMessageManager.on("message", listener);
return () => this.app.directMessageManager.off('message', listener); return () => this.app.directMessageManager.off("message", listener);
} }
async execute(args: ReportArguments['CONVERSATIONS']) { async execute(args: ReportArguments["CONVERSATIONS"]) {
const results = await this.getAllConversationResults(args.pubkey); const results = await this.getAllConversationResults(args.pubkey);
for (const result of results) { for (const result of results) {

10
src/modules/reports/reports/dm-search.ts
View File

@@ -1,10 +1,10 @@
import { ReportArguments } from '@satellite-earth/core/types'; import { ReportArguments } from "@satellite-earth/core/types";
import Report from '../report.js'; import Report from "../report.js";
export default class DMSearchReport extends Report<'DM_SEARCH'> { export default class DMSearchReport extends Report<"DM_SEARCH"> {
readonly type = 'DM_SEARCH'; readonly type = "DM_SEARCH";
async execute(args: ReportArguments['DM_SEARCH']) { async execute(args: ReportArguments["DM_SEARCH"]) {
const results = await this.app.decryptionCache.search(args.query, args); const results = await this.app.decryptionCache.search(args.query, args);
for (const result of results) this.send(result); for (const result of results) this.send(result);
} }

20
src/modules/reports/reports/events-summary.ts
View File

@@ -1,11 +1,11 @@
import { ReportArguments } from '@satellite-earth/core/types'; import { ReportArguments } from "@satellite-earth/core/types";
import { EventRow, parseEventRow } from '@satellite-earth/core'; import { EventRow, parseEventRow } from "@satellite-earth/core";
import Report from '../report.js'; import Report from "../report.js";
export default class EventsSummaryReport extends Report<'EVENTS_SUMMARY'> { export default class EventsSummaryReport extends Report<"EVENTS_SUMMARY"> {
readonly type = 'EVENTS_SUMMARY'; readonly type = "EVENTS_SUMMARY";
async execute(args: ReportArguments['EVENTS_SUMMARY']): Promise<void> { async execute(args: ReportArguments["EVENTS_SUMMARY"]): Promise<void> {
let sql = ` let sql = `
SELECT SELECT
events.*, events.*,
@@ -33,17 +33,17 @@ export default class EventsSummaryReport extends Report<'EVENTS_SUMMARY'> {
} }
if (conditions.length > 0) { if (conditions.length > 0) {
sql += ` WHERE ${conditions.join(' AND ')}\n`; sql += ` WHERE ${conditions.join(" AND ")}\n`;
} }
sql += ' GROUP BY events.id\n'; sql += " GROUP BY events.id\n";
switch (args.order) { switch (args.order) {
case 'created_at': case "created_at":
sql += ` ORDER BY events.created_at DESC\n`; sql += ` ORDER BY events.created_at DESC\n`;
break; break;
default: default:
case 'interactions': case "interactions":
sql += ` ORDER BY reactions + shares + replies DESC\n`; sql += ` ORDER BY reactions + shares + replies DESC\n`;
break; break;
} }

24
src/modules/reports/reports/index.ts
View File

@@ -1,16 +1,16 @@
import { ReportArguments } from '@satellite-earth/core/types'; import { ReportArguments } from "@satellite-earth/core/types";
import Report from '../report.js'; import Report from "../report.js";
import OverviewReport from './overview.js'; import OverviewReport from "./overview.js";
import ConversationsReport from './conversations.js'; import ConversationsReport from "./conversations.js";
import LogsReport from './logs.js'; import LogsReport from "./logs.js";
import ServicesReport from './services.js'; import ServicesReport from "./services.js";
import DMSearchReport from './dm-search.js'; import DMSearchReport from "./dm-search.js";
import ScrapperStatusReport from './scrapper-status.js'; import ScrapperStatusReport from "./scrapper-status.js";
import ReceiverStatusReport from './receiver-status.js'; import ReceiverStatusReport from "./receiver-status.js";
import NetworkStatusReport from './network-status.js'; import NetworkStatusReport from "./network-status.js";
import NotificationChannelsReport from './notification-channels.js'; import NotificationChannelsReport from "./notification-channels.js";
import EventsSummaryReport from './events-summary.js'; import EventsSummaryReport from "./events-summary.js";
const REPORT_CLASSES: { const REPORT_CLASSES: {
[k in keyof ReportArguments]?: typeof Report<k>; [k in keyof ReportArguments]?: typeof Report<k>;

16
src/modules/reports/reports/logs.ts
View File

@@ -1,22 +1,22 @@
import { ReportArguments } from '@satellite-earth/core/types'; import { ReportArguments } from "@satellite-earth/core/types";
import { LogEntry } from '../../log-store/log-store.js'; import { LogEntry } from "../../log-store/log-store.js";
import Report from '../report.js'; import Report from "../report.js";
/** WARNING: be careful of calling this.log in this class. it could trigger an infinite loop of logging */ /** WARNING: be careful of calling this.log in this class. it could trigger an infinite loop of logging */
export default class LogsReport extends Report<'LOGS'> { export default class LogsReport extends Report<"LOGS"> {
readonly type = 'LOGS'; readonly type = "LOGS";
async setup() { async setup() {
const listener = (entry: LogEntry) => { const listener = (entry: LogEntry) => {
if (!this.args?.service || entry.service === this.args.service) this.send(entry); if (!this.args?.service || entry.service === this.args.service) this.send(entry);
}; };
this.app.logStore.on('log', listener); this.app.logStore.on("log", listener);
return () => this.app.logStore.off('log', listener); return () => this.app.logStore.off("log", listener);
} }
async execute(args: ReportArguments['LOGS']) { async execute(args: ReportArguments["LOGS"]) {
const logs = this.app.logStore.getLogs({ service: args.service, limit: 500 }); const logs = this.app.logStore.getLogs({ service: args.service, limit: 500 });
for (const entry of logs) this.send(entry); for (const entry of logs) this.send(entry);
} }

6
src/modules/reports/reports/network-status.ts
View File

@@ -1,7 +1,7 @@
import Report from '../report.js'; import Report from "../report.js";
export default class NetworkStatusReport extends Report<'NETWORK_STATUS'> { export default class NetworkStatusReport extends Report<"NETWORK_STATUS"> {
readonly type = 'NETWORK_STATUS'; readonly type = "NETWORK_STATUS";
update() { update() {
const torIn = this.app.inboundNetwork.tor; const torIn = this.app.inboundNetwork.tor;

22
src/modules/reports/reports/notification-channels.ts
View File

@@ -1,23 +1,23 @@
import { NotificationChannel } from '@satellite-earth/core/types/control-api/notifications.js'; import { NotificationChannel } from "@satellite-earth/core/types/control-api/notifications.js";
import Report from '../report.js'; import Report from "../report.js";
export default class NotificationChannelsReport extends Report<'NOTIFICATION_CHANNELS'> { export default class NotificationChannelsReport extends Report<"NOTIFICATION_CHANNELS"> {
readonly type = 'NOTIFICATION_CHANNELS'; readonly type = "NOTIFICATION_CHANNELS";
async setup() { async setup() {
const listener = this.send.bind(this); const listener = this.send.bind(this);
const removeListener = (channel: NotificationChannel) => { const removeListener = (channel: NotificationChannel) => {
this.send(['removed', channel.id]); this.send(["removed", channel.id]);
}; };
this.app.notifications.on('addChannel', listener); this.app.notifications.on("addChannel", listener);
this.app.notifications.on('updateChannel', listener); this.app.notifications.on("updateChannel", listener);
this.app.notifications.on('removeChannel', removeListener); this.app.notifications.on("removeChannel", removeListener);
return () => { return () => {
this.app.notifications.off('addChannel', listener); this.app.notifications.off("addChannel", listener);
this.app.notifications.off('updateChannel', listener); this.app.notifications.off("updateChannel", listener);
this.app.notifications.off('removeChannel', removeListener); this.app.notifications.off("removeChannel", removeListener);
}; };
} }

16
src/modules/reports/reports/overview.ts
View File

@@ -1,10 +1,10 @@
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
import { ReportArguments } from '@satellite-earth/core/types'; import { ReportArguments } from "@satellite-earth/core/types";
import Report from '../report.js'; import Report from "../report.js";
export default class OverviewReport extends Report<'OVERVIEW'> { export default class OverviewReport extends Report<"OVERVIEW"> {
readonly type = 'OVERVIEW'; readonly type = "OVERVIEW";
async setup() { async setup() {
const listener = (event: NostrEvent) => { const listener = (event: NostrEvent) => {
@@ -19,13 +19,13 @@ export default class OverviewReport extends Report<'OVERVIEW'> {
if (result) this.send(result); if (result) this.send(result);
}; };
this.app.eventStore.on('event:inserted', listener); this.app.eventStore.on("event:inserted", listener);
return () => { return () => {
this.app.eventStore.off('event:inserted', listener); this.app.eventStore.off("event:inserted", listener);
}; };
} }
async execute(args: ReportArguments['OVERVIEW']) { async execute(args: ReportArguments["OVERVIEW"]) {
const results = await this.app.database.db const results = await this.app.database.db
.prepare< .prepare<
[], [],

22
src/modules/reports/reports/receiver-status.ts
View File

@@ -1,7 +1,7 @@
import Report from '../report.js'; import Report from "../report.js";
export default class ReceiverStatusReport extends Report<'RECEIVER_STATUS'> { export default class ReceiverStatusReport extends Report<"RECEIVER_STATUS"> {
readonly type = 'RECEIVER_STATUS'; readonly type = "RECEIVER_STATUS";
update() { update() {
this.send({ this.send({
@@ -19,16 +19,16 @@ export default class ReceiverStatusReport extends Report<'RECEIVER_STATUS'> {
async setup() { async setup() {
const listener = this.update.bind(this); const listener = this.update.bind(this);
this.app.receiver.on('status', listener); this.app.receiver.on("status", listener);
this.app.receiver.on('subscribed', listener); this.app.receiver.on("subscribed", listener);
this.app.receiver.on('closed', listener); this.app.receiver.on("closed", listener);
this.app.receiver.on('error', listener); this.app.receiver.on("error", listener);
return () => { return () => {
this.app.receiver.off('status', listener); this.app.receiver.off("status", listener);
this.app.receiver.off('subscribed', listener); this.app.receiver.off("subscribed", listener);
this.app.receiver.off('closed', listener); this.app.receiver.off("closed", listener);
this.app.receiver.off('error', listener); this.app.receiver.off("error", listener);
}; };
} }

14
src/modules/reports/reports/scrapper-status.ts
View File

@@ -1,9 +1,9 @@
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import Report from '../report.js'; import Report from "../report.js";
export default class ScrapperStatusReport extends Report<'SCRAPPER_STATUS'> { export default class ScrapperStatusReport extends Report<"SCRAPPER_STATUS"> {
readonly type = 'SCRAPPER_STATUS'; readonly type = "SCRAPPER_STATUS";
eventsPerSecond: number[] = [0]; eventsPerSecond: number[] = [0];
@@ -31,7 +31,7 @@ export default class ScrapperStatusReport extends Report<'SCRAPPER_STATUS'> {
this.eventsPerSecond[0]++; this.eventsPerSecond[0]++;
}; };
this.app.scrapper.on('event', onEvent); this.app.scrapper.on("event", onEvent);
const tick = setInterval(() => { const tick = setInterval(() => {
// start a new second // start a new second
@@ -44,7 +44,7 @@ export default class ScrapperStatusReport extends Report<'SCRAPPER_STATUS'> {
}, 1000); }, 1000);
return () => { return () => {
this.app.scrapper.off('event', onEvent); this.app.scrapper.off("event", onEvent);
clearInterval(tick); clearInterval(tick);
}; };
} }

6
src/modules/reports/reports/services.ts
View File

@@ -1,7 +1,7 @@
import Report from '../report.js'; import Report from "../report.js";
export default class ServicesReport extends Report<'SERVICES'> { export default class ServicesReport extends Report<"SERVICES"> {
readonly type = 'SERVICES'; readonly type = "SERVICES";
async execute() { async execute() {
const services = this.app.database.db const services = this.app.database.db

28
src/modules/scrapper/pubkey-relay-scrapper.ts
View File

@@ -1,13 +1,13 @@
import dayjs from 'dayjs'; import dayjs from "dayjs";
import { EventEmitter } from 'events'; import { EventEmitter } from "events";
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
import { Debugger } from 'debug'; import { Debugger } from "debug";
import { AbstractRelay, Subscription } from 'nostr-tools/abstract-relay'; import { AbstractRelay, Subscription } from "nostr-tools/abstract-relay";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
function stripProtocol(url: string) { function stripProtocol(url: string) {
return url.replace(/^\w+\:\/\//, ''); return url.replace(/^\w+\:\/\//, "");
} }
const DEFAULT_LIMIT = 1000; const DEFAULT_LIMIT = 1000;
@@ -53,7 +53,7 @@ export default class PubkeyRelayScrapper extends EventEmitter<EventMap> {
this.relay = relay; this.relay = relay;
if (state) this.state = state; if (state) this.state = state;
this.log = logger.extend('scrapper:' + pubkey + ':' + stripProtocol(relay.url)); this.log = logger.extend("scrapper:" + pubkey + ":" + stripProtocol(relay.url));
} }
async loadNext() { async loadNext() {
@@ -66,7 +66,7 @@ export default class PubkeyRelayScrapper extends EventEmitter<EventMap> {
await this.relay.connect(); await this.relay.connect();
const cursor = this.state.cursor || dayjs().unix(); const cursor = this.state.cursor || dayjs().unix();
this.log(`Requesting from ${dayjs.unix(cursor).format('lll')} (${cursor})`); this.log(`Requesting from ${dayjs.unix(cursor).format("lll")} (${cursor})`);
// return a promise to wait for the subscription to end // return a promise to wait for the subscription to end
return new Promise<void>((res, rej) => { return new Promise<void>((res, rej) => {
@@ -74,7 +74,7 @@ export default class PubkeyRelayScrapper extends EventEmitter<EventMap> {
let newCursor = cursor; let newCursor = cursor;
this.subscription = this.relay.subscribe([{ authors: [this.pubkey], until: cursor, limit: DEFAULT_LIMIT }], { this.subscription = this.relay.subscribe([{ authors: [this.pubkey], until: cursor, limit: DEFAULT_LIMIT }], {
onevent: (event) => { onevent: (event) => {
this.emit('event', event); this.emit("event", event);
count++; count++;
newCursor = Math.min(newCursor, event.created_at); newCursor = Math.min(newCursor, event.created_at);
@@ -88,19 +88,19 @@ export default class PubkeyRelayScrapper extends EventEmitter<EventMap> {
if (this.subscription?.closed === true) return; if (this.subscription?.closed === true) return;
this.complete = true; this.complete = true;
this.log('Got 0 events, complete'); this.log("Got 0 events, complete");
} else { } else {
this.log(`Got ${count} events and moved cursor to ${dayjs.unix(newCursor).format('lll')} (${newCursor})`); this.log(`Got ${count} events and moved cursor to ${dayjs.unix(newCursor).format("lll")} (${newCursor})`);
} }
this.state.cursor = newCursor - 1; this.state.cursor = newCursor - 1;
this.emit('chunk', { count, cursor: this.cursor }); this.emit("chunk", { count, cursor: this.cursor });
this.subscription?.close(); this.subscription?.close();
res(); res();
}, },
onclose: (reason) => { onclose: (reason) => {
if (reason !== 'closed by caller') { if (reason !== "closed by caller") {
// unexpected close // unexpected close
this.log(`Error: ${reason}`); this.log(`Error: ${reason}`);
this.error = new Error(reason); this.error = new Error(reason);

18
src/modules/scrapper/pubkey-scrapper.ts
View File

@@ -1,11 +1,11 @@
import App from '../../app/index.js'; import App from "../../app/index.js";
import { NostrEvent } from 'nostr-tools'; import { NostrEvent } from "nostr-tools";
import { EventEmitter } from 'events'; import { EventEmitter } from "events";
import { Debugger } from 'debug'; import { Debugger } from "debug";
import { getOutboxes } from '@satellite-earth/core/helpers/nostr/mailboxes.js'; import { getOutboxes } from "@satellite-earth/core/helpers/nostr/mailboxes.js";
import PubkeyRelayScrapper, { PubkeyRelayScrapperState } from './pubkey-relay-scrapper.js'; import PubkeyRelayScrapper, { PubkeyRelayScrapperState } from "./pubkey-relay-scrapper.js";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
type EventMap = { type EventMap = {
event: [NostrEvent]; event: [NostrEvent];
@@ -25,7 +25,7 @@ export default class PubkeyScrapper extends EventEmitter<EventMap> {
this.app = app; this.app = app;
this.pubkey = pubkey; this.pubkey = pubkey;
this.log = logger.extend('scrapper:' + this.pubkey); this.log = logger.extend("scrapper:" + this.pubkey);
} }
async ensureData() { async ensureData() {
@@ -51,7 +51,7 @@ export default class PubkeyScrapper extends EventEmitter<EventMap> {
if (!scrapper) { if (!scrapper) {
const relay = await this.app.pool.ensureRelay(url); const relay = await this.app.pool.ensureRelay(url);
scrapper = new PubkeyRelayScrapper(this.pubkey, relay); scrapper = new PubkeyRelayScrapper(this.pubkey, relay);
scrapper.on('event', (event) => this.emit('event', event)); scrapper.on("event", (event) => this.emit("event", event));
// load the state from the database // load the state from the database
const state = await this.app.state.getMutableState<PubkeyRelayScrapperState>( const state = await this.app.state.getMutableState<PubkeyRelayScrapperState>(

52
src/modules/secrets-manager.ts
View File

@@ -1,12 +1,12 @@
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import { generateSecretKey } from 'nostr-tools'; import { generateSecretKey } from "nostr-tools";
import EventEmitter from 'events'; import EventEmitter from "events";
import { bytesToHex, hexToBytes } from '@noble/hashes/utils'; import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
import webPush from 'web-push'; import webPush from "web-push";
import crypto from 'crypto'; import crypto from "crypto";
import fs from 'fs'; import fs from "fs";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
type Secrets = { type Secrets = {
nostrKey: Uint8Array; nostrKey: Uint8Array;
@@ -36,7 +36,7 @@ type EventMap = {
}; };
export default class SecretsManager extends EventEmitter<EventMap> { export default class SecretsManager extends EventEmitter<EventMap> {
log = logger.extend('SecretsManager'); log = logger.extend("SecretsManager");
protected secrets?: Secrets; protected secrets?: Secrets;
path: string; path: string;
@@ -46,25 +46,25 @@ export default class SecretsManager extends EventEmitter<EventMap> {
} }
get<T extends keyof Secrets>(secret: T): Secrets[T] { get<T extends keyof Secrets>(secret: T): Secrets[T] {
if (!this.secrets) throw new Error('Secrets not loaded'); if (!this.secrets) throw new Error("Secrets not loaded");
return this.secrets[secret]; return this.secrets[secret];
} }
set<T extends keyof Secrets>(secret: T, value: Secrets[T]) { set<T extends keyof Secrets>(secret: T, value: Secrets[T]) {
if (!this.secrets) throw new Error('Secrets not loaded'); if (!this.secrets) throw new Error("Secrets not loaded");
this.secrets[secret] = value; this.secrets[secret] = value;
this.emit('changed', secret, value); this.emit("changed", secret, value);
this.emit('updated'); this.emit("updated");
this.write(); this.write();
} }
read() { read() {
this.log('Loading secrets'); this.log("Loading secrets");
let json: Record<string, any> = {}; let json: Record<string, any> = {};
try { try {
json = JSON.parse(fs.readFileSync(this.path, { encoding: 'utf-8' })); json = JSON.parse(fs.readFileSync(this.path, { encoding: "utf-8" }));
} catch (error) {} } catch (error) {}
let changed = false; let changed = false;
@@ -72,13 +72,13 @@ export default class SecretsManager extends EventEmitter<EventMap> {
const secrets = {} as Secrets; const secrets = {} as Secrets;
if (!json.nostrKey) { if (!json.nostrKey) {
this.log('Generating new nostr key'); this.log("Generating new nostr key");
secrets.nostrKey = generateSecretKey(); secrets.nostrKey = generateSecretKey();
changed = true; changed = true;
} else secrets.nostrKey = hexToBytes(json.nostrKey); } else secrets.nostrKey = hexToBytes(json.nostrKey);
if (!json.vapidPrivateKey || !json.vapidPublicKey) { if (!json.vapidPrivateKey || !json.vapidPublicKey) {
this.log('Generating new vapid key'); this.log("Generating new vapid key");
const keys = webPush.generateVAPIDKeys(); const keys = webPush.generateVAPIDKeys();
secrets.vapidPrivateKey = keys.privateKey; secrets.vapidPrivateKey = keys.privateKey;
secrets.vapidPublicKey = keys.publicKey; secrets.vapidPublicKey = keys.publicKey;
@@ -89,37 +89,37 @@ export default class SecretsManager extends EventEmitter<EventMap> {
} }
if (!json.hyperKey) { if (!json.hyperKey) {
this.log('Generating new hyper key'); this.log("Generating new hyper key");
secrets.hyperKey = crypto.randomBytes(32); secrets.hyperKey = crypto.randomBytes(32);
changed = true; changed = true;
} else secrets.hyperKey = Buffer.from(json.hyperKey, 'hex'); } else secrets.hyperKey = Buffer.from(json.hyperKey, "hex");
secrets.i2pPrivateKey = json.i2pPrivateKey; secrets.i2pPrivateKey = json.i2pPrivateKey;
secrets.i2pPublicKey = json.i2pPublicKey; secrets.i2pPublicKey = json.i2pPublicKey;
this.secrets = secrets; this.secrets = secrets;
this.emit('loaded'); this.emit("loaded");
this.emit('updated'); this.emit("updated");
if (changed) this.write(); if (changed) this.write();
} }
write() { write() {
if (!this.secrets) throw new Error('Secrets not loaded'); if (!this.secrets) throw new Error("Secrets not loaded");
this.log('Saving'); this.log("Saving");
const json: RawJson = { const json: RawJson = {
nostrKey: bytesToHex(this.secrets?.nostrKey), nostrKey: bytesToHex(this.secrets?.nostrKey),
vapidPrivateKey: this.secrets.vapidPrivateKey, vapidPrivateKey: this.secrets.vapidPrivateKey,
vapidPublicKey: this.secrets.vapidPublicKey, vapidPublicKey: this.secrets.vapidPublicKey,
hyperKey: this.secrets.hyperKey?.toString('hex'), hyperKey: this.secrets.hyperKey?.toString("hex"),
i2pPrivateKey: this.secrets.i2pPrivateKey, i2pPrivateKey: this.secrets.i2pPrivateKey,
i2pPublicKey: this.secrets.i2pPublicKey, i2pPublicKey: this.secrets.i2pPublicKey,
}; };
fs.writeFileSync(this.path, JSON.stringify(json, null, 2), { encoding: 'utf-8' }); fs.writeFileSync(this.path, JSON.stringify(json, null, 2), { encoding: "utf-8" });
this.emit('saved'); this.emit("saved");
} }
} }

10
src/modules/state/application-state-manager.ts
View File

@@ -1,9 +1,9 @@
import { MigrationSet } from '@satellite-earth/core/sqlite'; import { MigrationSet } from "@satellite-earth/core/sqlite";
import { Database } from 'better-sqlite3'; import { Database } from "better-sqlite3";
import { MutableState } from './mutable-state.js'; import { MutableState } from "./mutable-state.js";
const migrations = new MigrationSet('application-state'); const migrations = new MigrationSet("application-state");
migrations.addScript(1, async (db, log) => { migrations.addScript(1, async (db, log) => {
db.prepare( db.prepare(
@@ -16,7 +16,7 @@ migrations.addScript(1, async (db, log) => {
`, `,
).run(); ).run();
log('Created application state table'); log("Created application state table");
}); });
export default class ApplicationStateManager { export default class ApplicationStateManager {

26
src/modules/state/mutable-state.ts
View File

@@ -1,9 +1,9 @@
import { EventEmitter } from 'events'; import { EventEmitter } from "events";
import { Database } from 'better-sqlite3'; import { Database } from "better-sqlite3";
import _throttle from 'lodash.throttle'; import _throttle from "lodash.throttle";
import { Debugger } from 'debug'; import { Debugger } from "debug";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
type EventMap<T> = { type EventMap<T> = {
/** fires when file is loaded */ /** fires when file is loaded */
@@ -23,7 +23,7 @@ export class MutableState<T extends object> extends EventEmitter<EventMap<T>> {
/** A Proxy object that will automatically save when mutated */ /** A Proxy object that will automatically save when mutated */
get proxy() { get proxy() {
if (!this._proxy) throw new Error('Cant access state before initialized'); if (!this._proxy) throw new Error("Cant access state before initialized");
return this._proxy; return this._proxy;
} }
@@ -48,8 +48,8 @@ export class MutableState<T extends object> extends EventEmitter<EventMap<T>> {
}, },
set: (target, p, newValue, receiver) => { set: (target, p, newValue, receiver) => {
Reflect.set(target, p, newValue, receiver); Reflect.set(target, p, newValue, receiver);
this.emit('changed', target as T, String(p), newValue); this.emit("changed", target as T, String(p), newValue);
this.emit('updated', target as T); this.emit("updated", target as T);
this.throttleSave(); this.throttleSave();
return newValue; return newValue;
}, },
@@ -66,7 +66,7 @@ export class MutableState<T extends object> extends EventEmitter<EventMap<T>> {
const state: T | undefined = row ? (JSON.parse(row.state) as T) : undefined; const state: T | undefined = row ? (JSON.parse(row.state) as T) : undefined;
if (state && this.state) { if (state && this.state) {
Object.assign(this.state, state); Object.assign(this.state, state);
this.log('Loaded'); this.log("Loaded");
} }
if (!this.state) throw new Error(`Missing initial state for ${this.key}`); if (!this.state) throw new Error(`Missing initial state for ${this.key}`);
@@ -74,8 +74,8 @@ export class MutableState<T extends object> extends EventEmitter<EventMap<T>> {
this.createProxy(); this.createProxy();
if (this.state) { if (this.state) {
this.emit('loaded', this.state); this.emit("loaded", this.state);
this.emit('updated', this.state); this.emit("updated", this.state);
} }
} }
async save() { async save() {
@@ -85,7 +85,7 @@ export class MutableState<T extends object> extends EventEmitter<EventMap<T>> {
.prepare<[string, string]>(`INSERT OR REPLACE INTO application_state (id, state) VALUES (?, ?)`) .prepare<[string, string]>(`INSERT OR REPLACE INTO application_state (id, state) VALUES (?, ?)`)
.run(this.key, JSON.stringify(this.state)); .run(this.key, JSON.stringify(this.state));
this.log('Saved'); this.log("Saved");
this.emit('saved', this.state); this.emit("saved", this.state);
} }
} }

46
src/modules/switchboard/switchboard.ts
View File

@@ -1,13 +1,13 @@
import { RawData, WebSocket } from 'ws'; import { RawData, WebSocket } from "ws";
import { IncomingMessage } from 'http'; import { IncomingMessage } from "http";
import { logger } from '../../logger.js'; import { logger } from "../../logger.js";
import OutboundProxyWebSocket from '../network/outbound/websocket.js'; import OutboundProxyWebSocket from "../network/outbound/websocket.js";
import { isHexKey } from 'applesauce-core/helpers'; import { isHexKey } from "applesauce-core/helpers";
import App from '../../app/index.js'; import App from "../../app/index.js";
export default class Switchboard { export default class Switchboard {
private app: App; private app: App;
private log = logger.extend('Switchboard'); private log = logger.extend("Switchboard");
constructor(app: App) { constructor(app: App) {
this.app = app; this.app = app;
@@ -19,23 +19,23 @@ export default class Switchboard {
const handleMessage = async (message: RawData) => { const handleMessage = async (message: RawData) => {
try { try {
// Parse JSON from the raw buffer // Parse JSON from the raw buffer
const data = JSON.parse(typeof message === 'string' ? message : message.toString('utf-8')); const data = JSON.parse(typeof message === "string" ? message : message.toString("utf-8"));
if (!Array.isArray(data)) throw new Error('Message is not an array'); if (!Array.isArray(data)) throw new Error("Message is not an array");
if (data[0] === 'PROXY' && data[1]) { if (data[0] === "PROXY" && data[1]) {
let addresses: string[]; let addresses: string[];
if (isHexKey(data[1])) { if (isHexKey(data[1])) {
addresses = await this.app.gossip.lookup(data[1]); addresses = await this.app.gossip.lookup(data[1]);
} else addresses = [data[1]]; } else addresses = [data[1]];
if (addresses.length === 0) { if (addresses.length === 0) {
downstream.send(JSON.stringify(['PROXY', 'ERROR', 'Lookup failed'])); downstream.send(JSON.stringify(["PROXY", "ERROR", "Lookup failed"]));
return; return;
} }
this.app.relay.disconnectSocket(downstream); this.app.relay.disconnectSocket(downstream);
downstream.send(JSON.stringify(['PROXY', 'CONNECTING'])); downstream.send(JSON.stringify(["PROXY", "CONNECTING"]));
let error: Error | undefined = undefined; let error: Error | undefined = undefined;
for (const address of addresses) { for (const address of addresses) {
@@ -44,8 +44,8 @@ export default class Switchboard {
// wait for connection // wait for connection
await new Promise<void>((res, rej) => { await new Promise<void>((res, rej) => {
upstream?.once('open', () => res()); upstream?.once("open", () => res());
upstream?.once('error', (error) => rej(error)); upstream?.once("error", (error) => rej(error));
}); });
this.log(`Proxy connection to ${address}`); this.log(`Proxy connection to ${address}`);
@@ -54,24 +54,24 @@ export default class Switchboard {
error = undefined; error = undefined;
// Forward from client to target relay // Forward from client to target relay
downstream.on('message', (message, isBinary) => { downstream.on("message", (message, isBinary) => {
upstream?.send(message, { binary: isBinary }); upstream?.send(message, { binary: isBinary });
}); });
// Forward back from target relay to client // Forward back from target relay to client
upstream.on('message', (message, isBinary) => { upstream.on("message", (message, isBinary) => {
downstream.send(message, { binary: isBinary }); downstream.send(message, { binary: isBinary });
}); });
// connect the close events // connect the close events
upstream.on('close', () => downstream.close()); upstream.on("close", () => downstream.close());
downstream.on('close', () => upstream?.close()); downstream.on("close", () => upstream?.close());
// tell downstream its connected // tell downstream its connected
downstream.send(JSON.stringify(['PROXY', 'CONNECTED'])); downstream.send(JSON.stringify(["PROXY", "CONNECTED"]));
// Step away from the connection // Step away from the connection
downstream.off('message', handleMessage); downstream.off("message", handleMessage);
} catch (err) { } catch (err) {
upstream = undefined; upstream = undefined;
if (err instanceof Error) error = err; if (err instanceof Error) error = err;
@@ -79,13 +79,13 @@ export default class Switchboard {
} }
// send the error back if we failed to connect to any address // send the error back if we failed to connect to any address
if (error) downstream.send(JSON.stringify(['PROXY', 'ERROR', error.message])); if (error) downstream.send(JSON.stringify(["PROXY", "ERROR", error.message]));
} }
} catch (err) { } catch (err) {
this.log('Failed to handle message', err); this.log("Failed to handle message", err);
} }
}; };
downstream.on('message', handleMessage); downstream.on("message", handleMessage);
this.app.relay.handleConnection(downstream, req); this.app.relay.handleConnection(downstream, req);
} }

6
src/polyfill.ts Normal file
View File

@@ -0,0 +1,6 @@
import { useWebSocketImplementation } from "nostr-tools/relay";
import OutboundProxyWebSocket from "./modules/network/outbound/websocket.js";
// @ts-expect-error
global.WebSocket = OutboundProxyWebSocket;
useWebSocketImplementation(OutboundProxyWebSocket);

8
src/sidecars/hyperdht.ts
View File

@@ -1,13 +1,13 @@
import HyperDHT from 'hyperdht'; import HyperDHT from "hyperdht";
import { logger } from '../logger.js'; import { logger } from "../logger.js";
const log = logger.extend('HyperDHT'); const log = logger.extend("HyperDHT");
let node: HyperDHT | undefined; let node: HyperDHT | undefined;
export function getOrCreateNode() { export function getOrCreateNode() {
if (node) return node; if (node) return node;
log('Creating HyperDHT Node'); log("Creating HyperDHT Node");
return (node = new HyperDHT()); return (node = new HyperDHT());
} }

4
src/types/holesail-server.d.ts vendored
View File

@@ -1,5 +1,5 @@
declare module 'holesail-server' { declare module "holesail-server" {
import HyperDHT, { KeyPair, Server } from 'hyperdht'; import HyperDHT, { KeyPair, Server } from "hyperdht";
type ServeArgs = { type ServeArgs = {
secure?: boolean; secure?: boolean;

6
src/types/hyperdht.d.ts vendored
View File

@@ -1,6 +1,6 @@
declare module 'hyperdht' { declare module "hyperdht" {
import type { Socket } from 'net'; import type { Socket } from "net";
import type EventEmitter from 'events'; import type EventEmitter from "events";
class NoiseStreamSocket extends Socket { class NoiseStreamSocket extends Socket {
remotePublicKey: Buffer; remotePublicKey: Buffer;

4
src/types/streamx.d.ts vendored
View File

@@ -1,5 +1,5 @@
declare module 'streamx' { declare module "streamx" {
import { Duplex, Stream } from 'stream'; import { Duplex, Stream } from "stream";
export function pipeline(...streams: Stream[]): Duplex; export function pipeline(...streams: Stream[]): Duplex;
} }