fix(consumer): return decrypted items

packages/consumer/mod.ts

···
 import { produceRequirements } from "@cistern/shared";
-import { generateKeys } from "@cistern/crypto";
+import { decryptText, generateKeys } from "@cistern/crypto";
 import { generateRandomName } from "@puregarlic/randimal";
 import { is, parse, type RecordKey } from "@atcute/lexicons";
 import { JetstreamSubscription } from "@atcute/jetstream";
···
   AppCisternLexiconItem,
   type AppCisternLexiconPubkey,
 } from "@cistern/lexicon";
-import type { ConsumerOptions, ConsumerParams, LocalKeyPair } from "./types.ts";
+import type {
+  ConsumerOptions,
+  ConsumerParams,
+  DecryptedItem,
+  LocalKeyPair,
+} from "./types.ts";
 
 import type {} from "@atcute/atproto";
 
···
    * Asynchronously iterate through items in the user's PDS
    */
   async *listItems(): AsyncIterator<
-    AppCisternLexiconItem.Main,
+    DecryptedItem,
     void,
     undefined
   > {
+    if (!this.keypair) {
+      throw new Error("no key pair set; generate a key before listing items");
+    }
+
     let cursor: string | undefined;
 
     while (true) {
···
       if (res.data.cursor) cursor = res.data.cursor;
 
       for (const record of res.data.records) {
-        yield parse(AppCisternLexiconItem.mainSchema, record.value);
+        const item = parse(AppCisternLexiconItem.mainSchema, record.value);
+        const decrypted = decryptText(this.keypair.privateKey, {
+          nonce: item.nonce,
+          cipherText: item.ciphertext,
+          content: item.payload,
+          hash: item.contentHash,
+          length: item.contentLength,
+        });
+
+        yield {
+          tid: item.tid,
+          text: decrypted,
+        };
       }
 
       if (!cursor) return;
···
    * @todo Allow specifying Jetstream endpoint
    */
   async *subscribeToItems(): AsyncIterator<
-    AppCisternLexiconItem.Main,
+    DecryptedItem,
     void,
     "stop" | undefined
   > {
···
           continue;
         }
 
-        if ((yield record) === "stop") return;
+        const decrypted = decryptText(this.keypair.privateKey, {
+          nonce: record.nonce,
+          cipherText: record.ciphertext,
+          content: record.payload,
+          hash: record.contentHash,
+          length: record.contentLength,
+        });
+
+        const command = yield { tid: record.tid, text: decrypted };
+
+        if (command === "stop") return;
       }
     }
   }

packages/consumer/types.ts

···
 import type { BaseClientOptions, ClientRequirements } from "@cistern/shared";
-import type { ResourceUri } from "@atcute/lexicons";
+import type { ResourceUri, Tid } from "@atcute/lexicons";
 
 export interface InputLocalKeyPair {
   privateKey: string;
···
 }
 
 export type ConsumerParams = ClientRequirements<ConsumerOptions>;
+
+export interface DecryptedItem {
+  tid: Tid;
+  text: string;
+}