prjct-cli 0.17.0 → 0.18.0

package/core/sync/sync-client.ts

@@ -0,0 +1,252 @@
+/**
+ * Sync Client - HTTP client for prjct API
+ *
+ * Handles communication with the backend API for push/pull operations.
+ * Uses native fetch API (available in Node 18+ and Bun).
+ */
+
+import authConfig from './auth-config'
+import type { SyncEvent } from '../events'
+
+// ============================================
+// Types
+// ============================================
+
+export interface SyncBatchResult {
+  success: boolean
+  processed: number
+  errors: Array<{ index: number; error: string }>
+  syncedAt: string
+}
+
+export interface SyncPullResult {
+  events: Array<{
+    type: string
+    path: string[]
+    data: unknown
+    timestamp: string
+  }>
+  syncedAt: string
+}
+
+export interface SyncStatus {
+  projectId: string
+  lastSync: string | null
+  pendingCount: number
+  hasConflicts: boolean
+}
+
+export interface SyncClientError {
+  code: 'AUTH_REQUIRED' | 'NETWORK_ERROR' | 'API_ERROR' | 'UNKNOWN'
+  message: string
+  status?: number
+}
+
+// ============================================
+// Sync Client
+// ============================================
+
+class SyncClient {
+  private retryConfig = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+  }
+
+  /**
+   * Push local events to the server
+   */
+  async pushEvents(projectId: string, events: SyncEvent[]): Promise<SyncBatchResult> {
+    const { apiUrl, apiKey } = await this.getAuthHeaders()
+
+    if (!apiKey) {
+      throw this.createError('AUTH_REQUIRED', 'No API key configured')
+    }
+
+    const response = await this.fetchWithRetry(`${apiUrl}/sync/batch`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Api-Key': apiKey,
+      },
+      body: JSON.stringify({
+        projectId,
+        events: events.map((e) => ({
+          type: e.type,
+          path: e.path,
+          data: e.data,
+          timestamp: e.timestamp,
+        })),
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await this.parseErrorResponse(response)
+      throw error
+    }
+
+    return (await response.json()) as SyncBatchResult
+  }
+
+  /**
+   * Pull events from the server since a timestamp
+   */
+  async pullEvents(projectId: string, since?: string): Promise<SyncPullResult> {
+    const { apiUrl, apiKey } = await this.getAuthHeaders()
+
+    if (!apiKey) {
+      throw this.createError('AUTH_REQUIRED', 'No API key configured')
+    }
+
+    const response = await this.fetchWithRetry(`${apiUrl}/sync/pull`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Api-Key': apiKey,
+      },
+      body: JSON.stringify({
+        projectId,
+        since,
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await this.parseErrorResponse(response)
+      throw error
+    }
+
+    return (await response.json()) as SyncPullResult
+  }
+
+  /**
+   * Get sync status for a project
+   */
+  async getStatus(projectId: string): Promise<SyncStatus> {
+    const { apiUrl, apiKey } = await this.getAuthHeaders()
+
+    if (!apiKey) {
+      throw this.createError('AUTH_REQUIRED', 'No API key configured')
+    }
+
+    const response = await this.fetchWithRetry(`${apiUrl}/sync/status/${projectId}`, {
+      method: 'GET',
+      headers: {
+        'X-Api-Key': apiKey,
+      },
+    })
+
+    if (!response.ok) {
+      const error = await this.parseErrorResponse(response)
+      throw error
+    }
+
+    return (await response.json()) as SyncStatus
+  }
+
+  /**
+   * Test connection to the API
+   */
+  async testConnection(): Promise<boolean> {
+    try {
+      const { apiUrl, apiKey } = await this.getAuthHeaders()
+
+      if (!apiKey) {
+        return false
+      }
+
+      const response = await fetch(`${apiUrl}/health`, {
+        method: 'GET',
+        headers: {
+          'X-Api-Key': apiKey,
+        },
+      })
+
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if we have valid authentication
+   */
+  async hasAuth(): Promise<boolean> {
+    return await authConfig.hasAuth()
+  }
+
+  // ============================================
+  // Private helpers
+  // ============================================
+
+  private async getAuthHeaders(): Promise<{ apiUrl: string; apiKey: string | null }> {
+    const [apiUrl, apiKey] = await Promise.all([authConfig.getApiUrl(), authConfig.getApiKey()])
+    return { apiUrl, apiKey }
+  }
+
+  private async fetchWithRetry(
+    url: string,
+    options: RequestInit,
+    retryCount = 0
+  ): Promise<Response> {
+    try {
+      const response = await fetch(url, options)
+
+      // Retry on server errors (5xx) but not client errors (4xx)
+      if (response.status >= 500 && retryCount < this.retryConfig.maxRetries) {
+        const delay = Math.min(
+          this.retryConfig.baseDelayMs * Math.pow(2, retryCount),
+          this.retryConfig.maxDelayMs
+        )
+        await this.sleep(delay)
+        return this.fetchWithRetry(url, options, retryCount + 1)
+      }
+
+      return response
+    } catch (error) {
+      // Retry on network errors
+      if (retryCount < this.retryConfig.maxRetries) {
+        const delay = Math.min(
+          this.retryConfig.baseDelayMs * Math.pow(2, retryCount),
+          this.retryConfig.maxDelayMs
+        )
+        await this.sleep(delay)
+        return this.fetchWithRetry(url, options, retryCount + 1)
+      }
+
+      throw this.createError(
+        'NETWORK_ERROR',
+        error instanceof Error ? error.message : 'Network request failed'
+      )
+    }
+  }
+
+  private async parseErrorResponse(response: Response): Promise<SyncClientError> {
+    try {
+      const body = (await response.json()) as { message?: string; error?: string }
+      const message = body.message || body.error || `HTTP ${response.status}`
+
+      if (response.status === 401 || response.status === 403) {
+        return this.createError('AUTH_REQUIRED', message, response.status)
+      }
+
+      return this.createError('API_ERROR', message, response.status)
+    } catch {
+      return this.createError('API_ERROR', `HTTP ${response.status}`, response.status)
+    }
+  }
+
+  private createError(
+    code: SyncClientError['code'],
+    message: string,
+    status?: number
+  ): SyncClientError {
+    return { code, message, status }
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+}
+
+export const syncClient = new SyncClient()
+export default syncClient

package/core/sync/sync-manager.ts

@@ -0,0 +1,358 @@
+/**
+ * Sync Manager - Orchestrates push/pull operations
+ *
+ * Main entry point for sync operations.
+ * Handles the coordination between local storage (EventBus) and remote API (SyncClient).
+ */
+
+import { syncClient, type SyncBatchResult, type SyncPullResult, type SyncStatus } from './sync-client'
+import authConfig from './auth-config'
+import eventBus, { type SyncEvent } from '../events'
+import { stateStorage } from '../storage/state-storage'
+import { queueStorage } from '../storage/queue-storage'
+import { ideasStorage, type IdeaPriority } from '../storage/ideas-storage'
+import { shippedStorage } from '../storage/shipped-storage'
+import type { TaskType, Priority, TaskSection } from '../schemas/state'
+
+// ============================================
+// Types
+// ============================================
+
+export interface SyncResult {
+  success: boolean
+  skipped: boolean
+  reason?: 'no_auth' | 'no_pending' | 'error'
+  pushed?: {
+    count: number
+    syncedAt: string
+  }
+  pulled?: {
+    count: number
+    syncedAt: string
+  }
+  error?: string
+}
+
+export interface PushResult {
+  success: boolean
+  skipped: boolean
+  reason?: 'no_auth' | 'no_pending' | 'error'
+  count?: number
+  syncedAt?: string
+  error?: string
+}
+
+export interface PullResult {
+  success: boolean
+  skipped: boolean
+  reason?: 'no_auth' | 'error'
+  count?: number
+  applied?: number
+  syncedAt?: string
+  error?: string
+}
+
+// ============================================
+// Sync Manager
+// ============================================
+
+class SyncManager {
+  /**
+   * Check if user is authenticated
+   */
+  async hasAuth(): Promise<boolean> {
+    return await authConfig.hasAuth()
+  }
+
+  /**
+   * Get sync status from API
+   */
+  async getStatus(projectId: string): Promise<SyncStatus | null> {
+    if (!(await this.hasAuth())) {
+      return null
+    }
+
+    try {
+      return await syncClient.getStatus(projectId)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Full sync: push local changes, then pull remote changes
+   */
+  async sync(projectId: string): Promise<SyncResult> {
+    // Check auth first
+    if (!(await this.hasAuth())) {
+      return { success: true, skipped: true, reason: 'no_auth' }
+    }
+
+    const result: SyncResult = { success: true, skipped: false }
+
+    // Push first
+    const pushResult = await this.push(projectId)
+    if (pushResult.success && !pushResult.skipped) {
+      result.pushed = {
+        count: pushResult.count || 0,
+        syncedAt: pushResult.syncedAt || new Date().toISOString(),
+      }
+    }
+
+    // Then pull
+    const pullResult = await this.pull(projectId)
+    if (pullResult.success && !pullResult.skipped) {
+      result.pulled = {
+        count: pullResult.count || 0,
+        syncedAt: pullResult.syncedAt || new Date().toISOString(),
+      }
+    }
+
+    // Determine overall success
+    if (!pushResult.success || !pullResult.success) {
+      result.success = false
+      result.error = pushResult.error || pullResult.error
+    }
+
+    return result
+  }
+
+  /**
+   * Push local pending events to the server
+   */
+  async push(projectId: string): Promise<PushResult> {
+    // Check auth first
+    if (!(await this.hasAuth())) {
+      return { success: true, skipped: true, reason: 'no_auth' }
+    }
+
+    try {
+      // Get pending events
+      const pending = await eventBus.getPending(projectId)
+
+      if (pending.length === 0) {
+        return { success: true, skipped: true, reason: 'no_pending' }
+      }
+
+      // Push to server
+      const result: SyncBatchResult = await syncClient.pushEvents(projectId, pending)
+
+      if (result.success) {
+        // Clear pending events on success
+        await eventBus.clearPending(projectId)
+        await eventBus.updateLastSync(projectId)
+
+        return {
+          success: true,
+          skipped: false,
+          count: result.processed,
+          syncedAt: result.syncedAt,
+        }
+      } else {
+        // Partial success - some events failed
+        const successCount = result.processed
+        const errorCount = result.errors.length
+        const errorMessages = result.errors.map((e) => e.error).join(', ')
+
+        return {
+          success: false,
+          skipped: false,
+          count: successCount,
+          syncedAt: result.syncedAt,
+          error: `${errorCount} events failed: ${errorMessages}`,
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      return {
+        success: false,
+        skipped: false,
+        reason: 'error',
+        error: message,
+      }
+    }
+  }
+
+  /**
+   * Pull remote changes from the server
+   */
+  async pull(projectId: string): Promise<PullResult> {
+    // Check auth first
+    if (!(await this.hasAuth())) {
+      return { success: true, skipped: true, reason: 'no_auth' }
+    }
+
+    try {
+      // Get last sync timestamp
+      const lastSync = await eventBus.getLastSync(projectId)
+      const since = lastSync?.timestamp
+
+      // Pull from server
+      const result: SyncPullResult = await syncClient.pullEvents(projectId, since)
+
+      if (result.events.length === 0) {
+        return {
+          success: true,
+          skipped: false,
+          count: 0,
+          applied: 0,
+          syncedAt: result.syncedAt,
+        }
+      }
+
+      // Apply pulled events to local storage
+      const applied = await this.applyPulledEvents(projectId, result.events)
+
+      // Update last sync timestamp
+      await eventBus.updateLastSync(projectId)
+
+      return {
+        success: true,
+        skipped: false,
+        count: result.events.length,
+        applied,
+        syncedAt: result.syncedAt,
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      return {
+        success: false,
+        skipped: false,
+        reason: 'error',
+        error: message,
+      }
+    }
+  }
+
+  /**
+   * Apply pulled events to local storage
+   * Returns number of events successfully applied
+   */
+  async applyPulledEvents(
+    projectId: string,
+    events: Array<{ type: string; path: string[]; data: unknown; timestamp: string }>
+  ): Promise<number> {
+    let applied = 0
+
+    for (const event of events) {
+      try {
+        await this.applyEvent(projectId, event)
+        applied++
+      } catch (error) {
+        // Log but continue with other events
+        console.error(`Failed to apply event ${event.type}:`, error)
+      }
+    }
+
+    return applied
+  }
+
+  /**
+   * Apply a single event to local storage
+   */
+  private async applyEvent(
+    projectId: string,
+    event: { type: string; path: string[]; data: unknown; timestamp: string }
+  ): Promise<void> {
+    const [entity, action] = event.type.split('.') as [string, string]
+    const data = event.data as Record<string, unknown>
+
+    switch (entity) {
+      case 'task':
+        await this.applyTaskEvent(projectId, action, data)
+        break
+      case 'idea':
+        await this.applyIdeaEvent(projectId, action, data)
+        break
+      case 'shipped':
+        await this.applyShippedEvent(projectId, action, data)
+        break
+      // Add more entity handlers as needed
+    }
+  }
+
+  private async applyTaskEvent(
+    projectId: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
+    switch (action) {
+      case 'started':
+        // Update state if this is a newer task
+        await stateStorage.update(projectId, (state) => {
+          if (!state.currentTask || (data.id as string) !== state.currentTask.id) {
+            return {
+              ...state,
+              currentTask: {
+                id: data.id as string,
+                description: data.description as string,
+                startedAt: data.startedAt as string,
+                sessionId: data.sessionId as string,
+              },
+            }
+          }
+          return state
+        })
+        break
+      case 'completed':
+        // Clear current task if it matches
+        await stateStorage.update(projectId, (state) => {
+          if (state.currentTask?.id === data.id) {
+            return { ...state, currentTask: null }
+          }
+          return state
+        })
+        break
+      case 'created':
+        // Add to queue
+        await queueStorage.addTask(projectId, {
+          description: data.description as string,
+          priority: (data.priority as Priority) || 'medium',
+          type: (data.type as TaskType) || 'feature',
+          section: 'backlog' as TaskSection,
+        })
+        break
+    }
+  }
+
+  private async applyIdeaEvent(
+    projectId: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
+    switch (action) {
+      case 'created':
+        await ideasStorage.addIdea(
+          projectId,
+          (data.title as string) || (data.text as string),
+          { priority: (data.priority as IdeaPriority) || 'medium' }
+        )
+        break
+      case 'archived':
+        await ideasStorage.update(projectId, (ideas) => ({
+          ...ideas,
+          ideas: ideas.ideas.map((idea) =>
+            idea.id === data.id ? { ...idea, status: 'archived' as const } : idea
+          ),
+        }))
+        break
+    }
+  }
+
+  private async applyShippedEvent(
+    projectId: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
+    if (action === 'created') {
+      await shippedStorage.addShipped(projectId, {
+        name: (data.name as string) || (data.title as string),
+        version: data.version as string,
+        description: data.description as string,
+      })
+    }
+  }
+}
+
+export const syncManager = new SyncManager()
+export default syncManager

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {