nastech-app 1.0.0

package/sources/dev/testRunner.ts

@@ -0,0 +1,277 @@
+interface TestResult {
+    name: string;
+    passed: boolean;
+    error?: Error;
+    duration: number;
+}
+
+interface TestSuite {
+    name: string;
+    tests: TestResult[];
+}
+
+class TestRunner {
+    private suites: Map<string, TestSuite> = new Map();
+    private currentSuite: string | null = null;
+    private currentTests: Array<{ name: string; fn: () => void | Promise<void> }> = [];
+
+    describe(name: string, fn: () => void) {
+        this.currentSuite = name;
+        this.currentTests = [];
+        
+        // Execute the describe block to collect tests
+        fn();
+        
+        // Store the collected tests
+        this.suites.set(name, {
+            name,
+            tests: []
+        });
+        
+        // Store test functions for later execution
+        const suite = this.suites.get(name)!;
+        suite.tests = this.currentTests.map(test => ({
+            name: test.name,
+            passed: false,
+            duration: 0
+        }));
+        
+        // Store the test functions separately for execution
+        (suite as any).testFunctions = this.currentTests;
+        
+        this.currentSuite = null;
+    }
+
+    it(name: string, fn: () => void | Promise<void>) {
+        if (!this.currentSuite) {
+            throw new Error('it() must be called inside describe()');
+        }
+        
+        this.currentTests.push({ name, fn });
+    }
+
+    async runAll(): Promise<TestSuite[]> {
+        const results: TestSuite[] = [];
+        
+        for (const [suiteName, suite] of this.suites) {
+            const testFunctions = (suite as any).testFunctions as Array<{ name: string; fn: () => void | Promise<void> }>;
+            const suiteResult: TestSuite = {
+                name: suiteName,
+                tests: []
+            };
+            
+            for (let i = 0; i < testFunctions.length; i++) {
+                const test = testFunctions[i];
+                const startTime = Date.now();
+                
+                try {
+                    await test.fn();
+                    suiteResult.tests.push({
+                        name: test.name,
+                        passed: true,
+                        duration: Date.now() - startTime
+                    });
+                } catch (error) {
+                    suiteResult.tests.push({
+                        name: test.name,
+                        passed: false,
+                        error: error as Error,
+                        duration: Date.now() - startTime
+                    });
+                }
+            }
+            
+            results.push(suiteResult);
+        }
+        
+        return results;
+    }
+
+    async runSuite(suiteName: string): Promise<TestSuite | null> {
+        const suite = this.suites.get(suiteName);
+        if (!suite) return null;
+        
+        const testFunctions = (suite as any).testFunctions as Array<{ name: string; fn: () => void | Promise<void> }>;
+        const suiteResult: TestSuite = {
+            name: suiteName,
+            tests: []
+        };
+        
+        for (const test of testFunctions) {
+            const startTime = Date.now();
+            
+            try {
+                await test.fn();
+                suiteResult.tests.push({
+                    name: test.name,
+                    passed: true,
+                    duration: Date.now() - startTime
+                });
+            } catch (error) {
+                suiteResult.tests.push({
+                    name: test.name,
+                    passed: false,
+                    error: error as Error,
+                    duration: Date.now() - startTime
+                });
+            }
+        }
+        
+        return suiteResult;
+    }
+
+    getSuites(): string[] {
+        return Array.from(this.suites.keys());
+    }
+
+    clear() {
+        this.suites.clear();
+        this.currentSuite = null;
+        this.currentTests = [];
+    }
+}
+
+// Simple expect implementation
+class Expect<T> {
+    private negated = false;
+
+    constructor(private actual: T) {}
+
+    get not(): Expect<T> {
+        const newExpect = new Expect(this.actual);
+        newExpect.negated = true;
+        return newExpect;
+    }
+
+    toEqual(expected: T) {
+        const isEqual = this.deepEqual(this.actual, expected);
+        
+        if (this.negated) {
+            if (isEqual) {
+                throw new Error(`Expected ${JSON.stringify(expected)} to not equal ${JSON.stringify(this.actual)}`);
+            }
+        } else {
+            if (!isEqual) {
+                throw new Error(`Expected ${JSON.stringify(expected)} but got ${JSON.stringify(this.actual)}`);
+            }
+        }
+    }
+
+    toBe(expected: T) {
+        const isEqual = this.actual === expected;
+        
+        if (this.negated) {
+            if (isEqual) {
+                throw new Error(`Expected ${expected} to not be ${this.actual}`);
+            }
+        } else {
+            if (!isEqual) {
+                throw new Error(`Expected ${expected} but got ${this.actual}`);
+            }
+        }
+    }
+
+    toBeTruthy() {
+        if (this.negated) {
+            if (this.actual) {
+                throw new Error(`Expected falsy value but got ${this.actual}`);
+            }
+        } else {
+            if (!this.actual) {
+                throw new Error(`Expected truthy value but got ${this.actual}`);
+            }
+        }
+    }
+
+    toBeFalsy() {
+        if (this.negated) {
+            if (!this.actual) {
+                throw new Error(`Expected truthy value but got ${this.actual}`);
+            }
+        } else {
+            if (this.actual) {
+                throw new Error(`Expected falsy value but got ${this.actual}`);
+            }
+        }
+    }
+
+    toBeGreaterThan(expected: number) {
+        const actualNum = this.actual as unknown as number;
+        if (this.negated) {
+            if (actualNum > expected) {
+                throw new Error(`Expected ${actualNum} to not be greater than ${expected}`);
+            }
+        } else {
+            if (!(actualNum > expected)) {
+                throw new Error(`Expected ${actualNum} to be greater than ${expected}`);
+            }
+        }
+    }
+
+    toThrow(message?: string) {
+        if (typeof this.actual !== 'function') {
+            throw new Error('toThrow can only be used with functions');
+        }
+        
+        let didThrow = false;
+        let thrownError: any;
+        
+        try {
+            (this.actual as any)();
+        } catch (error: any) {
+            didThrow = true;
+            thrownError = error;
+        }
+        
+        if (this.negated) {
+            if (didThrow) {
+                throw new Error('Expected function to not throw but it did');
+            }
+        } else {
+            if (!didThrow) {
+                throw new Error('Expected function to throw but it did not');
+            }
+            if (message && thrownError && !thrownError.message.includes(message)) {
+                throw new Error(`Expected error message to include "${message}" but got "${thrownError.message}"`);
+            }
+        }
+    }
+
+    private deepEqual(a: any, b: any): boolean {
+        if (a === b) return true;
+        
+        if (a instanceof Uint8Array && b instanceof Uint8Array) {
+            if (a.length !== b.length) return false;
+            for (let i = 0; i < a.length; i++) {
+                if (a[i] !== b[i]) return false;
+            }
+            return true;
+        }
+        
+        if (a && b && typeof a === 'object' && typeof b === 'object') {
+            const keysA = Object.keys(a);
+            const keysB = Object.keys(b);
+            
+            if (keysA.length !== keysB.length) return false;
+            
+            for (const key of keysA) {
+                if (!keysB.includes(key)) return false;
+                if (!this.deepEqual(a[key], b[key])) return false;
+            }
+            
+            return true;
+        }
+        
+        return false;
+    }
+}
+
+// Global test runner instance
+export const testRunner = new TestRunner();
+
+// Export test functions
+export const describe = (name: string, fn: () => void) => testRunner.describe(name, fn);
+export const it = (name: string, fn: () => void | Promise<void>) => testRunner.it(name, fn);
+export const expect = <T>(actual: T) => new Expect(actual);
+
+export type { TestResult, TestSuite };

