nastech-app 1.0.0

package/sources/sync/encryption/sessionEncryption.ts

@@ -0,0 +1,207 @@
+import { decodeBase64, encodeBase64 } from '@/encryption/base64';
+import { RawRecord } from '../typesRaw';
+import { ApiMessage } from '../apiTypes';
+import { DecryptedMessage, Metadata, MetadataSchema, AgentState, AgentStateSchema } from '../storageTypes';
+import { EncryptionCache } from './encryptionCache';
+import { Decryptor, Encryptor } from './encryptor';
+
+export class SessionEncryption {
+    private sessionId: string;
+    private encryptor: Encryptor & Decryptor;
+    private cache: EncryptionCache;
+
+    constructor(
+        sessionId: string,
+        encryptor: Encryptor & Decryptor,
+        cache: EncryptionCache
+    ) {
+        this.sessionId = sessionId;
+        this.encryptor = encryptor;
+        this.cache = cache;
+    }
+
+    /**
+     * Batch-first API for decrypting messages
+     */
+    async decryptMessages(messages: ApiMessage[]): Promise<(DecryptedMessage | null)[]> {
+        // Check cache for all messages first
+        const results: (DecryptedMessage | null)[] = new Array(messages.length);
+        const toDecrypt: { index: number; message: ApiMessage }[] = [];
+
+        for (let i = 0; i < messages.length; i++) {
+            const message = messages[i];
+            if (!message) {
+                results[i] = null;
+                continue;
+            }
+
+            // Check cache first
+            const cached = this.cache.getCachedMessage(message.id);
+            if (cached) {
+                results[i] = cached;
+            } else if (message.content.t === 'encrypted') {
+                toDecrypt.push({ index: i, message });
+            } else {
+                // Not encrypted or invalid
+                results[i] = {
+                    id: message.id,
+                    seq: message.seq,
+                    localId: message.localId ?? null,
+                    content: null,
+                    createdAt: message.createdAt,
+                };
+                this.cache.setCachedMessage(message.id, results[i]!);
+            }
+        }
+
+        // Batch decrypt uncached messages
+        if (toDecrypt.length > 0) {
+            const encrypted = toDecrypt.map(item =>
+                decodeBase64(item.message.content.c, 'base64')
+            );
+            
+            const decrypted = await this.encryptor.decrypt(encrypted);
+
+            for (let i = 0; i < toDecrypt.length; i++) {
+                const decryptedData = decrypted[i];
+                const { message, index } = toDecrypt[i];
+
+                if (decryptedData) {
+                    const result: DecryptedMessage = {
+                        id: message.id,
+                        seq: message.seq,
+                        localId: message.localId ?? null,
+                        content: decryptedData,
+                        createdAt: message.createdAt,
+                    };
+                    this.cache.setCachedMessage(message.id, result);
+                    results[index] = result;
+                } else {
+                    const result: DecryptedMessage = {
+                        id: message.id,
+                        seq: message.seq,
+                        localId: message.localId ?? null,
+                        content: null,
+                        createdAt: message.createdAt,
+                    };
+                    this.cache.setCachedMessage(message.id, result);
+                    results[index] = result;
+                }
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Single message convenience method
+     */
+    async decryptMessage(message: ApiMessage | null | undefined): Promise<DecryptedMessage | null> {
+        if (!message) {
+            return null;
+        }
+        const results = await this.decryptMessages([message]);
+        return results[0];
+    }
+
+    /**
+     * Encrypt a raw record
+     */
+    async encryptRawRecord(record: RawRecord): Promise<string> {
+        const encrypted = await this.encryptor.encrypt([record]);
+        return encodeBase64(encrypted[0], 'base64');
+    }
+
+    /**
+     * Encrypt raw data using session-specific encryption
+     */
+    async encryptRaw(data: any): Promise<string> {
+        const encrypted = await this.encryptor.encrypt([data]);
+        return encodeBase64(encrypted[0], 'base64');
+    }
+
+    /**
+     * Decrypt raw data using session-specific encryption
+     */
+    async decryptRaw(encrypted: string): Promise<any | null> {
+        try {
+            const encryptedData = decodeBase64(encrypted, 'base64');
+            const decrypted = await this.encryptor.decrypt([encryptedData]);
+            return decrypted[0] || null;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Encrypt metadata using session-specific encryption
+     */
+    async encryptMetadata(metadata: Metadata): Promise<string> {
+        const encrypted = await this.encryptor.encrypt([metadata]);
+        return encodeBase64(encrypted[0], 'base64');
+    }
+
+    /**
+     * Decrypt metadata using session-specific encryption
+     */
+    async decryptMetadata(version: number, encrypted: string): Promise<Metadata | null> {
+        // Check cache first
+        const cached = this.cache.getCachedMetadata(this.sessionId, version);
+        if (cached) {
+            return cached;
+        }
+
+        // Decrypt if not cached
+        const encryptedData = decodeBase64(encrypted, 'base64');
+        const decrypted = await this.encryptor.decrypt([encryptedData]);
+        if (!decrypted[0]) {
+            return null;
+        }
+        const parsed = MetadataSchema.safeParse(decrypted[0]);
+        if (!parsed.success) {
+            return null;
+        }
+
+        // Cache the result
+        this.cache.setCachedMetadata(this.sessionId, version, parsed.data);
+        return parsed.data;
+    }
+
+    /**
+     * Encrypt agent state using session-specific encryption
+     */
+    async encryptAgentState(state: AgentState): Promise<string> {
+        const encrypted = await this.encryptor.encrypt([state]);
+        return encodeBase64(encrypted[0], 'base64');
+    }
+
+    /**
+     * Decrypt agent state using session-specific encryption
+     */
+    async decryptAgentState(version: number, encrypted: string | null | undefined): Promise<AgentState> {
+        if (!encrypted) {
+            return {};
+        }
+
+        // Check cache first
+        const cached = this.cache.getCachedAgentState(this.sessionId, version);
+        if (cached) {
+            return cached;
+        }
+
+        // Decrypt if not cached
+        const encryptedData = decodeBase64(encrypted, 'base64');
+        const decrypted = await this.encryptor.decrypt([encryptedData]);
+        if (!decrypted[0]) {
+            return {};
+        }
+        const parsed = AgentStateSchema.safeParse(decrypted[0]);
+        if (!parsed.success) {
+            return {};
+        }
+
+        // Cache the result
+        this.cache.setCachedAgentState(this.sessionId, version, parsed.data);
+        return parsed.data;
+    }
+}

package/sources/sync/feedTypes.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+// Feed body schema matching backend exactly
+export const FeedBodySchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('friend_request'), uid: z.string() }),
+    z.object({ kind: z.literal('friend_accepted'), uid: z.string() }),
+    z.object({ kind: z.literal('text'), text: z.string() })
+]);
+
+export type FeedBody = z.infer<typeof FeedBodySchema>;
+
+// Feed item schema
+export const FeedItemSchema = z.object({
+    id: z.string(),
+    repeatKey: z.string().nullable(),
+    body: FeedBodySchema,
+    createdAt: z.number(),
+    cursor: z.string(),
+    counter: z.number()
+});
+
+export type FeedItem = z.infer<typeof FeedItemSchema>;
+
+// Feed response schema
+export const FeedResponseSchema = z.object({
+    items: z.array(z.object({
+        id: z.string(),
+        body: FeedBodySchema,
+        repeatKey: z.string().nullable(),
+        cursor: z.string(),
+        createdAt: z.number()
+    })),
+    hasMore: z.boolean()
+});
+
+export type FeedResponse = z.infer<typeof FeedResponseSchema>;
+
+// Feed options for API calls
+export interface FeedOptions {
+    limit?: number;
+    before?: string;
+    after?: string;
+}

package/sources/sync/friendTypes.ts

@@ -0,0 +1,92 @@
+import * as z from 'zod';
+import { ImageRefSchema } from './profile';
+
+//
+// Relationship Status
+//
+
+export const RelationshipStatusSchema = z.enum(['none', 'requested', 'pending', 'friend', 'rejected']);
+export type RelationshipStatus = z.infer<typeof RelationshipStatusSchema>;
+
+//
+// User Profile (Friend)
+//
+
+export const UserProfileSchema = z.object({
+    id: z.string(),
+    firstName: z.string(),
+    lastName: z.string().nullable(),
+    avatar: z.object({
+        path: z.string(),
+        url: z.string(),
+        width: z.number().optional(),
+        height: z.number().optional(),
+        thumbhash: z.string().optional()
+    }).nullable(),
+    username: z.string(),
+    bio: z.string().nullable(),
+    status: RelationshipStatusSchema
+});
+
+export type UserProfile = z.infer<typeof UserProfileSchema>;
+
+// Friend Request type no longer used in new API
+
+//
+// Relationship Updated Event
+//
+
+export const RelationshipUpdatedEventSchema = z.object({
+    fromUserId: z.string(),
+    toUserId: z.string(),
+    status: RelationshipStatusSchema,
+    action: z.enum(['created', 'updated', 'deleted']),
+    fromUser: UserProfileSchema.optional(),
+    toUser: UserProfileSchema.optional(),
+    timestamp: z.number()
+});
+
+export type RelationshipUpdatedEvent = z.infer<typeof RelationshipUpdatedEventSchema>;
+
+//
+// API Response Types
+//
+
+export const UserResponseSchema = z.object({
+    user: UserProfileSchema
+});
+
+export type UserResponse = z.infer<typeof UserResponseSchema>;
+
+export const FriendsResponseSchema = z.object({
+    friends: z.array(UserProfileSchema)
+});
+
+export type FriendsResponse = z.infer<typeof FriendsResponseSchema>;
+
+export const UsersSearchResponseSchema = z.object({
+    users: z.array(UserProfileSchema)
+});
+
+export type UsersSearchResponse = z.infer<typeof UsersSearchResponseSchema>;
+
+//
+// Utility functions
+//
+
+export function getDisplayName(profile: UserProfile): string {
+    const fullName = [profile.firstName, profile.lastName].filter(Boolean).join(' ');
+    return fullName || profile.username;
+}
+
+export function isFriend(status: RelationshipStatus): boolean {
+    return status === 'friend';
+}
+
+export function isPendingRequest(status: RelationshipStatus): boolean {
+    return status === 'pending';
+}
+
+export function isRequested(status: RelationshipStatus): boolean {
+    return status === 'requested';
+}

package/sources/sync/git-parsers/LineParser.ts

@@ -0,0 +1,62 @@
+/**
+ * Core line parser utility for processing git command output
+ * Based on simple-git's LineParser implementation
+ */
+
+export type LineParseHandler<T> = (target: T, matches: (string | undefined)[], lines: string[], index: number) => void;
+
+/**
+ * Generic line parser that processes lines using regular expressions
+ * 
+ * @template T The type of object being built by the parser
+ */
+export class LineParser<T> {
+    private readonly regexes: readonly RegExp[];
+    private readonly handler: LineParseHandler<T>;
+
+    constructor(regexes: RegExp | RegExp[], handler: LineParseHandler<T>) {
+        this.regexes = Array.isArray(regexes) ? regexes : [regexes];
+        this.handler = handler;
+    }
+
+    /**
+     * Parse lines and populate the target object
+     */
+    parse(target: T, lines: string[]): T {
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const regex of this.regexes) {
+                const match = regex.exec(line);
+                if (match) {
+                    this.handler(target, match, lines, i);
+                    break;
+                }
+            }
+        }
+        return target;
+    }
+}
+
+/**
+ * Specialized parser for remote messages (lines starting with "remote:")
+ */
+export class RemoteLineParser<T> extends LineParser<T> {
+    constructor(regexes: RegExp | RegExp[], handler: LineParseHandler<T>) {
+        super(regexes, (target, matches, lines, index) => {
+            const line = lines[index];
+            if (line.startsWith('remote:')) {
+                handler(target, matches, lines, index);
+            }
+        });
+    }
+}
+
+/**
+ * Helper function to create a simple line parser
+ */
+export function createLineParser<T>(
+    regex: RegExp | RegExp[],
+    handler: LineParseHandler<T>
+): LineParser<T> {
+    return new LineParser(regex, handler);
+}

