@kernlize/core 0.10.0 → 0.11.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +468 -102
- package/dist/index.js +805 -103
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -251,16 +251,16 @@ function fallbackFor(fallback, purpose) {
|
|
|
251
251
|
}
|
|
252
252
|
function parseQuery(raw) {
|
|
253
253
|
const lower = raw.trim().toLowerCase();
|
|
254
|
-
const
|
|
255
|
-
return { text:
|
|
254
|
+
const text3 = lower.replace(/^wss?:\/\//, "").replace(/\/+$/, "");
|
|
255
|
+
return { text: text3, anchored: text3 !== lower.replace(/\/+$/, "") };
|
|
256
256
|
}
|
|
257
|
-
function matchScore(url,
|
|
257
|
+
function matchScore(url, query2) {
|
|
258
258
|
const address = url.replace(/^wss?:\/\//, "").replace(/\/$/, "");
|
|
259
|
-
if (!
|
|
260
|
-
if (address.startsWith(
|
|
261
|
-
if (
|
|
262
|
-
if (address.split(/[.\-/]/).some((word) => word.startsWith(
|
|
263
|
-
return address.includes(
|
|
259
|
+
if (!query2.anchored && address.replace(/^(?:relay|nostr)\./, "").startsWith(query2.text)) return 3;
|
|
260
|
+
if (address.startsWith(query2.text)) return 2;
|
|
261
|
+
if (query2.anchored) return 0;
|
|
262
|
+
if (address.split(/[.\-/]/).some((word) => word.startsWith(query2.text))) return 2;
|
|
263
|
+
return address.includes(query2.text) ? 1 : 0;
|
|
264
264
|
}
|
|
265
265
|
function createRelayDirectory(options) {
|
|
266
266
|
const now = options.now ?? (() => Math.floor(Date.now() / 1e3));
|
|
@@ -319,9 +319,9 @@ function createRelayDirectory(options) {
|
|
|
319
319
|
return {
|
|
320
320
|
listings$: listings$.asObservable(),
|
|
321
321
|
listings: () => current().listings,
|
|
322
|
-
search(
|
|
323
|
-
const
|
|
324
|
-
return current().listings.map((listing) => ({ listing, score: matchScore(listing.url,
|
|
322
|
+
search(text3, limit = 10) {
|
|
323
|
+
const query2 = parseQuery(text3);
|
|
324
|
+
return current().listings.map((listing) => ({ listing, score: matchScore(listing.url, query2) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || b.listing.monitors - a.listing.monitors || byRtt(a.listing, b.listing)).slice(0, limit).map((entry) => entry.listing);
|
|
325
325
|
},
|
|
326
326
|
suggest,
|
|
327
327
|
start() {
|
|
@@ -832,12 +832,12 @@ var MANIFEST_KIND = 35129;
|
|
|
832
832
|
function builtinAddress(id) {
|
|
833
833
|
return `kernl:${id}`;
|
|
834
834
|
}
|
|
835
|
-
function decodeBuiltin(
|
|
836
|
-
const id = ADDRESS.exec(
|
|
835
|
+
function decodeBuiltin(text3) {
|
|
836
|
+
const id = ADDRESS.exec(text3)?.[1];
|
|
837
837
|
return id === void 0 ? void 0 : { kind: "builtin", id, relays: Object.freeze([]) };
|
|
838
838
|
}
|
|
839
|
-
async function sha256Hex(
|
|
840
|
-
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(
|
|
839
|
+
async function sha256Hex(text3) {
|
|
840
|
+
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text3));
|
|
841
841
|
return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
842
842
|
}
|
|
843
843
|
function manifestOf(applet) {
|
|
@@ -914,15 +914,15 @@ function fromBech32(input) {
|
|
|
914
914
|
return void 0;
|
|
915
915
|
}
|
|
916
916
|
function decodePointer(input) {
|
|
917
|
-
const
|
|
918
|
-
const builtin = decodeBuiltin(
|
|
917
|
+
const text3 = input.trim().replace(/^nostr:/i, "");
|
|
918
|
+
const builtin = decodeBuiltin(text3);
|
|
919
919
|
if (builtin) return builtin;
|
|
920
|
-
if (HEX_64.test(
|
|
921
|
-
const coordinate2 = COORDINATE.exec(
|
|
920
|
+
if (HEX_64.test(text3)) return { kind: "event", id: text3, relays: Object.freeze([]) };
|
|
921
|
+
const coordinate2 = COORDINATE.exec(text3);
|
|
922
922
|
if (coordinate2) return fromCoordinate(coordinate2[1], coordinate2[2], coordinate2[3]);
|
|
923
|
-
const aTag = A_TAG_COORDINATE.exec(
|
|
923
|
+
const aTag = A_TAG_COORDINATE.exec(text3);
|
|
924
924
|
if (aTag) return fromCoordinate(aTag[2], aTag[1], aTag[3]);
|
|
925
|
-
return fromBech32((ENCODED.exec(
|
|
925
|
+
return fromBech32((ENCODED.exec(text3)?.[0] ?? text3).toLowerCase()) ?? invalid();
|
|
926
926
|
}
|
|
927
927
|
|
|
928
928
|
// src/applets/resolve.ts
|
|
@@ -1100,10 +1100,10 @@ import {
|
|
|
1100
1100
|
resolveShellEnvironment
|
|
1101
1101
|
} from "@kehto/shell";
|
|
1102
1102
|
import { createAppletCsp, renderInsertionLockScript } from "@kernlize/guard";
|
|
1103
|
-
function spliceOnce(
|
|
1104
|
-
const at =
|
|
1103
|
+
function spliceOnce(text3, find, replacement) {
|
|
1104
|
+
const at = text3.indexOf(find);
|
|
1105
1105
|
if (at === -1) throw new Error("unavailable:frame-lock");
|
|
1106
|
-
return `${
|
|
1106
|
+
return `${text3.slice(0, at)}${replacement}${text3.slice(at + find.length)}`;
|
|
1107
1107
|
}
|
|
1108
1108
|
var NESTED_CONTEXT_LOCK = Object.freeze({ nestedContextLock: true });
|
|
1109
1109
|
function assertNoFrame(html) {
|
|
@@ -1204,10 +1204,10 @@ import {
|
|
|
1204
1204
|
estimateEnvelopeSize
|
|
1205
1205
|
} from "@kernlize/guard";
|
|
1206
1206
|
function toEnvelope(data) {
|
|
1207
|
-
const
|
|
1208
|
-
const event = typeof
|
|
1207
|
+
const record2 = typeof data === "object" && data !== null ? data : {};
|
|
1208
|
+
const event = typeof record2.event === "object" && record2.event !== null ? record2.event : {};
|
|
1209
1209
|
const envelope = {
|
|
1210
|
-
type: typeof
|
|
1210
|
+
type: typeof record2.type === "string" ? record2.type : "unknown",
|
|
1211
1211
|
size: estimateEnvelopeSize(data)
|
|
1212
1212
|
};
|
|
1213
1213
|
return typeof event.kind === "number" ? { ...envelope, kind: event.kind } : envelope;
|
|
@@ -1424,7 +1424,9 @@ var DOMAIN_CAPABILITIES = Object.freeze({
|
|
|
1424
1424
|
dm: ["dm:read", "dm:write"],
|
|
1425
1425
|
fs: ["fs:read", "fs:write"],
|
|
1426
1426
|
llm: ["llm:generate"],
|
|
1427
|
-
cache: ["cache:read", "cache:write"]
|
|
1427
|
+
cache: ["cache:read", "cache:write"],
|
|
1428
|
+
// kehto's ACL has no capability for direct connections; the service checks the grant itself (D-042).
|
|
1429
|
+
webrtc: []
|
|
1428
1430
|
});
|
|
1429
1431
|
var BASELINE_DOMAINS = Object.freeze(["shell", "inc", "theme", "storage"]);
|
|
1430
1432
|
function capabilitiesForDomain(domain) {
|
|
@@ -1453,7 +1455,7 @@ function createGrants(options) {
|
|
|
1453
1455
|
function stored(identity) {
|
|
1454
1456
|
return records.get(keyOf(identity)) ?? { dTag: identity.dTag, hash: identity.hash, domains: [], blocked: false };
|
|
1455
1457
|
}
|
|
1456
|
-
function
|
|
1458
|
+
function record2(entry) {
|
|
1457
1459
|
return {
|
|
1458
1460
|
identity: { dTag: entry.dTag, hash: entry.hash },
|
|
1459
1461
|
domains: Object.freeze([...entry.domains]),
|
|
@@ -1475,7 +1477,7 @@ function createGrants(options) {
|
|
|
1475
1477
|
records.set(`${entry.dTag}:${entry.hash}`, entry);
|
|
1476
1478
|
persist();
|
|
1477
1479
|
syncAcl(entry);
|
|
1478
|
-
const result =
|
|
1480
|
+
const result = record2(entry);
|
|
1479
1481
|
changes$.next(result);
|
|
1480
1482
|
return result;
|
|
1481
1483
|
}
|
|
@@ -1483,10 +1485,10 @@ function createGrants(options) {
|
|
|
1483
1485
|
commit({ ...stored(identity), domains: [...domains] });
|
|
1484
1486
|
}
|
|
1485
1487
|
return {
|
|
1486
|
-
list: () => [...records.values()].map(
|
|
1488
|
+
list: () => [...records.values()].map(record2),
|
|
1487
1489
|
get: (identity) => {
|
|
1488
1490
|
const entry = records.get(keyOf(identity));
|
|
1489
|
-
return entry ?
|
|
1491
|
+
return entry ? record2(entry) : void 0;
|
|
1490
1492
|
},
|
|
1491
1493
|
ensure: (identity) => commit(stored(identity)),
|
|
1492
1494
|
allowDomain(identity, domain) {
|
|
@@ -1512,8 +1514,8 @@ function createGrants(options) {
|
|
|
1512
1514
|
}
|
|
1513
1515
|
function createEnvironmentResolver(grants) {
|
|
1514
1516
|
return (identity, available) => {
|
|
1515
|
-
const
|
|
1516
|
-
const allowed = new Set(
|
|
1517
|
+
const record2 = grants.get({ dTag: identity.dTag, hash: identity.aggregateHash });
|
|
1518
|
+
const allowed = new Set(record2?.blocked ? ["shell"] : [...grants.baselineDomains(), ...record2?.domains ?? []]);
|
|
1517
1519
|
return Object.freeze({
|
|
1518
1520
|
domains: Object.freeze(available.domains.filter((domain) => allowed.has(domain))),
|
|
1519
1521
|
services: Object.freeze(available.services.filter((service) => allowed.has(service)))
|
|
@@ -1919,14 +1921,14 @@ function createConversationStore() {
|
|
|
1919
1921
|
const thread = threads.get(conversationId);
|
|
1920
1922
|
thread?.messages.splice(thread.messages.findIndex((entry) => entry.id === id), 1);
|
|
1921
1923
|
},
|
|
1922
|
-
conversations(
|
|
1924
|
+
conversations(query2 = {}) {
|
|
1923
1925
|
const all = [...threads].filter(([, thread]) => thread.messages.length > 0).sort(([, a], [, b]) => latest(b) - latest(a)).map(([id, thread]) => summarize2(id, thread));
|
|
1924
|
-
const result = page(all,
|
|
1926
|
+
const result = page(all, query2.cursor, query2.limit ?? DEFAULT_CONVERSATION_LIMIT);
|
|
1925
1927
|
return { conversations: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
|
|
1926
1928
|
},
|
|
1927
|
-
messages(
|
|
1928
|
-
const all = threads.get(
|
|
1929
|
-
const result = page(all,
|
|
1929
|
+
messages(query2) {
|
|
1930
|
+
const all = threads.get(query2.conversationId)?.messages ?? [];
|
|
1931
|
+
const result = page(all, query2.cursor, query2.limit ?? DEFAULT_MESSAGE_LIMIT);
|
|
1930
1932
|
return { messages: result.items, ...result.cursor === void 0 ? {} : { cursor: result.cursor } };
|
|
1931
1933
|
}
|
|
1932
1934
|
};
|
|
@@ -2041,13 +2043,13 @@ function createSignerBackend(options, format) {
|
|
|
2041
2043
|
capabilities: CAPABILITIES
|
|
2042
2044
|
};
|
|
2043
2045
|
},
|
|
2044
|
-
async conversations(
|
|
2046
|
+
async conversations(query2) {
|
|
2045
2047
|
await sync();
|
|
2046
|
-
return store.conversations(
|
|
2048
|
+
return store.conversations(query2);
|
|
2047
2049
|
},
|
|
2048
|
-
async messages(
|
|
2050
|
+
async messages(query2) {
|
|
2049
2051
|
await sync();
|
|
2050
|
-
return store.messages(
|
|
2052
|
+
return store.messages(query2);
|
|
2051
2053
|
},
|
|
2052
2054
|
async send(request) {
|
|
2053
2055
|
const current = session();
|
|
@@ -2156,9 +2158,9 @@ import { NdrRuntime } from "nostr-double-ratchet";
|
|
|
2156
2158
|
|
|
2157
2159
|
// src/messaging/ratchet-storage.ts
|
|
2158
2160
|
var CHUNK_UNITS = 16384;
|
|
2159
|
-
function chunks(
|
|
2161
|
+
function chunks(text3) {
|
|
2160
2162
|
const parts = [];
|
|
2161
|
-
for (let start = 0; start <
|
|
2163
|
+
for (let start = 0; start < text3.length; start += CHUNK_UNITS) parts.push(text3.slice(start, start + CHUNK_UNITS));
|
|
2162
2164
|
return parts;
|
|
2163
2165
|
}
|
|
2164
2166
|
function createSealedRatchetStorage(options) {
|
|
@@ -2318,13 +2320,13 @@ function createRatchetMessagesBackend(options) {
|
|
|
2318
2320
|
const self = options.selfPubkey();
|
|
2319
2321
|
return { available: usable(), ...self === void 0 ? {} : { ownerPubkey: self }, implementations: ["ndr"], capabilities: CAPABILITIES2 };
|
|
2320
2322
|
},
|
|
2321
|
-
async conversations(
|
|
2323
|
+
async conversations(query2) {
|
|
2322
2324
|
await sync();
|
|
2323
|
-
return store.conversations(
|
|
2325
|
+
return store.conversations(query2);
|
|
2324
2326
|
},
|
|
2325
|
-
async messages(
|
|
2327
|
+
async messages(query2) {
|
|
2326
2328
|
await sync();
|
|
2327
|
-
return store.messages(
|
|
2329
|
+
return store.messages(query2);
|
|
2328
2330
|
},
|
|
2329
2331
|
async send(request) {
|
|
2330
2332
|
const availability = signerAvailability(signerOf2(), "nip44");
|
|
@@ -2422,9 +2424,9 @@ function createSealedGroupStore(options, name) {
|
|
|
2422
2424
|
const loading = open();
|
|
2423
2425
|
let writes = loading;
|
|
2424
2426
|
const seal = async (entries) => {
|
|
2425
|
-
const
|
|
2427
|
+
const text3 = JSON.stringify(Object.fromEntries(entries), encode);
|
|
2426
2428
|
const parts = [];
|
|
2427
|
-
for (let start = 0; start <
|
|
2429
|
+
for (let start = 0; start < text3.length; start += SEAL_UNITS) parts.push(text3.slice(start, start + SEAL_UNITS));
|
|
2428
2430
|
storage.setItem(key, JSON.stringify(await Promise.all(parts.map((part) => nip44.encrypt(owner, part)))));
|
|
2429
2431
|
};
|
|
2430
2432
|
const write = (change) => {
|
|
@@ -2625,13 +2627,13 @@ function createGroupMessagesBackend(options) {
|
|
|
2625
2627
|
capabilities: CAPABILITIES3
|
|
2626
2628
|
};
|
|
2627
2629
|
},
|
|
2628
|
-
async conversations(
|
|
2630
|
+
async conversations(query2) {
|
|
2629
2631
|
await sync();
|
|
2630
|
-
return store.conversations(
|
|
2632
|
+
return store.conversations(query2);
|
|
2631
2633
|
},
|
|
2632
|
-
async messages(
|
|
2634
|
+
async messages(query2) {
|
|
2633
2635
|
await sync();
|
|
2634
|
-
return store.messages(
|
|
2636
|
+
return store.messages(query2);
|
|
2635
2637
|
},
|
|
2636
2638
|
async send(request) {
|
|
2637
2639
|
const live = active();
|
|
@@ -2701,8 +2703,8 @@ function labelConversations(adapter, profiles) {
|
|
|
2701
2703
|
};
|
|
2702
2704
|
return {
|
|
2703
2705
|
...adapter,
|
|
2704
|
-
async conversations(
|
|
2705
|
-
const page2 = await adapter.conversations(
|
|
2706
|
+
async conversations(query2) {
|
|
2707
|
+
const page2 = await adapter.conversations(query2);
|
|
2706
2708
|
return { ...page2, conversations: await Promise.all(page2.conversations.map(named)) };
|
|
2707
2709
|
}
|
|
2708
2710
|
};
|
|
@@ -2856,15 +2858,15 @@ function createBlossomUploader(options) {
|
|
|
2856
2858
|
var STORAGE_KEY4 = "applet-config:v1";
|
|
2857
2859
|
function createAppletConfig(options) {
|
|
2858
2860
|
const store = createNamespacedStore(options.storage, "kernl");
|
|
2859
|
-
const
|
|
2861
|
+
const read2 = () => store.getJson(STORAGE_KEY4, {});
|
|
2860
2862
|
return {
|
|
2861
2863
|
getValues(windowId) {
|
|
2862
2864
|
const applet = options.appletOf(windowId);
|
|
2863
|
-
return applet ? { ...
|
|
2865
|
+
return applet ? { ...read2()[applet.key] } : {};
|
|
2864
2866
|
},
|
|
2865
2867
|
saveValues(windowId, values) {
|
|
2866
2868
|
const applet = options.appletOf(windowId);
|
|
2867
|
-
if (applet) store.setJson(STORAGE_KEY4, { ...
|
|
2869
|
+
if (applet) store.setJson(STORAGE_KEY4, { ...read2(), [applet.key]: values });
|
|
2868
2870
|
},
|
|
2869
2871
|
openSettings(windowId, section, context) {
|
|
2870
2872
|
const applet = options.appletOf(windowId);
|
|
@@ -2937,9 +2939,9 @@ function createCommonActions(options) {
|
|
|
2937
2939
|
const tags = [["e", targetEventId], ...target ? [["p", target.pubkey], ["k", String(target.kind)]] : [], ...emoji];
|
|
2938
2940
|
return signed(options, context.windowId, { kind: REACTION, created_at: unixNow5(), tags, content: reaction });
|
|
2939
2941
|
},
|
|
2940
|
-
report(target, reason,
|
|
2942
|
+
report(target, reason, text3, context) {
|
|
2941
2943
|
const tags = target.type === "event" ? [["e", target.id, reason], ...target.pubkey ? [["p", target.pubkey]] : []] : [["p", target.pubkey, reason]];
|
|
2942
|
-
return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content:
|
|
2944
|
+
return signed(options, context.windowId, { kind: REPORT, created_at: unixNow5(), tags, content: text3 });
|
|
2943
2945
|
}
|
|
2944
2946
|
};
|
|
2945
2947
|
}
|
|
@@ -3073,8 +3075,643 @@ function commonActionsFor(parts, network, consent) {
|
|
|
3073
3075
|
});
|
|
3074
3076
|
}
|
|
3075
3077
|
|
|
3078
|
+
// src/multiplayer/remote-tools.ts
|
|
3079
|
+
import { createCvmService } from "@kehto/services";
|
|
3080
|
+
import { createNostrCvmTransport } from "@kehto/services/cvm-nostr-transport";
|
|
3081
|
+
function mergeFamilies(host, own) {
|
|
3082
|
+
const key = (family) => `${family.family}:${family.server.pubkey}`;
|
|
3083
|
+
const chosen = new Set(own.map(key));
|
|
3084
|
+
return [...host.filter((family) => !chosen.has(key(family))), ...own];
|
|
3085
|
+
}
|
|
3086
|
+
function createCvmRelayPool(pool) {
|
|
3087
|
+
return {
|
|
3088
|
+
subscribe(relays2, filter3, params) {
|
|
3089
|
+
const handle = subscribeWithEose(pool, relays2, [filter3], (item) => {
|
|
3090
|
+
if (item === "EOSE") params.oneose?.();
|
|
3091
|
+
else params.onevent?.(item);
|
|
3092
|
+
});
|
|
3093
|
+
return { close: () => handle.unsubscribe() };
|
|
3094
|
+
},
|
|
3095
|
+
async publish(relays2, event) {
|
|
3096
|
+
await publishAccepted(pool, relays2, event);
|
|
3097
|
+
}
|
|
3098
|
+
};
|
|
3099
|
+
}
|
|
3100
|
+
function createRemoteToolsService(options) {
|
|
3101
|
+
const windows = /* @__PURE__ */ new Map();
|
|
3102
|
+
let runtime;
|
|
3103
|
+
const serviceFor = (windowId) => {
|
|
3104
|
+
let service = windows.get(windowId);
|
|
3105
|
+
if (!service) {
|
|
3106
|
+
const transport = createNostrCvmTransport({
|
|
3107
|
+
pool: createCvmRelayPool(options.pool),
|
|
3108
|
+
defaultRelays: [...options.relays()],
|
|
3109
|
+
clientSecretKey: options.identities.signer(windowId).key
|
|
3110
|
+
});
|
|
3111
|
+
service = createCvmService({ transport, ...options.registry ? { registry: options.registry() } : {} });
|
|
3112
|
+
if (runtime) service.onRegistered?.(runtime);
|
|
3113
|
+
windows.set(windowId, service);
|
|
3114
|
+
}
|
|
3115
|
+
return service;
|
|
3116
|
+
};
|
|
3117
|
+
const end = (windowId) => {
|
|
3118
|
+
const service = windows.get(windowId);
|
|
3119
|
+
windows.delete(windowId);
|
|
3120
|
+
service?.onWindowDestroyed?.(windowId);
|
|
3121
|
+
service?.dispose();
|
|
3122
|
+
options.identities.release(windowId);
|
|
3123
|
+
};
|
|
3124
|
+
return {
|
|
3125
|
+
descriptor: { name: "cvm", version: "1.0.0", description: "Remote tools, each window calling under its own key" },
|
|
3126
|
+
onRegistered(context) {
|
|
3127
|
+
runtime = context;
|
|
3128
|
+
},
|
|
3129
|
+
onUnregistered() {
|
|
3130
|
+
for (const windowId of windows.keys()) end(windowId);
|
|
3131
|
+
runtime = void 0;
|
|
3132
|
+
},
|
|
3133
|
+
handleMessage(windowId, message, send) {
|
|
3134
|
+
serviceFor(windowId).handleMessage(windowId, message, send);
|
|
3135
|
+
},
|
|
3136
|
+
onWindowDestroyed: end,
|
|
3137
|
+
onPermissionRevoked: end
|
|
3138
|
+
};
|
|
3139
|
+
}
|
|
3140
|
+
|
|
3141
|
+
// src/multiplayer/window-identities.ts
|
|
3142
|
+
import { PrivateKeySigner as PrivateKeySigner2 } from "applesauce-signers";
|
|
3143
|
+
function createWindowIdentities() {
|
|
3144
|
+
const signers = /* @__PURE__ */ new Map();
|
|
3145
|
+
return {
|
|
3146
|
+
signer(windowId) {
|
|
3147
|
+
let signer = signers.get(windowId);
|
|
3148
|
+
if (!signer) {
|
|
3149
|
+
signer = new PrivateKeySigner2();
|
|
3150
|
+
signers.set(windowId, signer);
|
|
3151
|
+
}
|
|
3152
|
+
return signer;
|
|
3153
|
+
},
|
|
3154
|
+
release(windowId) {
|
|
3155
|
+
signers.get(windowId)?.key.fill(0);
|
|
3156
|
+
signers.delete(windowId);
|
|
3157
|
+
}
|
|
3158
|
+
};
|
|
3159
|
+
}
|
|
3160
|
+
|
|
3161
|
+
// src/multiplayer/settings.ts
|
|
3162
|
+
import { BehaviorSubject as BehaviorSubject7 } from "rxjs";
|
|
3163
|
+
var STORAGE_KEY5 = "multiplayer:v1";
|
|
3164
|
+
var HEX_KEY3 = /^[0-9a-f]{64}$/u;
|
|
3165
|
+
var HELPER_URL = /^(stuns?|turns?):\S+$/u;
|
|
3166
|
+
var RELAY_URL = /^wss?:\/\/\S+$/u;
|
|
3167
|
+
var text2 = (value) => typeof value === "string" && value.trim().length > 0 && value.length <= 256;
|
|
3168
|
+
function validServers(urls) {
|
|
3169
|
+
return urls.length <= 16 && urls.every((url) => typeof url === "string" && RELAY_URL.test(url));
|
|
3170
|
+
}
|
|
3171
|
+
function validHelper(helper) {
|
|
3172
|
+
return Array.isArray(helper.urls) && helper.urls.length > 0 && helper.urls.length <= 8 && helper.urls.every((url) => typeof url === "string" && HELPER_URL.test(url)) && (helper.username === void 0 || typeof helper.username === "string") && (helper.credential === void 0 || typeof helper.credential === "string");
|
|
3173
|
+
}
|
|
3174
|
+
function validFamily(family) {
|
|
3175
|
+
const { server, tools } = family;
|
|
3176
|
+
return text2(family.family) && HEX_KEY3.test(server.pubkey) && validServers(server.relays ?? []) && Array.isArray(tools) && tools.length > 0 && tools.length <= 64 && tools.every((tool) => text2(tool.name) && HEX_KEY3.test(tool.schemaHash)) && new Set(tools.map((tool) => tool.name)).size === tools.length;
|
|
3177
|
+
}
|
|
3178
|
+
function read(raw) {
|
|
3179
|
+
const families = Array.isArray(raw.families) ? raw.families.filter(validFamily).slice(0, 16) : [];
|
|
3180
|
+
return Object.freeze({
|
|
3181
|
+
...Array.isArray(raw.servers) && validServers(raw.servers) ? { servers: raw.servers } : {},
|
|
3182
|
+
...Array.isArray(raw.helpers) && raw.helpers.every(validHelper) ? { helpers: raw.helpers } : {},
|
|
3183
|
+
families
|
|
3184
|
+
});
|
|
3185
|
+
}
|
|
3186
|
+
function createMultiplayerSettings(storage) {
|
|
3187
|
+
const store = createNamespacedStore(storage, "kernl");
|
|
3188
|
+
const state$ = new BehaviorSubject7(read(store.getJson(STORAGE_KEY5, {})));
|
|
3189
|
+
const commit = (next) => {
|
|
3190
|
+
const state = read(next);
|
|
3191
|
+
store.setJson(STORAGE_KEY5, state);
|
|
3192
|
+
state$.next(state);
|
|
3193
|
+
};
|
|
3194
|
+
const without = (key) => {
|
|
3195
|
+
const { [key]: _dropped, ...rest } = state$.value;
|
|
3196
|
+
return rest;
|
|
3197
|
+
};
|
|
3198
|
+
return {
|
|
3199
|
+
state$: state$.asObservable(),
|
|
3200
|
+
state: () => state$.value,
|
|
3201
|
+
setServers(urls) {
|
|
3202
|
+
if (urls && !validServers(urls)) throw new Error("invalid:relay-url");
|
|
3203
|
+
commit(urls ? { ...state$.value, servers: [...new Set(urls)] } : without("servers"));
|
|
3204
|
+
},
|
|
3205
|
+
setHelpers(helpers) {
|
|
3206
|
+
if (helpers && !(helpers.length <= 8 && helpers.every(validHelper))) throw new Error("invalid:helper");
|
|
3207
|
+
commit(helpers ? { ...state$.value, helpers } : without("helpers"));
|
|
3208
|
+
},
|
|
3209
|
+
saveFamily(family) {
|
|
3210
|
+
if (!validFamily(family)) throw new Error("invalid:family");
|
|
3211
|
+
const others = state$.value.families.filter((saved) => saved.family !== family.family || saved.server.pubkey !== family.server.pubkey);
|
|
3212
|
+
if (others.length >= 16) throw new Error("invalid:family");
|
|
3213
|
+
commit({ ...state$.value, families: [...others, family] });
|
|
3214
|
+
},
|
|
3215
|
+
removeFamily(label, pubkey) {
|
|
3216
|
+
commit({ ...state$.value, families: state$.value.families.filter((saved) => saved.family !== label || saved.server.pubkey !== pubkey) });
|
|
3217
|
+
}
|
|
3218
|
+
};
|
|
3219
|
+
}
|
|
3220
|
+
|
|
3221
|
+
// src/multiplayer/tool-discovery.ts
|
|
3222
|
+
import { lastValueFrom as lastValueFrom8, takeUntil as takeUntil3, timer as timer5, toArray as toArray5 } from "rxjs";
|
|
3223
|
+
import { decodeEventPointer as decodeEventPointer2, verifyEvent as verifyEvent4 } from "applesauce-core/helpers";
|
|
3224
|
+
import { computeCvmToolSchemaHash } from "@kehto/services";
|
|
3225
|
+
var KIND_SERVER = 11316;
|
|
3226
|
+
var KIND_TOOLS = 11317;
|
|
3227
|
+
var KIND_RELAY_LIST = 10002;
|
|
3228
|
+
var HASH = /^[0-9a-f]{64}$/u;
|
|
3229
|
+
var MAX_BYTES = 1e6;
|
|
3230
|
+
var MAX_TOOLS = 64;
|
|
3231
|
+
var TOOL_DISCOVERY_TIMEOUT_MS = 15e3;
|
|
3232
|
+
var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
|
|
3233
|
+
function parseJson2(text3) {
|
|
3234
|
+
try {
|
|
3235
|
+
return JSON.parse(text3);
|
|
3236
|
+
} catch {
|
|
3237
|
+
return void 0;
|
|
3238
|
+
}
|
|
3239
|
+
}
|
|
3240
|
+
function parse(input) {
|
|
3241
|
+
const typed = input.trim().replace(/^nostr:/iu, "");
|
|
3242
|
+
if (HASH.test(typed.toLowerCase())) return { type: "hash", hash: typed.toLowerCase() };
|
|
3243
|
+
if (/^nevent1/iu.test(typed)) {
|
|
3244
|
+
const pointer = decodeEventPointer2(typed);
|
|
3245
|
+
if (!pointer || pointer.kind !== void 0 && pointer.kind !== KIND_SERVER && pointer.kind !== KIND_TOOLS) throw new Error("invalid:tool-reference");
|
|
3246
|
+
return { type: "event", id: pointer.id, ...pointer.author ? { author: pointer.author } : {}, relays: pointer.relays };
|
|
3247
|
+
}
|
|
3248
|
+
let url;
|
|
3249
|
+
try {
|
|
3250
|
+
url = new URL(typed.includes("://") ? typed : `https://${typed}`);
|
|
3251
|
+
} catch {
|
|
3252
|
+
throw new Error("invalid:tool-reference");
|
|
3253
|
+
}
|
|
3254
|
+
if (url.protocol !== "https:" || url.username || url.password || !url.hostname.includes(".")) throw new Error("invalid:tool-reference");
|
|
3255
|
+
return { type: "website", url: `${url.origin}/.well-known/napplet.json` };
|
|
3256
|
+
}
|
|
3257
|
+
async function query(options, relays2, filter3) {
|
|
3258
|
+
const limit = options.timeoutMs ?? TOOL_DISCOVERY_TIMEOUT_MS;
|
|
3259
|
+
const events = await lastValueFrom8(options.pool.request([...relays2], asFilters([{ ...filter3, limit: MAX_TOOLS }])).pipe(takeUntil3(timer5(limit)), toArray5()));
|
|
3260
|
+
return events.filter((event) => event.content.length <= MAX_BYTES && verifyEvent4(event)).sort((a, b) => b.created_at - a.created_at);
|
|
3261
|
+
}
|
|
3262
|
+
async function websiteProvider(url, options) {
|
|
3263
|
+
const response = await options.fetch(url, { credentials: "omit", redirect: "error", referrerPolicy: "no-referrer" }).catch(() => void 0);
|
|
3264
|
+
const body = response?.ok ? await response.text() : "";
|
|
3265
|
+
const document = body.length <= MAX_BYTES ? parseJson2(body) : void 0;
|
|
3266
|
+
const backend = record(document) && document.version === 1 ? document.backend : void 0;
|
|
3267
|
+
if (!record(backend) || typeof backend.pubkey !== "string" || !HASH.test(backend.pubkey) || !Array.isArray(backend.relays)) throw new Error("unavailable:website");
|
|
3268
|
+
return { pubkey: backend.pubkey, relays: backend.relays.filter((relay) => typeof relay === "string") };
|
|
3269
|
+
}
|
|
3270
|
+
async function inventory(event) {
|
|
3271
|
+
const payload = parseJson2(event.content);
|
|
3272
|
+
const listed = record(payload) && Array.isArray(payload.tools) ? payload.tools : [];
|
|
3273
|
+
if (listed.length === 0 || listed.length > MAX_TOOLS) throw new Error("invalid:tool-inventory");
|
|
3274
|
+
const tools = [];
|
|
3275
|
+
for (const raw of listed) {
|
|
3276
|
+
if (!record(raw) || typeof raw.name !== "string" || !raw.name || !record(raw.inputSchema) || tools.some((tool) => tool.name === raw.name)) throw new Error("invalid:tool-inventory");
|
|
3277
|
+
const schemaHash = await computeCvmToolSchemaHash({ name: raw.name, inputSchema: raw.inputSchema, ...record(raw.outputSchema) ? { outputSchema: raw.outputSchema } : {} });
|
|
3278
|
+
const tagged = event.tags.filter((tag) => tag[0] === "i" && tag[2] === raw.name);
|
|
3279
|
+
if (tagged.some((tag) => tag[1] !== schemaHash)) throw new Error("invalid:tool-inventory");
|
|
3280
|
+
tools.push({ name: raw.name, schemaHash });
|
|
3281
|
+
}
|
|
3282
|
+
return tools;
|
|
3283
|
+
}
|
|
3284
|
+
function providerRelays(lists, pubkey, found) {
|
|
3285
|
+
const listed = lists.find((list) => list.pubkey === pubkey)?.tags.filter((tag) => tag[0] === "r" && typeof tag[1] === "string") ?? [];
|
|
3286
|
+
const unmarked = listed.filter((tag) => !tag[2]);
|
|
3287
|
+
const chosen = (unmarked.length > 0 ? unmarked : listed).map((tag) => tag[1]);
|
|
3288
|
+
return chosen.length > 0 ? chosen : [...found];
|
|
3289
|
+
}
|
|
3290
|
+
async function announcements(reference, options) {
|
|
3291
|
+
if (reference.type === "website") {
|
|
3292
|
+
const provider = await websiteProvider(reference.url, options);
|
|
3293
|
+
return { events: await query(options, provider.relays, { kinds: [KIND_TOOLS], authors: [provider.pubkey] }), relays: provider.relays };
|
|
3294
|
+
}
|
|
3295
|
+
const relays2 = reference.type === "event" && reference.relays.length > 0 ? reference.relays : options.relays;
|
|
3296
|
+
if (reference.type === "hash") return { events: await query(options, relays2, { kinds: [KIND_TOOLS], "#i": [reference.hash] }), relays: relays2 };
|
|
3297
|
+
const found = await query(options, relays2, { ids: [reference.id], kinds: [KIND_SERVER, KIND_TOOLS], ...reference.author ? { authors: [reference.author] } : {} });
|
|
3298
|
+
const first = found[0];
|
|
3299
|
+
if (first?.kind === KIND_SERVER) return { events: await query(options, relays2, { kinds: [KIND_TOOLS], authors: [first.pubkey] }), relays: relays2 };
|
|
3300
|
+
return { events: found, relays: relays2 };
|
|
3301
|
+
}
|
|
3302
|
+
async function discoverToolFamilies(input, options) {
|
|
3303
|
+
const reference = parse(input);
|
|
3304
|
+
const { events, relays: relays2 } = await announcements(reference, options);
|
|
3305
|
+
const newest2 = /* @__PURE__ */ new Map();
|
|
3306
|
+
for (const event of events) if (event.kind === KIND_TOOLS && !newest2.has(event.pubkey)) newest2.set(event.pubkey, event);
|
|
3307
|
+
if (newest2.size === 0) throw new Error("unavailable:no-tools");
|
|
3308
|
+
const lists = reference.type === "website" ? [] : await query(options, relays2, { kinds: [KIND_RELAY_LIST], authors: [...newest2.keys()] });
|
|
3309
|
+
const candidates = [];
|
|
3310
|
+
for (const event of newest2.values()) {
|
|
3311
|
+
const tools = await inventory(event);
|
|
3312
|
+
if (reference.type === "hash" && !tools.some((tool) => tool.schemaHash === reference.hash)) continue;
|
|
3313
|
+
candidates.push({
|
|
3314
|
+
family: { family: `tools.${event.pubkey.slice(0, 12)}`, server: { pubkey: event.pubkey, relays: providerRelays(lists, event.pubkey, relays2) }, tools },
|
|
3315
|
+
eventId: event.id,
|
|
3316
|
+
source: `${input.trim()} \xB7 ${event.id.slice(0, 12)}`
|
|
3317
|
+
});
|
|
3318
|
+
}
|
|
3319
|
+
if (candidates.length === 0) throw new Error("unavailable:no-tools");
|
|
3320
|
+
return candidates;
|
|
3321
|
+
}
|
|
3322
|
+
|
|
3323
|
+
// src/multiplayer/direct-connections.ts
|
|
3324
|
+
import { createWebrtcService } from "@kehto/services";
|
|
3325
|
+
|
|
3326
|
+
// src/multiplayer/direct-signaling.ts
|
|
3327
|
+
import { verifyEvent as verifyEvent5 } from "applesauce-core/helpers";
|
|
3328
|
+
var DIRECT_SIGNALING_PROFILE = "soy-rtc/1";
|
|
3329
|
+
var DIRECT_SIGNAL_KIND = 25050;
|
|
3330
|
+
var DIRECT_MAX_PAYLOAD_BYTES = 16384;
|
|
3331
|
+
var MAX_SESSIONS = 4;
|
|
3332
|
+
var MAX_PEERS = 8;
|
|
3333
|
+
var HELLO_EVERY_MS = 2e3;
|
|
3334
|
+
var JOIN_PATIENCE_MS = 45e3;
|
|
3335
|
+
var GATHER_PATIENCE_MS = 8e3;
|
|
3336
|
+
var SIGNAL_LIFETIME_S = 60;
|
|
3337
|
+
var SIGNALS_PER_SECOND = 32;
|
|
3338
|
+
var MESSAGES_PER_SECOND = 240;
|
|
3339
|
+
var BYTES_PER_SECOND = 524288;
|
|
3340
|
+
var MAX_SIGNAL_CHARS = 64e3;
|
|
3341
|
+
var MAX_SDP_CHARS = 32e3;
|
|
3342
|
+
var UNSET_LIMIT = 65535;
|
|
3343
|
+
var HEX_KEY4 = /^[0-9a-f]{64}$/u;
|
|
3344
|
+
var encoder = new TextEncoder();
|
|
3345
|
+
function invalid2(message) {
|
|
3346
|
+
throw new Error(message);
|
|
3347
|
+
}
|
|
3348
|
+
function validate(request) {
|
|
3349
|
+
const { scope } = request;
|
|
3350
|
+
if (scope.type === "room") {
|
|
3351
|
+
if (typeof scope.room !== "string" || !scope.room || scope.room.length > 256) invalid2("invalid room");
|
|
3352
|
+
if (scope.peers && (scope.peers.length > MAX_PEERS || !scope.peers.every((key) => HEX_KEY4.test(key)))) invalid2("invalid peers");
|
|
3353
|
+
} else if (scope.type !== "direct" || !HEX_KEY4.test(scope.pubkey)) invalid2("invalid scope");
|
|
3354
|
+
if (request.channel !== void 0 && (!request.channel || request.channel.length > 64)) invalid2("invalid channel");
|
|
3355
|
+
if (request.protocol !== void 0 && request.protocol.length > 128) invalid2("invalid protocol");
|
|
3356
|
+
}
|
|
3357
|
+
function reliable(body) {
|
|
3358
|
+
if (body.realtime === void 0) return true;
|
|
3359
|
+
const realtime = body.realtime;
|
|
3360
|
+
return realtime?.profile === "soy-rtc/realtime-1" && realtime.ordered === true && realtime.maxRetransmits === null;
|
|
3361
|
+
}
|
|
3362
|
+
function reliableChannel(channel) {
|
|
3363
|
+
return channel.ordered && [channel.maxRetransmits, channel.maxPacketLifeTime].every((limit) => limit === null || limit === UNSET_LIMIT);
|
|
3364
|
+
}
|
|
3365
|
+
function gathered(connection) {
|
|
3366
|
+
return new Promise((resolve) => {
|
|
3367
|
+
const finish = () => {
|
|
3368
|
+
clearTimeout(timer8);
|
|
3369
|
+
connection.removeEventListener("icegatheringstatechange", changed);
|
|
3370
|
+
resolve();
|
|
3371
|
+
};
|
|
3372
|
+
const changed = () => {
|
|
3373
|
+
if (connection.iceGatheringState === "complete") finish();
|
|
3374
|
+
};
|
|
3375
|
+
const timer8 = setTimeout(finish, GATHER_PATIENCE_MS);
|
|
3376
|
+
connection.addEventListener("icegatheringstatechange", changed);
|
|
3377
|
+
changed();
|
|
3378
|
+
});
|
|
3379
|
+
}
|
|
3380
|
+
async function wireOf(namespace, self, request, channel) {
|
|
3381
|
+
const { scope } = request;
|
|
3382
|
+
const where = scope.type === "room" ? ["room", scope.room] : ["direct", ...[self, scope.pubkey].sort()];
|
|
3383
|
+
const identity = JSON.stringify([DIRECT_SIGNALING_PROFILE, namespace, where, channel, request.protocol ?? ""]);
|
|
3384
|
+
const digest = await crypto.subtle.digest("SHA-256", encoder.encode(identity));
|
|
3385
|
+
return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
3386
|
+
}
|
|
3387
|
+
function forgetStale(memory, now) {
|
|
3388
|
+
for (const [key, at] of memory) {
|
|
3389
|
+
if (now - at <= SIGNAL_LIFETIME_S * 1e3) break;
|
|
3390
|
+
memory.delete(key);
|
|
3391
|
+
}
|
|
3392
|
+
}
|
|
3393
|
+
function createDirectSignaling(options) {
|
|
3394
|
+
const signaling = new DirectSignaling(options);
|
|
3395
|
+
return {
|
|
3396
|
+
planOpen: (request) => signaling.planOpen(request),
|
|
3397
|
+
open: (request, context) => signaling.open(request, context),
|
|
3398
|
+
send: (id, payload, context) => signaling.send(id, payload, context),
|
|
3399
|
+
close: (id, reason, context) => signaling.close(signaling.sessionFor(id, context), reason),
|
|
3400
|
+
destroyWindow: () => signaling.closeAll(),
|
|
3401
|
+
revokeWindow: () => signaling.closeAll()
|
|
3402
|
+
};
|
|
3403
|
+
}
|
|
3404
|
+
var DirectSignaling = class {
|
|
3405
|
+
constructor(options) {
|
|
3406
|
+
this.options = options;
|
|
3407
|
+
this.self = options.signer.getPublicKey();
|
|
3408
|
+
}
|
|
3409
|
+
options;
|
|
3410
|
+
sessions = /* @__PURE__ */ new Map();
|
|
3411
|
+
self;
|
|
3412
|
+
planOpen(request) {
|
|
3413
|
+
validate(request);
|
|
3414
|
+
if (this.options.relays.length === 0) invalid2("signaling unavailable");
|
|
3415
|
+
const resource = request.scope.type === "room" ? `room:${request.scope.room}` : `peer:${request.scope.pubkey}`;
|
|
3416
|
+
return { signalingRelayUrls: this.options.relays, iceEndpoints: this.options.iceEndpoints, resource };
|
|
3417
|
+
}
|
|
3418
|
+
async open(request, context) {
|
|
3419
|
+
validate(request);
|
|
3420
|
+
const me = await this.self;
|
|
3421
|
+
if (this.sessions.size >= MAX_SESSIONS) invalid2("session limit reached");
|
|
3422
|
+
if (request.scope.type === "direct" && request.scope.pubkey === me) invalid2("cannot connect to self");
|
|
3423
|
+
const channel = request.channel ?? "napplet";
|
|
3424
|
+
const wire = await wireOf(this.options.namespace, me, request, channel);
|
|
3425
|
+
if ([...this.sessions.values()].some((session2) => session2.wire === wire)) invalid2("scope already open");
|
|
3426
|
+
const session = {
|
|
3427
|
+
id: crypto.randomUUID(),
|
|
3428
|
+
wire,
|
|
3429
|
+
nonce: crypto.randomUUID(),
|
|
3430
|
+
request,
|
|
3431
|
+
channel,
|
|
3432
|
+
context,
|
|
3433
|
+
peers: /* @__PURE__ */ new Map(),
|
|
3434
|
+
retired: /* @__PURE__ */ new Map(),
|
|
3435
|
+
seen: /* @__PURE__ */ new Map(),
|
|
3436
|
+
signals: { since: Date.now(), count: 0 },
|
|
3437
|
+
open: false
|
|
3438
|
+
};
|
|
3439
|
+
this.sessions.set(session.id, session);
|
|
3440
|
+
context.signal?.addEventListener("abort", () => this.close(session), { once: true });
|
|
3441
|
+
this.start(session);
|
|
3442
|
+
const { protocol } = request;
|
|
3443
|
+
return { session: { id: session.id, scope: request.scope, channel, ...protocol ? { protocol } : {}, state: "connecting" } };
|
|
3444
|
+
}
|
|
3445
|
+
send(id, payload, context) {
|
|
3446
|
+
const session = this.sessionFor(id, context);
|
|
3447
|
+
const json = JSON.stringify(payload);
|
|
3448
|
+
const size = json === void 0 ? Infinity : encoder.encode(json).length;
|
|
3449
|
+
if (size > DIRECT_MAX_PAYLOAD_BYTES) invalid2("payload is not JSON of at most 16 KiB");
|
|
3450
|
+
const channels = [...session.peers.values()].filter((peer) => peer.joined && peer.channel?.readyState === "open").map((peer) => peer.channel);
|
|
3451
|
+
if (channels.length === 0) invalid2("peer unavailable");
|
|
3452
|
+
for (const channel of channels) channel.send(json);
|
|
3453
|
+
}
|
|
3454
|
+
sessionFor(id, context) {
|
|
3455
|
+
const session = this.sessions.get(id);
|
|
3456
|
+
if (!session || session.context.windowId !== context.windowId || !this.live(session)) throw new Error("session not found");
|
|
3457
|
+
return session;
|
|
3458
|
+
}
|
|
3459
|
+
close(session, reason) {
|
|
3460
|
+
if (!this.sessions.has(session.id)) return;
|
|
3461
|
+
this.emit(session, { type: "closed", sessionId: session.id, ...reason ? { reason } : {} });
|
|
3462
|
+
this.sessions.delete(session.id);
|
|
3463
|
+
clearInterval(session.timer);
|
|
3464
|
+
session.subscription?.close();
|
|
3465
|
+
for (const peer of session.peers.values()) this.removePeer(session, peer);
|
|
3466
|
+
}
|
|
3467
|
+
closeAll() {
|
|
3468
|
+
for (const session of this.sessions.values()) this.close(session);
|
|
3469
|
+
}
|
|
3470
|
+
live(session) {
|
|
3471
|
+
return this.sessions.get(session.id) === session && !session.context.signal?.aborted;
|
|
3472
|
+
}
|
|
3473
|
+
emit(session, event) {
|
|
3474
|
+
if (this.live(session)) session.context.emit(event);
|
|
3475
|
+
}
|
|
3476
|
+
activePeer(session, peer) {
|
|
3477
|
+
return this.live(session) && session.peers.get(peer.key) === peer;
|
|
3478
|
+
}
|
|
3479
|
+
removePeer(session, peer) {
|
|
3480
|
+
if (session.peers.get(peer.key) !== peer) return;
|
|
3481
|
+
session.peers.delete(peer.key);
|
|
3482
|
+
if (peer.joined) this.emit(session, { type: "peer", sessionId: session.id, pubkey: peer.key, state: "left" });
|
|
3483
|
+
peer.channel?.close();
|
|
3484
|
+
peer.connection.close();
|
|
3485
|
+
}
|
|
3486
|
+
async publish(session, body, recipient) {
|
|
3487
|
+
const { signer } = this.options;
|
|
3488
|
+
const raw = JSON.stringify({ v: DIRECT_SIGNALING_PROFILE, wire: session.wire, nonce: session.nonce, ...body });
|
|
3489
|
+
const now = Math.floor(Date.now() / 1e3);
|
|
3490
|
+
const event = await signer.signEvent({
|
|
3491
|
+
kind: DIRECT_SIGNAL_KIND,
|
|
3492
|
+
created_at: now,
|
|
3493
|
+
content: recipient ? await signer.nip44.encrypt(recipient, raw) : raw,
|
|
3494
|
+
tags: [["d", session.wire], ["expiration", String(now + SIGNAL_LIFETIME_S)], ...recipient ? [["p", recipient]] : []]
|
|
3495
|
+
});
|
|
3496
|
+
try {
|
|
3497
|
+
await this.options.relay.publish(this.options.relays, event);
|
|
3498
|
+
} catch {
|
|
3499
|
+
}
|
|
3500
|
+
}
|
|
3501
|
+
attach(session, peer, channel) {
|
|
3502
|
+
if (!this.activePeer(session, peer) || peer.channel || channel.label !== session.channel || channel.protocol !== "" || !reliableChannel(channel)) {
|
|
3503
|
+
channel.close();
|
|
3504
|
+
return;
|
|
3505
|
+
}
|
|
3506
|
+
peer.channel = channel;
|
|
3507
|
+
channel.addEventListener("open", () => {
|
|
3508
|
+
peer.joined = true;
|
|
3509
|
+
this.emit(session, { type: "peer", sessionId: session.id, pubkey: peer.key, state: "joined" });
|
|
3510
|
+
if (session.open) return;
|
|
3511
|
+
session.open = true;
|
|
3512
|
+
this.emit(session, { type: "state", sessionId: session.id, state: "open" });
|
|
3513
|
+
});
|
|
3514
|
+
const budget = { since: Date.now(), messages: 0, bytes: 0 };
|
|
3515
|
+
channel.addEventListener("message", (event) => {
|
|
3516
|
+
if (!this.activePeer(session, peer) || typeof event.data !== "string") return;
|
|
3517
|
+
const size = encoder.encode(event.data).length;
|
|
3518
|
+
if (Date.now() - budget.since > 1e3) Object.assign(budget, { since: Date.now(), messages: 0, bytes: 0 });
|
|
3519
|
+
budget.messages += 1;
|
|
3520
|
+
budget.bytes += size;
|
|
3521
|
+
if (size > DIRECT_MAX_PAYLOAD_BYTES || budget.messages > MESSAGES_PER_SECOND || budget.bytes > BYTES_PER_SECOND) return;
|
|
3522
|
+
try {
|
|
3523
|
+
this.emit(session, { type: "message", sessionId: session.id, from: peer.key, payload: JSON.parse(event.data) });
|
|
3524
|
+
} catch {
|
|
3525
|
+
}
|
|
3526
|
+
});
|
|
3527
|
+
channel.addEventListener("close", () => this.removePeer(session, peer));
|
|
3528
|
+
}
|
|
3529
|
+
/** Run a peer's negotiation steps one at a time; a step that fails drops the peer. */
|
|
3530
|
+
queue(session, peer, step) {
|
|
3531
|
+
peer.chain = peer.chain.then(step).catch(() => this.removePeer(session, peer));
|
|
3532
|
+
}
|
|
3533
|
+
async meet(session, key, nonce) {
|
|
3534
|
+
const known = session.peers.get(key);
|
|
3535
|
+
if (known && known.nonce !== nonce) {
|
|
3536
|
+
session.retired.set(`${key}:${known.nonce}`, Date.now());
|
|
3537
|
+
this.removePeer(session, known);
|
|
3538
|
+
} else if (known) return;
|
|
3539
|
+
if (session.peers.size >= MAX_PEERS) return;
|
|
3540
|
+
const peer = { key, nonce, connection: this.options.createPeer(), started: Date.now(), joined: false, chain: Promise.resolve() };
|
|
3541
|
+
session.peers.set(key, peer);
|
|
3542
|
+
peer.connection.addEventListener("datachannel", (event) => this.attach(session, peer, event.channel));
|
|
3543
|
+
peer.connection.addEventListener("connectionstatechange", () => {
|
|
3544
|
+
if (peer.connection.connectionState === "failed" || peer.connection.connectionState === "closed") this.removePeer(session, peer);
|
|
3545
|
+
});
|
|
3546
|
+
void this.publish(session, { type: "hello" });
|
|
3547
|
+
if (await this.self < key) this.queue(session, peer, () => this.offer(session, peer));
|
|
3548
|
+
}
|
|
3549
|
+
async offer(session, peer) {
|
|
3550
|
+
this.attach(session, peer, peer.connection.createDataChannel(session.channel, { ordered: true }));
|
|
3551
|
+
await peer.connection.setLocalDescription(await peer.connection.createOffer());
|
|
3552
|
+
await gathered(peer.connection);
|
|
3553
|
+
peer.offer = peer.connection.localDescription.sdp;
|
|
3554
|
+
await this.publish(session, { type: "offer", to: peer.nonce, sdp: peer.offer }, peer.key);
|
|
3555
|
+
}
|
|
3556
|
+
async answer(session, peer, sdp) {
|
|
3557
|
+
if (!peer.answer) {
|
|
3558
|
+
await peer.connection.setRemoteDescription({ type: "offer", sdp });
|
|
3559
|
+
await peer.connection.setLocalDescription(await peer.connection.createAnswer());
|
|
3560
|
+
await gathered(peer.connection);
|
|
3561
|
+
peer.answer = peer.connection.localDescription.sdp;
|
|
3562
|
+
}
|
|
3563
|
+
await this.publish(session, { type: "answer", to: peer.nonce, sdp: peer.answer }, peer.key);
|
|
3564
|
+
}
|
|
3565
|
+
async negotiate(session, peer, body) {
|
|
3566
|
+
const me = await this.self;
|
|
3567
|
+
const sdp = body.sdp;
|
|
3568
|
+
if (body.type === "offer" && peer.key < me) this.queue(session, peer, () => this.answer(session, peer, sdp));
|
|
3569
|
+
else if (body.type === "answer" && me < peer.key && !peer.connection.remoteDescription) {
|
|
3570
|
+
this.queue(session, peer, () => peer.connection.setRemoteDescription({ type: "answer", sdp }));
|
|
3571
|
+
}
|
|
3572
|
+
}
|
|
3573
|
+
admitted(session, event, me) {
|
|
3574
|
+
const now = Date.now();
|
|
3575
|
+
forgetStale(session.seen, now);
|
|
3576
|
+
forgetStale(session.retired, now);
|
|
3577
|
+
if (now - session.signals.since > 1e3) Object.assign(session.signals, { since: now, count: 0 });
|
|
3578
|
+
session.signals.count += 1;
|
|
3579
|
+
const { scope } = session.request;
|
|
3580
|
+
const fromAllowed = scope.type === "direct" ? event.pubkey === scope.pubkey : !scope.peers || scope.peers.includes(event.pubkey);
|
|
3581
|
+
return session.signals.count <= SIGNALS_PER_SECOND && event.kind === DIRECT_SIGNAL_KIND && event.pubkey !== me && event.content.length <= MAX_SIGNAL_CHARS && Math.abs(now / 1e3 - event.created_at) <= SIGNAL_LIFETIME_S && !session.seen.has(event.id) && event.tags.some((tag) => tag[0] === "d" && tag[1] === session.wire) && fromAllowed && verifyEvent5(event);
|
|
3582
|
+
}
|
|
3583
|
+
async receive(session, event) {
|
|
3584
|
+
const me = await this.self;
|
|
3585
|
+
if (!this.live(session) || !this.admitted(session, event, me)) return;
|
|
3586
|
+
const recipient = event.tags.find((tag) => tag[0] === "p")?.[1];
|
|
3587
|
+
if (recipient !== void 0 && recipient !== me) return;
|
|
3588
|
+
session.seen.set(event.id, Date.now());
|
|
3589
|
+
const body = JSON.parse(recipient ? await this.options.signer.nip44.decrypt(event.pubkey, event.content) : event.content);
|
|
3590
|
+
const shaped = body.v === DIRECT_SIGNALING_PROFILE && body.wire === session.wire && typeof body.nonce === "string" && body.nonce.length > 0 && body.nonce.length <= 64;
|
|
3591
|
+
if (!shaped || session.retired.has(`${event.pubkey}:${body.nonce}`) || !reliable(body)) return;
|
|
3592
|
+
if (!recipient) {
|
|
3593
|
+
if (body.type === "hello") await this.meet(session, event.pubkey, body.nonce);
|
|
3594
|
+
return;
|
|
3595
|
+
}
|
|
3596
|
+
const peer = session.peers.get(event.pubkey);
|
|
3597
|
+
if (!peer || peer.nonce !== body.nonce || body.to !== session.nonce || typeof body.sdp !== "string" || body.sdp.length > MAX_SDP_CHARS) return;
|
|
3598
|
+
await this.negotiate(session, peer, body);
|
|
3599
|
+
}
|
|
3600
|
+
start(session) {
|
|
3601
|
+
const filter3 = { kinds: [DIRECT_SIGNAL_KIND], "#d": [session.wire], since: Math.floor(Date.now() / 1e3) - 10 };
|
|
3602
|
+
session.subscription = this.options.relay.subscribe(this.options.relays, [filter3], (event) => {
|
|
3603
|
+
void this.receive(session, event).catch(() => void 0);
|
|
3604
|
+
});
|
|
3605
|
+
const tick = () => {
|
|
3606
|
+
void this.publish(session, { type: "hello" });
|
|
3607
|
+
for (const peer of session.peers.values()) {
|
|
3608
|
+
if (!peer.joined && Date.now() - peer.started > JOIN_PATIENCE_MS) this.removePeer(session, peer);
|
|
3609
|
+
else if (peer.offer && !peer.connection.remoteDescription) void this.publish(session, { type: "offer", to: peer.nonce, sdp: peer.offer }, peer.key);
|
|
3610
|
+
}
|
|
3611
|
+
};
|
|
3612
|
+
tick();
|
|
3613
|
+
session.timer = setInterval(tick, HELLO_EVERY_MS);
|
|
3614
|
+
}
|
|
3615
|
+
};
|
|
3616
|
+
|
|
3617
|
+
// src/multiplayer/direct-connections.ts
|
|
3618
|
+
function directNamespace(summary) {
|
|
3619
|
+
const [, kind, ...rest] = summary.manifest.catalogId.split(":");
|
|
3620
|
+
if (rest[0] === summary.publisher) rest.shift();
|
|
3621
|
+
return `${summary.publisher}:${kind}:${rest.join(":")}`;
|
|
3622
|
+
}
|
|
3623
|
+
function describeDirectConnection(requirements, applet) {
|
|
3624
|
+
const resource = requirements.find((requirement) => requirement.category === "resource").scope.value;
|
|
3625
|
+
const scoped = (kind) => requirements.filter((requirement) => requirement.category === "network" && requirement.scope.kind === kind).map((requirement) => requirement.scope.value);
|
|
3626
|
+
const relays2 = scoped("origin").map((origin) => new URL(origin).host);
|
|
3627
|
+
const helpers = scoped("ice");
|
|
3628
|
+
const draft = { kind: DIRECT_SIGNAL_KIND, content: "", tags: [["t", "direct"]], created_at: 0, pubkey: "", id: "", sig: "" };
|
|
3629
|
+
return {
|
|
3630
|
+
title: "Connect directly to other people",
|
|
3631
|
+
severity: "direct",
|
|
3632
|
+
lines: [
|
|
3633
|
+
{ label: "With", after: resource.startsWith("room:") ? `Anyone who joins "${resource.slice(5)}" in this applet` : "One person this applet chose" },
|
|
3634
|
+
{ label: "They learn", after: "Your network address, which can show roughly where you are" },
|
|
3635
|
+
{ label: "They see", after: "Whatever this applet sends them. The shell cannot see it." },
|
|
3636
|
+
{ label: "Introduced by", after: relays2.join(", ") },
|
|
3637
|
+
...helpers.length > 0 ? [{ label: "Helped by", after: helpers.join(", ") }] : [],
|
|
3638
|
+
{ label: "They know you as", after: "A new name for this window, not your account" }
|
|
3639
|
+
],
|
|
3640
|
+
applet,
|
|
3641
|
+
event: draft
|
|
3642
|
+
};
|
|
3643
|
+
}
|
|
3644
|
+
function signalRelayOver(pool) {
|
|
3645
|
+
return {
|
|
3646
|
+
subscribe(relays2, filters, onEvent) {
|
|
3647
|
+
const handle = subscribeWithEose(pool, [...relays2], filters, (item) => {
|
|
3648
|
+
if (item !== "EOSE") onEvent(item);
|
|
3649
|
+
});
|
|
3650
|
+
return { close: () => handle.unsubscribe() };
|
|
3651
|
+
},
|
|
3652
|
+
async publish(relays2, event) {
|
|
3653
|
+
await publishAccepted(pool, [...relays2], event);
|
|
3654
|
+
}
|
|
3655
|
+
};
|
|
3656
|
+
}
|
|
3657
|
+
function createDirectConnectionsService(options) {
|
|
3658
|
+
const windows = /* @__PURE__ */ new Map();
|
|
3659
|
+
const createPeer = options.createPeer ?? ((configuration) => new RTCPeerConnection(configuration));
|
|
3660
|
+
let runtime;
|
|
3661
|
+
const authorize = (lifetime) => async (windowId, _operation, requirements, execute, signal) => {
|
|
3662
|
+
const applet = options.appletOf(windowId);
|
|
3663
|
+
if (!applet || !options.isGranted(windowId)) return { status: "denied" };
|
|
3664
|
+
if (!await options.ask(describeDirectConnection(requirements, applet.identity))) return { status: "denied" };
|
|
3665
|
+
if (lifetime.aborted || signal?.aborted || !options.isGranted(windowId)) return { status: "cancelled" };
|
|
3666
|
+
return { status: "executed", value: await execute(lifetime) };
|
|
3667
|
+
};
|
|
3668
|
+
const windowFor = (windowId) => {
|
|
3669
|
+
let entry = windows.get(windowId);
|
|
3670
|
+
if (!entry) {
|
|
3671
|
+
const lifetime = new AbortController();
|
|
3672
|
+
const applet = options.appletOf(windowId);
|
|
3673
|
+
const helpers = options.iceServers();
|
|
3674
|
+
const configuration = { iceServers: helpers.map((server) => ({ ...server, urls: [...server.urls] })) };
|
|
3675
|
+
const service = createWebrtcService(createDirectSignaling({
|
|
3676
|
+
signer: options.identities.signer(windowId),
|
|
3677
|
+
namespace: applet ? directNamespace(applet) : "",
|
|
3678
|
+
relays: [...options.relays()],
|
|
3679
|
+
relay: signalRelayOver(options.pool),
|
|
3680
|
+
iceEndpoints: helpers.flatMap((server) => server.urls),
|
|
3681
|
+
createPeer: () => createPeer(configuration)
|
|
3682
|
+
}));
|
|
3683
|
+
service.onRegistered?.({ ...runtime, authorizeOperation: authorize(lifetime.signal) });
|
|
3684
|
+
entry = { service, lifetime };
|
|
3685
|
+
windows.set(windowId, entry);
|
|
3686
|
+
}
|
|
3687
|
+
return entry;
|
|
3688
|
+
};
|
|
3689
|
+
const end = (windowId) => {
|
|
3690
|
+
const entry = windows.get(windowId);
|
|
3691
|
+
windows.delete(windowId);
|
|
3692
|
+
entry?.lifetime.abort();
|
|
3693
|
+
entry?.service.onWindowDestroyed?.(windowId);
|
|
3694
|
+
options.identities.release(windowId);
|
|
3695
|
+
};
|
|
3696
|
+
return {
|
|
3697
|
+
descriptor: { name: "webrtc", version: "1.0.0", description: "Direct sessions between people, each window under its own key" },
|
|
3698
|
+
onRegistered(context) {
|
|
3699
|
+
runtime = context;
|
|
3700
|
+
},
|
|
3701
|
+
onUnregistered() {
|
|
3702
|
+
for (const windowId of windows.keys()) end(windowId);
|
|
3703
|
+
runtime = void 0;
|
|
3704
|
+
},
|
|
3705
|
+
handleMessage(windowId, message, send) {
|
|
3706
|
+
windowFor(windowId).service.handleMessage(windowId, message, send);
|
|
3707
|
+
},
|
|
3708
|
+
onWindowDestroyed: end,
|
|
3709
|
+
onPermissionRevoked: end
|
|
3710
|
+
};
|
|
3711
|
+
}
|
|
3712
|
+
|
|
3076
3713
|
// src/kernl-services.ts
|
|
3077
|
-
import { verifyEvent as
|
|
3714
|
+
import { verifyEvent as verifyEvent6 } from "applesauce-core/helpers";
|
|
3078
3715
|
import {
|
|
3079
3716
|
createCommonService,
|
|
3080
3717
|
createConfigService,
|
|
@@ -3092,8 +3729,8 @@ import { createBridgeResourceResolver } from "@kernlize/bridges";
|
|
|
3092
3729
|
function isTheme(value) {
|
|
3093
3730
|
const colors = value?.colors;
|
|
3094
3731
|
if (typeof colors !== "object" || colors === null) return false;
|
|
3095
|
-
const { background, text:
|
|
3096
|
-
return typeof background === "string" && typeof
|
|
3732
|
+
const { background, text: text3, primary } = colors;
|
|
3733
|
+
return typeof background === "string" && typeof text3 === "string" && typeof primary === "string";
|
|
3097
3734
|
}
|
|
3098
3735
|
var LINK_PROTOCOLS = Object.freeze(["https:", "mailto:"]);
|
|
3099
3736
|
function toRelayListEntry(relays2) {
|
|
@@ -3154,7 +3791,7 @@ function createOutbox(deps, identity) {
|
|
|
3154
3791
|
if (!signer?.signEvent) throw new Error("denied:read-only");
|
|
3155
3792
|
return signer.signEvent(template);
|
|
3156
3793
|
},
|
|
3157
|
-
verifyEvent: (event) =>
|
|
3794
|
+
verifyEvent: (event) => verifyEvent6(event)
|
|
3158
3795
|
});
|
|
3159
3796
|
return createOutboxService({ router: acceptAnyRelay(router) });
|
|
3160
3797
|
}
|
|
@@ -3183,6 +3820,9 @@ function createKernlServices(deps) {
|
|
|
3183
3820
|
const composite = deps.messaging.composite();
|
|
3184
3821
|
const dm = createDmService({ adapter: deps.profiles ? labelConversations(composite, deps.profiles) : composite });
|
|
3185
3822
|
const resolve = createBridgeResourceResolver(deps.bridges);
|
|
3823
|
+
const identities = deps.identities ?? createWindowIdentities();
|
|
3824
|
+
const direct = deps.directConnections;
|
|
3825
|
+
const chosen = () => deps.multiplayer?.state();
|
|
3186
3826
|
const registry = {
|
|
3187
3827
|
relay: createAppletRelayService(deps.pool, deps.tiers),
|
|
3188
3828
|
identity: createIdentityService({ getSigner: createIdentitySigner(deps.auth), ...identity }),
|
|
@@ -3202,6 +3842,21 @@ function createKernlServices(deps) {
|
|
|
3202
3842
|
}),
|
|
3203
3843
|
dm,
|
|
3204
3844
|
outbox: gateOutboxPublish(createOutbox(deps, identity), deps.consent),
|
|
3845
|
+
cvm: createRemoteToolsService({
|
|
3846
|
+
pool: deps.pool,
|
|
3847
|
+
relays: () => chosen()?.servers ?? deps.remoteTools?.relays ?? deps.tiers.get().super,
|
|
3848
|
+
identities,
|
|
3849
|
+
registry: () => mergeFamilies(deps.remoteTools?.registry ?? [], chosen()?.families ?? [])
|
|
3850
|
+
}),
|
|
3851
|
+
...direct ? {
|
|
3852
|
+
webrtc: createDirectConnectionsService({
|
|
3853
|
+
...direct,
|
|
3854
|
+
pool: deps.pool,
|
|
3855
|
+
relays: () => chosen()?.servers ?? direct.settings.relays ?? deps.tiers.get().super,
|
|
3856
|
+
identities,
|
|
3857
|
+
iceServers: () => chosen()?.helpers ?? direct.settings.iceServers ?? []
|
|
3858
|
+
})
|
|
3859
|
+
} : {},
|
|
3205
3860
|
...deps.config ? { config: createConfigService(deps.config).handler } : {},
|
|
3206
3861
|
...deps.common ? { common: createCommonService(deps.common) } : {},
|
|
3207
3862
|
...deps.uploader ? { upload: createUploadService({ uploader: deps.uploader, uploadInfo: { rails: [{ rail: "blossom", enabled: true }] } }) } : {}
|
|
@@ -3210,7 +3865,7 @@ function createKernlServices(deps) {
|
|
|
3210
3865
|
}
|
|
3211
3866
|
|
|
3212
3867
|
// src/kernl-adapter.ts
|
|
3213
|
-
import { verifyEvent as
|
|
3868
|
+
import { verifyEvent as verifyEvent7 } from "applesauce-core/helpers";
|
|
3214
3869
|
var TIERS2 = ["discovery", "apps", "outbox", "super"];
|
|
3215
3870
|
var UPLOAD_BACKEND = Object.freeze({ rails: Object.freeze(["blossom"]) });
|
|
3216
3871
|
function isTier(tier) {
|
|
@@ -3241,7 +3896,9 @@ function createShellAdapter(deps) {
|
|
|
3241
3896
|
// kehto offers the upload domain only when both the service and this backend are present; kernl's uploads are Blossom (D-033).
|
|
3242
3897
|
upload: { getUploader: () => deps.services.upload ? UPLOAD_BACKEND : null },
|
|
3243
3898
|
common: { isAvailable: () => deps.services.common !== void 0 },
|
|
3244
|
-
|
|
3899
|
+
// kehto offers direct connections only when this says so; kernl registers the service only where the page can make peer connections (D-042).
|
|
3900
|
+
webrtc: { isAvailable: () => deps.services.webrtc !== void 0 },
|
|
3901
|
+
crypto: { verifyEvent: (event) => Promise.resolve(verifyEvent7(event)) },
|
|
3245
3902
|
link: { isAvailable: () => true },
|
|
3246
3903
|
intent: { isAvailable: () => true },
|
|
3247
3904
|
services: deps.services,
|
|
@@ -3257,11 +3914,11 @@ function createShellAdapter(deps) {
|
|
|
3257
3914
|
|
|
3258
3915
|
// src/kernl-lifecycle.ts
|
|
3259
3916
|
import { originRegistry } from "@kehto/shell";
|
|
3260
|
-
function grantNarrowingReason(plan,
|
|
3917
|
+
function grantNarrowingReason(plan, record2, baseline) {
|
|
3261
3918
|
const { identity } = plan.summary;
|
|
3262
|
-
if (
|
|
3263
|
-
if (
|
|
3264
|
-
const allowed = /* @__PURE__ */ new Set([...baseline, ...
|
|
3919
|
+
if (record2.identity.dTag !== identity.dTag || record2.identity.hash !== identity.hash) return void 0;
|
|
3920
|
+
if (record2.blocked) return "blocked";
|
|
3921
|
+
const allowed = /* @__PURE__ */ new Set([...baseline, ...record2.domains]);
|
|
3265
3922
|
return plan.environment.capabilities.domains.some((domain) => !allowed.has(domain)) ? "grant-narrowed" : void 0;
|
|
3266
3923
|
}
|
|
3267
3924
|
function keyOf2(identity) {
|
|
@@ -3322,8 +3979,8 @@ function createAppletLifecycle(context) {
|
|
|
3322
3979
|
onRevoked: (windowId, reason) => context.host.onRevoked(windowId, reason)
|
|
3323
3980
|
});
|
|
3324
3981
|
handles.set(plan.windowId, handle);
|
|
3325
|
-
const narrowed = context.grants.changes$.subscribe((
|
|
3326
|
-
const reason = grantNarrowingReason(plan,
|
|
3982
|
+
const narrowed = context.grants.changes$.subscribe((record2) => {
|
|
3983
|
+
const reason = grantNarrowingReason(plan, record2, context.grants.baselineDomains());
|
|
3327
3984
|
if (!reason) return;
|
|
3328
3985
|
handle.revoked(reason);
|
|
3329
3986
|
bridge.revokeNapplet(plan.windowId, "host");
|
|
@@ -3344,7 +4001,7 @@ function createAppletLifecycle(context) {
|
|
|
3344
4001
|
}
|
|
3345
4002
|
|
|
3346
4003
|
// src/kernl.ts
|
|
3347
|
-
import { BehaviorSubject as
|
|
4004
|
+
import { BehaviorSubject as BehaviorSubject9, map as map9, of as of3, Subject as Subject4, Subscription as Subscription2, switchMap as switchMap5 } from "rxjs";
|
|
3348
4005
|
import { EventStore } from "applesauce-core";
|
|
3349
4006
|
import { RelayPool } from "applesauce-relay";
|
|
3350
4007
|
import { buildShellCapabilities, createShellBridge } from "@kehto/shell";
|
|
@@ -3355,8 +4012,8 @@ import { Subscription } from "rxjs";
|
|
|
3355
4012
|
import { createIntentService } from "@kehto/services";
|
|
3356
4013
|
|
|
3357
4014
|
// src/intents/defaults.ts
|
|
3358
|
-
import { lastValueFrom as
|
|
3359
|
-
import { verifyEvent as
|
|
4015
|
+
import { lastValueFrom as lastValueFrom9, Subject as Subject3, takeUntil as takeUntil4, timer as timer6, toArray as toArray6 } from "rxjs";
|
|
4016
|
+
import { verifyEvent as verifyEvent8 } from "applesauce-core/helpers";
|
|
3360
4017
|
|
|
3361
4018
|
// src/intents/preferences.ts
|
|
3362
4019
|
var HANDLER_PREFERENCES_KIND = 31129;
|
|
@@ -3428,7 +4085,7 @@ function preferenceRelays(tiers) {
|
|
|
3428
4085
|
function newestPerArchetype(events, pubkey) {
|
|
3429
4086
|
const newest2 = /* @__PURE__ */ new Map();
|
|
3430
4087
|
for (const event of events) {
|
|
3431
|
-
if (event.kind !== HANDLER_PREFERENCES_KIND || event.pubkey !== pubkey || !
|
|
4088
|
+
if (event.kind !== HANDLER_PREFERENCES_KIND || event.pubkey !== pubkey || !verifyEvent8(event)) continue;
|
|
3432
4089
|
const archetype = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
|
|
3433
4090
|
const current = newest2.get(archetype);
|
|
3434
4091
|
if (archetype && (!current || event.created_at > current.created_at)) newest2.set(archetype, event);
|
|
@@ -3471,7 +4128,7 @@ function createHandlerDefaults(options) {
|
|
|
3471
4128
|
loadedFor = pubkey;
|
|
3472
4129
|
if (!pubkey) return;
|
|
3473
4130
|
const request = options.pool.request([...preferenceRelays(options.tiers)], asFilters([{ kinds: [HANDLER_PREFERENCES_KIND], authors: [pubkey] }]));
|
|
3474
|
-
const events = await
|
|
4131
|
+
const events = await lastValueFrom9(request.pipe(takeUntil4(timer6(LOAD_TIMEOUT_MS)), toArray6()), { defaultValue: [] }).catch(() => []);
|
|
3475
4132
|
for (const [archetype, event] of newestPerArchetype(events, pubkey)) {
|
|
3476
4133
|
published.set(archetype, event);
|
|
3477
4134
|
changes$.next(archetype);
|
|
@@ -3516,9 +4173,9 @@ function createIntentDelivery(options) {
|
|
|
3516
4173
|
}
|
|
3517
4174
|
|
|
3518
4175
|
// src/intents/installed.ts
|
|
3519
|
-
import { BehaviorSubject as
|
|
4176
|
+
import { BehaviorSubject as BehaviorSubject8 } from "rxjs";
|
|
3520
4177
|
import { manifestToIntentCatalogEntry } from "@kehto/services";
|
|
3521
|
-
var
|
|
4178
|
+
var STORAGE_KEY6 = "installed:v1";
|
|
3522
4179
|
function isInstalled(value) {
|
|
3523
4180
|
if (typeof value !== "object" || value === null) return false;
|
|
3524
4181
|
const row = value;
|
|
@@ -3538,10 +4195,10 @@ function toCatalogEntry2(applet) {
|
|
|
3538
4195
|
}
|
|
3539
4196
|
function createInstalledApplets(storage, now = Date.now) {
|
|
3540
4197
|
const store = createNamespacedStore(storage, "kernl");
|
|
3541
|
-
const stored = store.getJson(
|
|
3542
|
-
const changes$ = new
|
|
4198
|
+
const stored = store.getJson(STORAGE_KEY6, []);
|
|
4199
|
+
const changes$ = new BehaviorSubject8(Object.freeze(Array.isArray(stored) ? stored.filter(isInstalled) : []));
|
|
3543
4200
|
const commit = (next) => {
|
|
3544
|
-
store.setJson(
|
|
4201
|
+
store.setJson(STORAGE_KEY6, next);
|
|
3545
4202
|
changes$.next(Object.freeze([...next]));
|
|
3546
4203
|
};
|
|
3547
4204
|
return {
|
|
@@ -3733,7 +4390,7 @@ function createKernlIntents(deps) {
|
|
|
3733
4390
|
}
|
|
3734
4391
|
|
|
3735
4392
|
// src/catalog/fetch.ts
|
|
3736
|
-
import { auditTime as auditTime2, catchError as catchError4, EMPTY as EMPTY4, from, lastValueFrom as
|
|
4393
|
+
import { auditTime as auditTime2, catchError as catchError4, EMPTY as EMPTY4, from, lastValueFrom as lastValueFrom10, map as map8, merge as merge4, mergeAll, scan, share as share2, takeUntil as takeUntil5, tap, timer as timer7 } from "rxjs";
|
|
3737
4394
|
import { getSeenRelays } from "applesauce-core/helpers";
|
|
3738
4395
|
import { NAPPLET_KIND_NAMED, NAPPLET_KIND_ROOT } from "@kehto/nip/5d";
|
|
3739
4396
|
|
|
@@ -3783,7 +4440,7 @@ function streamCatalog(pool, tiers, options = {}) {
|
|
|
3783
4440
|
const filters = asFilters(catalogFilters(options));
|
|
3784
4441
|
const cached = options.cache ? from(options.cache(filters).catch(() => [])).pipe(mergeAll()) : EMPTY4;
|
|
3785
4442
|
const live = pool.request([...relays2], filters).pipe(
|
|
3786
|
-
|
|
4443
|
+
takeUntil5(timer7(options.timeoutMs ?? CATALOG_TIMEOUT_MS)),
|
|
3787
4444
|
catchError4(() => EMPTY4),
|
|
3788
4445
|
tap((event) => options.store?.add(event))
|
|
3789
4446
|
);
|
|
@@ -3797,11 +4454,11 @@ function streamCatalog(pool, tiers, options = {}) {
|
|
|
3797
4454
|
);
|
|
3798
4455
|
const listed = (state) => newestEntries(state.listed.filter(({ event }) => !isWithdrawn(event, state.withdrawn)).map(({ entry }) => entry));
|
|
3799
4456
|
const lists = found.pipe(auditTime2(options.emitMs ?? CATALOG_EMIT_MS), map8(listed), share2());
|
|
3800
|
-
const nothingYet =
|
|
4457
|
+
const nothingYet = timer7(options.settleMs ?? CATALOG_SETTLE_MS).pipe(map8(() => Object.freeze([])), takeUntil5(lists));
|
|
3801
4458
|
return merge4(nothingYet, lists);
|
|
3802
4459
|
}
|
|
3803
4460
|
async function loadCatalog(pool, tiers, options = {}) {
|
|
3804
|
-
return
|
|
4461
|
+
return lastValueFrom10(streamCatalog(pool, tiers, options), { defaultValue: Object.freeze([]) });
|
|
3805
4462
|
}
|
|
3806
4463
|
|
|
3807
4464
|
// src/kernl.ts
|
|
@@ -3881,6 +4538,37 @@ function registriesFor(options, parts) {
|
|
|
3881
4538
|
bridges: options.bridges ?? createDefaultBridges({ handoff: (uri) => host.openLink(uri), ...options.torrent ? { torrent: options.torrent } : {} })
|
|
3882
4539
|
};
|
|
3883
4540
|
}
|
|
4541
|
+
function meetingFor(options, parts) {
|
|
4542
|
+
const settings = createMultiplayerSettings(options.host.storage);
|
|
4543
|
+
const relays2 = () => settings.state().servers ?? options.remoteTools?.relays ?? parts.tiers.get().super;
|
|
4544
|
+
const multiplayer = { ...settings, discover: (input) => discoverToolFamilies(input, { pool: parts.pool, relays: relays2(), fetch: globalThis.fetch.bind(globalThis) }) };
|
|
4545
|
+
return {
|
|
4546
|
+
deps: { identities: createWindowIdentities(), remoteTools: options.remoteTools, directConnections: directConnectionsFor(options, parts.appletOf, parts.grants), multiplayer },
|
|
4547
|
+
multiplayer
|
|
4548
|
+
};
|
|
4549
|
+
}
|
|
4550
|
+
function uploaderFor(host, files, signer, identityOf) {
|
|
4551
|
+
return createBlossomUploader({
|
|
4552
|
+
servers: () => files.current(),
|
|
4553
|
+
signer,
|
|
4554
|
+
ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
|
|
4555
|
+
});
|
|
4556
|
+
}
|
|
4557
|
+
function directConnectionsFor(options, appletOf2, grants) {
|
|
4558
|
+
const { createPeer, ...settings } = options.directConnections ?? {};
|
|
4559
|
+
if (!createPeer && typeof RTCPeerConnection !== "function") return void 0;
|
|
4560
|
+
return {
|
|
4561
|
+
settings,
|
|
4562
|
+
...createPeer ? { createPeer } : {},
|
|
4563
|
+
appletOf: appletOf2,
|
|
4564
|
+
isGranted(windowId) {
|
|
4565
|
+
const identity = appletOf2(windowId)?.identity;
|
|
4566
|
+
const record2 = identity && grants().get(identity);
|
|
4567
|
+
return !!record2 && !record2.blocked && record2.domains.includes("webrtc");
|
|
4568
|
+
},
|
|
4569
|
+
ask: (summary) => new Promise((resolve) => options.host.presentConsent({ summary, resolve }))
|
|
4570
|
+
};
|
|
4571
|
+
}
|
|
3884
4572
|
function appletOf(handles, windowId) {
|
|
3885
4573
|
const summary = handles.get(windowId)?.summary;
|
|
3886
4574
|
return summary && { key: summary.manifest.catalogId, title: summary.title };
|
|
@@ -3908,7 +4596,7 @@ function createKernl(options) {
|
|
|
3908
4596
|
const { messaging, bridges } = registriesFor(options, { eventStore, pool, tiers, accounts });
|
|
3909
4597
|
const handles = /* @__PURE__ */ new Map();
|
|
3910
4598
|
const guardEvents$ = new Subject4();
|
|
3911
|
-
const session$ = new
|
|
4599
|
+
const session$ = new BehaviorSubject9(null);
|
|
3912
4600
|
const destroyed$ = new Subject4();
|
|
3913
4601
|
const subscriptions = new Subscription2();
|
|
3914
4602
|
let grants;
|
|
@@ -3930,6 +4618,7 @@ function createKernl(options) {
|
|
|
3930
4618
|
relays: () => [...tiers.get().outbox, ...tiers.get().discovery]
|
|
3931
4619
|
});
|
|
3932
4620
|
const consent = createSigningConsent({ host, lookupBefore, resolveApplet: identityOf, pubkey: () => accounts.active?.pubkey });
|
|
4621
|
+
const meeting = meetingFor(options, { pool, tiers, appletOf: (windowId) => handles.get(windowId)?.summary, grants: () => grants });
|
|
3933
4622
|
const services = createKernlServices({
|
|
3934
4623
|
pool,
|
|
3935
4624
|
tiers,
|
|
@@ -3942,12 +4631,9 @@ function createKernl(options) {
|
|
|
3942
4631
|
profiles,
|
|
3943
4632
|
...host.presentSettings ? { config: createAppletConfig({ storage: host.storage, appletOf: (windowId) => appletOf(handles, windowId), present: host.presentSettings.bind(host) }) } : {},
|
|
3944
4633
|
common: commonActionsFor({ eventStore, pool, tiers, accounts }, { profiles, replaceableLoader, signer }, consent),
|
|
3945
|
-
uploader:
|
|
3946
|
-
servers: () => files.current(),
|
|
3947
|
-
signer,
|
|
3948
|
-
ask: (windowId, details) => askUploadConsent(host, identityOf(windowId), details)
|
|
3949
|
-
}),
|
|
4634
|
+
uploader: uploaderFor(host, files, signer, identityOf),
|
|
3950
4635
|
...isTheme(options.theme) ? { theme: options.theme } : {},
|
|
4636
|
+
...meeting.deps,
|
|
3951
4637
|
resolveIdentity(windowId) {
|
|
3952
4638
|
const identity = identityOf(windowId);
|
|
3953
4639
|
return identity ? { dTag: identity.dTag, aggregateHash: identity.hash } : null;
|
|
@@ -4009,6 +4695,7 @@ function createKernl(options) {
|
|
|
4009
4695
|
profiles,
|
|
4010
4696
|
mailboxes,
|
|
4011
4697
|
files,
|
|
4698
|
+
multiplayer: meeting.multiplayer,
|
|
4012
4699
|
directory,
|
|
4013
4700
|
intents: intents.intents,
|
|
4014
4701
|
session$,
|
|
@@ -4051,8 +4738,8 @@ function wordScore(word, entry) {
|
|
|
4051
4738
|
}
|
|
4052
4739
|
return best;
|
|
4053
4740
|
}
|
|
4054
|
-
function textScore(
|
|
4055
|
-
const words =
|
|
4741
|
+
function textScore(text3, entry) {
|
|
4742
|
+
const words = text3.toLowerCase().split(/\s+/).filter(Boolean);
|
|
4056
4743
|
let total = 0;
|
|
4057
4744
|
for (const word of words) {
|
|
4058
4745
|
const score = wordScore(word, entry);
|
|
@@ -4061,16 +4748,16 @@ function textScore(text2, entry) {
|
|
|
4061
4748
|
}
|
|
4062
4749
|
return words.length === 0 ? 1 : total;
|
|
4063
4750
|
}
|
|
4064
|
-
function passesFilters(entry,
|
|
4065
|
-
if (
|
|
4066
|
-
if (
|
|
4067
|
-
return
|
|
4751
|
+
function passesFilters(entry, query2) {
|
|
4752
|
+
if (query2.topics?.some((topic) => !entry.topics.includes(topic))) return false;
|
|
4753
|
+
if (query2.available && entry.requires.some((domain) => !query2.available?.includes(domain))) return false;
|
|
4754
|
+
return query2.convention === void 0 || entry.conventions.includes(query2.convention);
|
|
4068
4755
|
}
|
|
4069
|
-
function searchCatalog(entries,
|
|
4756
|
+
function searchCatalog(entries, query2 = {}) {
|
|
4070
4757
|
const scored = [];
|
|
4071
4758
|
for (const entry of entries) {
|
|
4072
|
-
if (!passesFilters(entry,
|
|
4073
|
-
const score = textScore(
|
|
4759
|
+
if (!passesFilters(entry, query2)) continue;
|
|
4760
|
+
const score = textScore(query2.text ?? "", entry);
|
|
4074
4761
|
if (score > 0) scored.push({ entry, score });
|
|
4075
4762
|
}
|
|
4076
4763
|
scored.sort((a, b) => b.score - a.score || b.entry.publishedAt - a.entry.publishedAt);
|
|
@@ -4102,6 +4789,9 @@ export {
|
|
|
4102
4789
|
DEFAULT_RELAY_TIERS,
|
|
4103
4790
|
DEFAULT_SUGGESTIONS,
|
|
4104
4791
|
DELIVERY_RETRY,
|
|
4792
|
+
DIRECT_MAX_PAYLOAD_BYTES,
|
|
4793
|
+
DIRECT_SIGNALING_PROFILE,
|
|
4794
|
+
DIRECT_SIGNAL_KIND,
|
|
4105
4795
|
DOMAIN_CAPABILITIES,
|
|
4106
4796
|
HANDLER_PREFERENCES_KIND,
|
|
4107
4797
|
KERNL_FRAME_POLICY_META,
|
|
@@ -4114,6 +4804,7 @@ export {
|
|
|
4114
4804
|
RUNTIME_FIREWALL_STORAGE_KEY,
|
|
4115
4805
|
RUNTIME_OP_CLASSES,
|
|
4116
4806
|
SHELL_RELAY_OPTIONS,
|
|
4807
|
+
TOOL_DISCOVERY_TIMEOUT_MS,
|
|
4117
4808
|
UNKNOWN_CURRENT_VERSION,
|
|
4118
4809
|
abbreviate,
|
|
4119
4810
|
addressOf,
|
|
@@ -4139,9 +4830,12 @@ export {
|
|
|
4139
4830
|
createColumnsLayout,
|
|
4140
4831
|
createCommonActions,
|
|
4141
4832
|
createConsentHandler,
|
|
4833
|
+
createCvmRelayPool,
|
|
4142
4834
|
createDefaultBridges,
|
|
4143
4835
|
createDefaultLayouts,
|
|
4144
4836
|
createDefaultMessaging,
|
|
4837
|
+
createDirectConnectionsService,
|
|
4838
|
+
createDirectSignaling,
|
|
4145
4839
|
createDmRelayPool,
|
|
4146
4840
|
createDwindleLayout,
|
|
4147
4841
|
createEnvironmentResolver,
|
|
@@ -4166,6 +4860,7 @@ export {
|
|
|
4166
4860
|
createLegacyMessagesBackend,
|
|
4167
4861
|
createMasterStackLayout,
|
|
4168
4862
|
createMemoryCacheAdapter,
|
|
4863
|
+
createMultiplayerSettings,
|
|
4169
4864
|
createNamespacedStore,
|
|
4170
4865
|
createOutboxRelayPool,
|
|
4171
4866
|
createPrivateMessagesBackend,
|
|
@@ -4175,6 +4870,7 @@ export {
|
|
|
4175
4870
|
createRelayPoolHooks,
|
|
4176
4871
|
createRelayPoolLike,
|
|
4177
4872
|
createRelayTiers,
|
|
4873
|
+
createRemoteToolsService,
|
|
4178
4874
|
createReplaceableLoader,
|
|
4179
4875
|
createRuntimeFirewallHooks,
|
|
4180
4876
|
createSealedGroupStore,
|
|
@@ -4182,13 +4878,17 @@ export {
|
|
|
4182
4878
|
createShellAdapter,
|
|
4183
4879
|
createSigningConsent,
|
|
4184
4880
|
createSqliteOpfsCacheAdapter,
|
|
4881
|
+
createWindowIdentities,
|
|
4185
4882
|
createWindowManager,
|
|
4186
4883
|
decodePointer,
|
|
4187
4884
|
defaultFetchBlob,
|
|
4188
4885
|
defaultWebCacheAdapters,
|
|
4189
4886
|
describeChange,
|
|
4887
|
+
describeDirectConnection,
|
|
4190
4888
|
describeOutcome,
|
|
4191
4889
|
describeUpload,
|
|
4890
|
+
directNamespace,
|
|
4891
|
+
discoverToolFamilies,
|
|
4192
4892
|
fetchManifestEvent,
|
|
4193
4893
|
fileServerTags,
|
|
4194
4894
|
fileServersFromEvent,
|
|
@@ -4207,6 +4907,7 @@ export {
|
|
|
4207
4907
|
lookupReplaceable,
|
|
4208
4908
|
mailboxTags,
|
|
4209
4909
|
mailboxesFromEvent,
|
|
4910
|
+
mergeFamilies,
|
|
4210
4911
|
messagingSigner,
|
|
4211
4912
|
mountApplet,
|
|
4212
4913
|
newestEntries,
|
|
@@ -4241,6 +4942,7 @@ export {
|
|
|
4241
4942
|
toProfileCard,
|
|
4242
4943
|
toRelayUrl,
|
|
4243
4944
|
toSession,
|
|
4945
|
+
validFamily,
|
|
4244
4946
|
wrapAccountSigner
|
|
4245
4947
|
};
|
|
4246
4948
|
//# sourceMappingURL=index.js.map
|