package/sources/docs/autocomplete-text-manipulation.md

@@ -0,0 +1,224 @@
+# Autocomplete Text Manipulation Documentation
+
+Based on analysis of the Openland Apps repository, this document explains how text manipulation works for autocomplete functionality in both web and mobile implementations.
+
+## Core Algorithm: findActiveWord
+
+The foundation of the autocomplete system is the `findActiveWord` utility that detects when a user is typing a mention (@) or emoji (:).
+
+```typescript
+// packages/openland-y-utils/findActiveWord.ts
+const stoplist = ['\n', ',', '(', ')'];
+const prefixes = ['@', ':'];
+
+function findActiveWord(content: string, selection: { start: number, end: number }): string | undefined {
+    if (selection.start !== selection.end) {
+        return undefined; // No active word if text is selected
+    }
+    
+    let startIndex = findActiveWordStart(content, selection);
+    let res = content.substring(startIndex, selection.end);
+    
+    if (res.length === 0) {
+        return undefined;
+    } else {
+        return res;
+    }
+}
+```
+
+The algorithm:
+1. Works backwards from cursor position
+2. Looks for prefix characters (@ or :) that start a word
+3. Stops at whitespace, newlines, or special characters
+4. Returns the active word including the prefix
+
+## Web Implementation (Quill.js)
+
+### Text Input Component
+The web implementation uses Quill.js rich text editor with custom formats for mentions and emojis.
+
+```typescript
+// packages/openland-web/components/unicorn/URickInput.tsx
+
+// Extract active word from Quill editor
+function extractActiveWord(quill: QuillType.Quill) {
+    let selection = quill.getSelection();
+    if (!selection) {
+        return null;
+    }
+    let start = Math.max(0, selection.index - 64); // Maximum lookback
+    
+    return findActiveWord(
+        quill.getText(start, selection.index + selection.length - start), 
+        {
+            start: selection.index,
+            end: selection.index + selection.length,
+        }
+    );
+}
+```
+
+### Text Replacement Logic
+When a user selects a mention from the autocomplete suggestions:
+
+```typescript
+// URickInput.tsx - commitSuggestion method
+commitSuggestion: (type: 'mention' | 'emoji', src: MentionToSend | { name: string; value: string }) => {
+    let ed = editor.current;
+    if (ed) {
+        let selection = ed.getSelection(true);
+        let autocompleteWord = extractActiveWord(ed);
+        
+        if (autocompleteWord) {
+            // Insert the mention/emoji embed at current position
+            ed.insertEmbed(selection.index, type, src, 'user');
+            
+            // Add space after mention (not emoji)
+            if (type === 'mention') {
+                ed.insertText(selection.index + 1, ' ', 'user');
+            }
+            
+            // Delete the typed text (including the @ prefix)
+            ed.deleteText(
+                selection.index - autocompleteWord.length,
+                autocompleteWord.length + selection.length,
+                'user'
+            );
+            
+            // Move cursor after the inserted mention/emoji
+            ed.setSelection(selection.index + 1, 1, 'user');
+        }
+    }
+}
+```
+
+The process:
+1. Get current cursor position and selection
+2. Find the active word being typed
+3. Insert the mention/emoji as an embedded object
+4. Delete the original typed text (e.g., "@john")
+5. Position cursor after the inserted element
+
+### Real-time Updates
+The editor monitors text changes and updates autocomplete suggestions:
+
+```typescript
+q.on('editor-change', () => {
+    // ... other logic
+    
+    if (props.onAutocompleteWordChange && props.autocompletePrefixes) {
+        let selection = q.getSelection();
+        if (selection) {
+            let autocompleteWord: string | null = null;
+            let activeWord = extractActiveWord(q);
+            
+            if (activeWord) {
+                // Check if active word starts with any prefix
+                for (let p of props.autocompletePrefixes) {
+                    if (activeWord.toLowerCase().startsWith(p)) {
+                        autocompleteWord = activeWord;
+                        break;
+                    }
+                }
+            }
+            
+            // Notify parent component of autocomplete word change
+            if (lastAutocompleteText !== autocompleteWord) {
+                lastAutocompleteText = autocompleteWord;
+                props.onAutocompleteWordChange(autocompleteWord);
+            }
+        }
+    }
+});
+```
+
+## Mobile Implementation (React Native)
+
+### Text Input Component
+Mobile uses standard React Native TextInput with selection tracking:
+
+```typescript
+// packages/openland-mobile/pages/main/components/MessageInputInner.tsx
+<TextInput
+    ref={ref}
+    selectionColor={theme.accentPrimary}
+    style={{...}}
+    onChangeText={props.onChangeText}
+    onSelectionChange={props.onSelectionChange}
+    value={props.text}
+    multiline={true}
+    {...inputProps}
+/>
+```
+
+### Text Manipulation Pattern
+While the exact mobile text replacement code wasn't found in the examined files, the pattern follows:
+
+1. Track cursor position using `onSelectionChange`
+2. Use `findActiveWord` with current text and selection
+3. When mention selected, manipulate text string:
+   ```typescript
+   // Pseudo-code for mobile text replacement
+   const replaceText = (text: string, selection: Selection, mention: string) => {
+       const activeWord = findActiveWord(text, selection);
+       if (activeWord) {
+           const startIndex = selection.start - activeWord.length;
+           const newText = 
+               text.substring(0, startIndex) + 
+               mention + ' ' + 
+               text.substring(selection.end);
+           return {
+               text: newText,
+               selection: { start: startIndex + mention.length + 1, end: startIndex + mention.length + 1 }
+           };
+       }
+   };
+   ```
+
+### Suggestion Display
+Mobile shows suggestions in a floating view above the keyboard:
+
+```typescript
+// packages/openland-mobile/pages/main/components/MessageInputBar.tsx
+{props.suggestions && (
+    <ZBlurredView intensity="normal" style={{ position: 'absolute', bottom: '100%', left: 0, right: 0 }}>
+        {props.suggestions}
+    </ZBlurredView>
+)}
+```
+
+## Key Differences Between Platforms
+
+### Web (Quill.js)
+- Rich text editor with embedded objects
+- Mentions stored as objects, not plain text
+- Built-in undo/redo support
+- More complex but feature-rich
+
+### Mobile (React Native)
+- Plain text manipulation
+- Mentions stored as special text patterns
+- Manual string manipulation
+- Simpler but requires careful cursor management
+
+## Implementation Tips
+
+1. **Active Word Detection**: Always check from cursor position backwards, stop at special characters
+2. **Text Replacement**: Calculate correct indices before and after replacement
+3. **Cursor Management**: Always update cursor position after text manipulation
+4. **Platform Differences**: Web can use rich text, mobile typically uses plain text with markers
+5. **Performance**: Debounce autocomplete queries to avoid excessive API calls
+
+## Data Flow
+
+1. User types "@" or ":"
+2. `findActiveWord` detects the prefix and extracts the query
+3. Parent component receives the active word
+4. GraphQL query fetches matching users/emojis
+5. Suggestions displayed in dropdown/popup
+6. User selects suggestion
+7. Text manipulation replaces typed text with selection
+8. Cursor positioned after inserted content
+
+This architecture provides a responsive autocomplete experience across both web and mobile platforms while handling the complexity of text manipulation and cursor management.