package/sources/sync/git-parsers/parseBranch.ts

@@ -0,0 +1,97 @@
+/**
+ * Git branch parser
+ * Based on simple-git implementation for parsing branch information
+ */
+
+import { LineParser } from './LineParser';
+
+export interface BranchSummaryBranch {
+    name: string;
+    commit: string;
+    label: string;
+    current: boolean;
+}
+
+export interface BranchSummary {
+    detached: boolean;
+    current: string | null;
+    all: string[];
+    branches: Record<string, BranchSummaryBranch>;
+}
+
+// Regex patterns for different branch formats
+const BRANCH_REGEX = /^([*+]\s)?\((.+)\)$/;  // Detached HEAD: * (HEAD detached at abc1234)
+const NORMAL_BRANCH_REGEX = /^([*+]\s)?(\S+)(?:\s+([a-f0-9]+)\s+(.*))?$/;  // Normal branch: * main abc1234 commit message
+
+/**
+ * Parse git branch output
+ */
+export function parseBranchSummary(branchOutput: string): BranchSummary {
+    const lines = branchOutput.trim().split('\n').filter(line => line.length > 0);
+    
+    const result: BranchSummary = {
+        detached: false,
+        current: null,
+        all: [],
+        branches: {}
+    };
+
+    const parser = new LineParser(
+        [BRANCH_REGEX, NORMAL_BRANCH_REGEX],
+        (target: BranchSummary, matches: (string | undefined)[]) => {
+            const isCurrent = !!(matches[1] && matches[1].trim());
+            const branchName = matches[2];
+            
+            if (!branchName) return;
+
+            // Handle detached HEAD state
+            if (branchName.startsWith('HEAD detached at') || branchName.startsWith('HEAD detached from')) {
+                target.detached = true;
+                if (isCurrent) {
+                    target.current = branchName;
+                }
+                return;
+            }
+
+            // Handle normal branches
+            const commit = matches[3] || '';
+            const label = matches[4] || '';
+
+            target.all.push(branchName);
+            target.branches[branchName] = {
+                name: branchName,
+                commit,
+                label,
+                current: isCurrent
+            };
+
+            if (isCurrent) {
+                target.current = branchName;
+            }
+        }
+    );
+
+    return parser.parse(result, lines);
+}
+
+/**
+ * Parse simple branch name from git branch --show-current
+ */
+export function parseCurrentBranch(branchOutput: string): string | null {
+    const trimmed = branchOutput.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+
+/**
+ * Get branch status from status character
+ */
+export function getBranchStatus(statusChar: string): 'current' | 'remote' | 'normal' {
+    switch (statusChar?.trim()) {
+        case '*':
+            return 'current';
+        case '+':
+            return 'remote';
+        default:
+            return 'normal';
+    }
+}

package/sources/sync/git-parsers/parseDiff.ts

@@ -0,0 +1,180 @@
+/**
+ * Git diff parser for numstat and diff summary output
+ * Based on simple-git implementation with enhancements
+ */
+
+import { LineParser } from './LineParser';
+
+export interface DiffFileStat {
+    file: string;
+    changes: number;
+    insertions: number;
+    deletions: number;
+    binary: boolean;
+}
+
+export interface DiffSummary {
+    files: DiffFileStat[];
+    insertions: number;
+    deletions: number;
+    changes: number;
+    changed: number;  // Number of files changed
+}
+
+// Regex for git diff --numstat output: "insertions\tdeletions\tfilename"
+const NUMSTAT_REGEX = /^(\d+|-)\t(\d+|-)\t(.*)$/;
+
+// Regex for git diff --stat output summary line: " X files changed, Y insertions(+), Z deletions(-)"
+const STAT_SUMMARY_REGEX = /^\s*(\d+)\s+files? changed(?:,\s*(\d+)\s+insertions?\(\+\))?(?:,\s*(\d+)\s+deletions?\(-\))?/;
+
+/**
+ * Parse git diff --numstat output
+ */
+export function parseNumStat(numStatOutput: string): DiffSummary {
+    const lines = numStatOutput.trim().split('\n').filter(line => line.length > 0);
+    
+    const result: DiffSummary = {
+        files: [],
+        insertions: 0,
+        deletions: 0,
+        changes: 0,
+        changed: 0
+    };
+
+    const parser = new LineParser(
+        NUMSTAT_REGEX,
+        (target: DiffSummary, matches: (string | undefined)[]) => {
+            const insertionsStr = matches[1];
+            const deletionsStr = matches[2];
+            const file = matches[3];
+
+            if (!file || !insertionsStr || !deletionsStr) return;
+
+            // Handle binary files (git shows '-' for binary files)
+            const isBinary = insertionsStr === '-' || deletionsStr === '-';
+            const insertions = isBinary ? 0 : parseInt(insertionsStr, 10);
+            const deletions = isBinary ? 0 : parseInt(deletionsStr, 10);
+            const changes = insertions + deletions;
+
+            const fileStat: DiffFileStat = {
+                file,
+                changes,
+                insertions,
+                deletions,
+                binary: isBinary
+            };
+
+            target.files.push(fileStat);
+            target.insertions += insertions;
+            target.deletions += deletions;
+            target.changes += changes;
+            target.changed++;
+        }
+    );
+
+    return parser.parse(result, lines);
+}
+
+/**
+ * Parse git diff --stat output summary
+ */
+export function parseDiffStat(diffStatOutput: string): DiffSummary {
+    const lines = diffStatOutput.trim().split('\n');
+    const summaryLine = lines[lines.length - 1];
+    
+    const result: DiffSummary = {
+        files: [],
+        insertions: 0,
+        deletions: 0,
+        changes: 0,
+        changed: 0
+    };
+
+    // Parse the summary line
+    const match = STAT_SUMMARY_REGEX.exec(summaryLine);
+    if (match) {
+        result.changed = parseInt(match[1], 10) || 0;
+        result.insertions = parseInt(match[2], 10) || 0;
+        result.deletions = parseInt(match[3], 10) || 0;
+        result.changes = result.insertions + result.deletions;
+    }
+
+    // Parse individual file stats from the other lines
+    const fileLines = lines.slice(0, -1).filter(line => line.trim().length > 0);
+    for (const line of fileLines) {
+        const fileStat = parseFileStatLine(line);
+        if (fileStat) {
+            result.files.push(fileStat);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Parse a single file stat line from git diff --stat
+ * Example: " src/file.ts | 10 +++++-----"
+ */
+function parseFileStatLine(line: string): DiffFileStat | null {
+    const parts = line.split('|');
+    if (parts.length !== 2) return null;
+
+    const file = parts[0].trim();
+    const statsPart = parts[1].trim();
+    
+    // Extract numbers and +/- indicators
+    const match = /(\d+)\s*(.*)/. exec(statsPart);
+    if (!match) return null;
+
+    const changes = parseInt(match[1], 10);
+    const indicators = match[2];
+    
+    // Count + and - characters
+    const insertions = (indicators.match(/\+/g) || []).length;
+    const deletions = (indicators.match(/-/g) || []).length;
+    
+    // Check if it's a binary file
+    const binary = indicators.includes('Bin');
+
+    return {
+        file,
+        changes,
+        insertions,
+        deletions,
+        binary
+    };
+}
+
+/**
+ * Create a map of file paths to their diff statistics
+ */
+export function createDiffStatsMap(summary: DiffSummary): Record<string, { added: number; removed: number; binary: boolean }> {
+    const stats: Record<string, { added: number; removed: number; binary: boolean }> = {};
+    
+    for (const file of summary.files) {
+        stats[file.file] = {
+            added: file.insertions,
+            removed: file.deletions,
+            binary: file.binary
+        };
+    }
+    
+    return stats;
+}
+
+/**
+ * Merge two diff summaries (useful for combining staged and unstaged changes)
+ */
+export function mergeDiffSummaries(staged: DiffSummary, unstaged: DiffSummary): {
+    stagedAdded: number;
+    stagedRemoved: number;
+    unstagedAdded: number;
+    unstagedRemoved: number;
+} {
+    return {
+        stagedAdded: staged.insertions,
+        stagedRemoved: staged.deletions,
+        unstagedAdded: unstaged.insertions,
+        unstagedRemoved: unstaged.deletions
+    };
+}