@nsite/stealthis 0.1.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@nsite/stealthis",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/stealthis.js",
+  "module": "dist/stealthis.mjs",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "default": "./dist/stealthis.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite build --watch",
+    "build": "vite build"
+  },
+  "dependencies": {
+    "nostr-tools": "^2.23.3",
+    "qrcode-generator": "^1.4.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+import { NsiteDeployButton } from './widget';
+
+customElements.define('nsite-deploy', NsiteDeployButton);
+
+function autoInject() {
+  if (!document.querySelector('nsite-deploy')) {
+    const el = document.createElement('nsite-deploy');
+    el.classList.add('nd-fixed');
+    document.body.appendChild(el);
+  }
+}
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', autoInject);
+} else {
+  autoInject();
+}

package/src/nostr.ts

@@ -0,0 +1,296 @@
+import { npubEncode } from 'nostr-tools/nip19';
+import type { SignedEvent, EventTemplate } from './signer';
+
+export type { SignedEvent, EventTemplate };
+
+export interface NsiteContext {
+  pubkey: string;
+  identifier?: string;
+  baseDomain: string;
+}
+
+export interface Thief {
+  index: number;
+  pubkey: string;
+  relays: string[];
+}
+
+export { npubEncode };
+
+const BOOTSTRAP_RELAYS = ['wss://purplepag.es', 'wss://relay.damus.io', 'wss://nos.lol'];
+const B36_LEN = 50;
+const D_TAG_RE = /^[a-z0-9-]{1,13}$/;
+const NAMED_LABEL_RE = /^[0-9a-z]{50}[a-z0-9-]{1,13}$/;
+
+// --- Base36 ---
+
+export function pubkeyToBase36(hex: string): string {
+  return BigInt('0x' + hex)
+    .toString(36)
+    .padStart(B36_LEN, '0');
+}
+
+function base36ToHex(b36: string): string {
+  let n = 0n;
+  for (const c of b36) n = n * 36n + BigInt(parseInt(c, 36));
+  return n.toString(16).padStart(64, '0');
+}
+
+// --- Minimal bech32 decode (npub only) ---
+
+function npubDecode(npub: string): string | null {
+  if (!npub.startsWith('npub1')) return null;
+  const CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+  const values: number[] = [];
+  for (const c of npub.slice(5)) {
+    const v = CHARSET.indexOf(c);
+    if (v === -1) return null;
+    values.push(v);
+  }
+  const payload = values.slice(0, -6);
+  let acc = 0,
+    bits = 0;
+  const bytes: number[] = [];
+  for (const v of payload) {
+    acc = (acc << 5) | v;
+    bits += 5;
+    while (bits >= 8) {
+      bits -= 8;
+      bytes.push((acc >> bits) & 0xff);
+    }
+  }
+  if (bytes.length !== 32) return null;
+  return bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+// --- Context ---
+
+export function parseContext(): NsiteContext | null {
+  const parts = window.location.hostname.split('.');
+
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i].startsWith('npub1') && parts[i].length >= 63) {
+      const pubkey = npubDecode(parts[i]);
+      if (pubkey) return { pubkey, baseDomain: parts.slice(i + 1).join('.') };
+    }
+  }
+
+  const label = parts[0];
+  if (
+    label &&
+    label.length > B36_LEN &&
+    label.length <= 63 &&
+    NAMED_LABEL_RE.test(label) &&
+    !label.endsWith('-')
+  ) {
+    try {
+      const pubkey = base36ToHex(label.slice(0, B36_LEN));
+      return { pubkey, identifier: label.slice(B36_LEN), baseDomain: parts.slice(1).join('.') };
+    } catch {
+      /* invalid */
+    }
+  }
+
+  return null;
+}
+
+export function isValidDTag(s: string): boolean {
+  return D_TAG_RE.test(s) && !s.endsWith('-');
+}
+
+// --- Relay communication ---
+
+interface RelayEvent {
+  id: string;
+  pubkey: string;
+  created_at: number;
+  kind: number;
+  tags: string[][];
+  content: string;
+  sig: string;
+}
+
+function withSocket(
+  url: string,
+  sendMsg: unknown[],
+  onMsg: (data: unknown[]) => boolean,
+  timeout = 5000
+): Promise<void> {
+  return new Promise((resolve) => {
+    try {
+      const ws = new WebSocket(url);
+      const timer = setTimeout(() => {
+        try { ws.close(); } catch { /* */ }
+        resolve();
+      }, timeout);
+      const finish = () => {
+        clearTimeout(timer);
+        try { ws.close(); } catch { /* */ }
+        resolve();
+      };
+      ws.onopen = () => ws.send(JSON.stringify(sendMsg));
+      ws.onmessage = (e) => {
+        try { if (onMsg(JSON.parse(e.data))) finish(); } catch { /* */ }
+      };
+      ws.onerror = () => finish();
+    } catch {
+      resolve();
+    }
+  });
+}
+
+async function queryRelays(urls: string[], filter: Record<string, unknown>): Promise<RelayEvent[]> {
+  const events = new Map<string, RelayEvent>();
+  const subId = Math.random().toString(36).slice(2, 8);
+  await Promise.allSettled(
+    urls.map((url) =>
+      withSocket(url, ['REQ', subId, filter], (msg) => {
+        if (msg[0] === 'EVENT' && msg[1] === subId)
+          events.set((msg[2] as RelayEvent).id, msg[2] as RelayEvent);
+        return msg[0] === 'EOSE' && msg[1] === subId;
+      })
+    )
+  );
+  return [...events.values()];
+}
+
+async function publishRelay(url: string, event: SignedEvent): Promise<boolean> {
+  let ok = false;
+  await withSocket(url, ['EVENT', event], (msg) => {
+    if (msg[0] === 'OK') {
+      ok = msg[2] === true;
+      return true;
+    }
+    return false;
+  });
+  return ok;
+}
+
+export async function publishToRelays(urls: string[], event: SignedEvent): Promise<number> {
+  const results = await Promise.allSettled(urls.map((url) => publishRelay(url, event)));
+  return results.filter((r) => r.status === 'fulfilled' && r.value).length;
+}
+
+// --- High-level operations ---
+
+function extractWriteRelays(events: RelayEvent[]): string[] {
+  const relays = new Set<string>();
+  for (const e of events) {
+    for (const t of e.tags) {
+      if (t[0] === 'r' && t[1]?.startsWith('wss://') && (!t[2] || t[2] === 'write'))
+        relays.add(t[1].trim());
+    }
+  }
+  return [...relays];
+}
+
+export async function fetchManifest(ctx: NsiteContext): Promise<RelayEvent | null> {
+  const manifestFilter = ctx.identifier
+    ? { kinds: [35128], authors: [ctx.pubkey], '#d': [ctx.identifier] }
+    : { kinds: [15128], authors: [ctx.pubkey], limit: 1 };
+
+  // Query bootstrap relays for manifest AND relay list in parallel
+  const [bootstrapManifests, relayEvents] = await Promise.all([
+    queryRelays(BOOTSTRAP_RELAYS, manifestFilter),
+    queryRelays(BOOTSTRAP_RELAYS, { kinds: [10002], authors: [ctx.pubkey], limit: 5 })
+  ]);
+
+  // If bootstrap already found it, return immediately
+  if (bootstrapManifests.length > 0) {
+    return bootstrapManifests.sort((a, b) => b.created_at - a.created_at)[0];
+  }
+
+  // Otherwise try the owner's relays
+  const ownerRelays = extractWriteRelays(relayEvents).filter(
+    (r) => !BOOTSTRAP_RELAYS.includes(r)
+  );
+  if (ownerRelays.length === 0) return null;
+
+  const events = await queryRelays(ownerRelays, manifestFilter);
+  return events.sort((a, b) => b.created_at - a.created_at)[0] ?? null;
+}
+
+export async function getWriteRelays(pubkey: string): Promise<string[]> {
+  const events = await queryRelays(BOOTSTRAP_RELAYS, {
+    kinds: [10002],
+    authors: [pubkey],
+    limit: 5
+  });
+  const relays = extractWriteRelays(events);
+  return relays.length > 0 ? relays : BOOTSTRAP_RELAYS.filter((r) => r !== 'wss://purplepag.es');
+}
+
+export async function checkExistingSite(
+  relays: string[],
+  pubkey: string,
+  slug?: string
+): Promise<boolean> {
+  const filter = slug
+    ? { kinds: [35128], authors: [pubkey], '#d': [slug], limit: 1 }
+    : { kinds: [15128], authors: [pubkey], limit: 1 };
+  const events = await queryRelays(relays, filter);
+  return events.length > 0;
+}
+
+const MAX_THIEF_TAGS = 9;
+
+export function extractThieves(event: RelayEvent): Thief[] {
+  return event.tags
+    .filter((t) => t[0] === 'thief' && t[1] && t[2])
+    .map((t) => ({ index: parseInt(t[1], 10), pubkey: t[2], relays: t.slice(3) }))
+    .sort((a, b) => a.index - b.index);
+}
+
+export function createDeployEvent(
+  source: RelayEvent,
+  options: {
+    slug?: string;
+    title?: string;
+    description?: string;
+    deployerPubkey: string;
+    deployerRelays: string[];
+  }
+): EventTemplate {
+  const tags: string[][] = [];
+  if (options.slug) tags.push(['d', options.slug]);
+  for (const t of source.tags) {
+    if (t[0] === 'path' || t[0] === 'server') tags.push([...t]);
+  }
+
+  // Paper trail: copy thief tags, add new one, enforce max 9
+  const sourceThieves = source.tags
+    .filter((t) => t[0] === 'thief' && t[1] && t[2])
+    .map((t) => [...t])
+    .sort((a, b) => parseInt(a[1], 10) - parseInt(b[1], 10));
+
+  const maxIndex = sourceThieves.length > 0
+    ? Math.max(...sourceThieves.map((t) => parseInt(t[1], 10)))
+    : -1;
+  const newThief = ['thief', String(maxIndex + 1), options.deployerPubkey, ...options.deployerRelays];
+  const allThieves = [...sourceThieves, newThief];
+
+  // Keep index 0 (originator) + newest, FIFO truncate the middle
+  if (allThieves.length > MAX_THIEF_TAGS) {
+    const originator = allThieves[0];
+    const keep = allThieves.slice(allThieves.length - (MAX_THIEF_TAGS - 1));
+    tags.push(originator, ...keep);
+  } else {
+    for (const t of allThieves) tags.push(t);
+  }
+
+  if (options.title) tags.push(['title', options.title]);
+  if (options.description) tags.push(['description', options.description]);
+  return {
+    kind: options.slug ? 35128 : 15128,
+    created_at: Math.floor(Date.now() / 1000),
+    tags,
+    content: ''
+  };
+}
+
+export function buildSiteUrl(baseDomain: string, pubkey: string, slug?: string): string {
+  if (slug) {
+    return `https://${pubkeyToBase36(pubkey)}${slug}.${baseDomain}`;
+  }
+  return `https://${npubEncode(pubkey)}.${baseDomain}`;
+}