package/sources/encryption/aes.appspec.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from '@/dev/testRunner';
+import { decryptAESGCM, decryptAESGCMString, encryptAESGCM, encryptAESGCMString } from './aes';
+import { getRandomBytes } from 'expo-crypto';
+import { encodeBase64 } from '@/encryption/base64';
+
+describe('AES Tests', () => {
+    it('should encrypt and decrypt a string', async () => {
+        const key = encodeBase64(getRandomBytes(32));
+        const encrypted = await encryptAESGCMString(JSON.stringify('Hello, World!'), key);
+        expect(typeof encrypted).toEqual('string');
+        console.log(`Encrypted: ${encrypted}`);
+        const decrypted = await decryptAESGCMString(encrypted, key);
+        expect(typeof decrypted).toEqual('string');
+        console.log(`Decrypted: ${decrypted}`);
+        expect(decrypted).toEqual(JSON.stringify('Hello, World!'));
+    });
+    it('should encrypt and decrypt a Uint8Array', async () => {
+        const key = encodeBase64(getRandomBytes(32));
+        const encrypted = await encryptAESGCM(new TextEncoder().encode('Hello, World!'), key);
+        expect(encrypted instanceof Uint8Array).toBe(true);
+        const decrypted = await decryptAESGCM(encrypted, key);
+        expect(decrypted instanceof Uint8Array).toBe(true);
+        expect(decrypted).toEqual(new TextEncoder().encode('Hello, World!'));
+    });
+});

