truematch-plugin 0.1.0

package/dist/plugin.js

@@ -0,0 +1,328 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { loadSignals, saveSignals, pickPendingSignal, buildSignalInstruction, recordSignalDelivered, } from "./signals.js";
+import { loadPendingNotification, deletePendingNotification, buildMatchNotificationContext, getActiveHandoffContext, } from "./handoff.js";
+const TRUEMATCH_DIR = join(homedir(), ".truematch");
+const IDENTITY_FILE = join(TRUEMATCH_DIR, "identity.json");
+const PREFERENCES_FILE = join(TRUEMATCH_DIR, "preferences.json");
+const OBSERVATION_FILE = join(TRUEMATCH_DIR, "observation.json");
+/**
+ * OpenClaw plugin entry point.
+ *
+ * Exports the plugin object consumed by the OpenClaw runtime.
+ * The `register(api)` function wires up lifecycle hooks and tools.
+ *
+ * Hooks registered:
+ *   gateway:startup      — detects first-run and missing preferences at boot
+ *   session_start        — resets per-session delivery flags
+ *   before_prompt_build  — injects match notification, handoff context, observation signal
+ *   command:new          — on /new: runs setup, preferences, or observation update
+ *
+ * Tools registered:
+ *   truematch_update_prefs — handles /truematch-prefs slash command (non-observational)
+ */
+function loadObservation() {
+    if (!existsSync(OBSERVATION_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(OBSERVATION_FILE, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+// Per-session delivery flags — reset on session_start, prevent re-injection within a session.
+// Module-level state persists across sessions in the gateway process (correct behaviour).
+const sessionFlags = {
+    signalDelivered: false,
+    notificationDelivered: false,
+};
+// Module-scoped flags set at gateway:startup, consumed at first command:new.
+// Resets on every gateway restart (correct — sentinel file prevents repeat prompts).
+const pluginState = {
+    needsSetup: false,
+    needsPreferences: false,
+};
+function loadPrefs() {
+    if (!existsSync(PREFERENCES_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(PREFERENCES_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function savePrefs(prefs) {
+    writeFileSync(PREFERENCES_FILE, JSON.stringify(prefs, null, 2), "utf8");
+}
+function formatPrefs(prefs) {
+    const parts = [];
+    if (prefs.location) {
+        const radius = prefs.distance_radius_km !== undefined
+            ? ` (within ${prefs.distance_radius_km} km)`
+            : " (anywhere)";
+        parts.push(`location: ${prefs.location}${radius}`);
+    }
+    if (prefs.age_range) {
+        const { min, max } = prefs.age_range;
+        if (min !== undefined && max !== undefined)
+            parts.push(`age: ${min}–${max}`);
+        else if (min !== undefined)
+            parts.push(`age: ${min}+`);
+        else if (max !== undefined)
+            parts.push(`age: up to ${max}`);
+    }
+    if (prefs.gender_preference?.length) {
+        parts.push(`gender: ${prefs.gender_preference.join(" or ")}`);
+    }
+    return parts.length ? parts.join(", ") : "none set";
+}
+/**
+ * Parse simple key=value pairs from raw slash-command args.
+ * Supports quoted values: location="New York, NY"
+ */
+function parseArgs(raw) {
+    const result = {};
+    const re = /(\w+)=(?:"([^"]*)"|(\S+))/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+        result[m[1]] = (m[2] ?? m[3]);
+    }
+    return result;
+}
+/**
+ * Tool handler for /truematch-prefs slash command.
+ *
+ * The model is architecturally excluded from this turn (command-dispatch: tool).
+ * No behavioral observation can occur — the boundary is structural, not in-context.
+ *
+ * Usage:
+ *   /truematch-prefs                          — show current preferences
+ *   /truematch-prefs location="London, UK"    — update location (anywhere = no distance filter)
+ *   /truematch-prefs distance=city            — within ~50 km (city | travel | anywhere)
+ *   /truematch-prefs age_min=25 age_max=35    — age range (omit either for open-ended)
+ *   /truematch-prefs gender=anyone            — any; or comma-separated: man,woman,nonbinary
+ */
+function handleUpdatePrefs(rawArgs) {
+    const prefs = loadPrefs();
+    const trimmed = rawArgs.trim();
+    if (!trimmed) {
+        return (`Preferences mode. I won't read anything you say here as personality signal — ` +
+            `this is purely logistics.\n\n` +
+            `Current preferences: ${formatPrefs(prefs)}\n\n` +
+            `Update with: /truematch-prefs <field>=<value>\n` +
+            `  location="City, Country"    where you're based\n` +
+            `  distance=city               city (~50 km) | travel (~300 km) | anywhere\n` +
+            `  age_min=25 age_max=35       age range (either is optional)\n` +
+            `  gender=anyone               or: man,woman,nonbinary (comma-separated)`);
+    }
+    const args = parseArgs(trimmed);
+    let changed = false;
+    if (args["location"] !== undefined) {
+        prefs.location = args["location"];
+        changed = true;
+    }
+    if (args["distance"] !== undefined) {
+        const d = args["distance"].toLowerCase();
+        if (d === "city") {
+            prefs.distance_radius_km = 50;
+        }
+        else if (d === "travel") {
+            prefs.distance_radius_km = 300;
+        }
+        else if (d === "anywhere") {
+            delete prefs.distance_radius_km;
+        }
+        else {
+            return `Unknown distance value "${args["distance"]}". Use: city, travel, or anywhere.`;
+        }
+        changed = true;
+    }
+    if (args["age_min"] !== undefined || args["age_max"] !== undefined) {
+        const current = prefs.age_range ?? {};
+        if (args["age_min"] !== undefined) {
+            const n = parseInt(args["age_min"], 10);
+            if (isNaN(n))
+                return `Invalid age_min value: "${args["age_min"]}"`;
+            current.min = n;
+        }
+        if (args["age_max"] !== undefined) {
+            const n = parseInt(args["age_max"], 10);
+            if (isNaN(n))
+                return `Invalid age_max value: "${args["age_max"]}"`;
+            current.max = n;
+        }
+        prefs.age_range = current;
+        changed = true;
+    }
+    if (args["gender"] !== undefined) {
+        const g = args["gender"].toLowerCase();
+        prefs.gender_preference =
+            g === "anyone" || g === "any" || g === ""
+                ? []
+                : g
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+        changed = true;
+    }
+    if (!changed) {
+        return `No recognized fields in args. Use: location, distance, age_min, age_max, gender.`;
+    }
+    savePrefs(prefs);
+    return (`Updated. I'm going back to regular conversation now — anything here is observations again.\n\n` +
+        `Current preferences: ${formatPrefs(prefs)}`);
+}
+export default {
+    id: "truematch",
+    name: "TrueMatch",
+    description: "AI agent dating network — matched on who you actually are, not who you think you are",
+    version: "0.1.0",
+    kind: "lifecycle",
+    register(api) {
+        // ── Tool: /truematch-prefs ─────────────────────────────────────────────────
+        // Registered with command-dispatch: tool in skills/truematch-prefs/SKILL.md.
+        // The model is architecturally excluded from this turn — no observation possible.
+        api.registerTool({
+            name: "truematch_update_prefs",
+            description: "Update TrueMatch logistics preferences (location, distance, age range, gender). " +
+                "The model is excluded from this turn — no behavioral observation occurs.",
+            handler: handleUpdatePrefs,
+        });
+        // ── Hook: gateway:startup ──────────────────────────────────────────────────
+        // Fires once per gateway process, after channels and hooks load.
+        // Use it to detect setup state so command:new can prompt appropriately.
+        api.registerHook("gateway:startup", () => {
+            if (!existsSync(IDENTITY_FILE)) {
+                pluginState.needsSetup = true;
+            }
+            else if (!existsSync(PREFERENCES_FILE)) {
+                pluginState.needsPreferences = true;
+            }
+        }, {
+            name: "TrueMatch startup check",
+            description: "Detects whether TrueMatch setup and preferences are configured",
+        });
+        // ── Hook: session_start ───────────────────────────────────────────────────
+        // Reset per-session delivery flags so signals and notifications fire at most
+        // once per session even though before_prompt_build fires on every LLM invocation.
+        api.on("session_start", () => {
+            sessionFlags.signalDelivered = false;
+            sessionFlags.notificationDelivered = false;
+        });
+        // ── Hook: before_prompt_build ─────────────────────────────────────────────
+        // Fires on every LLM invocation. Returns prependContext injected into Claude's
+        // context before the model sees the conversation.
+        //
+        // NOTE: api.registerHook return values are silently discarded by the OpenClaw
+        // runtime (InternalHookHandler is typed as void). api.on("before_prompt_build")
+        // is the ONLY correct API for prependContext injection — its return value is
+        // collected and merged by runBeforePromptBuild in src/plugins/hooks.ts.
+        //
+        // Priority order (highest first):
+        //   1. Match notification — deliver once per session when a new match is confirmed
+        //   2. Handoff round context — frame Claude's role in the active handoff round
+        //   3. Observation signal — surface a growing dimension confidence naturally
+        api.on("before_prompt_build", () => {
+            const parts = [];
+            // 1. Match notification (once per session)
+            if (!sessionFlags.notificationDelivered) {
+                const notification = loadPendingNotification();
+                if (notification) {
+                    // Mark delivered BEFORE injecting — prevents re-fire if session crashes
+                    deletePendingNotification();
+                    sessionFlags.notificationDelivered = true;
+                    parts.push(buildMatchNotificationContext(notification));
+                }
+            }
+            // 2. Handoff round context
+            const handoffCtx = getActiveHandoffContext();
+            if (handoffCtx)
+                parts.push(handoffCtx);
+            // 3. Observation signal (once per session — ≥2 sessions, ≥0.15 delta, ≥5 day quiet)
+            if (!sessionFlags.signalDelivered) {
+                const obs = loadObservation();
+                if (obs) {
+                    const signals = loadSignals();
+                    const pending = pickPendingSignal(obs, signals);
+                    if (pending) {
+                        const updated = recordSignalDelivered(signals, pending.dimension, pending.confidence);
+                        saveSignals(updated);
+                        sessionFlags.signalDelivered = true;
+                        parts.push(buildSignalInstruction(pending.dimension, pending.confidence));
+                    }
+                }
+            }
+            if (parts.length === 0)
+                return;
+            return { prependContext: parts.join("\n\n---\n\n") };
+        });
+        // ── Hook: command:new ──────────────────────────────────────────────────────
+        // Fires on every /new invocation.
+        // Branches: first-time setup → preferences collection → normal observation update.
+        // No seed/bootstrapping questions — TrueMatch observes only. If confidence is low,
+        // Claude communicates this to the user naturally via the observation output.
+        api.registerHook("command:new", (event) => {
+            if (pluginState.needsSetup) {
+                pluginState.needsSetup = false;
+                event.messages.push(`[TrueMatch] First-time setup — greet the user with the following, then collect responses:\n\n` +
+                    `"Welcome to TrueMatch. I'm going to learn who you are through our conversations ` +
+                    `over time — you do not need to fill out a profile. Right now I just need three ` +
+                    `quick logistics so I know who to consider. Where are you based?"\n\n` +
+                    `Ask in this order (all in one exchange — do not drip across sessions):\n` +
+                    `1. Location — free text (e.g. "London, UK")\n` +
+                    `2. Distance — ask: "How far are you open to matching? Within your city (~50 km), ` +
+                    `within a few hours' travel (~300 km), or anywhere?" Map to: 50 / 300 / null.\n` +
+                    `3. Age range — both min and max optional. Accept "no preference" immediately.\n` +
+                    `4. Gender preference — accept "open to anyone" immediately; record as empty array [].\n\n` +
+                    `Do NOT push back on open/no-preference answers. Do NOT re-ask.\n\n` +
+                    `Then ask: "What's the best way to reach you when there's a match? ` +
+                    `(email, Discord, Telegram, WhatsApp, or iMessage)"\n\n` +
+                    `Run setup:\n` +
+                    `  node "$HOME/.truematch/truematch.js" setup --contact-type <type> --contact-value <value>\n` +
+                    `Save preferences:\n` +
+                    `  node "$HOME/.truematch/truematch.js" preferences --set '<json>'`);
+                return;
+            }
+            if (pluginState.needsPreferences) {
+                pluginState.needsPreferences = false;
+                event.messages.push(`[TrueMatch] Preferences not yet set. Ask the user (all in one exchange):\n` +
+                    `1. Where are you based? (free text)\n` +
+                    `2. How far are you open to matching? (within your city / few hours' travel / anywhere)\n` +
+                    `3. Any age range preference? (both optional, "no preference" is a complete answer)\n` +
+                    `4. Gender preference? ("open to anyone" is a complete answer — record as [])\n\n` +
+                    `Accept open/no-preference answers without pushback, then save:\n` +
+                    `  node "$HOME/.truematch/truematch.js" preferences --set '<json>'\n\n` +
+                    `If user tries to update preferences in main conversation later, redirect them:\n` +
+                    `"I don't update preferences here because this is my observation channel. ` +
+                    `Say /truematch-prefs and we can do it there."`);
+                return;
+            }
+            // Update observation summary from Claude's existing memory
+            let output;
+            try {
+                output = execSync("truematch observe --update", {
+                    encoding: "utf8",
+                    timeout: 5000,
+                });
+            }
+            catch {
+                // truematch not set up yet — silently skip
+                return;
+            }
+            event.messages.push(`[TrueMatch] Session ended. Review the observation summary below and update it ` +
+                `based on what you learned this session. Save with ` +
+                `\`truematch observe --write '<json>'\`.\n\n` +
+                `If matching_eligible is false, tell the user naturally — e.g. "I'm still ` +
+                `building a picture of you from our conversations. I'll let you know when ` +
+                `there's enough to start matching." Do NOT ask questions to accelerate this.\n\n` +
+                output);
+        }, {
+            name: "TrueMatch session hook",
+            description: "Runs setup on first use, collects preferences if missing, or updates observation summary",
+        });
+    },
+};

package/dist/poll.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * TrueMatch one-shot Nostr poll — called by bridge.sh every POLL_INTERVAL seconds.
+ *
+ * Fetches new NIP-04 DMs since the last successful poll, decrypts them, validates
+ * them as TrueMatch protocol messages, and outputs each as a JSONL line to stdout.
+ *
+ * Output format (one JSON object per line):
+ *   { thread_id, peer_pubkey, type, content, round_count }
+ *
+ * Errors and warnings go to stderr only — stdout is reserved for JSONL output.
+ *
+ * Exit codes: 0 = success (even if zero messages), 1 = fatal error (identity missing)
+ */
+export {};

package/dist/poll.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * TrueMatch one-shot Nostr poll — called by bridge.sh every POLL_INTERVAL seconds.
+ *
+ * Fetches new NIP-04 DMs since the last successful poll, decrypts them, validates
+ * them as TrueMatch protocol messages, and outputs each as a JSONL line to stdout.
+ *
+ * Output format (one JSON object per line):
+ *   { thread_id, peer_pubkey, type, content, round_count }
+ *
+ * Errors and warnings go to stderr only — stdout is reserved for JSONL output.
+ *
+ * Exit codes: 0 = success (even if zero messages), 1 = fatal error (identity missing)
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { SimplePool, verifyEvent } from "nostr-tools";
+import { nip04 } from "nostr-tools";
+const TRUEMATCH_DIR = join(homedir(), ".truematch");
+const IDENTITY_FILE = join(TRUEMATCH_DIR, "identity.json");
+const POLL_STATE_FILE = join(TRUEMATCH_DIR, "poll-state.json");
+const THREADS_DIR = join(TRUEMATCH_DIR, "threads");
+const DEFAULT_RELAYS = [
+    "wss://relay.damus.io",
+    "wss://nos.lol",
+    "wss://relay.nostr.band",
+    "wss://nostr.mom",
+];
+// NIP-04 (kind 4) is deprecated in favour of NIP-17 gift wraps (kind 1059).
+// Migrate when the registry goes live and the communication graph becomes observable.
+const KIND_ENCRYPTED_DM = 4;
+// UUID v4 — same pattern as negotiation.ts for consistent thread_id validation
+const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+// Safety cap on events per poll cycle
+const MAX_EVENTS = 100;
+// Overlap window to catch events near the last-poll boundary
+const OVERLAP_SECONDS = 30;
+// Maximum wait for EOSE from all relays
+const EOSE_TIMEOUT_MS = 10_000;
+function loadPollState() {
+    if (!existsSync(POLL_STATE_FILE)) {
+        // Default: last hour
+        return { last_poll_at: Math.floor(Date.now() / 1000) - 3600 };
+    }
+    try {
+        return JSON.parse(readFileSync(POLL_STATE_FILE, "utf8"));
+    }
+    catch {
+        return { last_poll_at: Math.floor(Date.now() / 1000) - 3600 };
+    }
+}
+function savePollState(state) {
+    if (!existsSync(TRUEMATCH_DIR))
+        mkdirSync(TRUEMATCH_DIR, { recursive: true });
+    writeFileSync(POLL_STATE_FILE, JSON.stringify(state, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+}
+function loadIdentity() {
+    if (!existsSync(IDENTITY_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(IDENTITY_FILE, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function loadThread(threadId) {
+    const path = join(THREADS_DIR, `${threadId}.json`);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function main() {
+    const identity = loadIdentity();
+    if (!identity) {
+        process.stderr.write("poll: identity not found — run truematch setup\n");
+        process.exit(1);
+    }
+    const pollState = loadPollState();
+    const since = pollState.last_poll_at - OVERLAP_SECONDS;
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const pool = new SimplePool();
+    const seenEventIds = new Set();
+    const outputLines = [];
+    await new Promise((resolve) => {
+        let eoseCount = 0;
+        let settled = false;
+        let eventCount = 0;
+        const safetyTimer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                process.stderr.write(`poll: EOSE timeout after ${EOSE_TIMEOUT_MS}ms — proceeding with ${outputLines.length} messages\n`);
+                sub.close();
+                pool.close(DEFAULT_RELAYS);
+                resolve();
+            }
+        }, EOSE_TIMEOUT_MS);
+        const filter = {
+            kinds: [KIND_ENCRYPTED_DM],
+            "#p": [identity.npub],
+            since,
+            limit: MAX_EVENTS,
+        };
+        const sub = pool.subscribeMany(DEFAULT_RELAYS, filter, {
+            onevent: (event) => {
+                if (settled)
+                    return;
+                // NIP-01: verify signature before processing
+                if (!verifyEvent(event))
+                    return;
+                // Skip duplicates (same event from multiple relays)
+                if (seenEventIds.has(event.id))
+                    return;
+                seenEventIds.add(event.id);
+                // Skip events already within overlap window that we've seen before
+                if (event.created_at < since)
+                    return;
+                eventCount++;
+                if (eventCount > MAX_EVENTS) {
+                    process.stderr.write(`poll: MAX_EVENTS (${MAX_EVENTS}) cap reached — consider reducing POLL_INTERVAL\n`);
+                    return;
+                }
+                const senderNpub = event.pubkey;
+                let message;
+                try {
+                    const plaintext = nip04.decrypt(identity.nsec, senderNpub, event.content);
+                    message = JSON.parse(plaintext);
+                }
+                catch {
+                    return; // Not a TrueMatch message or decryption failed
+                }
+                // Only process TrueMatch 2.0 protocol messages
+                if (typeof message !== "object" ||
+                    message === null ||
+                    message.truematch !== "2.0")
+                    return;
+                // Validate thread_id before any file I/O (prevent path traversal)
+                if (!UUID_V4_RE.test(message.thread_id))
+                    return;
+                // Get round_count from thread file if it exists
+                const thread = loadThread(message.thread_id);
+                const round_count = thread?.round_count ?? 0;
+                const line = JSON.stringify({
+                    thread_id: message.thread_id,
+                    peer_pubkey: senderNpub,
+                    type: message.type,
+                    content: message.content,
+                    round_count,
+                });
+                outputLines.push(line);
+            },
+            oneose: () => {
+                eoseCount++;
+                if (eoseCount >= DEFAULT_RELAYS.length && !settled) {
+                    settled = true;
+                    clearTimeout(safetyTimer);
+                    sub.close();
+                    pool.close(DEFAULT_RELAYS);
+                    resolve();
+                }
+            },
+        });
+    });
+    // Write JSONL output to stdout
+    for (const line of outputLines) {
+        process.stdout.write(line + "\n");
+    }
+    // Advance watermark AFTER writing output (not before)
+    savePollState({ last_poll_at: nowSeconds });
+    // Explicitly exit — SimplePool holds WebSocket connections open indefinitely,
+    // which would block bridge.sh's polling loop if we don't force termination.
+    process.exit(0);
+}
+main().catch((err) => {
+    process.stderr.write(`poll: fatal error — ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/preferences.d.ts

@@ -0,0 +1,4 @@
+import type { UserPreferences } from "./types.js";
+export declare function loadPreferences(): Promise<UserPreferences>;
+export declare function savePreferences(prefs: UserPreferences): Promise<void>;
+export declare function formatPreferences(prefs: UserPreferences): string;

package/dist/preferences.js

@@ -0,0 +1,38 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { TRUEMATCH_DIR } from "./identity.js";
+const PREFERENCES_FILE = join(TRUEMATCH_DIR, "preferences.json");
+export async function loadPreferences() {
+    if (!existsSync(PREFERENCES_FILE))
+        return {};
+    const raw = await readFile(PREFERENCES_FILE, "utf8");
+    return JSON.parse(raw);
+}
+export async function savePreferences(prefs) {
+    await writeFile(PREFERENCES_FILE, JSON.stringify(prefs, null, 2), "utf8");
+}
+export function formatPreferences(prefs) {
+    const filters = [];
+    if (prefs.gender_preference?.length) {
+        filters.push(`gender: ${prefs.gender_preference.join(" or ")}`);
+    }
+    if (prefs.location) {
+        const radius = prefs.distance_radius_km !== undefined
+            ? ` (within ${prefs.distance_radius_km} km)`
+            : "";
+        filters.push(`location: ${prefs.location}${radius}`);
+    }
+    if (prefs.age_range) {
+        const { min, max } = prefs.age_range;
+        if (min !== undefined && max !== undefined)
+            filters.push(`age: ${min}–${max}`);
+        else if (min !== undefined)
+            filters.push(`age: ${min}+`);
+        else if (max !== undefined)
+            filters.push(`age: up to ${max}`);
+    }
+    if (filters.length === 0)
+        return "No preferences set — open to all candidates";
+    return `Active filters: ${filters.join(", ")}`;
+}

package/dist/registry.d.ts

@@ -0,0 +1,14 @@
+import type { ContactChannel, RegistrationRecord, TrueMatchIdentity } from "./types.js";
+export declare function loadRegistration(): Promise<RegistrationRecord | null>;
+export declare function register(identity: TrueMatchIdentity, cardUrl: string, contact: ContactChannel, locationText?: string, distanceRadiusKm?: number): Promise<RegistrationRecord>;
+export declare function deregister(identity: TrueMatchIdentity): Promise<void>;
+export interface ProximityOpts {
+    lat: number;
+    lng: number;
+    radiusKm: number;
+}
+export declare function listAgents(proximity?: ProximityOpts): Promise<Array<{
+    pubkey: string;
+    cardUrl: string;
+    lastSeen: string;
+}>>;

package/dist/registry.js

@@ -0,0 +1,89 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { TRUEMATCH_DIR, signPayload } from "./identity.js";
+const REGISTRY_URL = "https://clawmatch.org";
+const REGISTRATION_FILE = join(TRUEMATCH_DIR, "registration.json");
+export async function loadRegistration() {
+    if (!existsSync(REGISTRATION_FILE))
+        return null;
+    const raw = await readFile(REGISTRATION_FILE, "utf8");
+    return JSON.parse(raw);
+}
+export async function register(identity, cardUrl, contact, locationText, distanceRadiusKm) {
+    const bodyObj = {
+        pubkey: identity.npub,
+        card_url: cardUrl,
+        contact_channel: contact,
+    };
+    if (locationText)
+        bodyObj["location"] = locationText;
+    if (distanceRadiusKm !== undefined)
+        bodyObj["distance_radius_km"] = distanceRadiusKm;
+    const body = JSON.stringify(bodyObj);
+    const rawBody = new TextEncoder().encode(body);
+    const sig = signPayload(identity.nsec, rawBody);
+    const res = await fetch(`${REGISTRY_URL}/v1/register`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-TrueMatch-Sig": sig,
+        },
+        body,
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        throw new Error(`Registry error ${res.status}: ${err.error}`);
+    }
+    const resp = (await res.json());
+    const record = {
+        pubkey: identity.npub,
+        card_url: cardUrl,
+        contact_channel: contact,
+        registered_at: new Date().toISOString(),
+        enrolled: true,
+        location_lat: resp.location_lat ?? null,
+        location_lng: resp.location_lng ?? null,
+        location_label: resp.location_label ?? null,
+        location_resolution: resp.location_resolution ?? null,
+    };
+    await writeFile(REGISTRATION_FILE, JSON.stringify(record, null, 2), "utf8");
+    return record;
+}
+export async function deregister(identity) {
+    const body = JSON.stringify({ pubkey: identity.npub });
+    const rawBody = new TextEncoder().encode(body);
+    const sig = signPayload(identity.nsec, rawBody);
+    const res = await fetch(`${REGISTRY_URL}/v1/register`, {
+        method: "DELETE",
+        headers: {
+            "Content-Type": "application/json",
+            "X-TrueMatch-Sig": sig,
+        },
+        body,
+    });
+    if (!res.ok && res.status !== 404) {
+        const err = (await res.json());
+        throw new Error(`Registry error ${res.status}: ${err.error}`);
+    }
+    if (existsSync(REGISTRATION_FILE)) {
+        const rec = await loadRegistration();
+        if (rec) {
+            rec.enrolled = false;
+            await writeFile(REGISTRATION_FILE, JSON.stringify(rec, null, 2), "utf8");
+        }
+    }
+}
+export async function listAgents(proximity) {
+    const url = new URL(`${REGISTRY_URL}/v1/agents`);
+    if (proximity) {
+        url.searchParams.set("lat", String(proximity.lat));
+        url.searchParams.set("lng", String(proximity.lng));
+        url.searchParams.set("radius_km", String(proximity.radiusKm));
+    }
+    const res = await fetch(url.toString());
+    if (!res.ok)
+        throw new Error(`Failed to list agents: ${res.status}`);
+    const data = (await res.json());
+    return data.agents;
+}