package/src/qr.ts

@@ -0,0 +1,8 @@
+import qrcode from 'qrcode-generator';
+
+export function toSvg(text: string): string {
+  const qr = qrcode(0, 'L');
+  qr.addData(text);
+  qr.make();
+  return qr.createSvgTag({ cellSize: 3, margin: 2, scalable: true });
+}

package/src/signer.ts

@@ -0,0 +1,90 @@
+import { generateSecretKey, getPublicKey } from 'nostr-tools/pure';
+import {
+  BunkerSigner as NtBunkerSigner,
+  parseBunkerInput,
+  createNostrConnectURI
+} from 'nostr-tools/nip46';
+
+export interface EventTemplate {
+  kind: number;
+  created_at: number;
+  tags: string[][];
+  content: string;
+}
+
+export interface SignedEvent extends EventTemplate {
+  id: string;
+  pubkey: string;
+  sig: string;
+}
+
+export interface Signer {
+  getPublicKey(): Promise<string>;
+  signEvent(event: EventTemplate): Promise<SignedEvent>;
+  close(): void;
+}
+
+declare global {
+  interface Window {
+    nostr?: {
+      getPublicKey(): Promise<string>;
+      signEvent(event: EventTemplate): Promise<SignedEvent>;
+    };
+  }
+}
+
+export const DEFAULT_NIP46_RELAY = 'wss://bucket.coracle.social';
+
+export function hasExtension(): boolean {
+  return !!window.nostr;
+}
+
+export function extensionSigner(): Signer {
+  if (!window.nostr) throw new Error('No Nostr signer extension found');
+  const ext = window.nostr;
+  return {
+    getPublicKey: () => ext.getPublicKey(),
+    signEvent: (e) => ext.signEvent(e),
+    close() {}
+  };
+}
+
+export async function bunkerConnect(input: string): Promise<Signer> {
+  const sk = generateSecretKey();
+  const bp = await parseBunkerInput(input);
+  if (!bp) throw new Error('Invalid bunker URI');
+  const signer = NtBunkerSigner.fromBunker(sk, bp);
+  await signer.connect();
+  return wrap(signer);
+}
+
+export function prepareNostrConnect(relay: string) {
+  const sk = generateSecretKey();
+  const clientPubkey = getPublicKey(sk);
+  const secret = Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) =>
+    b.toString(16).padStart(2, '0')
+  ).join('');
+
+  const uri = createNostrConnectURI({
+    clientPubkey,
+    relays: [relay],
+    secret,
+    name: 'nsite deploy'
+  });
+
+  return {
+    uri,
+    async connect(abort?: AbortSignal): Promise<Signer> {
+      const signer = await NtBunkerSigner.fromURI(sk, uri, {}, abort ?? 300_000);
+      return wrap(signer);
+    }
+  };
+}
+
+function wrap(signer: NtBunkerSigner): Signer {
+  return {
+    getPublicKey: () => signer.getPublicKey(),
+    signEvent: (e) => signer.signEvent(e) as Promise<SignedEvent>,
+    close: () => signer.close()
+  };
+}