package/sources/encryption/aes.ts

@@ -0,0 +1,21 @@
+import * as crypto from 'rn-encryption';
+import { decodeUTF8, encodeUTF8 } from './text';
+import { decodeBase64, encodeBase64 } from '@/encryption/base64';
+
+export async function encryptAESGCMString(data: string, key64: string): Promise<string> {
+    return await crypto.encryptAsyncAES(data, key64);
+}
+
+export async function decryptAESGCMString(data: string, key64: string): Promise<string | null> {
+    const res = (await crypto.decryptAsyncAES(data, key64)).trim();
+    return res;
+}
+
+export async function encryptAESGCM(data: Uint8Array, key64: string): Promise<Uint8Array> {
+    const encrypted = (await crypto.encryptAsyncAES(decodeUTF8(data), key64)).trim();
+    return decodeBase64(encrypted);
+}
+export async function decryptAESGCM(data: Uint8Array, key64: string): Promise<Uint8Array | null> {
+    let raw = await crypto.decryptAsyncAES(encodeBase64(data), key64);
+    return raw ? encodeUTF8(raw) : null;
+}

package/sources/encryption/aes.web.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Round-trip tests for aes.web.ts running against the same crypto.subtle
+ * that web-secure-encryption uses on the web build, so a successful round
+ * trip here implies wire compatibility with what rn-encryption emits on
+ * the native side (which uses the AES.GCM SealedBox combined-format:
+ * 12-byte nonce + ciphertext + 16-byte tag).
+ */
+import { describe, it, expect } from 'vitest';
+import {
+    encryptAESGCMString,
+    decryptAESGCMString,
+    encryptAESGCM,
+    decryptAESGCM,
+} from './aes.web';
+import { encodeBase64 } from './base64';
+
+function randomKeyB64(): string {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return encodeBase64(bytes);
+}
+
+describe('aes.web', () => {
+    it('round-trips a string', async () => {
+        const key = randomKeyB64();
+        const plain = JSON.stringify({ msg: 'Hello, World!', n: 42 });
+        const encrypted = await encryptAESGCMString(plain, key);
+        expect(typeof encrypted).toBe('string');
+        const decrypted = await decryptAESGCMString(encrypted, key);
+        expect(decrypted).toBe(plain);
+    });
+
+    it('produces a fresh IV per call (no two ciphertexts equal)', async () => {
+        const key = randomKeyB64();
+        const a = await encryptAESGCMString('same', key);
+        const b = await encryptAESGCMString('same', key);
+        expect(a).not.toBe(b);
+    });
+
+    it('rejects ciphertext encrypted under a different key', async () => {
+        const k1 = randomKeyB64();
+        const k2 = randomKeyB64();
+        const encrypted = await encryptAESGCMString('secret', k1);
+        const result = await decryptAESGCMString(encrypted, k2);
+        expect(result).toBeNull();
+    });
+
+    it('rejects truncated ciphertext gracefully', async () => {
+        const key = randomKeyB64();
+        const encrypted = await encryptAESGCMString('hello', key);
+        const result = await decryptAESGCMString(encrypted.slice(0, 4), key);
+        expect(result).toBeNull();
+    });
+
+    it('round-trips a Uint8Array via the bytes API', async () => {
+        const key = randomKeyB64();
+        const data = new TextEncoder().encode('Hello, World!');
+        const encrypted = await encryptAESGCM(data, key);
+        expect(encrypted).toBeInstanceOf(Uint8Array);
+        const decrypted = await decryptAESGCM(encrypted, key);
+        expect(decrypted).toBeInstanceOf(Uint8Array);
+        expect(new TextDecoder().decode(decrypted!)).toBe('Hello, World!');
+    });
+
+    it('produces wire format: 12-byte IV prefix + ciphertext + 16-byte tag', async () => {
+        const key = randomKeyB64();
+        const encrypted = await encryptAESGCMString('a', key);
+        // base64 payload = IV(12) + ciphertext("a" → 1 byte) + GCM tag(16) = 29 bytes
+        // base64 encoded length for 29 bytes = ceil(29/3)*4 = 40 chars (with padding)
+        const decoded = Uint8Array.from(atob(encrypted), (c) => c.charCodeAt(0));
+        expect(decoded.length).toBe(12 + 1 + 16);
+    });
+});

package/sources/encryption/aes.web.ts

@@ -0,0 +1,79 @@
+/**
+ * AES-GCM encryption — web implementation via crypto.subtle.
+ *
+ * Wire-format mirrors what the native `rn-encryption` module emits on iOS
+ * (`AES.GCM.seal` produces nonce(12) + ciphertext + tag(16)) and on Android
+ * (same Cryptokit-equivalent layout), so a blob encrypted on one platform
+ * can be decrypted on another. Output is base64. Keys are 32-byte AES-256
+ * passed as base64 strings.
+ *
+ * `rn-encryption` does already ship a web fallback through
+ * `web-secure-encryption`, so going through it on the web works today.
+ * Implementing this file directly against crypto.subtle drops the
+ * dependency hop on the web bundle and lets Metro resolve a cheaper
+ * platform-specific module without a runtime Platform.OS check.
+ *
+ * NOTE: encryptAESGCM / decryptAESGCM use `decodeUTF8`/`encodeUTF8` to keep
+ * binary contract parity with aes.ts. The roundtrip-only property still
+ * matches that file (see the comment in encryptor.ts about the
+ * UTF-8-via-Uint8Array quirk in the legacy AES path).
+ */
+import { decodeBase64, encodeBase64 } from '@/encryption/base64';
+import { decodeUTF8, encodeUTF8 } from './text';
+
+const ALGO = 'AES-GCM';
+const IV_LEN = 12;
+
+async function importKey(key64: string, usage: 'encrypt' | 'decrypt'): Promise<CryptoKey> {
+    const keyBytes = decodeBase64(key64);
+    return crypto.subtle.importKey('raw', keyBytes as BufferSource, { name: ALGO }, false, [usage]);
+}
+
+function concat(iv: Uint8Array, ciphertextWithTag: ArrayBuffer): Uint8Array {
+    const out = new Uint8Array(iv.length + ciphertextWithTag.byteLength);
+    out.set(iv, 0);
+    out.set(new Uint8Array(ciphertextWithTag), iv.length);
+    return out;
+}
+
+function split(bundle: Uint8Array): { iv: Uint8Array; ciphertext: Uint8Array } {
+    return { iv: bundle.slice(0, IV_LEN), ciphertext: bundle.slice(IV_LEN) };
+}
+
+export async function encryptAESGCMString(data: string, key64: string): Promise<string> {
+    const key = await importKey(key64, 'encrypt');
+    const iv = crypto.getRandomValues(new Uint8Array(IV_LEN));
+    const ciphertext = await crypto.subtle.encrypt(
+        { name: ALGO, iv: iv as BufferSource },
+        key,
+        new TextEncoder().encode(data) as BufferSource,
+    );
+    return encodeBase64(concat(iv, ciphertext));
+}
+
+export async function decryptAESGCMString(data: string, key64: string): Promise<string | null> {
+    try {
+        const key = await importKey(key64, 'decrypt');
+        const { iv, ciphertext } = split(decodeBase64(data));
+        const plaintext = await crypto.subtle.decrypt(
+            { name: ALGO, iv: iv as BufferSource },
+            key,
+            ciphertext as BufferSource,
+        );
+        return new TextDecoder().decode(plaintext);
+    } catch {
+        return null;
+    }
+}
+
+export async function encryptAESGCM(data: Uint8Array, key64: string): Promise<Uint8Array> {
+    // Mirror aes.ts: the existing AES path round-trips bytes-as-UTF-8-strings.
+    // Going around that here would diverge the web wire from the native one.
+    const encryptedB64 = (await encryptAESGCMString(decodeUTF8(data), key64)).trim();
+    return decodeBase64(encryptedB64);
+}
+
+export async function decryptAESGCM(data: Uint8Array, key64: string): Promise<Uint8Array | null> {
+    const result = await decryptAESGCMString(encodeBase64(data), key64);
+    return result ? encodeUTF8(result) : null;
+}